]> gcc.gnu.org Git - gcc.git/blame - gcc/fold-const.c
git://gcc.gnu.org / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
�
[gcc.git] / gcc / fold-const.c
CommitLineData
6d716ca8 1/* Fold a constant sub-tree into a single node for C-compiler
f8dac6eb 2 Copyright (C) 1987, 88, 92-97, 1998 Free Software Foundation, Inc.
6d716ca8
RS		 3
4This file is part of GNU CC.
5
6GNU CC is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2, or (at your option)
9any later version.
10
11GNU CC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GNU CC; see the file COPYING. If not, write to
a35311b0
RK		 18the Free Software Foundation, 59 Temple Place - Suite 330,
19Boston, MA 02111-1307, USA. */
6d716ca8 20
6dc42e49 21/*@@ This file should be rewritten to use an arbitrary precision
6d716ca8
RS		 22 @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
23 @@ Perhaps the routines could also be used for bc/dc, and made a lib.
24 @@ The routines that translate from the ap rep should
25 @@ warn if precision et. al. is lost.
26 @@ This would also make life easier when this technology is used
27 @@ for cross-compilers. */
28
29
f8dac6eb 30/* The entry points in this file are fold, size_int_wide, size_binop
0da6f3db 31 and force_fit_type.
6d716ca8
RS		 32
33 fold takes a tree as argument and returns a simplified tree.
34
35 size_binop takes a tree code for an arithmetic operation
36 and two operands that are trees, and produces a tree for the
37 result, assuming the type comes from `sizetype'.
38
39 size_int takes an integer value, and creates a tree constant
0da6f3db
DE		 40 with type from `sizetype'.
41
42 force_fit_type takes a constant and prior overflow indicator, and
43 forces the value to fit the type. It returns an overflow indicator. */
44
e9a25f70 45#include "config.h"
2fde567e 46#include "system.h"
6d716ca8 47#include <setjmp.h>
6d716ca8
RS		 48#include "flags.h"
49#include "tree.h"
10f0ad3d 50#include "toplev.h"
6d716ca8 51
7c7b029d
RS		 52/* Handle floating overflow for `const_binop'. */
53static jmp_buf float_error;
54
ebde8a27
RK		 55static void encode PROTO((HOST_WIDE_INT *,
56 HOST_WIDE_INT, HOST_WIDE_INT));
57static void decode PROTO((HOST_WIDE_INT *,
58 HOST_WIDE_INT *, HOST_WIDE_INT *));
59int div_and_round_double PROTO((enum tree_code, int, HOST_WIDE_INT,
6dc7571d
RK		 60 HOST_WIDE_INT, HOST_WIDE_INT,
61 HOST_WIDE_INT, HOST_WIDE_INT *,
62 HOST_WIDE_INT *, HOST_WIDE_INT *,
63 HOST_WIDE_INT *));
ebde8a27
RK		 64static int split_tree PROTO((tree, enum tree_code, tree *,
65 tree *, int *));
e9a25f70 66static tree int_const_binop PROTO((enum tree_code, tree, tree, int, int));
ebde8a27
RK		 67static tree const_binop PROTO((enum tree_code, tree, tree, int));
68static tree fold_convert PROTO((tree, tree));
6dc7571d
RK		 69static enum tree_code invert_tree_comparison PROTO((enum tree_code));
70static enum tree_code swap_tree_comparison PROTO((enum tree_code));
ebde8a27 71static int truth_value_p PROTO((enum tree_code));
6dc7571d 72static int operand_equal_for_comparison_p PROTO((tree, tree, tree));
ebde8a27
RK		 73static int twoval_comparison_p PROTO((tree, tree *, tree *, int *));
74static tree eval_subst PROTO((tree, tree, tree, tree, tree));
75static tree omit_one_operand PROTO((tree, tree, tree));
4ab3cb65 76static tree pedantic_omit_one_operand PROTO((tree, tree, tree));
6dc7571d 77static tree distribute_bit_expr PROTO((enum tree_code, tree, tree, tree));
ebde8a27 78static tree make_bit_field_ref PROTO((tree, tree, int, int, int));
6dc7571d
RK		 79static tree optimize_bit_field_compare PROTO((enum tree_code, tree,
80 tree, tree));
81static tree decode_field_reference PROTO((tree, int *, int *,
82 enum machine_mode *, int *,
d4453ee5 83 int *, tree *, tree *));
ebde8a27
RK		 84static int all_ones_mask_p PROTO((tree, int));
85static int simple_operand_p PROTO((tree));
86static tree range_binop PROTO((enum tree_code, tree, tree, int,
87 tree, int));
88static tree make_range PROTO((tree, int *, tree *, tree *));
89static tree build_range_check PROTO((tree, tree, int, tree, tree));
90static int merge_ranges PROTO((int *, tree *, tree *, int, tree, tree,
91 int, tree, tree));
92static tree fold_range_test PROTO((tree));
93static tree unextend PROTO((tree, int, int, tree));
94static tree fold_truthop PROTO((enum tree_code, tree, tree, tree));
b5f3b6b6 95static tree strip_compound_expr PROTO((tree, tree));
39dfb55a 96static int multiple_of_p PROTO((tree, tree, tree));
f628873f 97static tree constant_boolean_node PROTO((int, tree));
d35357ed
RS		 98
99#ifndef BRANCH_COST
100#define BRANCH_COST 1
101#endif
fe3e8e40 102
fe3e8e40
RS		 103/* Suppose A1 + B1 = SUM1, using 2's complement arithmetic ignoring overflow.
104 Suppose A, B and SUM have the same respective signs as A1, B1, and SUM1.
105 Then this yields nonzero if overflow occurred during the addition.
106 Overflow occurs if A and B have the same sign, but A and SUM differ in sign.
107 Use `^' to test whether signs differ, and `< 0' to isolate the sign. */
108#define overflow_sum_sign(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
6d716ca8 109\f
906c4e36 110/* To do constant folding on INTEGER_CST nodes requires two-word arithmetic.
37bdb7e3
TG		 111 We do that by representing the two-word integer in 4 words, with only
112 HOST_BITS_PER_WIDE_INT/2 bits stored in each word, as a positive number. */
113
114#define LOWPART(x) \
115 ((x) & (((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT/2)) - 1))
116#define HIGHPART(x) \
117 ((unsigned HOST_WIDE_INT) (x) >> HOST_BITS_PER_WIDE_INT/2)
118#define BASE ((unsigned HOST_WIDE_INT) 1 << HOST_BITS_PER_WIDE_INT/2)
6d716ca8 119
37bdb7e3 120/* Unpack a two-word integer into 4 words.
906c4e36 121 LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
37bdb7e3 122 WORDS points to the array of HOST_WIDE_INTs. */
6d716ca8
RS		 123
124static void
37bdb7e3
TG		 125encode (words, low, hi)
126 HOST_WIDE_INT *words;
906c4e36 127 HOST_WIDE_INT low, hi;
6d716ca8 128{
37bdb7e3
TG		 129 words[0] = LOWPART (low);
130 words[1] = HIGHPART (low);
131 words[2] = LOWPART (hi);
132 words[3] = HIGHPART (hi);
6d716ca8
RS		 133}
134
37bdb7e3
TG		 135/* Pack an array of 4 words into a two-word integer.
136 WORDS points to the array of words.
906c4e36 137 The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces. */
6d716ca8
RS		 138
139static void
37bdb7e3
TG		 140decode (words, low, hi)
141 HOST_WIDE_INT *words;
906c4e36 142 HOST_WIDE_INT *low, *hi;
6d716ca8 143{
37bdb7e3
TG		 144 *low = words[0] | words[1] * BASE;
145 *hi = words[2] | words[3] * BASE;
6d716ca8
RS		 146}
147\f
148/* Make the integer constant T valid for its type
149 by setting to 0 or 1 all the bits in the constant
e0f776fb
RS		 150 that don't belong in the type.
151 Yield 1 if a signed overflow occurs, 0 otherwise.
a4d8855c 152 If OVERFLOW is nonzero, a signed overflow has already occurred
649ff3b4
RK		 153 in calculating T, so propagate it.
154
155 Make the real constant T valid for its type by calling CHECK_FLOAT_VALUE,
156 if it exists. */
6d716ca8 157
e0f776fb
RS		 158int
159force_fit_type (t, overflow)
6d716ca8 160 tree t;
e0f776fb 161 int overflow;
6d716ca8 162{
ef2bf0c0
RS		 163 HOST_WIDE_INT low, high;
164 register int prec;
6d716ca8 165
649ff3b4
RK		 166 if (TREE_CODE (t) == REAL_CST)
167 {
168#ifdef CHECK_FLOAT_VALUE
169 CHECK_FLOAT_VALUE (TYPE_MODE (TREE_TYPE (t)), TREE_REAL_CST (t),
170 overflow);
171#endif
172 return overflow;
173 }
174
175 else if (TREE_CODE (t) != INTEGER_CST)
ef2bf0c0
RS		 176 return overflow;
177
178 low = TREE_INT_CST_LOW (t);
179 high = TREE_INT_CST_HIGH (t);
42f769c1 180
e5e809f4 181 if (POINTER_TYPE_P (TREE_TYPE (t)))
6d716ca8 182 prec = POINTER_SIZE;
ef2bf0c0
RS		 183 else
184 prec = TYPE_PRECISION (TREE_TYPE (t));
6d716ca8
RS		 185
186 /* First clear all bits that are beyond the type's precision. */
187
906c4e36 188 if (prec == 2 * HOST_BITS_PER_WIDE_INT)
6d716ca8 189 ;
906c4e36 190 else if (prec > HOST_BITS_PER_WIDE_INT)
6d716ca8
RS		 191 {
192 TREE_INT_CST_HIGH (t)
906c4e36 193 &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
6d716ca8
RS		 194 }
195 else
196 {
197 TREE_INT_CST_HIGH (t) = 0;
906c4e36
RK		 198 if (prec < HOST_BITS_PER_WIDE_INT)
199 TREE_INT_CST_LOW (t) &= ~((HOST_WIDE_INT) (-1) << prec);
6d716ca8
RS		 200 }
201
e0f776fb
RS		 202 /* Unsigned types do not suffer sign extension or overflow. */
203 if (TREE_UNSIGNED (TREE_TYPE (t)))
a7a05640 204 return overflow;
6d716ca8 205
e0f776fb
RS		 206 /* If the value's sign bit is set, extend the sign. */
207 if (prec != 2 * HOST_BITS_PER_WIDE_INT
906c4e36
RK		 208 && (prec > HOST_BITS_PER_WIDE_INT
209 ? (TREE_INT_CST_HIGH (t)
210 & ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)))
211 : TREE_INT_CST_LOW (t) & ((HOST_WIDE_INT) 1 << (prec - 1))))
6d716ca8
RS		 212 {
213 /* Value is negative:
214 set to 1 all the bits that are outside this type's precision. */
906c4e36 215 if (prec > HOST_BITS_PER_WIDE_INT)
6d716ca8
RS		 216 {
217 TREE_INT_CST_HIGH (t)
906c4e36 218 |= ((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
6d716ca8
RS		 219 }
220 else
221 {
222 TREE_INT_CST_HIGH (t) = -1;
906c4e36
RK		 223 if (prec < HOST_BITS_PER_WIDE_INT)
224 TREE_INT_CST_LOW (t) |= ((HOST_WIDE_INT) (-1) << prec);
6d716ca8
RS		 225 }
226 }
e0f776fb
RS		 227
228 /* Yield nonzero if signed overflow occurred. */
229 return
230 ((overflow | (low ^ TREE_INT_CST_LOW (t)) | (high ^ TREE_INT_CST_HIGH (t)))
231 != 0);
6d716ca8
RS		 232}
233\f
906c4e36
RK		 234/* Add two doubleword integers with doubleword result.
235 Each argument is given as two `HOST_WIDE_INT' pieces.
6d716ca8 236 One argument is L1 and H1; the other, L2 and H2.
37bdb7e3 237 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
6d716ca8 238
fe3e8e40 239int
6d716ca8 240add_double (l1, h1, l2, h2, lv, hv)
906c4e36
RK		 241 HOST_WIDE_INT l1, h1, l2, h2;
242 HOST_WIDE_INT *lv, *hv;
6d716ca8 243{
37bdb7e3 244 HOST_WIDE_INT l, h;
6d716ca8 245
37bdb7e3
TG		 246 l = l1 + l2;
247 h = h1 + h2 + ((unsigned HOST_WIDE_INT) l < l1);
6d716ca8 248
37bdb7e3
TG		 249 *lv = l;
250 *hv = h;
251 return overflow_sum_sign (h1, h2, h);
6d716ca8
RS		 252}
253
906c4e36 254/* Negate a doubleword integer with doubleword result.
fe3e8e40 255 Return nonzero if the operation overflows, assuming it's signed.
906c4e36 256 The argument is given as two `HOST_WIDE_INT' pieces in L1 and H1.
37bdb7e3 257 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
6d716ca8 258
fe3e8e40 259int
6d716ca8 260neg_double (l1, h1, lv, hv)
906c4e36
RK		 261 HOST_WIDE_INT l1, h1;
262 HOST_WIDE_INT *lv, *hv;
6d716ca8
RS		 263{
264 if (l1 == 0)
265 {
266 *lv = 0;
267 *hv = - h1;
e0f776fb 268 return (*hv & h1) < 0;
6d716ca8
RS		 269 }
270 else
271 {
272 *lv = - l1;
273 *hv = ~ h1;
fe3e8e40 274 return 0;
6d716ca8
RS		 275 }
276}
277\f
906c4e36 278/* Multiply two doubleword integers with doubleword result.
fe3e8e40 279 Return nonzero if the operation overflows, assuming it's signed.
906c4e36 280 Each argument is given as two `HOST_WIDE_INT' pieces.
6d716ca8 281 One argument is L1 and H1; the other, L2 and H2.
37bdb7e3 282 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
6d716ca8 283
fe3e8e40 284int
6d716ca8 285mul_double (l1, h1, l2, h2, lv, hv)
906c4e36
RK		 286 HOST_WIDE_INT l1, h1, l2, h2;
287 HOST_WIDE_INT *lv, *hv;
6d716ca8 288{
37bdb7e3
TG		 289 HOST_WIDE_INT arg1[4];
290 HOST_WIDE_INT arg2[4];
291 HOST_WIDE_INT prod[4 * 2];
292 register unsigned HOST_WIDE_INT carry;
6d716ca8 293 register int i, j, k;
fe3e8e40 294 HOST_WIDE_INT toplow, tophigh, neglow, neghigh;
6d716ca8 295
6d716ca8
RS		 296 encode (arg1, l1, h1);
297 encode (arg2, l2, h2);
298
4c9a05bc 299 bzero ((char *) prod, sizeof prod);
6d716ca8 300
37bdb7e3
TG		 301 for (i = 0; i < 4; i++)
302 {
303 carry = 0;
304 for (j = 0; j < 4; j++)
305 {
306 k = i + j;
307 /* This product is <= 0xFFFE0001, the sum <= 0xFFFF0000. */
308 carry += arg1[i] * arg2[j];
309 /* Since prod[p] < 0xFFFF, this sum <= 0xFFFFFFFF. */
310 carry += prod[k];
311 prod[k] = LOWPART (carry);
312 carry = HIGHPART (carry);
313 }
314 prod[i + 4] = carry;
315 }
6d716ca8 316
37bdb7e3 317 decode (prod, lv, hv); /* This ignores prod[4] through prod[4*2-1] */
fe3e8e40
RS		 318
319 /* Check for overflow by calculating the top half of the answer in full;
320 it should agree with the low half's sign bit. */
37bdb7e3 321 decode (prod+4, &toplow, &tophigh);
fe3e8e40
RS		 322 if (h1 < 0)
323 {
324 neg_double (l2, h2, &neglow, &neghigh);
325 add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
326 }
327 if (h2 < 0)
328 {
329 neg_double (l1, h1, &neglow, &neghigh);
330 add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
331 }
332 return (*hv < 0 ? ~(toplow & tophigh) : toplow | tophigh) != 0;
6d716ca8
RS		 333}
334\f
906c4e36 335/* Shift the doubleword integer in L1, H1 left by COUNT places
6d716ca8
RS		 336 keeping only PREC bits of result.
337 Shift right if COUNT is negative.
338 ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
906c4e36 339 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
6d716ca8 340
e0f776fb 341void
6d716ca8 342lshift_double (l1, h1, count, prec, lv, hv, arith)
6dc7571d
RK		 343 HOST_WIDE_INT l1, h1, count;
344 int prec;
906c4e36 345 HOST_WIDE_INT *lv, *hv;
6d716ca8
RS		 346 int arith;
347{
6d716ca8
RS		 348 if (count < 0)
349 {
350 rshift_double (l1, h1, - count, prec, lv, hv, arith);
e0f776fb 351 return;
6d716ca8 352 }
37bdb7e3 353
3d1877b1
RK		 354#ifdef SHIFT_COUNT_TRUNCATED
355 if (SHIFT_COUNT_TRUNCATED)
356 count %= prec;
357#endif
6d716ca8 358
37bdb7e3 359 if (count >= HOST_BITS_PER_WIDE_INT)
6d716ca8 360 {
2fde567e 361 *hv = (unsigned HOST_WIDE_INT) l1 << (count - HOST_BITS_PER_WIDE_INT);
37bdb7e3
TG		 362 *lv = 0;
363 }
364 else
365 {
366 *hv = (((unsigned HOST_WIDE_INT) h1 << count)
2fde567e 367 | ((unsigned HOST_WIDE_INT) l1 >> (HOST_BITS_PER_WIDE_INT - count - 1) >> 1));
37bdb7e3 368 *lv = (unsigned HOST_WIDE_INT) l1 << count;
6d716ca8 369 }
6d716ca8
RS		 370}
371
906c4e36 372/* Shift the doubleword integer in L1, H1 right by COUNT places
6d716ca8
RS		 373 keeping only PREC bits of result. COUNT must be positive.
374 ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
906c4e36 375 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
6d716ca8
RS		 376
377void
378rshift_double (l1, h1, count, prec, lv, hv, arith)
6dc7571d
RK		 379 HOST_WIDE_INT l1, h1, count;
380 int prec;
906c4e36 381 HOST_WIDE_INT *lv, *hv;
6d716ca8
RS		 382 int arith;
383{
37bdb7e3
TG		 384 unsigned HOST_WIDE_INT signmask;
385 signmask = (arith
386 ? -((unsigned HOST_WIDE_INT) h1 >> (HOST_BITS_PER_WIDE_INT - 1))
387 : 0);
6d716ca8 388
3d1877b1
RK		 389#ifdef SHIFT_COUNT_TRUNCATED
390 if (SHIFT_COUNT_TRUNCATED)
391 count %= prec;
392#endif
6d716ca8 393
37bdb7e3 394 if (count >= HOST_BITS_PER_WIDE_INT)
6d716ca8 395 {
37bdb7e3 396 *hv = signmask;
2fde567e
KG		 397 *lv = ((signmask << (2 * HOST_BITS_PER_WIDE_INT - count - 1) << 1)
398 | ((unsigned HOST_WIDE_INT) h1 >> (count - HOST_BITS_PER_WIDE_INT)));
37bdb7e3
TG		 399 }
400 else
401 {
402 *lv = (((unsigned HOST_WIDE_INT) l1 >> count)
2fde567e
KG		 403 | ((unsigned HOST_WIDE_INT) h1 << (HOST_BITS_PER_WIDE_INT - count - 1) << 1));
404 *hv = ((signmask << (HOST_BITS_PER_WIDE_INT - count))
37bdb7e3 405 | ((unsigned HOST_WIDE_INT) h1 >> count));
6d716ca8 406 }
6d716ca8
RS		 407}
408\f
37bdb7e3 409/* Rotate the doubleword integer in L1, H1 left by COUNT places
6d716ca8
RS		 410 keeping only PREC bits of result.
411 Rotate right if COUNT is negative.
906c4e36 412 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
6d716ca8
RS		 413
414void
415lrotate_double (l1, h1, count, prec, lv, hv)
6dc7571d
RK		 416 HOST_WIDE_INT l1, h1, count;
417 int prec;
906c4e36 418 HOST_WIDE_INT *lv, *hv;
6d716ca8 419{
4d39710e 420 HOST_WIDE_INT s1l, s1h, s2l, s2h;
6d716ca8 421
4d39710e 422 count %= prec;
6d716ca8 423 if (count < 0)
4d39710e 424 count += prec;
6d716ca8 425
4d39710e
RK		 426 lshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
427 rshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
428 *lv = s1l | s2l;
429 *hv = s1h | s2h;
6d716ca8
RS		 430}
431
906c4e36 432/* Rotate the doubleword integer in L1, H1 left by COUNT places
6d716ca8 433 keeping only PREC bits of result. COUNT must be positive.
906c4e36 434 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
6d716ca8
RS		 435
436void
437rrotate_double (l1, h1, count, prec, lv, hv)
6dc7571d
RK		 438 HOST_WIDE_INT l1, h1, count;
439 int prec;
906c4e36 440 HOST_WIDE_INT *lv, *hv;
6d716ca8 441{
4d39710e 442 HOST_WIDE_INT s1l, s1h, s2l, s2h;
6d716ca8 443
4d39710e
RK		 444 count %= prec;
445 if (count < 0)
446 count += prec;
6d716ca8 447
4d39710e
RK		 448 rshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
449 lshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
450 *lv = s1l | s2l;
451 *hv = s1h | s2h;
6d716ca8
RS		 452}
453\f
906c4e36 454/* Divide doubleword integer LNUM, HNUM by doubleword integer LDEN, HDEN
6d716ca8
RS		 455 for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
456 CODE is a tree code for a kind of division, one of
457 TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR, ROUND_DIV_EXPR
458 or EXACT_DIV_EXPR
fe3e8e40
RS		 459 It controls how the quotient is rounded to a integer.
460 Return nonzero if the operation overflows.
6d716ca8
RS		 461 UNS nonzero says do unsigned division. */
462
dbb5b3ce 463int
6d716ca8
RS		 464div_and_round_double (code, uns,
465 lnum_orig, hnum_orig, lden_orig, hden_orig,
466 lquo, hquo, lrem, hrem)
467 enum tree_code code;
468 int uns;
906c4e36
RK		 469 HOST_WIDE_INT lnum_orig, hnum_orig; /* num == numerator == dividend */
470 HOST_WIDE_INT lden_orig, hden_orig; /* den == denominator == divisor */
471 HOST_WIDE_INT *lquo, *hquo, *lrem, *hrem;
6d716ca8
RS		 472{
473 int quo_neg = 0;
37bdb7e3
TG		 474 HOST_WIDE_INT num[4 + 1]; /* extra element for scaling. */
475 HOST_WIDE_INT den[4], quo[4];
476 register int i, j;
477 unsigned HOST_WIDE_INT work;
10fa1ee2 478 register unsigned HOST_WIDE_INT carry = 0;
88ee2651 479 HOST_WIDE_INT lnum = lnum_orig;
b8eb43a2 480 HOST_WIDE_INT hnum = hnum_orig;
88ee2651 481 HOST_WIDE_INT lden = lden_orig;
b8eb43a2 482 HOST_WIDE_INT hden = hden_orig;
fe3e8e40 483 int overflow = 0;
6d716ca8
RS		 484
485 if ((hden == 0) && (lden == 0))
956d6950 486 overflow = 1, lden = 1;
6d716ca8
RS		 487
488 /* calculate quotient sign and convert operands to unsigned. */
489 if (!uns)
490 {
fe3e8e40 491 if (hnum < 0)
6d716ca8
RS		 492 {
493 quo_neg = ~ quo_neg;
fe3e8e40
RS		 494 /* (minimum integer) / (-1) is the only overflow case. */
495 if (neg_double (lnum, hnum, &lnum, &hnum) && (lden & hden) == -1)
496 overflow = 1;
6d716ca8 497 }
fe3e8e40 498 if (hden < 0)
6d716ca8
RS		 499 {
500 quo_neg = ~ quo_neg;
fe3e8e40 501 neg_double (lden, hden, &lden, &hden);
6d716ca8
RS		 502 }
503 }
504
505 if (hnum == 0 && hden == 0)
506 { /* single precision */
507 *hquo = *hrem = 0;
88ee2651
RK		 508 /* This unsigned division rounds toward zero. */
509 *lquo = lnum / (unsigned HOST_WIDE_INT) lden;
6d716ca8
RS		 510 goto finish_up;
511 }
512
513 if (hnum == 0)
514 { /* trivial case: dividend < divisor */
515 /* hden != 0 already checked. */
516 *hquo = *lquo = 0;
517 *hrem = hnum;
518 *lrem = lnum;
519 goto finish_up;
520 }
521
4c9a05bc 522 bzero ((char *) quo, sizeof quo);
6d716ca8 523
4c9a05bc
RK		 524 bzero ((char *) num, sizeof num); /* to zero 9th element */
525 bzero ((char *) den, sizeof den);
6d716ca8
RS		 526
527 encode (num, lnum, hnum);
528 encode (den, lden, hden);
529
37bdb7e3
TG		 530 /* Special code for when the divisor < BASE. */
531 if (hden == 0 && lden < BASE)
532 {
6d716ca8 533 /* hnum != 0 already checked. */
37bdb7e3 534 for (i = 4 - 1; i >= 0; i--)
6d716ca8 535 {
37bdb7e3 536 work = num[i] + carry * BASE;
88ee2651
RK		 537 quo[i] = work / (unsigned HOST_WIDE_INT) lden;
538 carry = work % (unsigned HOST_WIDE_INT) lden;
6d716ca8
RS		 539 }
540 }
37bdb7e3
TG		 541 else
542 {
543 /* Full double precision division,
544 with thanks to Don Knuth's "Seminumerical Algorithms". */
10fa1ee2
RK		 545 int num_hi_sig, den_hi_sig;
546 unsigned HOST_WIDE_INT quo_est, scale;
6d716ca8
RS		 547
548 /* Find the highest non-zero divisor digit. */
37bdb7e3 549 for (i = 4 - 1; ; i--)
6d716ca8
RS		 550 if (den[i] != 0) {
551 den_hi_sig = i;
552 break;
553 }
6d716ca8
RS		 554
555 /* Insure that the first digit of the divisor is at least BASE/2.
556 This is required by the quotient digit estimation algorithm. */
557
558 scale = BASE / (den[den_hi_sig] + 1);
559 if (scale > 1) { /* scale divisor and dividend */
560 carry = 0;
37bdb7e3 561 for (i = 0; i <= 4 - 1; i++) {
6d716ca8 562 work = (num[i] * scale) + carry;
37bdb7e3
TG		 563 num[i] = LOWPART (work);
564 carry = HIGHPART (work);
565 } num[4] = carry;
6d716ca8 566 carry = 0;
37bdb7e3 567 for (i = 0; i <= 4 - 1; i++) {
6d716ca8 568 work = (den[i] * scale) + carry;
37bdb7e3
TG		 569 den[i] = LOWPART (work);
570 carry = HIGHPART (work);
6d716ca8
RS		 571 if (den[i] != 0) den_hi_sig = i;
572 }
573 }
574
37bdb7e3
TG		 575 num_hi_sig = 4;
576
6d716ca8 577 /* Main loop */
37bdb7e3 578 for (i = num_hi_sig - den_hi_sig - 1; i >= 0; i--) {
6dc42e49 579 /* guess the next quotient digit, quo_est, by dividing the first
6d716ca8
RS		 580 two remaining dividend digits by the high order quotient digit.
581 quo_est is never low and is at most 2 high. */
37bdb7e3 582 unsigned HOST_WIDE_INT tmp;
6d716ca8 583
37bdb7e3
TG		 584 num_hi_sig = i + den_hi_sig + 1;
585 work = num[num_hi_sig] * BASE + num[num_hi_sig - 1];
586 if (num[num_hi_sig] != den[den_hi_sig])
6d716ca8 587 quo_est = work / den[den_hi_sig];
37bdb7e3 588 else
6d716ca8 589 quo_est = BASE - 1;
6d716ca8
RS		 590
591 /* refine quo_est so it's usually correct, and at most one high. */
37bdb7e3
TG		 592 tmp = work - quo_est * den[den_hi_sig];
593 if (tmp < BASE
594 && den[den_hi_sig - 1] * quo_est > (tmp * BASE + num[num_hi_sig - 2]))
6d716ca8
RS		 595 quo_est--;
596
597 /* Try QUO_EST as the quotient digit, by multiplying the
598 divisor by QUO_EST and subtracting from the remaining dividend.
599 Keep in mind that QUO_EST is the I - 1st digit. */
600
601 carry = 0;
6d716ca8
RS		 602 for (j = 0; j <= den_hi_sig; j++)
603 {
37bdb7e3
TG		 604 work = quo_est * den[j] + carry;
605 carry = HIGHPART (work);
606 work = num[i + j] - LOWPART (work);
607 num[i + j] = LOWPART (work);
608 carry += HIGHPART (work) != 0;
6d716ca8
RS		 609 }
610
611 /* if quo_est was high by one, then num[i] went negative and
612 we need to correct things. */
613
37bdb7e3 614 if (num[num_hi_sig] < carry)
6d716ca8
RS		 615 {
616 quo_est--;
617 carry = 0; /* add divisor back in */
618 for (j = 0; j <= den_hi_sig; j++)
619 {
37bdb7e3
TG		 620 work = num[i + j] + den[j] + carry;
621 carry = HIGHPART (work);
622 num[i + j] = LOWPART (work);
6d716ca8 623 }
37bdb7e3 624 num [num_hi_sig] += carry;
6d716ca8
RS		 625 }
626
627 /* store the quotient digit. */
37bdb7e3 628 quo[i] = quo_est;
6d716ca8
RS		 629 }
630 }
631
632 decode (quo, lquo, hquo);
633
634 finish_up:
635 /* if result is negative, make it so. */
636 if (quo_neg)
637 neg_double (*lquo, *hquo, lquo, hquo);
638
639 /* compute trial remainder: rem = num - (quo * den) */
640 mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
641 neg_double (*lrem, *hrem, lrem, hrem);
642 add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
643
644 switch (code)
645 {
646 case TRUNC_DIV_EXPR:
647 case TRUNC_MOD_EXPR: /* round toward zero */
648 case EXACT_DIV_EXPR: /* for this one, it shouldn't matter */
fe3e8e40 649 return overflow;
6d716ca8
RS		 650
651 case FLOOR_DIV_EXPR:
652 case FLOOR_MOD_EXPR: /* round toward negative infinity */
653 if (quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio < 0 && rem != 0 */
654 {
655 /* quo = quo - 1; */
906c4e36
RK		 656 add_double (*lquo, *hquo, (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1,
657 lquo, hquo);
6d716ca8 658 }
fe3e8e40 659 else return overflow;
6d716ca8
RS		 660 break;
661
662 case CEIL_DIV_EXPR:
663 case CEIL_MOD_EXPR: /* round toward positive infinity */
664 if (!quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio > 0 && rem != 0 */
665 {
906c4e36
RK		 666 add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
667 lquo, hquo);
6d716ca8 668 }
fe3e8e40 669 else return overflow;
6d716ca8
RS		 670 break;
671
672 case ROUND_DIV_EXPR:
673 case ROUND_MOD_EXPR: /* round to closest integer */
674 {
906c4e36
RK		 675 HOST_WIDE_INT labs_rem = *lrem, habs_rem = *hrem;
676 HOST_WIDE_INT labs_den = lden, habs_den = hden, ltwice, htwice;
6d716ca8
RS		 677
678 /* get absolute values */
679 if (*hrem < 0) neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
680 if (hden < 0) neg_double (lden, hden, &labs_den, &habs_den);
681
682 /* if (2 * abs (lrem) >= abs (lden)) */
906c4e36
RK		 683 mul_double ((HOST_WIDE_INT) 2, (HOST_WIDE_INT) 0,
684 labs_rem, habs_rem, &ltwice, &htwice);
685 if (((unsigned HOST_WIDE_INT) habs_den
686 < (unsigned HOST_WIDE_INT) htwice)
687 || (((unsigned HOST_WIDE_INT) habs_den
688 == (unsigned HOST_WIDE_INT) htwice)
689 && ((HOST_WIDE_INT unsigned) labs_den
690 < (unsigned HOST_WIDE_INT) ltwice)))
6d716ca8
RS		 691 {
692 if (*hquo < 0)
693 /* quo = quo - 1; */
906c4e36
RK		 694 add_double (*lquo, *hquo,
695 (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1, lquo, hquo);
6d716ca8
RS		 696 else
697 /* quo = quo + 1; */
906c4e36
RK		 698 add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
699 lquo, hquo);
6d716ca8 700 }
fe3e8e40 701 else return overflow;
6d716ca8
RS		 702 }
703 break;
704
705 default:
706 abort ();
707 }
708
709 /* compute true remainder: rem = num - (quo * den) */
710 mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
711 neg_double (*lrem, *hrem, lrem, hrem);
712 add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
fe3e8e40 713 return overflow;
6d716ca8
RS		 714}
715\f
5008b8ae 716#ifndef REAL_ARITHMETIC
649ff3b4
RK		 717/* Effectively truncate a real value to represent the nearest possible value
718 in a narrower mode. The result is actually represented in the same data
719 type as the argument, but its value is usually different.
720
721 A trap may occur during the FP operations and it is the responsibility
722 of the calling function to have a handler established. */
5352b11a
RS		 723
724REAL_VALUE_TYPE
725real_value_truncate (mode, arg)
726 enum machine_mode mode;
727 REAL_VALUE_TYPE arg;
728{
649ff3b4 729 return REAL_VALUE_TRUNCATE (mode, arg);
5352b11a
RS		 730}
731
6d716ca8
RS		 732#if TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
733
734/* Check for infinity in an IEEE double precision number. */
735
736int
737target_isinf (x)
738 REAL_VALUE_TYPE x;
739{
740 /* The IEEE 64-bit double format. */
741 union {
742 REAL_VALUE_TYPE d;
743 struct {
744 unsigned sign : 1;
745 unsigned exponent : 11;
746 unsigned mantissa1 : 20;
747 unsigned mantissa2;
748 } little_endian;
749 struct {
750 unsigned mantissa2;
751 unsigned mantissa1 : 20;
752 unsigned exponent : 11;
753 unsigned sign : 1;
754 } big_endian;
755 } u;
756
757 u.d = dconstm1;
758 if (u.big_endian.sign == 1)
759 {
760 u.d = x;
761 return (u.big_endian.exponent == 2047
762 && u.big_endian.mantissa1 == 0
763 && u.big_endian.mantissa2 == 0);
764 }
765 else
766 {
767 u.d = x;
768 return (u.little_endian.exponent == 2047
769 && u.little_endian.mantissa1 == 0
770 && u.little_endian.mantissa2 == 0);
771 }
772}
773
7d4d4d22
RS		 774/* Check whether an IEEE double precision number is a NaN. */
775
776int
777target_isnan (x)
778 REAL_VALUE_TYPE x;
779{
780 /* The IEEE 64-bit double format. */
781 union {
782 REAL_VALUE_TYPE d;
783 struct {
784 unsigned sign : 1;
785 unsigned exponent : 11;
786 unsigned mantissa1 : 20;
787 unsigned mantissa2;
788 } little_endian;
789 struct {
790 unsigned mantissa2;
791 unsigned mantissa1 : 20;
792 unsigned exponent : 11;
793 unsigned sign : 1;
794 } big_endian;
795 } u;
796
797 u.d = dconstm1;
798 if (u.big_endian.sign == 1)
799 {
800 u.d = x;
801 return (u.big_endian.exponent == 2047
802 && (u.big_endian.mantissa1 != 0
803 || u.big_endian.mantissa2 != 0));
804 }
805 else
806 {
807 u.d = x;
808 return (u.little_endian.exponent == 2047
809 && (u.little_endian.mantissa1 != 0
810 || u.little_endian.mantissa2 != 0));
811 }
812}
813
c05a9b68 814/* Check for a negative IEEE double precision number. */
6d716ca8
RS		 815
816int
c05a9b68 817target_negative (x)
6d716ca8
RS		 818 REAL_VALUE_TYPE x;
819{
c05a9b68
RS		 820 /* The IEEE 64-bit double format. */
821 union {
822 REAL_VALUE_TYPE d;
823 struct {
824 unsigned sign : 1;
825 unsigned exponent : 11;
826 unsigned mantissa1 : 20;
827 unsigned mantissa2;
828 } little_endian;
829 struct {
830 unsigned mantissa2;
831 unsigned mantissa1 : 20;
832 unsigned exponent : 11;
833 unsigned sign : 1;
834 } big_endian;
835 } u;
6d716ca8 836
c05a9b68
RS		 837 u.d = dconstm1;
838 if (u.big_endian.sign == 1)
839 {
840 u.d = x;
841 return u.big_endian.sign;
842 }
843 else
844 {
845 u.d = x;
846 return u.little_endian.sign;
847 }
6d716ca8
RS		 848}
849#else /* Target not IEEE */
850
851/* Let's assume other float formats don't have infinity.
852 (This can be overridden by redefining REAL_VALUE_ISINF.) */
853
854target_isinf (x)
855 REAL_VALUE_TYPE x;
856{
857 return 0;
858}
859
7d4d4d22
RS		 860/* Let's assume other float formats don't have NaNs.
861 (This can be overridden by redefining REAL_VALUE_ISNAN.) */
862
863target_isnan (x)
864 REAL_VALUE_TYPE x;
865{
866 return 0;
867}
868
6d716ca8 869/* Let's assume other float formats don't have minus zero.
c05a9b68 870 (This can be overridden by redefining REAL_VALUE_NEGATIVE.) */
6d716ca8 871
c05a9b68 872target_negative (x)
6d716ca8
RS		 873 REAL_VALUE_TYPE x;
874{
c05a9b68 875 return x < 0;
6d716ca8
RS		 876}
877#endif /* Target not IEEE */
39647dcb
RK		 878
879/* Try to change R into its exact multiplicative inverse in machine mode
880 MODE. Return nonzero function value if successful. */
881
882int
883exact_real_inverse (mode, r)
884 enum machine_mode mode;
885 REAL_VALUE_TYPE *r;
886{
887 union
888 {
889 double d;
890 unsigned short i[4];
891 }x, t, y;
892 int i;
893
894 /* Usually disable if bounds checks are not reliable. */
895 if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT) && !flag_pretend_float)
896 return 0;
897
898 /* Set array index to the less significant bits in the unions, depending
899 on the endian-ness of the host doubles.
900 Disable if insufficient information on the data structure. */
901#if HOST_FLOAT_FORMAT == UNKNOWN_FLOAT_FORMAT
902 return 0;
903#else
904#if HOST_FLOAT_FORMAT == VAX_FLOAT_FORMAT
905#define K 2
906#else
907#if HOST_FLOAT_FORMAT == IBM_FLOAT_FORMAT
908#define K 2
909#else
910#define K (2 * HOST_FLOAT_WORDS_BIG_ENDIAN)
911#endif
912#endif
913#endif
914
915 if (setjmp (float_error))
916 {
917 /* Don't do the optimization if there was an arithmetic error. */
918fail:
919 set_float_handler (NULL_PTR);
920 return 0;
921 }
922 set_float_handler (float_error);
923
924 /* Domain check the argument. */
925 x.d = *r;
926 if (x.d == 0.0)
927 goto fail;
928
929#ifdef REAL_INFINITY
930 if (REAL_VALUE_ISINF (x.d) || REAL_VALUE_ISNAN (x.d))
931 goto fail;
932#endif
933
934 /* Compute the reciprocal and check for numerical exactness.
935 It is unnecessary to check all the significand bits to determine
936 whether X is a power of 2. If X is not, then it is impossible for
937 the bottom half significand of both X and 1/X to be all zero bits.
938 Hence we ignore the data structure of the top half and examine only
939 the low order bits of the two significands. */
940 t.d = 1.0 / x.d;
941 if (x.i[K] != 0 || x.i[K + 1] != 0 || t.i[K] != 0 || t.i[K + 1] != 0)
942 goto fail;
943
944 /* Truncate to the required mode and range-check the result. */
945 y.d = REAL_VALUE_TRUNCATE (mode, t.d);
946#ifdef CHECK_FLOAT_VALUE
947 i = 0;
948 if (CHECK_FLOAT_VALUE (mode, y.d, i))
949 goto fail;
950#endif
951
952 /* Fail if truncation changed the value. */
953 if (y.d != t.d || y.d == 0.0)
954 goto fail;
955
956#ifdef REAL_INFINITY
957 if (REAL_VALUE_ISINF (y.d) || REAL_VALUE_ISNAN (y.d))
958 goto fail;
959#endif
960
961 /* Output the reciprocal and return success flag. */
962 set_float_handler (NULL_PTR);
963 *r = y.d;
964 return 1;
965}
5008b8ae 966#endif /* no REAL_ARITHMETIC */
6d716ca8
RS		 967\f
968/* Split a tree IN into a constant and a variable part
969 that could be combined with CODE to make IN.
970 CODE must be a commutative arithmetic operation.
971 Store the constant part into *CONP and the variable in &VARP.
972 Return 1 if this was done; zero means the tree IN did not decompose
973 this way.
974
975 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.
976 Therefore, we must tell the caller whether the variable part
977 was subtracted. We do this by storing 1 or -1 into *VARSIGNP.
978 The value stored is the coefficient for the variable term.
979 The constant term we return should always be added;
980 we negate it if necessary. */
981
982static int
983split_tree (in, code, varp, conp, varsignp)
984 tree in;
985 enum tree_code code;
986 tree *varp, *conp;
987 int *varsignp;
988{
989 register tree outtype = TREE_TYPE (in);
990 *varp = 0;
991 *conp = 0;
992
993 /* Strip any conversions that don't change the machine mode. */
994 while ((TREE_CODE (in) == NOP_EXPR
995 || TREE_CODE (in) == CONVERT_EXPR)
996 && (TYPE_MODE (TREE_TYPE (in))
997 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (in, 0)))))
998 in = TREE_OPERAND (in, 0);
999
1000 if (TREE_CODE (in) == code
7178e3af 1001 || (! FLOAT_TYPE_P (TREE_TYPE (in))
6d716ca8
RS		 1002 /* We can associate addition and subtraction together
1003 (even though the C standard doesn't say so)
1004 for integers because the value is not affected.
1005 For reals, the value might be affected, so we can't. */
7178e3af
RK		 1006 && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
1007 || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
6d716ca8
RS		 1008 {
1009 enum tree_code code = TREE_CODE (TREE_OPERAND (in, 0));
1010 if (code == INTEGER_CST)
1011 {
1012 *conp = TREE_OPERAND (in, 0);
1013 *varp = TREE_OPERAND (in, 1);
1014 if (TYPE_MODE (TREE_TYPE (*varp)) != TYPE_MODE (outtype)
1015 && TREE_TYPE (*varp) != outtype)
1016 *varp = convert (outtype, *varp);
1017 *varsignp = (TREE_CODE (in) == MINUS_EXPR) ? -1 : 1;
1018 return 1;
1019 }
1020 if (TREE_CONSTANT (TREE_OPERAND (in, 1)))
1021 {
1022 *conp = TREE_OPERAND (in, 1);
1023 *varp = TREE_OPERAND (in, 0);
1024 *varsignp = 1;
1025 if (TYPE_MODE (TREE_TYPE (*varp)) != TYPE_MODE (outtype)
1026 && TREE_TYPE (*varp) != outtype)
1027 *varp = convert (outtype, *varp);
1028 if (TREE_CODE (in) == MINUS_EXPR)
1029 {
1030 /* If operation is subtraction and constant is second,
1031 must negate it to get an additive constant.
1032 And this cannot be done unless it is a manifest constant.
1033 It could also be the address of a static variable.
1034 We cannot negate that, so give up. */
1035 if (TREE_CODE (*conp) == INTEGER_CST)
1036 /* Subtracting from integer_zero_node loses for long long. */
1037 *conp = fold (build1 (NEGATE_EXPR, TREE_TYPE (*conp), *conp));
1038 else
1039 return 0;
1040 }
1041 return 1;
1042 }
1043 if (TREE_CONSTANT (TREE_OPERAND (in, 0)))
1044 {
1045 *conp = TREE_OPERAND (in, 0);
1046 *varp = TREE_OPERAND (in, 1);
1047 if (TYPE_MODE (TREE_TYPE (*varp)) != TYPE_MODE (outtype)
1048 && TREE_TYPE (*varp) != outtype)
1049 *varp = convert (outtype, *varp);
1050 *varsignp = (TREE_CODE (in) == MINUS_EXPR) ? -1 : 1;
1051 return 1;
1052 }
1053 }
1054 return 0;
1055}
1056\f
e9a25f70 1057/* Combine two integer constants ARG1 and ARG2 under operation CODE
6d716ca8 1058 to produce a new constant.
91d33e36 1059
e9a25f70
JL		 1060 If NOTRUNC is nonzero, do not truncate the result to fit the data type.
1061 If FORSIZE is nonzero, compute overflow for unsigned types. */
6d716ca8 1062
6d716ca8 1063static tree
e9a25f70 1064int_const_binop (code, arg1, arg2, notrunc, forsize)
6d716ca8
RS		 1065 enum tree_code code;
1066 register tree arg1, arg2;
e9a25f70 1067 int notrunc, forsize;
6d716ca8 1068{
e9a25f70
JL		 1069 HOST_WIDE_INT int1l, int1h, int2l, int2h;
1070 HOST_WIDE_INT low, hi;
1071 HOST_WIDE_INT garbagel, garbageh;
1072 register tree t;
1073 int uns = TREE_UNSIGNED (TREE_TYPE (arg1));
1074 int overflow = 0;
1075 int no_overflow = 0;
3dedc65a 1076
e9a25f70
JL		 1077 int1l = TREE_INT_CST_LOW (arg1);
1078 int1h = TREE_INT_CST_HIGH (arg1);
1079 int2l = TREE_INT_CST_LOW (arg2);
1080 int2h = TREE_INT_CST_HIGH (arg2);
1081
1082 switch (code)
6d716ca8 1083 {
e9a25f70
JL		 1084 case BIT_IOR_EXPR:
1085 low = int1l | int2l, hi = int1h | int2h;
1086 break;
6d716ca8 1087
e9a25f70
JL		 1088 case BIT_XOR_EXPR:
1089 low = int1l ^ int2l, hi = int1h ^ int2h;
1090 break;
6d716ca8 1091
e9a25f70
JL		 1092 case BIT_AND_EXPR:
1093 low = int1l & int2l, hi = int1h & int2h;
1094 break;
6d716ca8 1095
e9a25f70
JL		 1096 case BIT_ANDTC_EXPR:
1097 low = int1l & ~int2l, hi = int1h & ~int2h;
1098 break;
6d716ca8 1099
e9a25f70
JL		 1100 case RSHIFT_EXPR:
1101 int2l = - int2l;
1102 case LSHIFT_EXPR:
1103 /* It's unclear from the C standard whether shifts can overflow.
1104 The following code ignores overflow; perhaps a C standard
1105 interpretation ruling is needed. */
1106 lshift_double (int1l, int1h, int2l,
1107 TYPE_PRECISION (TREE_TYPE (arg1)),
1108 &low, &hi,
1109 !uns);
1110 no_overflow = 1;
1111 break;
6d716ca8 1112
e9a25f70
JL		 1113 case RROTATE_EXPR:
1114 int2l = - int2l;
1115 case LROTATE_EXPR:
1116 lrotate_double (int1l, int1h, int2l,
1117 TYPE_PRECISION (TREE_TYPE (arg1)),
1118 &low, &hi);
1119 break;
6d716ca8 1120
e9a25f70
JL		 1121 case PLUS_EXPR:
1122 overflow = add_double (int1l, int1h, int2l, int2h, &low, &hi);
1123 break;
6d716ca8 1124
e9a25f70
JL		 1125 case MINUS_EXPR:
1126 neg_double (int2l, int2h, &low, &hi);
1127 add_double (int1l, int1h, low, hi, &low, &hi);
1128 overflow = overflow_sum_sign (hi, int2h, int1h);
1129 break;
6d716ca8 1130
e9a25f70
JL		 1131 case MULT_EXPR:
1132 overflow = mul_double (int1l, int1h, int2l, int2h, &low, &hi);
1133 break;
6d716ca8 1134
e9a25f70
JL		 1135 case TRUNC_DIV_EXPR:
1136 case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
1137 case EXACT_DIV_EXPR:
1138 /* This is a shortcut for a common special case. */
1139 if (int2h == 0 && int2l > 0
1140 && ! TREE_CONSTANT_OVERFLOW (arg1)
1141 && ! TREE_CONSTANT_OVERFLOW (arg2)
1142 && int1h == 0 && int1l >= 0)
1143 {
1144 if (code == CEIL_DIV_EXPR)
1145 int1l += int2l - 1;
1146 low = int1l / int2l, hi = 0;
6d716ca8 1147 break;
e9a25f70 1148 }
6d716ca8 1149
e9a25f70 1150 /* ... fall through ... */
6d716ca8 1151
e9a25f70
JL		 1152 case ROUND_DIV_EXPR:
1153 if (int2h == 0 && int2l == 1)
1154 {
1155 low = int1l, hi = int1h;
6d716ca8 1156 break;
e9a25f70
JL		 1157 }
1158 if (int1l == int2l && int1h == int2h
1159 && ! (int1l == 0 && int1h == 0))
1160 {
1161 low = 1, hi = 0;
63e7fe9b 1162 break;
e9a25f70
JL		 1163 }
1164 overflow = div_and_round_double (code, uns,
1165 int1l, int1h, int2l, int2h,
1166 &low, &hi, &garbagel, &garbageh);
1167 break;
63e7fe9b 1168
e9a25f70
JL		 1169 case TRUNC_MOD_EXPR:
1170 case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
1171 /* This is a shortcut for a common special case. */
1172 if (int2h == 0 && int2l > 0
1173 && ! TREE_CONSTANT_OVERFLOW (arg1)
1174 && ! TREE_CONSTANT_OVERFLOW (arg2)
1175 && int1h == 0 && int1l >= 0)
1176 {
1177 if (code == CEIL_MOD_EXPR)
1178 int1l += int2l - 1;
1179 low = int1l % int2l, hi = 0;
63e7fe9b 1180 break;
e9a25f70 1181 }
63e7fe9b 1182
e9a25f70
JL		 1183 /* ... fall through ... */
1184
1185 case ROUND_MOD_EXPR:
1186 overflow = div_and_round_double (code, uns,
1187 int1l, int1h, int2l, int2h,
1188 &garbagel, &garbageh, &low, &hi);
1189 break;
1190
1191 case MIN_EXPR:
1192 case MAX_EXPR:
1193 if (uns)
1194 {
1195 low = (((unsigned HOST_WIDE_INT) int1h
1196 < (unsigned HOST_WIDE_INT) int2h)
1197 || (((unsigned HOST_WIDE_INT) int1h
1198 == (unsigned HOST_WIDE_INT) int2h)
1199 && ((unsigned HOST_WIDE_INT) int1l
1200 < (unsigned HOST_WIDE_INT) int2l)));
6d716ca8 1201 }
380ff34a
RK		 1202 else
1203 {
e9a25f70
JL		 1204 low = ((int1h < int2h)
1205 || ((int1h == int2h)
1206 && ((unsigned HOST_WIDE_INT) int1l
1207 < (unsigned HOST_WIDE_INT) int2l)));
380ff34a 1208 }
e9a25f70
JL		 1209 if (low == (code == MIN_EXPR))
1210 low = int1l, hi = int1h;
1211 else
1212 low = int2l, hi = int2h;
1213 break;
3dedc65a 1214
e9a25f70
JL		 1215 default:
1216 abort ();
3dedc65a 1217 }
e9a25f70
JL		 1218
1219 if (TREE_TYPE (arg1) == sizetype && hi == 0
e1ee5cdc
RH		 1220 && low >= 0
1221 && (TYPE_MAX_VALUE (sizetype) == NULL
1222 || low <= TREE_INT_CST_LOW (TYPE_MAX_VALUE (sizetype)))
e9a25f70
JL		 1223 && ! overflow
1224 && ! TREE_OVERFLOW (arg1) && ! TREE_OVERFLOW (arg2))
1225 t = size_int (low);
1226 else
1227 {
1228 t = build_int_2 (low, hi);
1229 TREE_TYPE (t) = TREE_TYPE (arg1);
1230 }
1231
1232 TREE_OVERFLOW (t)
1233 = ((notrunc ? (!uns || forsize) && overflow
1234 : force_fit_type (t, (!uns || forsize) && overflow) && ! no_overflow)
1235 | TREE_OVERFLOW (arg1)
1236 | TREE_OVERFLOW (arg2));
1237 /* If we're doing a size calculation, unsigned arithmetic does overflow.
1238 So check if force_fit_type truncated the value. */
1239 if (forsize
1240 && ! TREE_OVERFLOW (t)
1241 && (TREE_INT_CST_HIGH (t) != hi
1242 || TREE_INT_CST_LOW (t) != low))
1243 TREE_OVERFLOW (t) = 1;
1244 TREE_CONSTANT_OVERFLOW (t) = (TREE_OVERFLOW (t)
1245 | TREE_CONSTANT_OVERFLOW (arg1)
1246 | TREE_CONSTANT_OVERFLOW (arg2));
1247 return t;
1248}
1249
1250/* Combine two constants ARG1 and ARG2 under operation CODE
1251 to produce a new constant.
1252 We assume ARG1 and ARG2 have the same data type,
1253 or at least are the same kind of constant and the same machine mode.
1254
1255 If NOTRUNC is nonzero, do not truncate the result to fit the data type. */
1256
1257static tree
1258const_binop (code, arg1, arg2, notrunc)
1259 enum tree_code code;
1260 register tree arg1, arg2;
1261 int notrunc;
1262{
1263 STRIP_NOPS (arg1); STRIP_NOPS (arg2);
1264
1265 if (TREE_CODE (arg1) == INTEGER_CST)
1266 return int_const_binop (code, arg1, arg2, notrunc, 0);
1267
6d716ca8
RS		 1268#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1269 if (TREE_CODE (arg1) == REAL_CST)
1270 {
79c844cd
RK		 1271 REAL_VALUE_TYPE d1;
1272 REAL_VALUE_TYPE d2;
649ff3b4 1273 int overflow = 0;
5008b8ae 1274 REAL_VALUE_TYPE value;
7c7b029d 1275 tree t;
6d716ca8 1276
79c844cd
RK		 1277 d1 = TREE_REAL_CST (arg1);
1278 d2 = TREE_REAL_CST (arg2);
5f610074
RK		 1279
1280 /* If either operand is a NaN, just return it. Otherwise, set up
1281 for floating-point trap; we return an overflow. */
1282 if (REAL_VALUE_ISNAN (d1))
1283 return arg1;
1284 else if (REAL_VALUE_ISNAN (d2))
1285 return arg2;
1286 else if (setjmp (float_error))
6d716ca8 1287 {
649ff3b4
RK		 1288 t = copy_node (arg1);
1289 overflow = 1;
1290 goto got_float;
6d716ca8 1291 }
649ff3b4 1292
7c7b029d 1293 set_float_handler (float_error);
6d716ca8
RS		 1294
1295#ifdef REAL_ARITHMETIC
1296 REAL_ARITHMETIC (value, code, d1, d2);
1297#else
1298 switch (code)
1299 {
1300 case PLUS_EXPR:
1301 value = d1 + d2;
1302 break;
1303
1304 case MINUS_EXPR:
1305 value = d1 - d2;
1306 break;
1307
1308 case MULT_EXPR:
1309 value = d1 * d2;
1310 break;
1311
1312 case RDIV_EXPR:
1313#ifndef REAL_INFINITY
1314 if (d2 == 0)
1315 abort ();
1316#endif
1317
1318 value = d1 / d2;
1319 break;
1320
1321 case MIN_EXPR:
1322 value = MIN (d1, d2);
1323 break;
1324
1325 case MAX_EXPR:
1326 value = MAX (d1, d2);
1327 break;
1328
1329 default:
1330 abort ();
1331 }
1332#endif /* no REAL_ARITHMETIC */
7c7b029d 1333 t = build_real (TREE_TYPE (arg1),
5352b11a 1334 real_value_truncate (TYPE_MODE (TREE_TYPE (arg1)), value));
649ff3b4 1335 got_float:
906c4e36 1336 set_float_handler (NULL_PTR);
649ff3b4
RK		 1337
1338 TREE_OVERFLOW (t)
1339 = (force_fit_type (t, overflow)
1340 | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2));
1341 TREE_CONSTANT_OVERFLOW (t)
1342 = TREE_OVERFLOW (t)
1343 | TREE_CONSTANT_OVERFLOW (arg1)
1344 | TREE_CONSTANT_OVERFLOW (arg2);
7c7b029d 1345 return t;
6d716ca8
RS		 1346 }
1347#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1348 if (TREE_CODE (arg1) == COMPLEX_CST)
1349 {
214d5b84 1350 register tree type = TREE_TYPE (arg1);
6d716ca8
RS		 1351 register tree r1 = TREE_REALPART (arg1);
1352 register tree i1 = TREE_IMAGPART (arg1);
1353 register tree r2 = TREE_REALPART (arg2);
1354 register tree i2 = TREE_IMAGPART (arg2);
1355 register tree t;
1356
1357 switch (code)
1358 {
1359 case PLUS_EXPR:
214d5b84
RK		 1360 t = build_complex (type,
1361 const_binop (PLUS_EXPR, r1, r2, notrunc),
91d33e36 1362 const_binop (PLUS_EXPR, i1, i2, notrunc));
6d716ca8
RS		 1363 break;
1364
1365 case MINUS_EXPR:
214d5b84
RK		 1366 t = build_complex (type,
1367 const_binop (MINUS_EXPR, r1, r2, notrunc),
91d33e36 1368 const_binop (MINUS_EXPR, i1, i2, notrunc));
6d716ca8
RS		 1369 break;
1370
1371 case MULT_EXPR:
214d5b84
RK		 1372 t = build_complex (type,
1373 const_binop (MINUS_EXPR,
91d33e36
RS		 1374 const_binop (MULT_EXPR,
1375 r1, r2, notrunc),
1376 const_binop (MULT_EXPR,
1377 i1, i2, notrunc),
1378 notrunc),
6d716ca8 1379 const_binop (PLUS_EXPR,
91d33e36
RS		 1380 const_binop (MULT_EXPR,
1381 r1, i2, notrunc),
1382 const_binop (MULT_EXPR,
1383 i1, r2, notrunc),
1384 notrunc));
6d716ca8
RS		 1385 break;
1386
1387 case RDIV_EXPR:
1388 {
1389 register tree magsquared
1390 = const_binop (PLUS_EXPR,
91d33e36
RS		 1391 const_binop (MULT_EXPR, r2, r2, notrunc),
1392 const_binop (MULT_EXPR, i2, i2, notrunc),
1393 notrunc);
58633be8 1394
214d5b84
RK		 1395 t = build_complex (type,
1396 const_binop
1397 (INTEGRAL_TYPE_P (TREE_TYPE (r1))
1398 ? TRUNC_DIV_EXPR : RDIV_EXPR,
1399 const_binop (PLUS_EXPR,
1400 const_binop (MULT_EXPR, r1, r2,
1401 notrunc),
1402 const_binop (MULT_EXPR, i1, i2,
1403 notrunc),
1404 notrunc),
1405 magsquared, notrunc),
1406 const_binop
1407 (INTEGRAL_TYPE_P (TREE_TYPE (r1))
1408 ? TRUNC_DIV_EXPR : RDIV_EXPR,
1409 const_binop (MINUS_EXPR,
1410 const_binop (MULT_EXPR, i1, r2,
1411 notrunc),
1412 const_binop (MULT_EXPR, r1, i2,
1413 notrunc),
1414 notrunc),
1415 magsquared, notrunc));
6d716ca8
RS		 1416 }
1417 break;
1418
1419 default:
1420 abort ();
1421 }
6d716ca8
RS		 1422 return t;
1423 }
1424 return 0;
1425}
1426\f
f8dac6eb
R		 1427/* Return an INTEGER_CST with value V . The type is determined by bit_p:
1428 if it is zero, the type is taken from sizetype; if it is one, the type
1429 is taken from bitsizetype. */
6d716ca8
RS		 1430
1431tree
f8dac6eb
R		 1432size_int_wide (number, high, bit_p)
1433 unsigned HOST_WIDE_INT number, high;
2fde567e 1434 int bit_p;
6d716ca8
RS		 1435{
1436 register tree t;
1437 /* Type-size nodes already made for small sizes. */
f8dac6eb 1438 static tree size_table[2*HOST_BITS_PER_WIDE_INT + 1][2];
6d716ca8 1439
f8dac6eb
R		 1440 if (number < 2*HOST_BITS_PER_WIDE_INT + 1 && ! high
1441 && size_table[number][bit_p] != 0)
1442 return size_table[number][bit_p];
1443 if (number < 2*HOST_BITS_PER_WIDE_INT + 1 && ! high)
6d716ca8 1444 {
6d716ca8
RS		 1445 push_obstacks_nochange ();
1446 /* Make this a permanent node. */
c05a9b68 1447 end_temporary_allocation ();
6d716ca8 1448 t = build_int_2 (number, 0);
896cced4 1449 TREE_TYPE (t) = bit_p ? bitsizetype : sizetype;
f8dac6eb 1450 size_table[number][bit_p] = t;
6d716ca8
RS		 1451 pop_obstacks ();
1452 }
1453 else
1454 {
f8dac6eb 1455 t = build_int_2 (number, high);
896cced4 1456 TREE_TYPE (t) = bit_p ? bitsizetype : sizetype;
380ff34a 1457 TREE_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (t) = force_fit_type (t, 0);
6d716ca8
RS		 1458 }
1459 return t;
1460}
1461
1462/* Combine operands OP1 and OP2 with arithmetic operation CODE.
1463 CODE is a tree code. Data type is taken from `sizetype',
1464 If the operands are constant, so is the result. */
1465
1466tree
1467size_binop (code, arg0, arg1)
1468 enum tree_code code;
1469 tree arg0, arg1;
1470{
1471 /* Handle the special case of two integer constants faster. */
1472 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1473 {
1474 /* And some specific cases even faster than that. */
9898deac 1475 if (code == PLUS_EXPR && integer_zerop (arg0))
6d716ca8 1476 return arg1;
9898deac
RK		 1477 else if ((code == MINUS_EXPR || code == PLUS_EXPR)
1478 && integer_zerop (arg1))
6d716ca8 1479 return arg0;
9898deac 1480 else if (code == MULT_EXPR && integer_onep (arg0))
6d716ca8 1481 return arg1;
9898deac 1482
6d716ca8 1483 /* Handle general case of two integer constants. */
e9a25f70 1484 return int_const_binop (code, arg0, arg1, 0, 1);
6d716ca8
RS		 1485 }
1486
1487 if (arg0 == error_mark_node || arg1 == error_mark_node)
1488 return error_mark_node;
1489
1490 return fold (build (code, sizetype, arg0, arg1));
1491}
697073d9
JM		 1492
1493/* Combine operands OP1 and OP2 with arithmetic operation CODE.
1494 CODE is a tree code. Data type is taken from `ssizetype',
1495 If the operands are constant, so is the result. */
1496
1497tree
1498ssize_binop (code, arg0, arg1)
1499 enum tree_code code;
1500 tree arg0, arg1;
1501{
1502 /* Handle the special case of two integer constants faster. */
1503 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1504 {
1505 /* And some specific cases even faster than that. */
1506 if (code == PLUS_EXPR && integer_zerop (arg0))
1507 return arg1;
1508 else if ((code == MINUS_EXPR || code == PLUS_EXPR)
1509 && integer_zerop (arg1))
1510 return arg0;
1511 else if (code == MULT_EXPR && integer_onep (arg0))
1512 return arg1;
1513
1514 /* Handle general case of two integer constants. We convert
1515 arg0 to ssizetype because int_const_binop uses its type for the
1516 return value. */
1517 arg0 = convert (ssizetype, arg0);
1518 return int_const_binop (code, arg0, arg1, 0, 0);
1519 }
1520
1521 if (arg0 == error_mark_node || arg1 == error_mark_node)
1522 return error_mark_node;
1523
1524 return fold (build (code, ssizetype, arg0, arg1));
1525}
6d716ca8
RS		 1526\f
1527/* Given T, a tree representing type conversion of ARG1, a constant,
1528 return a constant tree representing the result of conversion. */
1529
1530static tree
1531fold_convert (t, arg1)
1532 register tree t;
1533 register tree arg1;
1534{
1535 register tree type = TREE_TYPE (t);
649ff3b4 1536 int overflow = 0;
6d716ca8 1537
e5e809f4 1538 if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type))
6d716ca8
RS		 1539 {
1540 if (TREE_CODE (arg1) == INTEGER_CST)
1541 {
e3374525
RK		 1542 /* If we would build a constant wider than GCC supports,
1543 leave the conversion unfolded. */
1544 if (TYPE_PRECISION (type) > 2 * HOST_BITS_PER_WIDE_INT)
1545 return t;
1546
6d716ca8
RS		 1547 /* Given an integer constant, make new constant with new type,
1548 appropriately sign-extended or truncated. */
1549 t = build_int_2 (TREE_INT_CST_LOW (arg1),
1550 TREE_INT_CST_HIGH (arg1));
1551 TREE_TYPE (t) = type;
e0f776fb 1552 /* Indicate an overflow if (1) ARG1 already overflowed,
dc3907c5
PE		 1553 or (2) force_fit_type indicates an overflow.
1554 Tell force_fit_type that an overflow has already occurred
b472527b
JL		 1555 if ARG1 is a too-large unsigned value and T is signed.
1556 But don't indicate an overflow if converting a pointer. */
dc3907c5 1557 TREE_OVERFLOW (t)
e5e809f4
JL		 1558 = ((force_fit_type (t,
1559 (TREE_INT_CST_HIGH (arg1) < 0
4f242db3 1560 && (TREE_UNSIGNED (type)
e5e809f4
JL		 1561 < TREE_UNSIGNED (TREE_TYPE (arg1)))))
1562 && ! POINTER_TYPE_P (TREE_TYPE (arg1)))
1563 || TREE_OVERFLOW (arg1));
dc3907c5
PE		 1564 TREE_CONSTANT_OVERFLOW (t)
1565 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
6d716ca8
RS		 1566 }
1567#if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1568 else if (TREE_CODE (arg1) == REAL_CST)
1569 {
4b8a0062
RK		 1570 /* Don't initialize these, use assignments.
1571 Initialized local aggregates don't work on old compilers. */
1572 REAL_VALUE_TYPE x;
1573 REAL_VALUE_TYPE l;
1574 REAL_VALUE_TYPE u;
7cb6a121 1575 tree type1 = TREE_TYPE (arg1);
e1ee5cdc 1576 int no_upper_bound;
4b8a0062
RK		 1577
1578 x = TREE_REAL_CST (arg1);
7cb6a121 1579 l = real_value_from_int_cst (type1, TYPE_MIN_VALUE (type));
e1ee5cdc
RH		 1580
1581 no_upper_bound = (TYPE_MAX_VALUE (type) == NULL);
1582 if (!no_upper_bound)
1583 u = real_value_from_int_cst (type1, TYPE_MAX_VALUE (type));
1584
4b3d5ea0
RS		 1585 /* See if X will be in range after truncation towards 0.
1586 To compensate for truncation, move the bounds away from 0,
1587 but reject if X exactly equals the adjusted bounds. */
1588#ifdef REAL_ARITHMETIC
1589 REAL_ARITHMETIC (l, MINUS_EXPR, l, dconst1);
e1ee5cdc
RH		 1590 if (!no_upper_bound)
1591 REAL_ARITHMETIC (u, PLUS_EXPR, u, dconst1);
4b3d5ea0
RS		 1592#else
1593 l--;
e1ee5cdc
RH		 1594 if (!no_upper_bound)
1595 u++;
4b3d5ea0 1596#endif
5f610074
RK		 1597 /* If X is a NaN, use zero instead and show we have an overflow.
1598 Otherwise, range check. */
1599 if (REAL_VALUE_ISNAN (x))
1600 overflow = 1, x = dconst0;
e1ee5cdc
RH		 1601 else if (! (REAL_VALUES_LESS (l, x)
1602 && !no_upper_bound
1603 && REAL_VALUES_LESS (x, u)))
649ff3b4
RK		 1604 overflow = 1;
1605
6d716ca8
RS		 1606#ifndef REAL_ARITHMETIC
1607 {
906c4e36
RK		 1608 HOST_WIDE_INT low, high;
1609 HOST_WIDE_INT half_word
1610 = (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2);
6d716ca8 1611
5f610074
RK		 1612 if (x < 0)
1613 x = -x;
6d716ca8 1614
5f610074
RK		 1615 high = (HOST_WIDE_INT) (x / half_word / half_word);
1616 x -= (REAL_VALUE_TYPE) high * half_word * half_word;
1617 if (x >= (REAL_VALUE_TYPE) half_word * half_word / 2)
b6b19f41 1618 {
5f610074 1619 low = x - (REAL_VALUE_TYPE) half_word * half_word / 2;
e0f776fb 1620 low |= (HOST_WIDE_INT) -1 << (HOST_BITS_PER_WIDE_INT - 1);
b6b19f41
RS		 1621 }
1622 else
5f610074 1623 low = (HOST_WIDE_INT) x;
6d716ca8
RS		 1624 if (TREE_REAL_CST (arg1) < 0)
1625 neg_double (low, high, &low, &high);
1626 t = build_int_2 (low, high);
1627 }
1628#else
1629 {
906c4e36 1630 HOST_WIDE_INT low, high;
5f610074 1631 REAL_VALUE_TO_INT (&low, &high, x);
6d716ca8
RS		 1632 t = build_int_2 (low, high);
1633 }
1634#endif
1635 TREE_TYPE (t) = type;
649ff3b4
RK		 1636 TREE_OVERFLOW (t)
1637 = TREE_OVERFLOW (arg1) | force_fit_type (t, overflow);
1638 TREE_CONSTANT_OVERFLOW (t)
1639 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
6d716ca8
RS		 1640 }
1641#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1642 TREE_TYPE (t) = type;
1643 }
1644 else if (TREE_CODE (type) == REAL_TYPE)
1645 {
1646#if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1647 if (TREE_CODE (arg1) == INTEGER_CST)
1648 return build_real_from_int_cst (type, arg1);
1649#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1650 if (TREE_CODE (arg1) == REAL_CST)
7c7b029d 1651 {
5f610074 1652 if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
a377ff85
RK		 1653 {
1654 t = arg1;
1655 TREE_TYPE (arg1) = type;
1656 return t;
1657 }
5f610074 1658 else if (setjmp (float_error))
7c7b029d 1659 {
649ff3b4
RK		 1660 overflow = 1;
1661 t = copy_node (arg1);
1662 goto got_it;
7c7b029d
RS		 1663 }
1664 set_float_handler (float_error);
1665
5352b11a 1666 t = build_real (type, real_value_truncate (TYPE_MODE (type),
7c7b029d 1667 TREE_REAL_CST (arg1)));
906c4e36 1668 set_float_handler (NULL_PTR);
649ff3b4
RK		 1669
1670 got_it:
1671 TREE_OVERFLOW (t)
1672 = TREE_OVERFLOW (arg1) | force_fit_type (t, overflow);
1673 TREE_CONSTANT_OVERFLOW (t)
1674 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
7c7b029d
RS		 1675 return t;
1676 }
6d716ca8
RS		 1677 }
1678 TREE_CONSTANT (t) = 1;
1679 return t;
1680}
1681\f
d023bff9
RS		 1682/* Return an expr equal to X but certainly not valid as an lvalue.
1683 Also make sure it is not valid as an null pointer constant. */
6d716ca8
RS		 1684
1685tree
1686non_lvalue (x)
1687 tree x;
1688{
1689 tree result;
1690
1691 /* These things are certainly not lvalues. */
1692 if (TREE_CODE (x) == NON_LVALUE_EXPR
1693 || TREE_CODE (x) == INTEGER_CST
1694 || TREE_CODE (x) == REAL_CST
1695 || TREE_CODE (x) == STRING_CST
1696 || TREE_CODE (x) == ADDR_EXPR)
d023bff9
RS		 1697 {
1698 if (TREE_CODE (x) == INTEGER_CST && integer_zerop (x))
1699 {
b1aa345d
RS		 1700 /* Use NOP_EXPR instead of NON_LVALUE_EXPR
1701 so convert_for_assignment won't strip it.
1702 This is so this 0 won't be treated as a null pointer constant. */
d023bff9
RS		 1703 result = build1 (NOP_EXPR, TREE_TYPE (x), x);
1704 TREE_CONSTANT (result) = TREE_CONSTANT (x);
1705 return result;
1706 }
1707 return x;
1708 }
6d716ca8
RS		 1709
1710 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
1711 TREE_CONSTANT (result) = TREE_CONSTANT (x);
1712 return result;
1713}
a5e9b124 1714
e9866da3
JM		 1715/* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
1716 Zero means allow extended lvalues. */
1717
1718int pedantic_lvalues;
1719
a5e9b124
JW		 1720/* When pedantic, return an expr equal to X but certainly not valid as a
1721 pedantic lvalue. Otherwise, return X. */
1722
1723tree
1724pedantic_non_lvalue (x)
1725 tree x;
1726{
e9866da3 1727 if (pedantic_lvalues)
a5e9b124
JW		 1728 return non_lvalue (x);
1729 else
1730 return x;
1731}
c05a9b68
RS		 1732\f
1733/* Given a tree comparison code, return the code that is the logical inverse
1734 of the given code. It is not safe to do this for floating-point
1735 comparisons, except for NE_EXPR and EQ_EXPR. */
6d716ca8 1736
c05a9b68
RS		 1737static enum tree_code
1738invert_tree_comparison (code)
1739 enum tree_code code;
1740{
1741 switch (code)
1742 {
1743 case EQ_EXPR:
1744 return NE_EXPR;
1745 case NE_EXPR:
1746 return EQ_EXPR;
1747 case GT_EXPR:
1748 return LE_EXPR;
1749 case GE_EXPR:
1750 return LT_EXPR;
1751 case LT_EXPR:
1752 return GE_EXPR;
1753 case LE_EXPR:
1754 return GT_EXPR;
1755 default:
1756 abort ();
1757 }
1758}
1759
1760/* Similar, but return the comparison that results if the operands are
1761 swapped. This is safe for floating-point. */
1762
1763static enum tree_code
1764swap_tree_comparison (code)
1765 enum tree_code code;
1766{
1767 switch (code)
1768 {
1769 case EQ_EXPR:
1770 case NE_EXPR:
1771 return code;
1772 case GT_EXPR:
1773 return LT_EXPR;
1774 case GE_EXPR:
1775 return LE_EXPR;
1776 case LT_EXPR:
1777 return GT_EXPR;
1778 case LE_EXPR:
1779 return GE_EXPR;
1780 default:
1781 abort ();
1782 }
1783}
61f275ff
RK		 1784
1785/* Return nonzero if CODE is a tree code that represents a truth value. */
1786
1787static int
1788truth_value_p (code)
1789 enum tree_code code;
1790{
1791 return (TREE_CODE_CLASS (code) == '<'
1792 || code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
1793 || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
1794 || code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
1795}
c05a9b68 1796\f
6a1746af
RS		 1797/* Return nonzero if two operands are necessarily equal.
1798 If ONLY_CONST is non-zero, only return non-zero for constants.
1799 This function tests whether the operands are indistinguishable;
1800 it does not test whether they are equal using C's == operation.
1801 The distinction is important for IEEE floating point, because
1802 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
1803 (2) two NaNs may be indistinguishable, but NaN!=NaN. */
6d716ca8
RS		 1804
1805int
1806operand_equal_p (arg0, arg1, only_const)
1807 tree arg0, arg1;
1808 int only_const;
1809{
1810 /* If both types don't have the same signedness, then we can't consider
1811 them equal. We must check this before the STRIP_NOPS calls
1812 because they may change the signedness of the arguments. */
1813 if (TREE_UNSIGNED (TREE_TYPE (arg0)) != TREE_UNSIGNED (TREE_TYPE (arg1)))
1814 return 0;
1815
1816 STRIP_NOPS (arg0);
1817 STRIP_NOPS (arg1);
1818
c7cfe938
RK		 1819 if (TREE_CODE (arg0) != TREE_CODE (arg1)
1820 /* This is needed for conversions and for COMPONENT_REF.
1821 Might as well play it safe and always test this. */
1822 || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
6d716ca8
RS		 1823 return 0;
1824
c7cfe938
RK		 1825 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
1826 We don't care about side effects in that case because the SAVE_EXPR
1827 takes care of that for us. In all other cases, two expressions are
1828 equal if they have no side effects. If we have two identical
1829 expressions with side effects that should be treated the same due
1830 to the only side effects being identical SAVE_EXPR's, that will
1831 be detected in the recursive calls below. */
1832 if (arg0 == arg1 && ! only_const
1833 && (TREE_CODE (arg0) == SAVE_EXPR
1834 || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
6d716ca8
RS		 1835 return 1;
1836
c7cfe938
RK		 1837 /* Next handle constant cases, those for which we can return 1 even
1838 if ONLY_CONST is set. */
1839 if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
1840 switch (TREE_CODE (arg0))
1841 {
1842 case INTEGER_CST:
3c9b0091
RK		 1843 return (! TREE_CONSTANT_OVERFLOW (arg0)
1844 && ! TREE_CONSTANT_OVERFLOW (arg1)
1845 && TREE_INT_CST_LOW (arg0) == TREE_INT_CST_LOW (arg1)
c7cfe938
RK		 1846 && TREE_INT_CST_HIGH (arg0) == TREE_INT_CST_HIGH (arg1));
1847
1848 case REAL_CST:
3c9b0091
RK		 1849 return (! TREE_CONSTANT_OVERFLOW (arg0)
1850 && ! TREE_CONSTANT_OVERFLOW (arg1)
41c9120b
PE		 1851 && REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
1852 TREE_REAL_CST (arg1)));
c7cfe938
RK		 1853
1854 case COMPLEX_CST:
1855 return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
1856 only_const)
1857 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
1858 only_const));
1859
1860 case STRING_CST:
1861 return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
1862 && ! strncmp (TREE_STRING_POINTER (arg0),
1863 TREE_STRING_POINTER (arg1),
1864 TREE_STRING_LENGTH (arg0)));
1865
1866 case ADDR_EXPR:
1867 return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
1868 0);
e9a25f70
JL		 1869 default:
1870 break;
c7cfe938 1871 }
6d716ca8
RS		 1872
1873 if (only_const)
1874 return 0;
1875
6d716ca8
RS		 1876 switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
1877 {
1878 case '1':
1879 /* Two conversions are equal only if signedness and modes match. */
1880 if ((TREE_CODE (arg0) == NOP_EXPR || TREE_CODE (arg0) == CONVERT_EXPR)
1881 && (TREE_UNSIGNED (TREE_TYPE (arg0))
1882 != TREE_UNSIGNED (TREE_TYPE (arg1))))
1883 return 0;
1884
1885 return operand_equal_p (TREE_OPERAND (arg0, 0),
1886 TREE_OPERAND (arg1, 0), 0);
1887
1888 case '<':
1889 case '2':
c7cfe938
RK		 1890 if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0)
1891 && operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1),
1892 0))
1893 return 1;
1894
1895 /* For commutative ops, allow the other order. */
1896 return ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MULT_EXPR
1897 || TREE_CODE (arg0) == MIN_EXPR || TREE_CODE (arg0) == MAX_EXPR
1898 || TREE_CODE (arg0) == BIT_IOR_EXPR
1899 || TREE_CODE (arg0) == BIT_XOR_EXPR
1900 || TREE_CODE (arg0) == BIT_AND_EXPR
1901 || TREE_CODE (arg0) == NE_EXPR || TREE_CODE (arg0) == EQ_EXPR)
1902 && operand_equal_p (TREE_OPERAND (arg0, 0),
1903 TREE_OPERAND (arg1, 1), 0)
6d716ca8 1904 && operand_equal_p (TREE_OPERAND (arg0, 1),
c7cfe938 1905 TREE_OPERAND (arg1, 0), 0));
6d716ca8
RS		 1906
1907 case 'r':
1908 switch (TREE_CODE (arg0))
1909 {
1910 case INDIRECT_REF:
1911 return operand_equal_p (TREE_OPERAND (arg0, 0),
1912 TREE_OPERAND (arg1, 0), 0);
1913
1914 case COMPONENT_REF:
1915 case ARRAY_REF:
1916 return (operand_equal_p (TREE_OPERAND (arg0, 0),
1917 TREE_OPERAND (arg1, 0), 0)
1918 && operand_equal_p (TREE_OPERAND (arg0, 1),
1919 TREE_OPERAND (arg1, 1), 0));
1920
1921 case BIT_FIELD_REF:
1922 return (operand_equal_p (TREE_OPERAND (arg0, 0),
1923 TREE_OPERAND (arg1, 0), 0)
1924 && operand_equal_p (TREE_OPERAND (arg0, 1),
1925 TREE_OPERAND (arg1, 1), 0)
1926 && operand_equal_p (TREE_OPERAND (arg0, 2),
1927 TREE_OPERAND (arg1, 2), 0));
e9a25f70
JL		 1928 default:
1929 return 0;
6d716ca8 1930 }
e9a25f70
JL		 1931
1932 default:
1933 return 0;
6d716ca8 1934 }
6d716ca8 1935}
c05a9b68
RS		 1936\f
1937/* Similar to operand_equal_p, but see if ARG0 might have been made by
1938 shorten_compare from ARG1 when ARG1 was being compared with OTHER.
6d716ca8 1939
6d716ca8
RS		 1940 When in doubt, return 0. */
1941
1942static int
c05a9b68
RS		 1943operand_equal_for_comparison_p (arg0, arg1, other)
1944 tree arg0, arg1;
1945 tree other;
6d716ca8 1946{
c05a9b68 1947 int unsignedp1, unsignedpo;
52de9b6c 1948 tree primarg0, primarg1, primother;
7a75868d 1949 unsigned correct_width;
6d716ca8 1950
c05a9b68 1951 if (operand_equal_p (arg0, arg1, 0))
6d716ca8
RS		 1952 return 1;
1953
0982a4b8
JM		 1954 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
1955 || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
6d716ca8
RS		 1956 return 0;
1957
52de9b6c
RK		 1958 /* Discard any conversions that don't change the modes of ARG0 and ARG1
1959 and see if the inner values are the same. This removes any
1960 signedness comparison, which doesn't matter here. */
1961 primarg0 = arg0, primarg1 = arg1;
1962 STRIP_NOPS (primarg0); STRIP_NOPS (primarg1);
1963 if (operand_equal_p (primarg0, primarg1, 0))
1964 return 1;
1965
c05a9b68
RS		 1966 /* Duplicate what shorten_compare does to ARG1 and see if that gives the
1967 actual comparison operand, ARG0.
6d716ca8 1968
c05a9b68 1969 First throw away any conversions to wider types
6d716ca8 1970 already present in the operands. */
6d716ca8 1971
c05a9b68
RS		 1972 primarg1 = get_narrower (arg1, &unsignedp1);
1973 primother = get_narrower (other, &unsignedpo);
1974
1975 correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
1976 if (unsignedp1 == unsignedpo
1977 && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
1978 && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
6d716ca8 1979 {
c05a9b68 1980 tree type = TREE_TYPE (arg0);
6d716ca8
RS		 1981
1982 /* Make sure shorter operand is extended the right way
1983 to match the longer operand. */
c05a9b68
RS		 1984 primarg1 = convert (signed_or_unsigned_type (unsignedp1,
1985 TREE_TYPE (primarg1)),
1986 primarg1);
6d716ca8 1987
c05a9b68 1988 if (operand_equal_p (arg0, convert (type, primarg1), 0))
6d716ca8
RS		 1989 return 1;
1990 }
1991
1992 return 0;
1993}
1994\f
f72aed24 1995/* See if ARG is an expression that is either a comparison or is performing
c05a9b68
RS		 1996 arithmetic on comparisons. The comparisons must only be comparing
1997 two different values, which will be stored in *CVAL1 and *CVAL2; if
1998 they are non-zero it means that some operands have already been found.
1999 No variables may be used anywhere else in the expression except in the
35e66bd1
RK		 2000 comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
2001 the expression and save_expr needs to be called with CVAL1 and CVAL2.
c05a9b68
RS		 2002
2003 If this is true, return 1. Otherwise, return zero. */
2004
2005static int
35e66bd1 2006twoval_comparison_p (arg, cval1, cval2, save_p)
c05a9b68
RS		 2007 tree arg;
2008 tree *cval1, *cval2;
35e66bd1 2009 int *save_p;
c05a9b68
RS		 2010{
2011 enum tree_code code = TREE_CODE (arg);
2012 char class = TREE_CODE_CLASS (code);
2013
2014 /* We can handle some of the 'e' cases here. */
35e66bd1 2015 if (class == 'e' && code == TRUTH_NOT_EXPR)
c05a9b68
RS		 2016 class = '1';
2017 else if (class == 'e'
2018 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
2019 || code == COMPOUND_EXPR))
2020 class = '2';
2315a5db
RS		 2021
2022 /* ??? Disable this since the SAVE_EXPR might already be in use outside
2023 the expression. There may be no way to make this work, but it needs
2024 to be looked at again for 2.6. */
2025#if 0
35e66bd1
RK		 2026 else if (class == 'e' && code == SAVE_EXPR && SAVE_EXPR_RTL (arg) == 0)
2027 {
2028 /* If we've already found a CVAL1 or CVAL2, this expression is
2029 two complex to handle. */
2030 if (*cval1 || *cval2)
2031 return 0;
2032
2033 class = '1';
2034 *save_p = 1;
2035 }
2315a5db 2036#endif
c05a9b68
RS		 2037
2038 switch (class)
2039 {
2040 case '1':
35e66bd1 2041 return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
c05a9b68
RS		 2042
2043 case '2':
35e66bd1
RK		 2044 return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
2045 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2046 cval1, cval2, save_p));
c05a9b68
RS		 2047
2048 case 'c':
2049 return 1;
2050
2051 case 'e':
2052 if (code == COND_EXPR)
35e66bd1
RK		 2053 return (twoval_comparison_p (TREE_OPERAND (arg, 0),
2054 cval1, cval2, save_p)
2055 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2056 cval1, cval2, save_p)
c05a9b68 2057 && twoval_comparison_p (TREE_OPERAND (arg, 2),
35e66bd1 2058 cval1, cval2, save_p));
c05a9b68
RS		 2059 return 0;
2060
2061 case '<':
2062 /* First see if we can handle the first operand, then the second. For
2063 the second operand, we know *CVAL1 can't be zero. It must be that
2064 one side of the comparison is each of the values; test for the
2065 case where this isn't true by failing if the two operands
2066 are the same. */
2067
2068 if (operand_equal_p (TREE_OPERAND (arg, 0),
2069 TREE_OPERAND (arg, 1), 0))
2070 return 0;
2071
2072 if (*cval1 == 0)
2073 *cval1 = TREE_OPERAND (arg, 0);
2074 else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
2075 ;
2076 else if (*cval2 == 0)
2077 *cval2 = TREE_OPERAND (arg, 0);
2078 else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
2079 ;
2080 else
2081 return 0;
2082
2083 if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
2084 ;
2085 else if (*cval2 == 0)
2086 *cval2 = TREE_OPERAND (arg, 1);
2087 else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
2088 ;
2089 else
2090 return 0;
2091
2092 return 1;
c05a9b68 2093
e9a25f70
JL		 2094 default:
2095 return 0;
2096 }
c05a9b68
RS		 2097}
2098\f
2099/* ARG is a tree that is known to contain just arithmetic operations and
2100 comparisons. Evaluate the operations in the tree substituting NEW0 for
f72aed24 2101 any occurrence of OLD0 as an operand of a comparison and likewise for
c05a9b68
RS		 2102 NEW1 and OLD1. */
2103
2104static tree
2105eval_subst (arg, old0, new0, old1, new1)
2106 tree arg;
2107 tree old0, new0, old1, new1;
2108{
2109 tree type = TREE_TYPE (arg);
2110 enum tree_code code = TREE_CODE (arg);
2111 char class = TREE_CODE_CLASS (code);
2112
2113 /* We can handle some of the 'e' cases here. */
2114 if (class == 'e' && code == TRUTH_NOT_EXPR)
2115 class = '1';
2116 else if (class == 'e'
2117 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2118 class = '2';
2119
2120 switch (class)
2121 {
2122 case '1':
2123 return fold (build1 (code, type,
2124 eval_subst (TREE_OPERAND (arg, 0),
2125 old0, new0, old1, new1)));
2126
2127 case '2':
2128 return fold (build (code, type,
2129 eval_subst (TREE_OPERAND (arg, 0),
2130 old0, new0, old1, new1),
2131 eval_subst (TREE_OPERAND (arg, 1),
2132 old0, new0, old1, new1)));
2133
2134 case 'e':
2135 switch (code)
2136 {
2137 case SAVE_EXPR:
2138 return eval_subst (TREE_OPERAND (arg, 0), old0, new0, old1, new1);
2139
2140 case COMPOUND_EXPR:
2141 return eval_subst (TREE_OPERAND (arg, 1), old0, new0, old1, new1);
2142
2143 case COND_EXPR:
2144 return fold (build (code, type,
2145 eval_subst (TREE_OPERAND (arg, 0),
2146 old0, new0, old1, new1),
2147 eval_subst (TREE_OPERAND (arg, 1),
2148 old0, new0, old1, new1),
2149 eval_subst (TREE_OPERAND (arg, 2),
2150 old0, new0, old1, new1)));
e9a25f70
JL		 2151 default:
2152 break;
c05a9b68 2153 }
e9a25f70 2154 /* fall through (???) */
c05a9b68
RS		 2155
2156 case '<':
2157 {
2158 tree arg0 = TREE_OPERAND (arg, 0);
2159 tree arg1 = TREE_OPERAND (arg, 1);
2160
2161 /* We need to check both for exact equality and tree equality. The
2162 former will be true if the operand has a side-effect. In that
2163 case, we know the operand occurred exactly once. */
2164
2165 if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
2166 arg0 = new0;
2167 else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
2168 arg0 = new1;
2169
2170 if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
2171 arg1 = new0;
2172 else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
2173 arg1 = new1;
2174
2175 return fold (build (code, type, arg0, arg1));
2176 }
c05a9b68 2177
e9a25f70
JL		 2178 default:
2179 return arg;
2180 }
c05a9b68
RS		 2181}
2182\f
6d716ca8
RS		 2183/* Return a tree for the case when the result of an expression is RESULT
2184 converted to TYPE and OMITTED was previously an operand of the expression
2185 but is now not needed (e.g., we folded OMITTED * 0).
2186
2187 If OMITTED has side effects, we must evaluate it. Otherwise, just do
2188 the conversion of RESULT to TYPE. */
2189
2190static tree
2191omit_one_operand (type, result, omitted)
2192 tree type, result, omitted;
2193{
2194 tree t = convert (type, result);
2195
2196 if (TREE_SIDE_EFFECTS (omitted))
2197 return build (COMPOUND_EXPR, type, omitted, t);
2198
d023bff9 2199 return non_lvalue (t);
6d716ca8 2200}
4ab3cb65
RK		 2201
2202/* Similar, but call pedantic_non_lvalue instead of non_lvalue. */
2203
2204static tree
2205pedantic_omit_one_operand (type, result, omitted)
2206 tree type, result, omitted;
2207{
2208 tree t = convert (type, result);
2209
2210 if (TREE_SIDE_EFFECTS (omitted))
2211 return build (COMPOUND_EXPR, type, omitted, t);
2212
2213 return pedantic_non_lvalue (t);
2214}
2215
2216
6d716ca8 2217\f
3f783329
RS		 2218/* Return a simplified tree node for the truth-negation of ARG. This
2219 never alters ARG itself. We assume that ARG is an operation that
6d716ca8
RS		 2220 returns a truth value (0 or 1). */
2221
2222tree
2223invert_truthvalue (arg)
2224 tree arg;
2225{
2226 tree type = TREE_TYPE (arg);
c05a9b68 2227 enum tree_code code = TREE_CODE (arg);
6d716ca8 2228
8ac1abdf
JW		 2229 if (code == ERROR_MARK)
2230 return arg;
2231
c05a9b68
RS		 2232 /* If this is a comparison, we can simply invert it, except for
2233 floating-point non-equality comparisons, in which case we just
2234 enclose a TRUTH_NOT_EXPR around what we have. */
6d716ca8 2235
c05a9b68 2236 if (TREE_CODE_CLASS (code) == '<')
6d716ca8 2237 {
7178e3af 2238 if (FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg, 0)))
c05a9b68
RS		 2239 && code != NE_EXPR && code != EQ_EXPR)
2240 return build1 (TRUTH_NOT_EXPR, type, arg);
2241 else
ca46db87 2242 return build (invert_tree_comparison (code), type,
3f783329 2243 TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
c05a9b68 2244 }
6d716ca8 2245
c05a9b68
RS		 2246 switch (code)
2247 {
6d716ca8
RS		 2248 case INTEGER_CST:
2249 return convert (type, build_int_2 (TREE_INT_CST_LOW (arg) == 0
2250 && TREE_INT_CST_HIGH (arg) == 0, 0));
2251
2252 case TRUTH_AND_EXPR:
2253 return build (TRUTH_OR_EXPR, type,
2254 invert_truthvalue (TREE_OPERAND (arg, 0)),
2255 invert_truthvalue (TREE_OPERAND (arg, 1)));
2256
2257 case TRUTH_OR_EXPR:
2258 return build (TRUTH_AND_EXPR, type,
2259 invert_truthvalue (TREE_OPERAND (arg, 0)),
2260 invert_truthvalue (TREE_OPERAND (arg, 1)));
2261
772447c5
RK		 2262 case TRUTH_XOR_EXPR:
2263 /* Here we can invert either operand. We invert the first operand
2264 unless the second operand is a TRUTH_NOT_EXPR in which case our
2265 result is the XOR of the first operand with the inside of the
2266 negation of the second operand. */
2267
2268 if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
2269 return build (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
2270 TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
2271 else
2272 return build (TRUTH_XOR_EXPR, type,
2273 invert_truthvalue (TREE_OPERAND (arg, 0)),
2274 TREE_OPERAND (arg, 1));
2275
6d716ca8
RS		 2276 case TRUTH_ANDIF_EXPR:
2277 return build (TRUTH_ORIF_EXPR, type,
2278 invert_truthvalue (TREE_OPERAND (arg, 0)),
2279 invert_truthvalue (TREE_OPERAND (arg, 1)));
2280
2281 case TRUTH_ORIF_EXPR:
2282 return build (TRUTH_ANDIF_EXPR, type,
2283 invert_truthvalue (TREE_OPERAND (arg, 0)),
2284 invert_truthvalue (TREE_OPERAND (arg, 1)));
2285
2286 case TRUTH_NOT_EXPR:
2287 return TREE_OPERAND (arg, 0);
2288
2289 case COND_EXPR:
2290 return build (COND_EXPR, type, TREE_OPERAND (arg, 0),
2291 invert_truthvalue (TREE_OPERAND (arg, 1)),
2292 invert_truthvalue (TREE_OPERAND (arg, 2)));
2293
ef9fe0da
RK		 2294 case COMPOUND_EXPR:
2295 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg, 0),
2296 invert_truthvalue (TREE_OPERAND (arg, 1)));
2297
6d716ca8
RS		 2298 case NON_LVALUE_EXPR:
2299 return invert_truthvalue (TREE_OPERAND (arg, 0));
2300
2301 case NOP_EXPR:
2302 case CONVERT_EXPR:
2303 case FLOAT_EXPR:
2304 return build1 (TREE_CODE (arg), type,
2305 invert_truthvalue (TREE_OPERAND (arg, 0)));
2306
2307 case BIT_AND_EXPR:
efc1a4d9
PB		 2308 if (!integer_onep (TREE_OPERAND (arg, 1)))
2309 break;
6d716ca8 2310 return build (EQ_EXPR, type, arg, convert (type, integer_zero_node));
6d716ca8 2311
dfa90b42
RS		 2312 case SAVE_EXPR:
2313 return build1 (TRUTH_NOT_EXPR, type, arg);
a25ee332
RK		 2314
2315 case CLEANUP_POINT_EXPR:
2316 return build1 (CLEANUP_POINT_EXPR, type,
2317 invert_truthvalue (TREE_OPERAND (arg, 0)));
e9a25f70
JL		 2318
2319 default:
2320 break;
efc1a4d9
PB		 2321 }
2322 if (TREE_CODE (TREE_TYPE (arg)) != BOOLEAN_TYPE)
dfa90b42 2323 abort ();
efc1a4d9 2324 return build1 (TRUTH_NOT_EXPR, type, arg);
6d716ca8
RS		 2325}
2326
2327/* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
2328 operands are another bit-wise operation with a common input. If so,
2329 distribute the bit operations to save an operation and possibly two if
2330 constants are involved. For example, convert
2331 (A | B) & (A | C) into A | (B & C)
2332 Further simplification will occur if B and C are constants.
2333
2334 If this optimization cannot be done, 0 will be returned. */
2335
2336static tree
2337distribute_bit_expr (code, type, arg0, arg1)
2338 enum tree_code code;
2339 tree type;
2340 tree arg0, arg1;
2341{
2342 tree common;
2343 tree left, right;
2344
2345 if (TREE_CODE (arg0) != TREE_CODE (arg1)
2346 || TREE_CODE (arg0) == code
fced8ba3
RS		 2347 || (TREE_CODE (arg0) != BIT_AND_EXPR
2348 && TREE_CODE (arg0) != BIT_IOR_EXPR))
6d716ca8
RS		 2349 return 0;
2350
2351 if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
2352 {
2353 common = TREE_OPERAND (arg0, 0);
2354 left = TREE_OPERAND (arg0, 1);
2355 right = TREE_OPERAND (arg1, 1);
2356 }
2357 else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
2358 {
2359 common = TREE_OPERAND (arg0, 0);
2360 left = TREE_OPERAND (arg0, 1);
2361 right = TREE_OPERAND (arg1, 0);
2362 }
2363 else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
2364 {
2365 common = TREE_OPERAND (arg0, 1);
2366 left = TREE_OPERAND (arg0, 0);
2367 right = TREE_OPERAND (arg1, 1);
2368 }
2369 else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
2370 {
2371 common = TREE_OPERAND (arg0, 1);
2372 left = TREE_OPERAND (arg0, 0);
2373 right = TREE_OPERAND (arg1, 0);
2374 }
2375 else
2376 return 0;
2377
2378 return fold (build (TREE_CODE (arg0), type, common,
2379 fold (build (code, type, left, right))));
2380}
2381\f
2382/* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
2383 starting at BITPOS. The field is unsigned if UNSIGNEDP is non-zero. */
2384
2385static tree
2386make_bit_field_ref (inner, type, bitsize, bitpos, unsignedp)
2387 tree inner;
2388 tree type;
2389 int bitsize, bitpos;
2390 int unsignedp;
2391{
2392 tree result = build (BIT_FIELD_REF, type, inner,
f8dac6eb 2393 size_int (bitsize), bitsize_int (bitpos, 0L));
6d716ca8
RS		 2394
2395 TREE_UNSIGNED (result) = unsignedp;
2396
2397 return result;
2398}
2399
2400/* Optimize a bit-field compare.
2401
2402 There are two cases: First is a compare against a constant and the
2403 second is a comparison of two items where the fields are at the same
2404 bit position relative to the start of a chunk (byte, halfword, word)
2405 large enough to contain it. In these cases we can avoid the shift
2406 implicit in bitfield extractions.
2407
2408 For constants, we emit a compare of the shifted constant with the
2409 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
2410 compared. For two fields at the same position, we do the ANDs with the
2411 similar mask and compare the result of the ANDs.
2412
2413 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
2414 COMPARE_TYPE is the type of the comparison, and LHS and RHS
2415 are the left and right operands of the comparison, respectively.
2416
6dc42e49 2417 If the optimization described above can be done, we return the resulting
6d716ca8
RS		 2418 tree. Otherwise we return zero. */
2419
2420static tree
2421optimize_bit_field_compare (code, compare_type, lhs, rhs)
2422 enum tree_code code;
2423 tree compare_type;
2424 tree lhs, rhs;
2425{
2426 int lbitpos, lbitsize, rbitpos, rbitsize;
4e86caed 2427 int lnbitpos, lnbitsize, rnbitpos = 0, rnbitsize = 0;
6d716ca8
RS		 2428 tree type = TREE_TYPE (lhs);
2429 tree signed_type, unsigned_type;
2430 int const_p = TREE_CODE (rhs) == INTEGER_CST;
4e86caed 2431 enum machine_mode lmode, rmode, lnmode, rnmode = VOIDmode;
6d716ca8
RS		 2432 int lunsignedp, runsignedp;
2433 int lvolatilep = 0, rvolatilep = 0;
23bd99ae 2434 int alignment;
4e86caed 2435 tree linner, rinner = NULL_TREE;
6d716ca8 2436 tree mask;
f1e60ec6 2437 tree offset;
6d716ca8
RS		 2438
2439 /* Get all the information about the extractions being done. If the bit size
2440 if the same as the size of the underlying object, we aren't doing an
2441 extraction at all and so can do nothing. */
f1e60ec6 2442 linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
23bd99ae 2443 &lunsignedp, &lvolatilep, &alignment);
9f5e873c 2444 if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
f1e60ec6 2445 || offset != 0)
6d716ca8
RS		 2446 return 0;
2447
2448 if (!const_p)
2449 {
2450 /* If this is not a constant, we can only do something if bit positions,
2451 sizes, and signedness are the same. */
23bd99ae
RK		 2452 rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
2453 &runsignedp, &rvolatilep, &alignment);
6d716ca8 2454
9f5e873c 2455 if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
f1e60ec6 2456 || lunsignedp != runsignedp || offset != 0)
6d716ca8
RS		 2457 return 0;
2458 }
2459
2460 /* See if we can find a mode to refer to this field. We should be able to,
2461 but fail if we can't. */
2462 lnmode = get_best_mode (lbitsize, lbitpos,
2463 TYPE_ALIGN (TREE_TYPE (linner)), word_mode,
2464 lvolatilep);
2465 if (lnmode == VOIDmode)
2466 return 0;
2467
2468 /* Set signed and unsigned types of the precision of this mode for the
2469 shifts below. */
2470 signed_type = type_for_mode (lnmode, 0);
2471 unsigned_type = type_for_mode (lnmode, 1);
2472
2473 if (! const_p)
2474 {
2475 rnmode = get_best_mode (rbitsize, rbitpos,
2476 TYPE_ALIGN (TREE_TYPE (rinner)), word_mode,
2477 rvolatilep);
2478 if (rnmode == VOIDmode)
2479 return 0;
2480 }
2481
2482 /* Compute the bit position and size for the new reference and our offset
2483 within it. If the new reference is the same size as the original, we
2484 won't optimize anything, so return zero. */
2485 lnbitsize = GET_MODE_BITSIZE (lnmode);
2486 lnbitpos = lbitpos & ~ (lnbitsize - 1);
2487 lbitpos -= lnbitpos;
2488 if (lnbitsize == lbitsize)
2489 return 0;
2490
2491 if (! const_p)
2492 {
2493 rnbitsize = GET_MODE_BITSIZE (rnmode);
2494 rnbitpos = rbitpos & ~ (rnbitsize - 1);
2495 rbitpos -= rnbitpos;
2496 if (rnbitsize == rbitsize)
2497 return 0;
2498 }
2499
f76b9db2
ILT		 2500 if (BYTES_BIG_ENDIAN)
2501 lbitpos = lnbitsize - lbitsize - lbitpos;
6d716ca8
RS		 2502
2503 /* Make the mask to be used against the extracted field. */
13af526d
RS		 2504 mask = build_int_2 (~0, ~0);
2505 TREE_TYPE (mask) = unsigned_type;
aa830baf 2506 force_fit_type (mask, 0);
13af526d 2507 mask = convert (unsigned_type, mask);
91d33e36 2508 mask = const_binop (LSHIFT_EXPR, mask, size_int (lnbitsize - lbitsize), 0);
6d716ca8 2509 mask = const_binop (RSHIFT_EXPR, mask,
91d33e36 2510 size_int (lnbitsize - lbitsize - lbitpos), 0);
6d716ca8
RS		 2511
2512 if (! const_p)
2513 /* If not comparing with constant, just rework the comparison
2514 and return. */
2515 return build (code, compare_type,
c0b9d4c8
RK		 2516 build (BIT_AND_EXPR, unsigned_type,
2517 make_bit_field_ref (linner, unsigned_type,
2518 lnbitsize, lnbitpos, 1),
6d716ca8 2519 mask),
c0b9d4c8
RK		 2520 build (BIT_AND_EXPR, unsigned_type,
2521 make_bit_field_ref (rinner, unsigned_type,
2522 rnbitsize, rnbitpos, 1),
6d716ca8
RS		 2523 mask));
2524
2525 /* Otherwise, we are handling the constant case. See if the constant is too
2526 big for the field. Warn and return a tree of for 0 (false) if so. We do
2527 this not only for its own sake, but to avoid having to test for this
2528 error case below. If we didn't, we might generate wrong code.
2529
2530 For unsigned fields, the constant shifted right by the field length should
2531 be all zero. For signed fields, the high-order bits should agree with
2532 the sign bit. */
2533
2534 if (lunsignedp)
2535 {
2536 if (! integer_zerop (const_binop (RSHIFT_EXPR,
2537 convert (unsigned_type, rhs),
91d33e36 2538 size_int (lbitsize), 0)))
6d716ca8
RS		 2539 {
2540 warning ("comparison is always %s due to width of bitfield",
2541 code == NE_EXPR ? "one" : "zero");
2542 return convert (compare_type,
2543 (code == NE_EXPR
2544 ? integer_one_node : integer_zero_node));
2545 }
2546 }
2547 else
2548 {
2549 tree tem = const_binop (RSHIFT_EXPR, convert (signed_type, rhs),
91d33e36 2550 size_int (lbitsize - 1), 0);
6d716ca8
RS		 2551 if (! integer_zerop (tem) && ! integer_all_onesp (tem))
2552 {
2553 warning ("comparison is always %s due to width of bitfield",
2554 code == NE_EXPR ? "one" : "zero");
2555 return convert (compare_type,
2556 (code == NE_EXPR
2557 ? integer_one_node : integer_zero_node));
2558 }
2559 }
2560
2561 /* Single-bit compares should always be against zero. */
2562 if (lbitsize == 1 && ! integer_zerop (rhs))
2563 {
2564 code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
2565 rhs = convert (type, integer_zero_node);
2566 }
2567
2568 /* Make a new bitfield reference, shift the constant over the
2569 appropriate number of bits and mask it with the computed mask
2570 (in case this was a signed field). If we changed it, make a new one. */
c0b9d4c8 2571 lhs = make_bit_field_ref (linner, unsigned_type, lnbitsize, lnbitpos, 1);
9db73acb
RK		 2572 if (lvolatilep)
2573 {
2574 TREE_SIDE_EFFECTS (lhs) = 1;
2575 TREE_THIS_VOLATILE (lhs) = 1;
2576 }
6d716ca8 2577
c0b9d4c8
RK		 2578 rhs = fold (const_binop (BIT_AND_EXPR,
2579 const_binop (LSHIFT_EXPR,
2580 convert (unsigned_type, rhs),
194c082f 2581 size_int (lbitpos), 0),
91d33e36 2582 mask, 0));
6d716ca8
RS		 2583
2584 return build (code, compare_type,
c0b9d4c8 2585 build (BIT_AND_EXPR, unsigned_type, lhs, mask),
6d716ca8
RS		 2586 rhs);
2587}
2588\f
b2215d83 2589/* Subroutine for fold_truthop: decode a field reference.
6d716ca8
RS		 2590
2591 If EXP is a comparison reference, we return the innermost reference.
2592
2593 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
2594 set to the starting bit number.
2595
2596 If the innermost field can be completely contained in a mode-sized
2597 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
2598
2599 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
2600 otherwise it is not changed.
2601
2602 *PUNSIGNEDP is set to the signedness of the field.
2603
2604 *PMASK is set to the mask used. This is either contained in a
2605 BIT_AND_EXPR or derived from the width of the field.
2606
38e01259 2607 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
d4453ee5 2608
6d716ca8
RS		 2609 Return 0 if this is not a component reference or is one that we can't
2610 do anything with. */
2611
2612static tree
2613decode_field_reference (exp, pbitsize, pbitpos, pmode, punsignedp,
d4453ee5 2614 pvolatilep, pmask, pand_mask)
6d716ca8
RS		 2615 tree exp;
2616 int *pbitsize, *pbitpos;
2617 enum machine_mode *pmode;
2618 int *punsignedp, *pvolatilep;
2619 tree *pmask;
d4453ee5 2620 tree *pand_mask;
6d716ca8 2621{
6d9f1f5f
RK		 2622 tree and_mask = 0;
2623 tree mask, inner, offset;
2624 tree unsigned_type;
2625 int precision;
23bd99ae 2626 int alignment;
6d716ca8 2627
772ae9f0
RK		 2628 /* All the optimizations using this function assume integer fields.
2629 There are problems with FP fields since the type_for_size call
2630 below can fail for, e.g., XFmode. */
2631 if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
2632 return 0;
2633
6d716ca8
RS		 2634 STRIP_NOPS (exp);
2635
2636 if (TREE_CODE (exp) == BIT_AND_EXPR)
2637 {
6d9f1f5f 2638 and_mask = TREE_OPERAND (exp, 1);
6d716ca8 2639 exp = TREE_OPERAND (exp, 0);
6d9f1f5f
RK		 2640 STRIP_NOPS (exp); STRIP_NOPS (and_mask);
2641 if (TREE_CODE (and_mask) != INTEGER_CST)
6d716ca8
RS		 2642 return 0;
2643 }
2644
6d716ca8 2645
f1e60ec6 2646 inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
23bd99ae 2647 punsignedp, pvolatilep, &alignment);
02103577
RK		 2648 if ((inner == exp && and_mask == 0)
2649 || *pbitsize < 0 || offset != 0)
c05a9b68 2650 return 0;
6d716ca8 2651
6d9f1f5f
RK		 2652 /* Compute the mask to access the bitfield. */
2653 unsigned_type = type_for_size (*pbitsize, 1);
2654 precision = TYPE_PRECISION (unsigned_type);
2655
2656 mask = build_int_2 (~0, ~0);
2657 TREE_TYPE (mask) = unsigned_type;
2658 force_fit_type (mask, 0);
2659 mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
2660 mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
2661
2662 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
2663 if (and_mask != 0)
2664 mask = fold (build (BIT_AND_EXPR, unsigned_type,
2665 convert (unsigned_type, and_mask), mask));
6d716ca8
RS		 2666
2667 *pmask = mask;
d4453ee5 2668 *pand_mask = and_mask;
6d716ca8
RS		 2669 return inner;
2670}
2671
6dc42e49 2672/* Return non-zero if MASK represents a mask of SIZE ones in the low-order
6d716ca8
RS		 2673 bit positions. */
2674
2675static int
2676all_ones_mask_p (mask, size)
2677 tree mask;
2678 int size;
2679{
2680 tree type = TREE_TYPE (mask);
2681 int precision = TYPE_PRECISION (type);
13af526d 2682 tree tmask;
6d716ca8 2683
13af526d
RS		 2684 tmask = build_int_2 (~0, ~0);
2685 TREE_TYPE (tmask) = signed_type (type);
aa830baf 2686 force_fit_type (tmask, 0);
6d716ca8 2687 return
02103577
RK		 2688 tree_int_cst_equal (mask,
2689 const_binop (RSHIFT_EXPR,
2690 const_binop (LSHIFT_EXPR, tmask,
2691 size_int (precision - size),
2692 0),
2693 size_int (precision - size), 0));
6d716ca8 2694}
b2215d83
TW		 2695
2696/* Subroutine for fold_truthop: determine if an operand is simple enough
2697 to be evaluated unconditionally. */
2698
b2215d83
TW		 2699static int
2700simple_operand_p (exp)
2701 tree exp;
2702{
2703 /* Strip any conversions that don't change the machine mode. */
2704 while ((TREE_CODE (exp) == NOP_EXPR
2705 || TREE_CODE (exp) == CONVERT_EXPR)
2706 && (TYPE_MODE (TREE_TYPE (exp))
2707 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
2708 exp = TREE_OPERAND (exp, 0);
2709
2710 return (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c'
2711 || (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
2712 && ! TREE_ADDRESSABLE (exp)
2713 && ! TREE_THIS_VOLATILE (exp)
8227896c
TW		 2714 && ! DECL_NONLOCAL (exp)
2715 /* Don't regard global variables as simple. They may be
2716 allocated in ways unknown to the compiler (shared memory,
2717 #pragma weak, etc). */
2718 && ! TREE_PUBLIC (exp)
2719 && ! DECL_EXTERNAL (exp)
2720 /* Loading a static variable is unduly expensive, but global
2721 registers aren't expensive. */
2722 && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
b2215d83 2723}
6d716ca8 2724\f
ebde8a27
RK		 2725/* The following functions are subroutines to fold_range_test and allow it to
2726 try to change a logical combination of comparisons into a range test.
2727
2728 For example, both
2729 X == 2 && X == 3 && X == 4 && X == 5
2730 and
2731 X >= 2 && X <= 5
2732 are converted to
2733 (unsigned) (X - 2) <= 3
2734
956d6950 2735 We describe each set of comparisons as being either inside or outside
ebde8a27
RK		 2736 a range, using a variable named like IN_P, and then describe the
2737 range with a lower and upper bound. If one of the bounds is omitted,
2738 it represents either the highest or lowest value of the type.
2739
2740 In the comments below, we represent a range by two numbers in brackets
956d6950 2741 preceded by a "+" to designate being inside that range, or a "-" to
ebde8a27
RK		 2742 designate being outside that range, so the condition can be inverted by
2743 flipping the prefix. An omitted bound is represented by a "-". For
2744 example, "- [-, 10]" means being outside the range starting at the lowest
2745 possible value and ending at 10, in other words, being greater than 10.
2746 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
2747 always false.
2748
2749 We set up things so that the missing bounds are handled in a consistent
2750 manner so neither a missing bound nor "true" and "false" need to be
2751 handled using a special case. */
2752
2753/* Return the result of applying CODE to ARG0 and ARG1, but handle the case
2754 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
2755 and UPPER1_P are nonzero if the respective argument is an upper bound
2756 and zero for a lower. TYPE, if nonzero, is the type of the result; it
2757 must be specified for a comparison. ARG1 will be converted to ARG0's
2758 type if both are specified. */
ef659ec0 2759
ebde8a27
RK		 2760static tree
2761range_binop (code, type, arg0, upper0_p, arg1, upper1_p)
2762 enum tree_code code;
2763 tree type;
2764 tree arg0, arg1;
2765 int upper0_p, upper1_p;
2766{
27bae8e5 2767 tree tem;
ebde8a27
RK		 2768 int result;
2769 int sgn0, sgn1;
ef659ec0 2770
ebde8a27
RK		 2771 /* If neither arg represents infinity, do the normal operation.
2772 Else, if not a comparison, return infinity. Else handle the special
2773 comparison rules. Note that most of the cases below won't occur, but
2774 are handled for consistency. */
ef659ec0 2775
ebde8a27 2776 if (arg0 != 0 && arg1 != 0)
27bae8e5
RK		 2777 {
2778 tem = fold (build (code, type != 0 ? type : TREE_TYPE (arg0),
2779 arg0, convert (TREE_TYPE (arg0), arg1)));
2780 STRIP_NOPS (tem);
2781 return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
2782 }
ef659ec0 2783
ebde8a27
RK		 2784 if (TREE_CODE_CLASS (code) != '<')
2785 return 0;
2786
2787 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
2788 for neither. Then compute our result treating them as never equal
2789 and comparing bounds to non-bounds as above. */
2790 sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
4e644c93 2791 sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
ebde8a27
RK		 2792 switch (code)
2793 {
2794 case EQ_EXPR: case NE_EXPR:
2795 result = (code == NE_EXPR);
2796 break;
2797 case LT_EXPR: case LE_EXPR:
2798 result = sgn0 < sgn1;
2799 break;
2800 case GT_EXPR: case GE_EXPR:
2801 result = sgn0 > sgn1;
2802 break;
e9a25f70
JL		 2803 default:
2804 abort ();
ebde8a27
RK		 2805 }
2806
2807 return convert (type, result ? integer_one_node : integer_zero_node);
2808}
2809\f
2810/* Given EXP, a logical expression, set the range it is testing into
2811 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
2812 actually being tested. *PLOW and *PHIGH will have be made the same type
2813 as the returned expression. If EXP is not a comparison, we will most
2814 likely not be returning a useful value and range. */
ef659ec0 2815
6dc7571d 2816static tree
ebde8a27
RK		 2817make_range (exp, pin_p, plow, phigh)
2818 tree exp;
2819 int *pin_p;
2820 tree *plow, *phigh;
ef659ec0 2821{
ebde8a27 2822 enum tree_code code;
4e86caed 2823 tree arg0, arg1, type = NULL_TREE;
7d12cee1 2824 tree orig_type = NULL_TREE;
ebde8a27
RK		 2825 int in_p, n_in_p;
2826 tree low, high, n_low, n_high;
ef659ec0 2827
ebde8a27
RK		 2828 /* Start with simply saying "EXP != 0" and then look at the code of EXP
2829 and see if we can refine the range. Some of the cases below may not
2830 happen, but it doesn't seem worth worrying about this. We "continue"
2831 the outer loop when we've changed something; otherwise we "break"
2832 the switch, which will "break" the while. */
ef659ec0 2833
ebde8a27
RK		 2834 in_p = 0, low = high = convert (TREE_TYPE (exp), integer_zero_node);
2835
2836 while (1)
ef659ec0 2837 {
ebde8a27
RK		 2838 code = TREE_CODE (exp);
2839 arg0 = TREE_OPERAND (exp, 0), arg1 = TREE_OPERAND (exp, 1);
80906567
RK		 2840 if (TREE_CODE_CLASS (code) == '<' || TREE_CODE_CLASS (code) == '1'
2841 || TREE_CODE_CLASS (code) == '2')
ebde8a27 2842 type = TREE_TYPE (arg0);
ef659ec0 2843
ebde8a27
RK		 2844 switch (code)
2845 {
2846 case TRUTH_NOT_EXPR:
2847 in_p = ! in_p, exp = arg0;
2848 continue;
2849
2850 case EQ_EXPR: case NE_EXPR:
2851 case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
2852 /* We can only do something if the range is testing for zero
2853 and if the second operand is an integer constant. Note that
2854 saying something is "in" the range we make is done by
2855 complementing IN_P since it will set in the initial case of
2856 being not equal to zero; "out" is leaving it alone. */
2857 if (low == 0 || high == 0
2858 || ! integer_zerop (low) || ! integer_zerop (high)
2859 || TREE_CODE (arg1) != INTEGER_CST)
2860 break;
ef659ec0 2861
ebde8a27
RK		 2862 switch (code)
2863 {
2864 case NE_EXPR: /* - [c, c] */
2865 low = high = arg1;
2866 break;
2867 case EQ_EXPR: /* + [c, c] */
2868 in_p = ! in_p, low = high = arg1;
2869 break;
2870 case GT_EXPR: /* - [-, c] */
2871 low = 0, high = arg1;
2872 break;
2873 case GE_EXPR: /* + [c, -] */
2874 in_p = ! in_p, low = arg1, high = 0;
2875 break;
2876 case LT_EXPR: /* - [c, -] */
2877 low = arg1, high = 0;
2878 break;
2879 case LE_EXPR: /* + [-, c] */
2880 in_p = ! in_p, low = 0, high = arg1;
2881 break;
e9a25f70
JL		 2882 default:
2883 abort ();
ebde8a27 2884 }
ef659ec0 2885
ebde8a27 2886 exp = arg0;
ef659ec0 2887
7f423031 2888 /* If this is an unsigned comparison, we also know that EXP is
0e1c7fc7
RK		 2889 greater than or equal to zero. We base the range tests we make
2890 on that fact, so we record it here so we can parse existing
2891 range tests. */
7f423031 2892 if (TREE_UNSIGNED (type) && (low == 0 || high == 0))
ebde8a27
RK		 2893 {
2894 if (! merge_ranges (&n_in_p, &n_low, &n_high, in_p, low, high,
2895 1, convert (type, integer_zero_node),
0e1c7fc7 2896 NULL_TREE))
ebde8a27 2897 break;
ef659ec0 2898
ebde8a27 2899 in_p = n_in_p, low = n_low, high = n_high;
0e1c7fc7
RK		 2900
2901 /* If the high bound is missing, reverse the range so it
2902 goes from zero to the low bound minus 1. */
2903 if (high == 0)
2904 {
2905 in_p = ! in_p;
2906 high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
2907 integer_one_node, 0);
2908 low = convert (type, integer_zero_node);
2909 }
ebde8a27
RK		 2910 }
2911 continue;
2912
2913 case NEGATE_EXPR:
2914 /* (-x) IN [a,b] -> x in [-b, -a] */
2915 n_low = range_binop (MINUS_EXPR, type,
2916 convert (type, integer_zero_node), 0, high, 1);
2917 n_high = range_binop (MINUS_EXPR, type,
2918 convert (type, integer_zero_node), 0, low, 0);
2919 low = n_low, high = n_high;
2920 exp = arg0;
2921 continue;
2922
2923 case BIT_NOT_EXPR:
2924 /* ~ X -> -X - 1 */
2925 exp = build (MINUS_EXPR, type, build1 (NEGATE_EXPR, type, arg0),
27bae8e5 2926 convert (type, integer_one_node));
ebde8a27
RK		 2927 continue;
2928
2929 case PLUS_EXPR: case MINUS_EXPR:
2930 if (TREE_CODE (arg1) != INTEGER_CST)
2931 break;
2932
2933 /* If EXP is signed, any overflow in the computation is undefined,
2934 so we don't worry about it so long as our computations on
2935 the bounds don't overflow. For unsigned, overflow is defined
2936 and this is exactly the right thing. */
2937 n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
2938 type, low, 0, arg1, 0);
2939 n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
2940 type, high, 1, arg1, 0);
2941 if ((n_low != 0 && TREE_OVERFLOW (n_low))
2942 || (n_high != 0 && TREE_OVERFLOW (n_high)))
2943 break;
2944
3c00684e
JL		 2945 /* Check for an unsigned range which has wrapped around the maximum
2946 value thus making n_high < n_low, and normalize it. */
5a9d82a6 2947 if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
3c00684e
JL		 2948 {
2949 low = range_binop (PLUS_EXPR, type, n_high, 0,
0e1c7fc7 2950 integer_one_node, 0);
3c00684e 2951 high = range_binop (MINUS_EXPR, type, n_low, 0,
0e1c7fc7 2952 integer_one_node, 0);
3c00684e
JL		 2953 in_p = ! in_p;
2954 }
5a9d82a6
JW		 2955 else
2956 low = n_low, high = n_high;
27bae8e5 2957
ebde8a27
RK		 2958 exp = arg0;
2959 continue;
2960
2961 case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR:
7d12cee1
JL		 2962 if (orig_type == NULL_TREE)
2963 orig_type = type;
2964 if (TYPE_PRECISION (type) > TYPE_PRECISION (orig_type))
2965 break;
2966
ebde8a27
RK		 2967 if (! INTEGRAL_TYPE_P (type)
2968 || (low != 0 && ! int_fits_type_p (low, type))
2969 || (high != 0 && ! int_fits_type_p (high, type)))
2970 break;
2971
ce2157a1 2972 n_low = low, n_high = high;
ebde8a27 2973
ce2157a1
JL		 2974 if (n_low != 0)
2975 n_low = convert (type, n_low);
2976
2977 if (n_high != 0)
2978 n_high = convert (type, n_high);
2979
2980 /* If we're converting from an unsigned to a signed type,
2981 we will be doing the comparison as unsigned. The tests above
2982 have already verified that LOW and HIGH are both positive.
2983
2984 So we have to make sure that the original unsigned value will
2985 be interpreted as positive. */
2986 if (TREE_UNSIGNED (type) && ! TREE_UNSIGNED (TREE_TYPE (exp)))
2987 {
2988 tree equiv_type = type_for_mode (TYPE_MODE (type), 1);
e1ee5cdc
RH		 2989 tree high_positive;
2990
2991 /* A range without an upper bound is, naturally, unbounded.
2992 Since convert would have cropped a very large value, use
2993 the max value for the destination type. */
2994
2995 high_positive = TYPE_MAX_VALUE (equiv_type);
2996 if (!high_positive)
2997 {
2998 high_positive = TYPE_MAX_VALUE (type);
2999 if (!high_positive)
3000 abort();
3001 }
3002 high_positive = fold (build (RSHIFT_EXPR, type,
3003 convert (type, high_positive),
3004 convert (type, integer_one_node)));
ce2157a1
JL		 3005
3006 /* If the low bound is specified, "and" the range with the
3007 range for which the original unsigned value will be
3008 positive. */
3009 if (low != 0)
3010 {
3011 if (! merge_ranges (&n_in_p, &n_low, &n_high,
3012 1, n_low, n_high,
3013 1, convert (type, integer_zero_node),
3014 high_positive))
3015 break;
3016
3017 in_p = (n_in_p == in_p);
3018 }
3019 else
3020 {
3021 /* Otherwise, "or" the range with the range of the input
3022 that will be interpreted as negative. */
3023 if (! merge_ranges (&n_in_p, &n_low, &n_high,
3024 0, n_low, n_high,
3025 1, convert (type, integer_zero_node),
3026 high_positive))
3027 break;
3028
3029 in_p = (in_p != n_in_p);
3030 }
3031 }
ebde8a27
RK		 3032
3033 exp = arg0;
ce2157a1 3034 low = n_low, high = n_high;
ebde8a27 3035 continue;
ce2157a1
JL		 3036
3037 default:
3038 break;
ef659ec0 3039 }
ebde8a27
RK		 3040
3041 break;
ef659ec0 3042 }
ebde8a27 3043
80906567
RK		 3044 /* If EXP is a constant, we can evaluate whether this is true or false. */
3045 if (TREE_CODE (exp) == INTEGER_CST)
3046 {
3047 in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
3048 exp, 0, low, 0))
3049 && integer_onep (range_binop (LE_EXPR, integer_type_node,
3050 exp, 1, high, 1)));
3051 low = high = 0;
3052 exp = 0;
3053 }
3054
ebde8a27
RK		 3055 *pin_p = in_p, *plow = low, *phigh = high;
3056 return exp;
3057}
3058\f
3059/* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
3060 type, TYPE, return an expression to test if EXP is in (or out of, depending
3061 on IN_P) the range. */
3062
3063static tree
3064build_range_check (type, exp, in_p, low, high)
3065 tree type;
3066 tree exp;
3067 int in_p;
3068 tree low, high;
3069{
3070 tree etype = TREE_TYPE (exp);
3071 tree utype, value;
3072
3073 if (! in_p
3074 && (0 != (value = build_range_check (type, exp, 1, low, high))))
3075 return invert_truthvalue (value);
3076
3077 else if (low == 0 && high == 0)
3078 return convert (type, integer_one_node);
3079
3080 else if (low == 0)
3081 return fold (build (LE_EXPR, type, exp, high));
3082
3083 else if (high == 0)
3084 return fold (build (GE_EXPR, type, exp, low));
3085
3086 else if (operand_equal_p (low, high, 0))
3087 return fold (build (EQ_EXPR, type, exp, low));
3088
3089 else if (TREE_UNSIGNED (etype) && integer_zerop (low))
3090 return build_range_check (type, exp, 1, 0, high);
3091
3092 else if (integer_zerop (low))
ef659ec0 3093 {
ebde8a27
RK		 3094 utype = unsigned_type (etype);
3095 return build_range_check (type, convert (utype, exp), 1, 0,
3096 convert (utype, high));
3097 }
ef659ec0 3098
ebde8a27
RK		 3099 else if (0 != (value = const_binop (MINUS_EXPR, high, low, 0))
3100 && ! TREE_OVERFLOW (value))
3101 return build_range_check (type,
3102 fold (build (MINUS_EXPR, etype, exp, low)),
3103 1, convert (etype, integer_zero_node), value);
3104 else
3105 return 0;
3106}
3107\f
3108/* Given two ranges, see if we can merge them into one. Return 1 if we
3109 can, 0 if we can't. Set the output range into the specified parameters. */
ef659ec0 3110
ebde8a27
RK		 3111static int
3112merge_ranges (pin_p, plow, phigh, in0_p, low0, high0, in1_p, low1, high1)
3113 int *pin_p;
3114 tree *plow, *phigh;
3115 int in0_p, in1_p;
3116 tree low0, high0, low1, high1;
3117{
3118 int no_overlap;
3119 int subset;
3120 int temp;
3121 tree tem;
3122 int in_p;
3123 tree low, high;
ce2157a1
JL		 3124 int lowequal = ((low0 == 0 && low1 == 0)
3125 || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3126 low0, 0, low1, 0)));
3127 int highequal = ((high0 == 0 && high1 == 0)
3128 || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3129 high0, 1, high1, 1)));
3130
3131 /* Make range 0 be the range that starts first, or ends last if they
3132 start at the same value. Swap them if it isn't. */
ebde8a27
RK		 3133 if (integer_onep (range_binop (GT_EXPR, integer_type_node,
3134 low0, 0, low1, 0))
ce2157a1 3135 || (lowequal
ebde8a27 3136 && integer_onep (range_binop (GT_EXPR, integer_type_node,
ce2157a1 3137 high1, 1, high0, 1))))
ebde8a27
RK		 3138 {
3139 temp = in0_p, in0_p = in1_p, in1_p = temp;
3140 tem = low0, low0 = low1, low1 = tem;
3141 tem = high0, high0 = high1, high1 = tem;
3142 }
ef659ec0 3143
ebde8a27
RK		 3144 /* Now flag two cases, whether the ranges are disjoint or whether the
3145 second range is totally subsumed in the first. Note that the tests
3146 below are simplified by the ones above. */
3147 no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
3148 high0, 1, low1, 0));
5df8a1f2 3149 subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
ebde8a27
RK		 3150 high1, 1, high0, 1));
3151
3152 /* We now have four cases, depending on whether we are including or
3153 excluding the two ranges. */
3154 if (in0_p && in1_p)
3155 {
3156 /* If they don't overlap, the result is false. If the second range
3157 is a subset it is the result. Otherwise, the range is from the start
3158 of the second to the end of the first. */
3159 if (no_overlap)
3160 in_p = 0, low = high = 0;
3161 else if (subset)
3162 in_p = 1, low = low1, high = high1;
3163 else
3164 in_p = 1, low = low1, high = high0;
3165 }
ef659ec0 3166
ebde8a27
RK		 3167 else if (in0_p && ! in1_p)
3168 {
ce2157a1
JL		 3169 /* If they don't overlap, the result is the first range. If they are
3170 equal, the result is false. If the second range is a subset of the
3171 first, and the ranges begin at the same place, we go from just after
3172 the end of the first range to the end of the second. If the second
3173 range is not a subset of the first, or if it is a subset and both
3174 ranges end at the same place, the range starts at the start of the
3175 first range and ends just before the second range.
3176 Otherwise, we can't describe this as a single range. */
ebde8a27
RK		 3177 if (no_overlap)
3178 in_p = 1, low = low0, high = high0;
ce2157a1 3179 else if (lowequal && highequal)
405862dd 3180 in_p = 0, low = high = 0;
ce2157a1
JL		 3181 else if (subset && lowequal)
3182 {
3183 in_p = 1, high = high0;
3184 low = range_binop (PLUS_EXPR, NULL_TREE, high1, 0,
3185 integer_one_node, 0);
3186 }
3187 else if (! subset || highequal)
ebde8a27
RK		 3188 {
3189 in_p = 1, low = low0;
3190 high = range_binop (MINUS_EXPR, NULL_TREE, low1, 0,
0e1c7fc7 3191 integer_one_node, 0);
ebde8a27 3192 }
ce2157a1
JL		 3193 else
3194 return 0;
ebde8a27 3195 }
ef659ec0 3196
ebde8a27
RK		 3197 else if (! in0_p && in1_p)
3198 {
3199 /* If they don't overlap, the result is the second range. If the second
3200 is a subset of the first, the result is false. Otherwise,
3201 the range starts just after the first range and ends at the
3202 end of the second. */
3203 if (no_overlap)
3204 in_p = 1, low = low1, high = high1;
3205 else if (subset)
3206 in_p = 0, low = high = 0;
3207 else
3208 {
3209 in_p = 1, high = high1;
3210 low = range_binop (PLUS_EXPR, NULL_TREE, high0, 1,
3211 integer_one_node, 0);
ef659ec0
TW		 3212 }
3213 }
3214
ebde8a27
RK		 3215 else
3216 {
3217 /* The case where we are excluding both ranges. Here the complex case
3218 is if they don't overlap. In that case, the only time we have a
3219 range is if they are adjacent. If the second is a subset of the
3220 first, the result is the first. Otherwise, the range to exclude
3221 starts at the beginning of the first range and ends at the end of the
3222 second. */
3223 if (no_overlap)
3224 {
3225 if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
3226 range_binop (PLUS_EXPR, NULL_TREE,
3227 high0, 1,
3228 integer_one_node, 1),
3229 1, low1, 0)))
3230 in_p = 0, low = low0, high = high1;
3231 else
3232 return 0;
3233 }
3234 else if (subset)
3235 in_p = 0, low = low0, high = high0;
3236 else
3237 in_p = 0, low = low0, high = high1;
3238 }
f5902869 3239
ebde8a27
RK		 3240 *pin_p = in_p, *plow = low, *phigh = high;
3241 return 1;
3242}
3243\f
3244/* EXP is some logical combination of boolean tests. See if we can
3245 merge it into some range test. Return the new tree if so. */
ef659ec0 3246
ebde8a27
RK		 3247static tree
3248fold_range_test (exp)
3249 tree exp;
3250{
3251 int or_op = (TREE_CODE (exp) == TRUTH_ORIF_EXPR
3252 || TREE_CODE (exp) == TRUTH_OR_EXPR);
3253 int in0_p, in1_p, in_p;
3254 tree low0, low1, low, high0, high1, high;
3255 tree lhs = make_range (TREE_OPERAND (exp, 0), &in0_p, &low0, &high0);
3256 tree rhs = make_range (TREE_OPERAND (exp, 1), &in1_p, &low1, &high1);
3257 tree tem;
ef659ec0 3258
ebde8a27
RK		 3259 /* If this is an OR operation, invert both sides; we will invert
3260 again at the end. */
3261 if (or_op)
3262 in0_p = ! in0_p, in1_p = ! in1_p;
3263
3264 /* If both expressions are the same, if we can merge the ranges, and we
80906567
RK		 3265 can build the range test, return it or it inverted. If one of the
3266 ranges is always true or always false, consider it to be the same
3267 expression as the other. */
3268 if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
ebde8a27
RK		 3269 && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
3270 in1_p, low1, high1)
80906567
RK		 3271 && 0 != (tem = (build_range_check (TREE_TYPE (exp),
3272 lhs != 0 ? lhs
3273 : rhs != 0 ? rhs : integer_zero_node,
ebde8a27
RK		 3274 in_p, low, high))))
3275 return or_op ? invert_truthvalue (tem) : tem;
3276
3277 /* On machines where the branch cost is expensive, if this is a
3278 short-circuited branch and the underlying object on both sides
3279 is the same, make a non-short-circuit operation. */
3280 else if (BRANCH_COST >= 2
3281 && (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3282 || TREE_CODE (exp) == TRUTH_ORIF_EXPR)
3283 && operand_equal_p (lhs, rhs, 0))
ef659ec0 3284 {
f0eebf28
RK		 3285 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
3286 unless we are at top level, in which case we can't do this. */
ebde8a27
RK		 3287 if (simple_operand_p (lhs))
3288 return build (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3289 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
3290 TREE_TYPE (exp), TREE_OPERAND (exp, 0),
3291 TREE_OPERAND (exp, 1));
f0eebf28
RK		 3292
3293 else if (current_function_decl != 0)
ebde8a27
RK		 3294 {
3295 tree common = save_expr (lhs);
3296
3297 if (0 != (lhs = build_range_check (TREE_TYPE (exp), common,
3298 or_op ? ! in0_p : in0_p,
3299 low0, high0))
3300 && (0 != (rhs = build_range_check (TREE_TYPE (exp), common,
3301 or_op ? ! in1_p : in1_p,
3302 low1, high1))))
3303 return build (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3304 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
3305 TREE_TYPE (exp), lhs, rhs);
3306 }
ef659ec0 3307 }
de153e82
JL		 3308
3309
3310 return 0;
ef659ec0
TW		 3311}
3312\f
02103577 3313/* Subroutine for fold_truthop: C is an INTEGER_CST interpreted as a P
25216284 3314 bit value. Arrange things so the extra bits will be set to zero if and
d4453ee5
RK		 3315 only if C is signed-extended to its full width. If MASK is nonzero,
3316 it is an INTEGER_CST that should be AND'ed with the extra bits. */
02103577
RK		 3317
3318static tree
d4453ee5 3319unextend (c, p, unsignedp, mask)
02103577
RK		 3320 tree c;
3321 int p;
3322 int unsignedp;
d4453ee5 3323 tree mask;
02103577
RK		 3324{
3325 tree type = TREE_TYPE (c);
3326 int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
3327 tree temp;
3328
3329 if (p == modesize || unsignedp)
3330 return c;
3331
02103577 3332 /* We work by getting just the sign bit into the low-order bit, then
9faa82d8 3333 into the high-order bit, then sign-extend. We then XOR that value
02103577
RK		 3334 with C. */
3335 temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1), 0);
3336 temp = const_binop (BIT_AND_EXPR, temp, size_int (1), 0);
cf85c69b
JW		 3337
3338 /* We must use a signed type in order to get an arithmetic right shift.
3339 However, we must also avoid introducing accidental overflows, so that
3340 a subsequent call to integer_zerop will work. Hence we must
3341 do the type conversion here. At this point, the constant is either
3342 zero or one, and the conversion to a signed type can never overflow.
3343 We could get an overflow if this conversion is done anywhere else. */
3344 if (TREE_UNSIGNED (type))
3345 temp = convert (signed_type (type), temp);
3346
02103577
RK		 3347 temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
3348 temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
d4453ee5
RK		 3349 if (mask != 0)
3350 temp = const_binop (BIT_AND_EXPR, temp, convert (TREE_TYPE (c), mask), 0);
cf85c69b
JW		 3351 /* If necessary, convert the type back to match the type of C. */
3352 if (TREE_UNSIGNED (type))
3353 temp = convert (type, temp);
d4453ee5 3354
02103577
RK		 3355 return convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
3356}
3357\f
b2215d83
TW		 3358/* Find ways of folding logical expressions of LHS and RHS:
3359 Try to merge two comparisons to the same innermost item.
3360 Look for range tests like "ch >= '0' && ch <= '9'".
3361 Look for combinations of simple terms on machines with expensive branches
3362 and evaluate the RHS unconditionally.
6d716ca8
RS		 3363
3364 For example, if we have p->a == 2 && p->b == 4 and we can make an
3365 object large enough to span both A and B, we can do this with a comparison
3366 against the object ANDed with the a mask.
3367
3368 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
3369 operations to do this with one comparison.
3370
3371 We check for both normal comparisons and the BIT_AND_EXPRs made this by
3372 function and the one above.
3373
3374 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
3375 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
3376
3377 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
3378 two operands.
3379
3380 We return the simplified tree or 0 if no optimization is possible. */
3381
3382static tree
b2215d83 3383fold_truthop (code, truth_type, lhs, rhs)
6d716ca8
RS		 3384 enum tree_code code;
3385 tree truth_type, lhs, rhs;
3386{
3387 /* If this is the "or" of two comparisons, we can do something if we
3388 the comparisons are NE_EXPR. If this is the "and", we can do something
3389 if the comparisons are EQ_EXPR. I.e.,
3390 (a->b == 2 && a->c == 4) can become (a->new == NEW).
3391
3392 WANTED_CODE is this operation code. For single bit fields, we can
3393 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
3394 comparison for one-bit fields. */
3395
b2215d83 3396 enum tree_code wanted_code;
6d716ca8 3397 enum tree_code lcode, rcode;
b2215d83 3398 tree ll_arg, lr_arg, rl_arg, rr_arg;
6d716ca8
RS		 3399 tree ll_inner, lr_inner, rl_inner, rr_inner;
3400 int ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
3401 int rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
3402 int xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
3403 int lnbitsize, lnbitpos, rnbitsize, rnbitpos;
3404 int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
3405 enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
3406 enum machine_mode lnmode, rnmode;
3407 tree ll_mask, lr_mask, rl_mask, rr_mask;
d4453ee5 3408 tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
b2215d83 3409 tree l_const, r_const;
6d716ca8
RS		 3410 tree type, result;
3411 int first_bit, end_bit;
b2215d83 3412 int volatilep;
6d716ca8 3413
ebde8a27
RK		 3414 /* Start by getting the comparison codes. Fail if anything is volatile.
3415 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
3416 it were surrounded with a NE_EXPR. */
6d716ca8 3417
ebde8a27 3418 if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
b2215d83
TW		 3419 return 0;
3420
6d716ca8
RS		 3421 lcode = TREE_CODE (lhs);
3422 rcode = TREE_CODE (rhs);
ef659ec0 3423
96d4cf0a
RK		 3424 if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
3425 lcode = NE_EXPR, lhs = build (NE_EXPR, truth_type, lhs, integer_zero_node);
3426
3427 if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
3428 rcode = NE_EXPR, rhs = build (NE_EXPR, truth_type, rhs, integer_zero_node);
3429
ebde8a27 3430 if (TREE_CODE_CLASS (lcode) != '<' || TREE_CODE_CLASS (rcode) != '<')
ef659ec0
TW		 3431 return 0;
3432
b2215d83 3433 code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
9c0ae98b 3434 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
b2215d83
TW		 3435
3436 ll_arg = TREE_OPERAND (lhs, 0);
3437 lr_arg = TREE_OPERAND (lhs, 1);
3438 rl_arg = TREE_OPERAND (rhs, 0);
3439 rr_arg = TREE_OPERAND (rhs, 1);
3440
8227896c 3441 /* If the RHS can be evaluated unconditionally and its operands are
b2215d83
TW		 3442 simple, it wins to evaluate the RHS unconditionally on machines
3443 with expensive branches. In this case, this isn't a comparison
3444 that can be merged. */
3445
3446 /* @@ I'm not sure it wins on the m88110 to do this if the comparisons
3447 are with zero (tmw). */
3448
3449 if (BRANCH_COST >= 2
7178e3af 3450 && INTEGRAL_TYPE_P (TREE_TYPE (rhs))
b2215d83 3451 && simple_operand_p (rl_arg)
8227896c 3452 && simple_operand_p (rr_arg))
b2215d83
TW		 3453 return build (code, truth_type, lhs, rhs);
3454
ef659ec0
TW		 3455 /* See if the comparisons can be merged. Then get all the parameters for
3456 each side. */
3457
6d716ca8 3458 if ((lcode != EQ_EXPR && lcode != NE_EXPR)
ef659ec0 3459 || (rcode != EQ_EXPR && rcode != NE_EXPR))
6d716ca8
RS		 3460 return 0;
3461
b2215d83
TW		 3462 volatilep = 0;
3463 ll_inner = decode_field_reference (ll_arg,
6d716ca8 3464 &ll_bitsize, &ll_bitpos, &ll_mode,
d4453ee5
RK		 3465 &ll_unsignedp, &volatilep, &ll_mask,
3466 &ll_and_mask);
b2215d83 3467 lr_inner = decode_field_reference (lr_arg,
6d716ca8 3468 &lr_bitsize, &lr_bitpos, &lr_mode,
d4453ee5
RK		 3469 &lr_unsignedp, &volatilep, &lr_mask,
3470 &lr_and_mask);
b2215d83 3471 rl_inner = decode_field_reference (rl_arg,
6d716ca8 3472 &rl_bitsize, &rl_bitpos, &rl_mode,
d4453ee5
RK		 3473 &rl_unsignedp, &volatilep, &rl_mask,
3474 &rl_and_mask);
b2215d83 3475 rr_inner = decode_field_reference (rr_arg,
6d716ca8 3476 &rr_bitsize, &rr_bitpos, &rr_mode,
d4453ee5
RK		 3477 &rr_unsignedp, &volatilep, &rr_mask,
3478 &rr_and_mask);
6d716ca8
RS		 3479
3480 /* It must be true that the inner operation on the lhs of each
3481 comparison must be the same if we are to be able to do anything.
3482 Then see if we have constants. If not, the same must be true for
3483 the rhs's. */
3484 if (volatilep || ll_inner == 0 || rl_inner == 0
3485 || ! operand_equal_p (ll_inner, rl_inner, 0))
3486 return 0;
3487
b2215d83
TW		 3488 if (TREE_CODE (lr_arg) == INTEGER_CST
3489 && TREE_CODE (rr_arg) == INTEGER_CST)
3490 l_const = lr_arg, r_const = rr_arg;
6d716ca8
RS		 3491 else if (lr_inner == 0 || rr_inner == 0
3492 || ! operand_equal_p (lr_inner, rr_inner, 0))
3493 return 0;
b2215d83
TW		 3494 else
3495 l_const = r_const = 0;
6d716ca8
RS		 3496
3497 /* If either comparison code is not correct for our logical operation,
3498 fail. However, we can convert a one-bit comparison against zero into
3499 the opposite comparison against that bit being set in the field. */
b2215d83 3500
9c0ae98b 3501 wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
6d716ca8
RS		 3502 if (lcode != wanted_code)
3503 {
3504 if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
5a6b3365 3505 {
9f29ca78 3506 if (ll_unsignedp || tree_log2 (ll_mask) + 1 < ll_bitsize)
5a6b3365
R		 3507 l_const = ll_mask;
3508 else
3509 /* Since ll_arg is a single bit bit mask, we can sign extend
3510 it appropriately with a NEGATE_EXPR.
3511 l_const is made a signed value here, but since for l_const != NULL
3512 lr_unsignedp is not used, we don't need to clear the latter. */
3513 l_const = fold (build1 (NEGATE_EXPR, TREE_TYPE (ll_arg),
3514 convert (TREE_TYPE (ll_arg), ll_mask)));
3515 }
6d716ca8
RS		 3516 else
3517 return 0;
3518 }
3519
3520 if (rcode != wanted_code)
3521 {
3522 if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
5a6b3365 3523 {
9f29ca78 3524 if (rl_unsignedp || tree_log2 (rl_mask) + 1 < rl_bitsize)
5a6b3365
R		 3525 r_const = rl_mask;
3526 else
3527 /* This is analogous to the code for l_const above. */
3528 r_const = fold (build1 (NEGATE_EXPR, TREE_TYPE (rl_arg),
3529 convert (TREE_TYPE (rl_arg), rl_mask)));
3530 }
6d716ca8
RS		 3531 else
3532 return 0;
3533 }
3534
3535 /* See if we can find a mode that contains both fields being compared on
3536 the left. If we can't, fail. Otherwise, update all constants and masks
3537 to be relative to a field of that size. */
3538 first_bit = MIN (ll_bitpos, rl_bitpos);
3539 end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
3540 lnmode = get_best_mode (end_bit - first_bit, first_bit,
3541 TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
3542 volatilep);
3543 if (lnmode == VOIDmode)
3544 return 0;
3545
3546 lnbitsize = GET_MODE_BITSIZE (lnmode);
3547 lnbitpos = first_bit & ~ (lnbitsize - 1);
3548 type = type_for_size (lnbitsize, 1);
3549 xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
3550
f76b9db2
ILT		 3551 if (BYTES_BIG_ENDIAN)
3552 {
3553 xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
3554 xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
3555 }
6d716ca8
RS		 3556
3557 ll_mask = const_binop (LSHIFT_EXPR, convert (type, ll_mask),
91d33e36 3558 size_int (xll_bitpos), 0);
6d716ca8 3559 rl_mask = const_binop (LSHIFT_EXPR, convert (type, rl_mask),
91d33e36 3560 size_int (xrl_bitpos), 0);
6d716ca8 3561
6d716ca8
RS		 3562 if (l_const)
3563 {
d4453ee5
RK		 3564 l_const = convert (type, l_const);
3565 l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
02103577
RK		 3566 l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
3567 if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
3568 fold (build1 (BIT_NOT_EXPR,
3569 type, ll_mask)),
3570 0)))
3571 {
3572 warning ("comparison is always %s",
3573 wanted_code == NE_EXPR ? "one" : "zero");
3574
3575 return convert (truth_type,
3576 wanted_code == NE_EXPR
3577 ? integer_one_node : integer_zero_node);
3578 }
6d716ca8
RS		 3579 }
3580 if (r_const)
3581 {
d4453ee5
RK		 3582 r_const = convert (type, r_const);
3583 r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
02103577
RK		 3584 r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
3585 if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
3586 fold (build1 (BIT_NOT_EXPR,
3587 type, rl_mask)),
3588 0)))
3589 {
3590 warning ("comparison is always %s",
3591 wanted_code == NE_EXPR ? "one" : "zero");
3592
3593 return convert (truth_type,
3594 wanted_code == NE_EXPR
3595 ? integer_one_node : integer_zero_node);
3596 }
6d716ca8
RS		 3597 }
3598
3599 /* If the right sides are not constant, do the same for it. Also,
3600 disallow this optimization if a size or signedness mismatch occurs
3601 between the left and right sides. */
3602 if (l_const == 0)
3603 {
3604 if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
e6a28f26
RS		 3605 || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
3606 /* Make sure the two fields on the right
3607 correspond to the left without being swapped. */
3608 || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
6d716ca8
RS		 3609 return 0;
3610
3611 first_bit = MIN (lr_bitpos, rr_bitpos);
3612 end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
3613 rnmode = get_best_mode (end_bit - first_bit, first_bit,
3614 TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
3615 volatilep);
3616 if (rnmode == VOIDmode)
3617 return 0;
3618
3619 rnbitsize = GET_MODE_BITSIZE (rnmode);
3620 rnbitpos = first_bit & ~ (rnbitsize - 1);
3621 xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
3622
f76b9db2
ILT		 3623 if (BYTES_BIG_ENDIAN)
3624 {
3625 xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
3626 xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
3627 }
6d716ca8
RS		 3628
3629 lr_mask = const_binop (LSHIFT_EXPR, convert (type, lr_mask),
91d33e36 3630 size_int (xlr_bitpos), 0);
6d716ca8 3631 rr_mask = const_binop (LSHIFT_EXPR, convert (type, rr_mask),
91d33e36 3632 size_int (xrr_bitpos), 0);
6d716ca8
RS		 3633
3634 /* Make a mask that corresponds to both fields being compared.
3635 Do this for both items being compared. If the masks agree,
3636 we can do this by masking both and comparing the masked
3637 results. */
91d33e36
RS		 3638 ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
3639 lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
6d716ca8
RS		 3640 if (operand_equal_p (ll_mask, lr_mask, 0) && lnbitsize == rnbitsize)
3641 {
3642 lhs = make_bit_field_ref (ll_inner, type, lnbitsize, lnbitpos,
3643 ll_unsignedp || rl_unsignedp);
3644 rhs = make_bit_field_ref (lr_inner, type, rnbitsize, rnbitpos,
3645 lr_unsignedp || rr_unsignedp);
3646 if (! all_ones_mask_p (ll_mask, lnbitsize))
3647 {
3648 lhs = build (BIT_AND_EXPR, type, lhs, ll_mask);
3649 rhs = build (BIT_AND_EXPR, type, rhs, ll_mask);
3650 }
3651 return build (wanted_code, truth_type, lhs, rhs);
3652 }
3653
3654 /* There is still another way we can do something: If both pairs of
3655 fields being compared are adjacent, we may be able to make a wider
3656 field containing them both. */
3657 if ((ll_bitsize + ll_bitpos == rl_bitpos
3658 && lr_bitsize + lr_bitpos == rr_bitpos)
3659 || (ll_bitpos == rl_bitpos + rl_bitsize
3660 && lr_bitpos == rr_bitpos + rr_bitsize))
3661 return build (wanted_code, truth_type,
3662 make_bit_field_ref (ll_inner, type,
3663 ll_bitsize + rl_bitsize,
3664 MIN (ll_bitpos, rl_bitpos),
3665 ll_unsignedp),
3666 make_bit_field_ref (lr_inner, type,
3667 lr_bitsize + rr_bitsize,
3668 MIN (lr_bitpos, rr_bitpos),
3669 lr_unsignedp));
3670
3671 return 0;
3672 }
3673
3674 /* Handle the case of comparisons with constants. If there is something in
3675 common between the masks, those bits of the constants must be the same.
3676 If not, the condition is always false. Test for this to avoid generating
3677 incorrect code below. */
91d33e36 3678 result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
6d716ca8 3679 if (! integer_zerop (result)
91d33e36
RS		 3680 && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
3681 const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
6d716ca8
RS		 3682 {
3683 if (wanted_code == NE_EXPR)
3684 {
3685 warning ("`or' of unmatched not-equal tests is always 1");
3686 return convert (truth_type, integer_one_node);
3687 }
3688 else
3689 {
3690 warning ("`and' of mutually exclusive equal-tests is always zero");
3691 return convert (truth_type, integer_zero_node);
3692 }
3693 }
3694
3695 /* Construct the expression we will return. First get the component
3696 reference we will make. Unless the mask is all ones the width of
3697 that field, perform the mask operation. Then compare with the
3698 merged constant. */
3699 result = make_bit_field_ref (ll_inner, type, lnbitsize, lnbitpos,
3700 ll_unsignedp || rl_unsignedp);
3701
91d33e36 3702 ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
6d716ca8
RS		 3703 if (! all_ones_mask_p (ll_mask, lnbitsize))
3704 result = build (BIT_AND_EXPR, type, result, ll_mask);
3705
3706 return build (wanted_code, truth_type, result,
91d33e36 3707 const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
6d716ca8
RS		 3708}
3709\f
b5f3b6b6
RK		 3710/* If T contains a COMPOUND_EXPR which was inserted merely to evaluate
3711 S, a SAVE_EXPR, return the expression actually being evaluated. Note
3712 that we may sometimes modify the tree. */
3713
3714static tree
3715strip_compound_expr (t, s)
3716 tree t;
3717 tree s;
3718{
b5f3b6b6
RK		 3719 enum tree_code code = TREE_CODE (t);
3720
3721 /* See if this is the COMPOUND_EXPR we want to eliminate. */
3722 if (code == COMPOUND_EXPR && TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR
3723 && TREE_OPERAND (TREE_OPERAND (t, 0), 0) == s)
3724 return TREE_OPERAND (t, 1);
3725
3726 /* See if this is a COND_EXPR or a simple arithmetic operator. We
3727 don't bother handling any other types. */
3728 else if (code == COND_EXPR)
3729 {
3730 TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
3731 TREE_OPERAND (t, 1) = strip_compound_expr (TREE_OPERAND (t, 1), s);
3732 TREE_OPERAND (t, 2) = strip_compound_expr (TREE_OPERAND (t, 2), s);
3733 }
3734 else if (TREE_CODE_CLASS (code) == '1')
3735 TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
3736 else if (TREE_CODE_CLASS (code) == '<'
3737 || TREE_CODE_CLASS (code) == '2')
3738 {
3739 TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
3740 TREE_OPERAND (t, 1) = strip_compound_expr (TREE_OPERAND (t, 1), s);
3741 }
3742
3743 return t;
3744}
3745\f
f628873f
MM		 3746/* Return a node which has the indicated constant VALUE (either 0 or
3747 1), and is of the indicated TYPE. */
3748
83e0821b 3749static tree
f628873f
MM		 3750constant_boolean_node (value, type)
3751 int value;
3752 tree type;
3753{
3754 if (type == integer_type_node)
3755 return value ? integer_one_node : integer_zero_node;
3756 else if (TREE_CODE (type) == BOOLEAN_TYPE)
3757 return truthvalue_conversion (value ? integer_one_node :
3758 integer_zero_node);
3759 else
3760 {
3761 tree t = build_int_2 (value, 0);
3762 TREE_TYPE (t) = type;
3763 return t;
3764 }
3765}
3766
6d716ca8
RS		 3767/* Perform constant folding and related simplification of EXPR.
3768 The related simplifications include x*1 => x, x*0 => 0, etc.,
3769 and application of the associative law.
3770 NOP_EXPR conversions may be removed freely (as long as we
3771 are careful not to change the C type of the overall expression)
3772 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
3773 but we can constant-fold them if they have constant operands. */
3774
3775tree
3776fold (expr)
3777 tree expr;
3778{
3779 register tree t = expr;
3780 tree t1 = NULL_TREE;
c05a9b68 3781 tree tem;
6d716ca8 3782 tree type = TREE_TYPE (expr);
4e86caed 3783 register tree arg0 = NULL_TREE, arg1 = NULL_TREE;
6d716ca8
RS		 3784 register enum tree_code code = TREE_CODE (t);
3785 register int kind;
c05a9b68 3786 int invert;
6d716ca8
RS		 3787
3788 /* WINS will be nonzero when the switch is done
3789 if all operands are constant. */
3790
3791 int wins = 1;
3792
5fd7f37d
RK		 3793 /* Don't try to process an RTL_EXPR since its operands aren't trees.
3794 Likewise for a SAVE_EXPR that's already been evaluated. */
3795 if (code == RTL_EXPR || (code == SAVE_EXPR && SAVE_EXPR_RTL (t)) != 0)
ac27d589
RK		 3796 return t;
3797
6d716ca8
RS		 3798 /* Return right away if already constant. */
3799 if (TREE_CONSTANT (t))
3800 {
3801 if (code == CONST_DECL)
3802 return DECL_INITIAL (t);
3803 return t;
3804 }
3805
dbecbbe4
JL		 3806#ifdef MAX_INTEGER_COMPUTATION_MODE
3807 check_max_integer_computation_mode (expr);
3808#endif
3809
6d716ca8 3810 kind = TREE_CODE_CLASS (code);
1b81aa14
RS		 3811 if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
3812 {
1cc1b11a
RS		 3813 tree subop;
3814
1b81aa14
RS		 3815 /* Special case for conversion ops that can have fixed point args. */
3816 arg0 = TREE_OPERAND (t, 0);
3817
3818 /* Don't use STRIP_NOPS, because signedness of argument type matters. */
3819 if (arg0 != 0)
3820 STRIP_TYPE_NOPS (arg0);
3821
1cc1b11a
RS		 3822 if (arg0 != 0 && TREE_CODE (arg0) == COMPLEX_CST)
3823 subop = TREE_REALPART (arg0);
3824 else
3825 subop = arg0;
3826
3827 if (subop != 0 && TREE_CODE (subop) != INTEGER_CST
1b81aa14 3828#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1cc1b11a 3829 && TREE_CODE (subop) != REAL_CST
1b81aa14
RS		 3830#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
3831 )
3832 /* Note that TREE_CONSTANT isn't enough:
3833 static var addresses are constant but we can't
3834 do arithmetic on them. */
3835 wins = 0;
3836 }
3837 else if (kind == 'e' || kind == '<'
3838 || kind == '1' || kind == '2' || kind == 'r')
6d716ca8
RS		 3839 {
3840 register int len = tree_code_length[(int) code];
3841 register int i;
3842 for (i = 0; i < len; i++)
3843 {
3844 tree op = TREE_OPERAND (t, i);
1cc1b11a 3845 tree subop;
6d716ca8
RS		 3846
3847 if (op == 0)
3848 continue; /* Valid for CALL_EXPR, at least. */
3849
b8a91430
RK		 3850 if (kind == '<' || code == RSHIFT_EXPR)
3851 {
3852 /* Signedness matters here. Perhaps we can refine this
3853 later. */
3854 STRIP_TYPE_NOPS (op);
3855 }
3856 else
3857 {
3858 /* Strip any conversions that don't change the mode. */
3859 STRIP_NOPS (op);
3860 }
6d716ca8 3861
1cc1b11a
RS		 3862 if (TREE_CODE (op) == COMPLEX_CST)
3863 subop = TREE_REALPART (op);
3864 else
3865 subop = op;
3866
3867 if (TREE_CODE (subop) != INTEGER_CST
6d716ca8 3868#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1cc1b11a 3869 && TREE_CODE (subop) != REAL_CST
6d716ca8
RS		 3870#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
3871 )
3872 /* Note that TREE_CONSTANT isn't enough:
3873 static var addresses are constant but we can't
3874 do arithmetic on them. */
3875 wins = 0;
3876
3877 if (i == 0)
3878 arg0 = op;
3879 else if (i == 1)
3880 arg1 = op;
3881 }
3882 }
3883
3884 /* If this is a commutative operation, and ARG0 is a constant, move it
3885 to ARG1 to reduce the number of tests below. */
3886 if ((code == PLUS_EXPR || code == MULT_EXPR || code == MIN_EXPR
3887 || code == MAX_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR
3888 || code == BIT_AND_EXPR)
3889 && (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST))
3890 {
c05a9b68 3891 tem = arg0; arg0 = arg1; arg1 = tem;
6d716ca8 3892
c05a9b68
RS		 3893 tem = TREE_OPERAND (t, 0); TREE_OPERAND (t, 0) = TREE_OPERAND (t, 1);
3894 TREE_OPERAND (t, 1) = tem;
6d716ca8
RS		 3895 }
3896
3897 /* Now WINS is set as described above,
3898 ARG0 is the first operand of EXPR,
3899 and ARG1 is the second operand (if it has more than one operand).
3900
3901 First check for cases where an arithmetic operation is applied to a
3902 compound, conditional, or comparison operation. Push the arithmetic
3903 operation inside the compound or conditional to see if any folding
3904 can then be done. Convert comparison to conditional for this purpose.
3905 The also optimizes non-constant cases that used to be done in
96d4cf0a
RK		 3906 expand_expr.
3907
3908 Before we do that, see if this is a BIT_AND_EXPR or a BIT_OR_EXPR,
61f275ff
RK		 3909 one of the operands is a comparison and the other is a comparison, a
3910 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
3911 code below would make the expression more complex. Change it to a
2df46b06
RK		 3912 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
3913 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
96d4cf0a 3914
2df46b06
RK		 3915 if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
3916 || code == EQ_EXPR || code == NE_EXPR)
61f275ff
RK		 3917 && ((truth_value_p (TREE_CODE (arg0))
3918 && (truth_value_p (TREE_CODE (arg1))
96d4cf0a
RK		 3919 || (TREE_CODE (arg1) == BIT_AND_EXPR
3920 && integer_onep (TREE_OPERAND (arg1, 1)))))
61f275ff
RK		 3921 || (truth_value_p (TREE_CODE (arg1))
3922 && (truth_value_p (TREE_CODE (arg0))
96d4cf0a
RK		 3923 || (TREE_CODE (arg0) == BIT_AND_EXPR
3924 && integer_onep (TREE_OPERAND (arg0, 1)))))))
2df46b06
RK		 3925 {
3926 t = fold (build (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
3927 : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
3928 : TRUTH_XOR_EXPR,
3929 type, arg0, arg1));
3930
3931 if (code == EQ_EXPR)
3932 t = invert_truthvalue (t);
3933
3934 return t;
3935 }
96d4cf0a 3936
6d716ca8
RS		 3937 if (TREE_CODE_CLASS (code) == '1')
3938 {
3939 if (TREE_CODE (arg0) == COMPOUND_EXPR)
3940 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
3941 fold (build1 (code, type, TREE_OPERAND (arg0, 1))));
3942 else if (TREE_CODE (arg0) == COND_EXPR)
b8eb43a2
RK		 3943 {
3944 t = fold (build (COND_EXPR, type, TREE_OPERAND (arg0, 0),
3945 fold (build1 (code, type, TREE_OPERAND (arg0, 1))),
3946 fold (build1 (code, type, TREE_OPERAND (arg0, 2)))));
3947
3948 /* If this was a conversion, and all we did was to move into
e1f56f62
RK		 3949 inside the COND_EXPR, bring it back out. But leave it if
3950 it is a conversion from integer to integer and the
3951 result precision is no wider than a word since such a
3952 conversion is cheap and may be optimized away by combine,
3953 while it couldn't if it were outside the COND_EXPR. Then return
3954 so we don't get into an infinite recursion loop taking the
3955 conversion out and then back in. */
b8eb43a2
RK		 3956
3957 if ((code == NOP_EXPR || code == CONVERT_EXPR
3958 || code == NON_LVALUE_EXPR)
3959 && TREE_CODE (t) == COND_EXPR
3960 && TREE_CODE (TREE_OPERAND (t, 1)) == code
459a2653
RK		 3961 && TREE_CODE (TREE_OPERAND (t, 2)) == code
3962 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0))
e1f56f62
RK		 3963 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 2), 0)))
3964 && ! (INTEGRAL_TYPE_P (TREE_TYPE (t))
3965 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0)))
3966 && TYPE_PRECISION (TREE_TYPE (t)) <= BITS_PER_WORD))
b8eb43a2
RK		 3967 t = build1 (code, type,
3968 build (COND_EXPR,
3969 TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0)),
3970 TREE_OPERAND (t, 0),
3971 TREE_OPERAND (TREE_OPERAND (t, 1), 0),
3972 TREE_OPERAND (TREE_OPERAND (t, 2), 0)));
3973 return t;
3974 }
6d716ca8
RS		 3975 else if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
3976 return fold (build (COND_EXPR, type, arg0,
3977 fold (build1 (code, type, integer_one_node)),
3978 fold (build1 (code, type, integer_zero_node))));
3979 }
96d4cf0a
RK		 3980 else if (TREE_CODE_CLASS (code) == '2'
3981 || TREE_CODE_CLASS (code) == '<')
6d716ca8
RS		 3982 {
3983 if (TREE_CODE (arg1) == COMPOUND_EXPR)
3984 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
96d4cf0a
RK		 3985 fold (build (code, type,
3986 arg0, TREE_OPERAND (arg1, 1))));
f0eebf28
RK		 3987 else if ((TREE_CODE (arg1) == COND_EXPR
3988 || (TREE_CODE_CLASS (TREE_CODE (arg1)) == '<'
3989 && TREE_CODE_CLASS (code) != '<'))
3990 && (! TREE_SIDE_EFFECTS (arg0) || current_function_decl != 0))
6d716ca8
RS		 3991 {
3992 tree test, true_value, false_value;
f5963e61 3993 tree lhs = 0, rhs = 0;
6d716ca8
RS		 3994
3995 if (TREE_CODE (arg1) == COND_EXPR)
3996 {
3997 test = TREE_OPERAND (arg1, 0);
3998 true_value = TREE_OPERAND (arg1, 1);
3999 false_value = TREE_OPERAND (arg1, 2);
4000 }
4001 else
4002 {
25216284 4003 tree testtype = TREE_TYPE (arg1);
6d716ca8 4004 test = arg1;
25216284
RK		 4005 true_value = convert (testtype, integer_one_node);
4006 false_value = convert (testtype, integer_zero_node);
6d716ca8
RS		 4007 }
4008
96d4cf0a
RK		 4009 /* If ARG0 is complex we want to make sure we only evaluate
4010 it once. Though this is only required if it is volatile, it
4011 might be more efficient even if it is not. However, if we
4012 succeed in folding one part to a constant, we do not need
4013 to make this SAVE_EXPR. Since we do this optimization
4014 primarily to see if we do end up with constant and this
9faa82d8 4015 SAVE_EXPR interferes with later optimizations, suppressing
f5963e61 4016 it when we can is important.
96d4cf0a 4017
f5963e61
JL		 4018 If we are not in a function, we can't make a SAVE_EXPR, so don't
4019 try to do so. Don't try to see if the result is a constant
4020 if an arm is a COND_EXPR since we get exponential behavior
4021 in that case. */
4022
4023 if (TREE_CODE (arg0) != SAVE_EXPR && ! TREE_CONSTANT (arg0)
4024 && current_function_decl != 0
b5f3b6b6
RK		 4025 && ((TREE_CODE (arg0) != VAR_DECL
4026 && TREE_CODE (arg0) != PARM_DECL)
4027 || TREE_SIDE_EFFECTS (arg0)))
96d4cf0a 4028 {
f5963e61
JL		 4029 if (TREE_CODE (true_value) != COND_EXPR)
4030 lhs = fold (build (code, type, arg0, true_value));
96d4cf0a 4031
f5963e61
JL		 4032 if (TREE_CODE (false_value) != COND_EXPR)
4033 rhs = fold (build (code, type, arg0, false_value));
96d4cf0a 4034
f5963e61
JL		 4035 if ((lhs == 0 || ! TREE_CONSTANT (lhs))
4036 && (rhs == 0 || !TREE_CONSTANT (rhs)))
4037 arg0 = save_expr (arg0), lhs = rhs = 0;
96d4cf0a
RK		 4038 }
4039
f5963e61
JL		 4040 if (lhs == 0)
4041 lhs = fold (build (code, type, arg0, true_value));
4042 if (rhs == 0)
4043 rhs = fold (build (code, type, arg0, false_value));
4044
4045 test = fold (build (COND_EXPR, type, test, lhs, rhs));
4046
6d716ca8
RS		 4047 if (TREE_CODE (arg0) == SAVE_EXPR)
4048 return build (COMPOUND_EXPR, type,
b5f3b6b6
RK		 4049 convert (void_type_node, arg0),
4050 strip_compound_expr (test, arg0));
6d716ca8
RS		 4051 else
4052 return convert (type, test);
4053 }
4054
4055 else if (TREE_CODE (arg0) == COMPOUND_EXPR)
4056 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4057 fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
f0eebf28
RK		 4058 else if ((TREE_CODE (arg0) == COND_EXPR
4059 || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
4060 && TREE_CODE_CLASS (code) != '<'))
4061 && (! TREE_SIDE_EFFECTS (arg1) || current_function_decl != 0))
6d716ca8
RS		 4062 {
4063 tree test, true_value, false_value;
f5963e61 4064 tree lhs = 0, rhs = 0;
6d716ca8
RS		 4065
4066 if (TREE_CODE (arg0) == COND_EXPR)
4067 {
4068 test = TREE_OPERAND (arg0, 0);
4069 true_value = TREE_OPERAND (arg0, 1);
4070 false_value = TREE_OPERAND (arg0, 2);
4071 }
4072 else
4073 {
25216284 4074 tree testtype = TREE_TYPE (arg0);
6d716ca8 4075 test = arg0;
25216284
RK		 4076 true_value = convert (testtype, integer_one_node);
4077 false_value = convert (testtype, integer_zero_node);
6d716ca8
RS		 4078 }
4079
f5963e61
JL		 4080 if (TREE_CODE (arg1) != SAVE_EXPR && ! TREE_CONSTANT (arg0)
4081 && current_function_decl != 0
b5f3b6b6
RK		 4082 && ((TREE_CODE (arg1) != VAR_DECL
4083 && TREE_CODE (arg1) != PARM_DECL)
4084 || TREE_SIDE_EFFECTS (arg1)))
96d4cf0a 4085 {
f5963e61
JL		 4086 if (TREE_CODE (true_value) != COND_EXPR)
4087 lhs = fold (build (code, type, true_value, arg1));
96d4cf0a 4088
f5963e61
JL		 4089 if (TREE_CODE (false_value) != COND_EXPR)
4090 rhs = fold (build (code, type, false_value, arg1));
96d4cf0a 4091
f5963e61
JL		 4092 if ((lhs == 0 || ! TREE_CONSTANT (lhs))
4093 && (rhs == 0 || !TREE_CONSTANT (rhs)))
4094 arg1 = save_expr (arg1), lhs = rhs = 0;
96d4cf0a
RK		 4095 }
4096
f5963e61
JL		 4097 if (lhs == 0)
4098 lhs = fold (build (code, type, true_value, arg1));
4099
4100 if (rhs == 0)
4101 rhs = fold (build (code, type, false_value, arg1));
4102
4103 test = fold (build (COND_EXPR, type, test, lhs, rhs));
6d716ca8
RS		 4104 if (TREE_CODE (arg1) == SAVE_EXPR)
4105 return build (COMPOUND_EXPR, type,
b5f3b6b6
RK		 4106 convert (void_type_node, arg1),
4107 strip_compound_expr (test, arg1));
6d716ca8
RS		 4108 else
4109 return convert (type, test);
4110 }
4111 }
c05a9b68
RS		 4112 else if (TREE_CODE_CLASS (code) == '<'
4113 && TREE_CODE (arg0) == COMPOUND_EXPR)
4114 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4115 fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
4116 else if (TREE_CODE_CLASS (code) == '<'
4117 && TREE_CODE (arg1) == COMPOUND_EXPR)
4118 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
4119 fold (build (code, type, arg0, TREE_OPERAND (arg1, 1))));
6d716ca8
RS		 4120
4121 switch (code)
4122 {
4123 case INTEGER_CST:
4124 case REAL_CST:
4125 case STRING_CST:
4126 case COMPLEX_CST:
4127 case CONSTRUCTOR:
4128 return t;
4129
4130 case CONST_DECL:
4131 return fold (DECL_INITIAL (t));
4132
4133 case NOP_EXPR:
4134 case FLOAT_EXPR:
4135 case CONVERT_EXPR:
4136 case FIX_TRUNC_EXPR:
4137 /* Other kinds of FIX are not handled properly by fold_convert. */
33558beb 4138
e1f56f62
RK		 4139 if (TREE_TYPE (TREE_OPERAND (t, 0)) == TREE_TYPE (t))
4140 return TREE_OPERAND (t, 0);
4141
7e139075
RK		 4142 /* Handle cases of two conversions in a row. */
4143 if (TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
4144 || TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR)
4145 {
4146 tree inside_type = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4147 tree inter_type = TREE_TYPE (TREE_OPERAND (t, 0));
4148 tree final_type = TREE_TYPE (t);
4149 int inside_int = INTEGRAL_TYPE_P (inside_type);
7f0b305c 4150 int inside_ptr = POINTER_TYPE_P (inside_type);
7e139075
RK		 4151 int inside_float = FLOAT_TYPE_P (inside_type);
4152 int inside_prec = TYPE_PRECISION (inside_type);
4153 int inside_unsignedp = TREE_UNSIGNED (inside_type);
4154 int inter_int = INTEGRAL_TYPE_P (inter_type);
7f0b305c 4155 int inter_ptr = POINTER_TYPE_P (inter_type);
7e139075
RK		 4156 int inter_float = FLOAT_TYPE_P (inter_type);
4157 int inter_prec = TYPE_PRECISION (inter_type);
4158 int inter_unsignedp = TREE_UNSIGNED (inter_type);
4159 int final_int = INTEGRAL_TYPE_P (final_type);
7f0b305c 4160 int final_ptr = POINTER_TYPE_P (final_type);
7e139075
RK		 4161 int final_float = FLOAT_TYPE_P (final_type);
4162 int final_prec = TYPE_PRECISION (final_type);
4163 int final_unsignedp = TREE_UNSIGNED (final_type);
4164
4165 /* In addition to the cases of two conversions in a row
4166 handled below, if we are converting something to its own
4167 type via an object of identical or wider precision, neither
4168 conversion is needed. */
4169 if (inside_type == final_type
4170 && ((inter_int && final_int) || (inter_float && final_float))
4171 && inter_prec >= final_prec)
4172 return TREE_OPERAND (TREE_OPERAND (t, 0), 0);
4173
4174 /* Likewise, if the intermediate and final types are either both
4175 float or both integer, we don't need the middle conversion if
4176 it is wider than the final type and doesn't change the signedness
7f0b305c 4177 (for integers). Avoid this if the final type is a pointer
410d3f5d
RK		 4178 since then we sometimes need the inner conversion. Likewise if
4179 the outer has a precision not equal to the size of its mode. */
7e139075
RK		 4180 if ((((inter_int || inter_ptr) && (inside_int || inside_ptr))
4181 || (inter_float && inside_float))
4182 && inter_prec >= inside_prec
7f0b305c 4183 && (inter_float || inter_unsignedp == inside_unsignedp)
410d3f5d
RK		 4184 && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
4185 && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
7f0b305c 4186 && ! final_ptr)
7e139075
RK		 4187 return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4188
ba3ad5e0
PDM		 4189 /* If we have a sign-extension of a zero-extended value, we can
4190 replace that by a single zero-extension. */
4191 if (inside_int && inter_int && final_int
4192 && inside_prec < inter_prec && inter_prec < final_prec
4193 && inside_unsignedp && !inter_unsignedp)
4194 return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4195
7e139075
RK		 4196 /* Two conversions in a row are not needed unless:
4197 - some conversion is floating-point (overstrict for now), or
4198 - the intermediate type is narrower than both initial and
4199 final, or
4200 - the intermediate type and innermost type differ in signedness,
4201 and the outermost type is wider than the intermediate, or
4202 - the initial type is a pointer type and the precisions of the
4203 intermediate and final types differ, or
4204 - the final type is a pointer type and the precisions of the
4205 initial and intermediate types differ. */
4206 if (! inside_float && ! inter_float && ! final_float
4207 && (inter_prec > inside_prec || inter_prec > final_prec)
4208 && ! (inside_int && inter_int
4209 && inter_unsignedp != inside_unsignedp
4210 && inter_prec < final_prec)
4211 && ((inter_unsignedp && inter_prec > inside_prec)
4212 == (final_unsignedp && final_prec > inter_prec))
4213 && ! (inside_ptr && inter_prec != final_prec)
410d3f5d
RK		 4214 && ! (final_ptr && inside_prec != inter_prec)
4215 && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
4216 && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
4217 && ! final_ptr)
7e139075
RK		 4218 return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4219 }
6d716ca8
RS		 4220
4221 if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR
d8f6dbb9
RS		 4222 && TREE_CONSTANT (TREE_OPERAND (TREE_OPERAND (t, 0), 1))
4223 /* Detect assigning a bitfield. */
4224 && !(TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)) == COMPONENT_REF
4225 && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 0), 0), 1))))
6d716ca8 4226 {
d8f6dbb9 4227 /* Don't leave an assignment inside a conversion
f72aed24 4228 unless assigning a bitfield. */
6d716ca8
RS		 4229 tree prev = TREE_OPERAND (t, 0);
4230 TREE_OPERAND (t, 0) = TREE_OPERAND (prev, 1);
4231 /* First do the assignment, then return converted constant. */
4232 t = build (COMPOUND_EXPR, TREE_TYPE (t), prev, fold (t));
4233 TREE_USED (t) = 1;
4234 return t;
4235 }
4236 if (!wins)
4237 {
4238 TREE_CONSTANT (t) = TREE_CONSTANT (arg0);
4239 return t;
4240 }
4241 return fold_convert (t, arg0);
4242
4243#if 0 /* This loses on &"foo"[0]. */
4244 case ARRAY_REF:
4245 {
4246 int i;
4247
4248 /* Fold an expression like: "foo"[2] */
4249 if (TREE_CODE (arg0) == STRING_CST
4250 && TREE_CODE (arg1) == INTEGER_CST
4251 && !TREE_INT_CST_HIGH (arg1)
4252 && (i = TREE_INT_CST_LOW (arg1)) < TREE_STRING_LENGTH (arg0))
4253 {
4254 t = build_int_2 (TREE_STRING_POINTER (arg0)[i], 0);
4255 TREE_TYPE (t) = TREE_TYPE (TREE_TYPE (arg0));
ef2bf0c0 4256 force_fit_type (t, 0);
6d716ca8
RS		 4257 }
4258 }
4259 return t;
4260#endif /* 0 */
4261
e082358b
JM		 4262 case COMPONENT_REF:
4263 if (TREE_CODE (arg0) == CONSTRUCTOR)
3ac4f0e6
JM		 4264 {
4265 tree m = purpose_member (arg1, CONSTRUCTOR_ELTS (arg0));
4266 if (m)
4267 t = TREE_VALUE (m);
4268 }
e082358b
JM		 4269 return t;
4270
6d716ca8
RS		 4271 case RANGE_EXPR:
4272 TREE_CONSTANT (t) = wins;
4273 return t;
4274
4275 case NEGATE_EXPR:
4276 if (wins)
4277 {
4278 if (TREE_CODE (arg0) == INTEGER_CST)
4279 {
fe3e8e40
RS		 4280 HOST_WIDE_INT low, high;
4281 int overflow = neg_double (TREE_INT_CST_LOW (arg0),
4282 TREE_INT_CST_HIGH (arg0),
4283 &low, &high);
4284 t = build_int_2 (low, high);
6d716ca8 4285 TREE_TYPE (t) = type;
dc3907c5
PE		 4286 TREE_OVERFLOW (t)
4287 = (TREE_OVERFLOW (arg0)
0c9cabe7 4288 | force_fit_type (t, overflow && !TREE_UNSIGNED (type)));
dc3907c5
PE		 4289 TREE_CONSTANT_OVERFLOW (t)
4290 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
6d716ca8
RS		 4291 }
4292 else if (TREE_CODE (arg0) == REAL_CST)
4293 t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
6d716ca8
RS		 4294 }
4295 else if (TREE_CODE (arg0) == NEGATE_EXPR)
4296 return TREE_OPERAND (arg0, 0);
4297
4298 /* Convert - (a - b) to (b - a) for non-floating-point. */
7178e3af 4299 else if (TREE_CODE (arg0) == MINUS_EXPR && ! FLOAT_TYPE_P (type))
6d716ca8
RS		 4300 return build (MINUS_EXPR, type, TREE_OPERAND (arg0, 1),
4301 TREE_OPERAND (arg0, 0));
4302
4303 return t;
4304
4305 case ABS_EXPR:
4306 if (wins)
4307 {
4308 if (TREE_CODE (arg0) == INTEGER_CST)
4309 {
4310 if (! TREE_UNSIGNED (type)
4311 && TREE_INT_CST_HIGH (arg0) < 0)
4312 {
2a23183e
RS		 4313 HOST_WIDE_INT low, high;
4314 int overflow = neg_double (TREE_INT_CST_LOW (arg0),
4315 TREE_INT_CST_HIGH (arg0),
4316 &low, &high);
4317 t = build_int_2 (low, high);
4318 TREE_TYPE (t) = type;
dc3907c5
PE		 4319 TREE_OVERFLOW (t)
4320 = (TREE_OVERFLOW (arg0)
e0f776fb 4321 | force_fit_type (t, overflow));
dc3907c5
PE		 4322 TREE_CONSTANT_OVERFLOW (t)
4323 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
6d716ca8
RS		 4324 }
4325 }
4326 else if (TREE_CODE (arg0) == REAL_CST)
4327 {
c05a9b68 4328 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
6d716ca8
RS		 4329 t = build_real (type,
4330 REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
4331 }
6d716ca8
RS		 4332 }
4333 else if (TREE_CODE (arg0) == ABS_EXPR || TREE_CODE (arg0) == NEGATE_EXPR)
4334 return build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0));
4335 return t;
4336
551064b1
RS		 4337 case CONJ_EXPR:
4338 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
4339 return arg0;
4340 else if (TREE_CODE (arg0) == COMPLEX_EXPR)
4341 return build (COMPLEX_EXPR, TREE_TYPE (arg0),
4342 TREE_OPERAND (arg0, 0),
4343 fold (build1 (NEGATE_EXPR,
4344 TREE_TYPE (TREE_TYPE (arg0)),
4345 TREE_OPERAND (arg0, 1))));
4346 else if (TREE_CODE (arg0) == COMPLEX_CST)
214d5b84 4347 return build_complex (type, TREE_OPERAND (arg0, 0),
551064b1
RS		 4348 fold (build1 (NEGATE_EXPR,
4349 TREE_TYPE (TREE_TYPE (arg0)),
4350 TREE_OPERAND (arg0, 1))));
4351 else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
4352 return fold (build (TREE_CODE (arg0), type,
4353 fold (build1 (CONJ_EXPR, type,
4354 TREE_OPERAND (arg0, 0))),
4355 fold (build1 (CONJ_EXPR,
4356 type, TREE_OPERAND (arg0, 1)))));
4357 else if (TREE_CODE (arg0) == CONJ_EXPR)
4358 return TREE_OPERAND (arg0, 0);
4359 return t;
4360
6d716ca8
RS		 4361 case BIT_NOT_EXPR:
4362 if (wins)
4363 {
380ff34a
RK		 4364 t = build_int_2 (~ TREE_INT_CST_LOW (arg0),
4365 ~ TREE_INT_CST_HIGH (arg0));
6d716ca8 4366 TREE_TYPE (t) = type;
e0f776fb 4367 force_fit_type (t, 0);
dc3907c5 4368 TREE_OVERFLOW (t) = TREE_OVERFLOW (arg0);
fe3e8e40 4369 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (arg0);
6d716ca8
RS		 4370 }
4371 else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
4372 return TREE_OPERAND (arg0, 0);
4373 return t;
4374
4375 case PLUS_EXPR:
4376 /* A + (-B) -> A - B */
4377 if (TREE_CODE (arg1) == NEGATE_EXPR)
4378 return fold (build (MINUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
7178e3af 4379 else if (! FLOAT_TYPE_P (type))
6d716ca8
RS		 4380 {
4381 if (integer_zerop (arg1))
4382 return non_lvalue (convert (type, arg0));
4383
4384 /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
4385 with a constant, and the two constants have no bits in common,
4386 we should treat this as a BIT_IOR_EXPR since this may produce more
4387 simplifications. */
4388 if (TREE_CODE (arg0) == BIT_AND_EXPR
4389 && TREE_CODE (arg1) == BIT_AND_EXPR
4390 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
4391 && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
4392 && integer_zerop (const_binop (BIT_AND_EXPR,
4393 TREE_OPERAND (arg0, 1),
91d33e36 4394 TREE_OPERAND (arg1, 1), 0)))
6d716ca8
RS		 4395 {
4396 code = BIT_IOR_EXPR;
4397 goto bit_ior;
4398 }
6a96fcb4
RK		 4399
4400 /* (A * C) + (B * C) -> (A+B) * C. Since we are most concerned
4401 about the case where C is a constant, just try one of the
4402 four possibilities. */
4403
4404 if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR
4405 && operand_equal_p (TREE_OPERAND (arg0, 1),
4406 TREE_OPERAND (arg1, 1), 0))
4407 return fold (build (MULT_EXPR, type,
4408 fold (build (PLUS_EXPR, type,
4409 TREE_OPERAND (arg0, 0),
4410 TREE_OPERAND (arg1, 0))),
4411 TREE_OPERAND (arg0, 1)));
6d716ca8
RS		 4412 }
4413 /* In IEEE floating point, x+0 may not equal x. */
996c63d3
RK		 4414 else if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
4415 || flag_fast_math)
6d716ca8
RS		 4416 && real_zerop (arg1))
4417 return non_lvalue (convert (type, arg0));
4418 associate:
4419 /* In most languages, can't associate operations on floats
4420 through parentheses. Rather than remember where the parentheses
e9aaa5a5
RK		 4421 were, we don't associate floats at all. It shouldn't matter much.
4422 However, associating multiplications is only very slightly
4423 inaccurate, so do that if -ffast-math is specified. */
4424 if (FLOAT_TYPE_P (type)
4425 && ! (flag_fast_math && code == MULT_EXPR))
6d716ca8 4426 goto binary;
e9aaa5a5 4427
6d716ca8
RS		 4428 /* The varsign == -1 cases happen only for addition and subtraction.
4429 It says that the arg that was split was really CON minus VAR.
4430 The rest of the code applies to all associative operations. */
4431 if (!wins)
4432 {
c05a9b68 4433 tree var, con;
6d716ca8
RS		 4434 int varsign;
4435
4436 if (split_tree (arg0, code, &var, &con, &varsign))
4437 {
4438 if (varsign == -1)
4439 {
4440 /* EXPR is (CON-VAR) +- ARG1. */
4441 /* If it is + and VAR==ARG1, return just CONST. */
4442 if (code == PLUS_EXPR && operand_equal_p (var, arg1, 0))
4443 return convert (TREE_TYPE (t), con);
4444
ca86a57a 4445 /* If ARG0 is a constant, don't change things around;
77a45a2e 4446 instead keep all the constant computations together. */
ca86a57a 4447
77a45a2e 4448 if (TREE_CONSTANT (arg0))
ca86a57a
RK		 4449 return t;
4450
6d716ca8 4451 /* Otherwise return (CON +- ARG1) - VAR. */
cd7ece66
RK		 4452 t = build (MINUS_EXPR, type,
4453 fold (build (code, type, con, arg1)), var);
6d716ca8
RS		 4454 }
4455 else
4456 {
4457 /* EXPR is (VAR+CON) +- ARG1. */
4458 /* If it is - and VAR==ARG1, return just CONST. */
4459 if (code == MINUS_EXPR && operand_equal_p (var, arg1, 0))
4460 return convert (TREE_TYPE (t), con);
4461
ca86a57a 4462 /* If ARG0 is a constant, don't change things around;
77a45a2e 4463 instead keep all the constant computations together. */
ca86a57a 4464
77a45a2e 4465 if (TREE_CONSTANT (arg0))
ca86a57a
RK		 4466 return t;
4467
6d716ca8 4468 /* Otherwise return VAR +- (ARG1 +- CON). */
cd7ece66
RK		 4469 tem = fold (build (code, type, arg1, con));
4470 t = build (code, type, var, tem);
4471
6d716ca8
RS		 4472 if (integer_zerop (tem)
4473 && (code == PLUS_EXPR || code == MINUS_EXPR))
4474 return convert (type, var);
4475 /* If we have x +/- (c - d) [c an explicit integer]
4476 change it to x -/+ (d - c) since if d is relocatable
4477 then the latter can be a single immediate insn
4478 and the former cannot. */
4479 if (TREE_CODE (tem) == MINUS_EXPR
4480 && TREE_CODE (TREE_OPERAND (tem, 0)) == INTEGER_CST)
4481 {
4482 tree tem1 = TREE_OPERAND (tem, 1);
4483 TREE_OPERAND (tem, 1) = TREE_OPERAND (tem, 0);
4484 TREE_OPERAND (tem, 0) = tem1;
4485 TREE_SET_CODE (t,
4486 (code == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR));
4487 }
4488 }
4489 return t;
4490 }
4491
4492 if (split_tree (arg1, code, &var, &con, &varsign))
4493 {
77a45a2e 4494 if (TREE_CONSTANT (arg1))
cc5edac6
RK		 4495 return t;
4496
4497 if (varsign == -1)
4498 TREE_SET_CODE (t,
4499 (code == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR));
4500
6d716ca8 4501 /* EXPR is ARG0 +- (CON +- VAR). */
6d716ca8
RS		 4502 if (TREE_CODE (t) == MINUS_EXPR
4503 && operand_equal_p (var, arg0, 0))
4504 {
4505 /* If VAR and ARG0 cancel, return just CON or -CON. */
4506 if (code == PLUS_EXPR)
4507 return convert (TREE_TYPE (t), con);
4508 return fold (build1 (NEGATE_EXPR, TREE_TYPE (t),
4509 convert (TREE_TYPE (t), con)));
4510 }
cc5edac6 4511
cd7ece66
RK		 4512 t = build (TREE_CODE (t), type,
4513 fold (build (code, TREE_TYPE (t), arg0, con)), var);
4514
6d716ca8
RS		 4515 if (integer_zerop (TREE_OPERAND (t, 0))
4516 && TREE_CODE (t) == PLUS_EXPR)
4517 return convert (TREE_TYPE (t), var);
4518 return t;
4519 }
4520 }
4521 binary:
4522#if defined (REAL_IS_NOT_DOUBLE) && ! defined (REAL_ARITHMETIC)
4523 if (TREE_CODE (arg1) == REAL_CST)
4524 return t;
4525#endif /* REAL_IS_NOT_DOUBLE, and no REAL_ARITHMETIC */
4526 if (wins)
91d33e36 4527 t1 = const_binop (code, arg0, arg1, 0);
6d716ca8
RS		 4528 if (t1 != NULL_TREE)
4529 {
4530 /* The return value should always have
4531 the same type as the original expression. */
380ff34a
RK		 4532 if (TREE_TYPE (t1) != TREE_TYPE (t))
4533 t1 = convert (TREE_TYPE (t), t1);
4534
6d716ca8
RS		 4535 return t1;
4536 }
4537 return t;
4538
4539 case MINUS_EXPR:
7178e3af 4540 if (! FLOAT_TYPE_P (type))
6d716ca8
RS		 4541 {
4542 if (! wins && integer_zerop (arg0))
4543 return build1 (NEGATE_EXPR, type, arg1);
4544 if (integer_zerop (arg1))
4545 return non_lvalue (convert (type, arg0));
6a96fcb4
RK		 4546
4547 /* (A * C) - (B * C) -> (A-B) * C. Since we are most concerned
4548 about the case where C is a constant, just try one of the
4549 four possibilities. */
4550
4551 if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR
4552 && operand_equal_p (TREE_OPERAND (arg0, 1),
4553 TREE_OPERAND (arg1, 1), 0))
4554 return fold (build (MULT_EXPR, type,
4555 fold (build (MINUS_EXPR, type,
4556 TREE_OPERAND (arg0, 0),
4557 TREE_OPERAND (arg1, 0))),
4558 TREE_OPERAND (arg0, 1)));
6d716ca8
RS		 4559 }
4560 /* Convert A - (-B) to A + B. */
4561 else if (TREE_CODE (arg1) == NEGATE_EXPR)
4562 return fold (build (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
fab446b8
RK		 4563
4564 else if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
4565 || flag_fast_math)
6d716ca8 4566 {
c05a9b68 4567 /* Except with IEEE floating point, 0-x equals -x. */
6d716ca8
RS		 4568 if (! wins && real_zerop (arg0))
4569 return build1 (NEGATE_EXPR, type, arg1);
c05a9b68
RS		 4570 /* Except with IEEE floating point, x-0 equals x. */
4571 if (real_zerop (arg1))
6d716ca8 4572 return non_lvalue (convert (type, arg0));
fab446b8 4573 }
a6acbe15 4574
fab446b8
RK		 4575 /* Fold &x - &x. This can happen from &x.foo - &x.
4576 This is unsafe for certain floats even in non-IEEE formats.
4577 In IEEE, it is unsafe because it does wrong for NaNs.
4578 Also note that operand_equal_p is always false if an operand
4579 is volatile. */
4580
59d90212
JW		 4581 if ((! FLOAT_TYPE_P (type) || flag_fast_math)
4582 && operand_equal_p (arg0, arg1, 0))
fab446b8 4583 return convert (type, integer_zero_node);
a6acbe15 4584
6d716ca8
RS		 4585 goto associate;
4586
4587 case MULT_EXPR:
7178e3af 4588 if (! FLOAT_TYPE_P (type))
6d716ca8
RS		 4589 {
4590 if (integer_zerop (arg1))
4591 return omit_one_operand (type, arg1, arg0);
4592 if (integer_onep (arg1))
4593 return non_lvalue (convert (type, arg0));
4594
b9b5c1b3
RK		 4595 /* ((A / C) * C) is A if the division is an
4596 EXACT_DIV_EXPR. Since C is normally a constant,
4597 just check for one of the four possibilities. */
4598
4599 if (TREE_CODE (arg0) == EXACT_DIV_EXPR
4600 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
4601 return TREE_OPERAND (arg0, 0);
4602
6d716ca8
RS		 4603 /* (a * (1 << b)) is (a << b) */
4604 if (TREE_CODE (arg1) == LSHIFT_EXPR
4605 && integer_onep (TREE_OPERAND (arg1, 0)))
4606 return fold (build (LSHIFT_EXPR, type, arg0,
4607 TREE_OPERAND (arg1, 1)));
4608 if (TREE_CODE (arg0) == LSHIFT_EXPR
4609 && integer_onep (TREE_OPERAND (arg0, 0)))
4610 return fold (build (LSHIFT_EXPR, type, arg1,
4611 TREE_OPERAND (arg0, 1)));
4612 }
6d716ca8
RS		 4613 else
4614 {
c05a9b68 4615 /* x*0 is 0, except for IEEE floating point. */
fab446b8
RK		 4616 if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
4617 || flag_fast_math)
6d716ca8
RS		 4618 && real_zerop (arg1))
4619 return omit_one_operand (type, arg1, arg0);
c05a9b68 4620 /* In IEEE floating point, x*1 is not equivalent to x for snans.
6d716ca8
RS		 4621 However, ANSI says we can drop signals,
4622 so we can do this anyway. */
4623 if (real_onep (arg1))
4624 return non_lvalue (convert (type, arg0));
4625 /* x*2 is x+x */
f0eebf28 4626 if (! wins && real_twop (arg1) && current_function_decl != 0)
6d716ca8
RS		 4627 {
4628 tree arg = save_expr (arg0);
4629 return build (PLUS_EXPR, type, arg, arg);
4630 }
4631 }
4632 goto associate;
4633
4634 case BIT_IOR_EXPR:
4635 bit_ior:
65d8b1ce
RK		 4636 {
4637 register enum tree_code code0, code1;
4638
6d716ca8
RS		 4639 if (integer_all_onesp (arg1))
4640 return omit_one_operand (type, arg1, arg0);
4641 if (integer_zerop (arg1))
4642 return non_lvalue (convert (type, arg0));
4643 t1 = distribute_bit_expr (code, type, arg0, arg1);
4644 if (t1 != NULL_TREE)
4645 return t1;
85d2e16c 4646
65d8b1ce 4647 /* (A << C1) | (A >> C2) if A is unsigned and C1+C2 is the size of A
85d2e16c 4648 is a rotate of A by C1 bits. */
65d8b1ce
RK		 4649 /* (A << B) | (A >> (Z - B)) if A is unsigned and Z is the size of A
4650 is a rotate of A by B bits. */
85d2e16c 4651
65d8b1ce
RK		 4652 code0 = TREE_CODE (arg0);
4653 code1 = TREE_CODE (arg1);
4654 if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
4655 || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
85d2e16c 4656 && operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1,0), 0)
65d8b1ce
RK		 4657 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
4658 {
4659 register tree tree01, tree11;
4660 register enum tree_code code01, code11;
4661
4662 tree01 = TREE_OPERAND (arg0, 1);
4663 tree11 = TREE_OPERAND (arg1, 1);
4664 code01 = TREE_CODE (tree01);
4665 code11 = TREE_CODE (tree11);
4666 if (code01 == INTEGER_CST
4667 && code11 == INTEGER_CST
4668 && TREE_INT_CST_HIGH (tree01) == 0
4669 && TREE_INT_CST_HIGH (tree11) == 0
4670 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
85d2e16c 4671 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
65d8b1ce
RK		 4672 return build (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
4673 code0 == LSHIFT_EXPR ? tree01 : tree11);
4674 else if (code11 == MINUS_EXPR
4675 && TREE_CODE (TREE_OPERAND (tree11, 0)) == INTEGER_CST
4676 && TREE_INT_CST_HIGH (TREE_OPERAND (tree11, 0)) == 0
4677 && TREE_INT_CST_LOW (TREE_OPERAND (tree11, 0))
4678 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))
4679 && operand_equal_p (tree01, TREE_OPERAND (tree11, 1), 0))
4680 return build (code0 == LSHIFT_EXPR ? LROTATE_EXPR : RROTATE_EXPR,
4681 type, TREE_OPERAND (arg0, 0), tree01);
4682 else if (code01 == MINUS_EXPR
4683 && TREE_CODE (TREE_OPERAND (tree01, 0)) == INTEGER_CST
4684 && TREE_INT_CST_HIGH (TREE_OPERAND (tree01, 0)) == 0
4685 && TREE_INT_CST_LOW (TREE_OPERAND (tree01, 0))
4686 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))
4687 && operand_equal_p (tree11, TREE_OPERAND (tree01, 1), 0))
4688 return build (code0 != LSHIFT_EXPR ? LROTATE_EXPR : RROTATE_EXPR,
4689 type, TREE_OPERAND (arg0, 0), tree11);
4690 }
85d2e16c 4691
6d716ca8 4692 goto associate;
65d8b1ce 4693 }
6d716ca8
RS		 4694
4695 case BIT_XOR_EXPR:
4696 if (integer_zerop (arg1))
4697 return non_lvalue (convert (type, arg0));
4698 if (integer_all_onesp (arg1))
4699 return fold (build1 (BIT_NOT_EXPR, type, arg0));
4700 goto associate;
4701
4702 case BIT_AND_EXPR:
4703 bit_and:
4704 if (integer_all_onesp (arg1))
4705 return non_lvalue (convert (type, arg0));
4706 if (integer_zerop (arg1))
4707 return omit_one_operand (type, arg1, arg0);
4708 t1 = distribute_bit_expr (code, type, arg0, arg1);
4709 if (t1 != NULL_TREE)
4710 return t1;
4711 /* Simplify ((int)c & 0x377) into (int)c, if c is unsigned char. */
4712 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == NOP_EXPR
4713 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1, 0))))
4714 {
4715 int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0)));
906c4e36
RK		 4716 if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
4717 && (~TREE_INT_CST_LOW (arg0)
4718 & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
6d716ca8
RS		 4719 return build1 (NOP_EXPR, type, TREE_OPERAND (arg1, 0));
4720 }
4721 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
4722 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
4723 {
4724 int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
906c4e36
RK		 4725 if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
4726 && (~TREE_INT_CST_LOW (arg1)
4727 & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
6d716ca8
RS		 4728 return build1 (NOP_EXPR, type, TREE_OPERAND (arg0, 0));
4729 }
4730 goto associate;
4731
4732 case BIT_ANDTC_EXPR:
4733 if (integer_all_onesp (arg0))
4734 return non_lvalue (convert (type, arg1));
4735 if (integer_zerop (arg0))
4736 return omit_one_operand (type, arg0, arg1);
4737 if (TREE_CODE (arg1) == INTEGER_CST)
4738 {
4739 arg1 = fold (build1 (BIT_NOT_EXPR, type, arg1));
4740 code = BIT_AND_EXPR;
4741 goto bit_and;
4742 }
4743 goto binary;
4744
e9aaa5a5
RK		 4745 case RDIV_EXPR:
4746 /* In most cases, do nothing with a divide by zero. */
4747#if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
4748#ifndef REAL_INFINITY
4749 if (TREE_CODE (arg1) == REAL_CST && real_zerop (arg1))
4750 return t;
4751#endif
4752#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
4753
4754 /* In IEEE floating point, x/1 is not equivalent to x for snans.
4755 However, ANSI says we can drop signals, so we can do this anyway. */
4756 if (real_onep (arg1))
4757 return non_lvalue (convert (type, arg0));
4758
4759 /* If ARG1 is a constant, we can convert this to a multiply by the
4760 reciprocal. This does not have the same rounding properties,
4761 so only do this if -ffast-math. We can actually always safely
4762 do it if ARG1 is a power of two, but it's hard to tell if it is
4763 or not in a portable manner. */
39647dcb
RK		 4764 if (TREE_CODE (arg1) == REAL_CST)
4765 {
4766 if (flag_fast_math
4767 && 0 != (tem = const_binop (code, build_real (type, dconst1),
4768 arg1, 0)))
4769 return fold (build (MULT_EXPR, type, arg0, tem));
4770 /* Find the reciprocal if optimizing and the result is exact. */
4771 else if (optimize)
4772 {
4773 REAL_VALUE_TYPE r;
4774 r = TREE_REAL_CST (arg1);
4775 if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
4776 {
4777 tem = build_real (type, r);
4778 return fold (build (MULT_EXPR, type, arg0, tem));
4779 }
4780 }
4781 }
e9aaa5a5
RK		 4782 goto binary;
4783
6d716ca8
RS		 4784 case TRUNC_DIV_EXPR:
4785 case ROUND_DIV_EXPR:
4786 case FLOOR_DIV_EXPR:
4787 case CEIL_DIV_EXPR:
4788 case EXACT_DIV_EXPR:
6d716ca8
RS		 4789 if (integer_onep (arg1))
4790 return non_lvalue (convert (type, arg0));
4791 if (integer_zerop (arg1))
4792 return t;
3b998c11 4793
39dfb55a
JL		 4794 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
4795 operation, EXACT_DIV_EXPR.
4796
91585c63
TM		 4797 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
4798 At one time others generated faster code, it's not clear if they do
4799 after the last round to changes to the DIV code in expmed.c. */
4800 if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
39dfb55a
JL		 4801 && multiple_of_p (type, arg0, arg1))
4802 return fold (build (EXACT_DIV_EXPR, type, arg0, arg1));
4803
37bdb7e3 4804 /* If we have ((a / C1) / C2) where both division are the same type, try
e9aaa5a5
RK		 4805 to simplify. First see if C1 * C2 overflows or not. */
4806 if (TREE_CODE (arg0) == code && TREE_CODE (arg1) == INTEGER_CST
4807 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
4808 {
37bdb7e3 4809 tree new_divisor;
e9aaa5a5 4810
37bdb7e3
TG		 4811 new_divisor = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 1), arg1, 0);
4812 tem = const_binop (FLOOR_DIV_EXPR, new_divisor, arg1, 0);
3122945e 4813
37bdb7e3
TG		 4814 if (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) == TREE_INT_CST_LOW (tem)
4815 && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == TREE_INT_CST_HIGH (tem))
e9aaa5a5 4816 {
37bdb7e3
TG		 4817 /* If no overflow, divide by C1*C2. */
4818 return fold (build (code, type, TREE_OPERAND (arg0, 0), new_divisor));
e9aaa5a5 4819 }
e9aaa5a5
RK		 4820 }
4821
6a96fcb4
RK		 4822 /* Look for ((a * C1) / C3) or (((a * C1) + C2) / C3),
4823 where C1 % C3 == 0 or C3 % C1 == 0. We can simplify these
4824 expressions, which often appear in the offsets or sizes of
4825 objects with a varying size. Only deal with positive divisors
aae67841 4826 and multiplicands. If C2 is negative, we must have C2 % C3 == 0.
6a96fcb4
RK		 4827
4828 Look for NOPs and SAVE_EXPRs inside. */
4829
3b998c11 4830 if (TREE_CODE (arg1) == INTEGER_CST
d0cb4c65 4831 && tree_int_cst_sgn (arg1) >= 0)
3b998c11 4832 {
6a96fcb4
RK		 4833 int have_save_expr = 0;
4834 tree c2 = integer_zero_node;
4835 tree xarg0 = arg0;
3b998c11 4836
d011fbf9 4837 if (TREE_CODE (xarg0) == SAVE_EXPR && SAVE_EXPR_RTL (xarg0) == 0)
6a96fcb4 4838 have_save_expr = 1, xarg0 = TREE_OPERAND (xarg0, 0);
3b998c11 4839
6a96fcb4
RK		 4840 STRIP_NOPS (xarg0);
4841
750e8348
TM		 4842 /* Look inside the dividend and simplify using EXACT_DIV_EXPR
4843 if possible. */
4844 if (TREE_CODE (xarg0) == MULT_EXPR
4845 && multiple_of_p (type, TREE_OPERAND (xarg0, 0), arg1))
4846 {
4847 tree t;
4848
4849 t = fold (build (MULT_EXPR, type,
4850 fold (build (EXACT_DIV_EXPR, type,
4851 TREE_OPERAND (xarg0, 0), arg1)),
4852 TREE_OPERAND (xarg0, 1)));
4853 if (have_save_expr)
4854 t = save_expr (t);
4855 return t;
4856
4857 }
4858
4859 if (TREE_CODE (xarg0) == MULT_EXPR
4860 && multiple_of_p (type, TREE_OPERAND (xarg0, 1), arg1))
4861 {
4862 tree t;
4863
4864 t = fold (build (MULT_EXPR, type,
4865 fold (build (EXACT_DIV_EXPR, type,
4866 TREE_OPERAND (xarg0, 1), arg1)),
4867 TREE_OPERAND (xarg0, 0)));
4868 if (have_save_expr)
4869 t = save_expr (t);
4870 return t;
4871 }
4872
6a96fcb4
RK		 4873 if (TREE_CODE (xarg0) == PLUS_EXPR
4874 && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST)
4875 c2 = TREE_OPERAND (xarg0, 1), xarg0 = TREE_OPERAND (xarg0, 0);
4876 else if (TREE_CODE (xarg0) == MINUS_EXPR
aae67841
RK		 4877 && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST
4878 /* If we are doing this computation unsigned, the negate
4879 is incorrect. */
4880 && ! TREE_UNSIGNED (type))
6a96fcb4
RK		 4881 {
4882 c2 = fold (build1 (NEGATE_EXPR, type, TREE_OPERAND (xarg0, 1)));
4883 xarg0 = TREE_OPERAND (xarg0, 0);
4884 }
4885
d011fbf9 4886 if (TREE_CODE (xarg0) == SAVE_EXPR && SAVE_EXPR_RTL (xarg0) == 0)
6a96fcb4
RK		 4887 have_save_expr = 1, xarg0 = TREE_OPERAND (xarg0, 0);
4888
4889 STRIP_NOPS (xarg0);
4890
4891 if (TREE_CODE (xarg0) == MULT_EXPR
4892 && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST
d0cb4c65 4893 && tree_int_cst_sgn (TREE_OPERAND (xarg0, 1)) >= 0
6a96fcb4
RK		 4894 && (integer_zerop (const_binop (TRUNC_MOD_EXPR,
4895 TREE_OPERAND (xarg0, 1), arg1, 1))
4896 || integer_zerop (const_binop (TRUNC_MOD_EXPR, arg1,
aae67841 4897 TREE_OPERAND (xarg0, 1), 1)))
d0cb4c65 4898 && (tree_int_cst_sgn (c2) >= 0
aae67841
RK		 4899 || integer_zerop (const_binop (TRUNC_MOD_EXPR, c2,
4900 arg1, 1))))
6a96fcb4
RK		 4901 {
4902 tree outer_div = integer_one_node;
4903 tree c1 = TREE_OPERAND (xarg0, 1);
4904 tree c3 = arg1;
4905
4906 /* If C3 > C1, set them equal and do a divide by
4907 C3/C1 at the end of the operation. */
4908 if (tree_int_cst_lt (c1, c3))
4909 outer_div = const_binop (code, c3, c1, 0), c3 = c1;
4910
4911 /* The result is A * (C1/C3) + (C2/C3). */
4912 t = fold (build (PLUS_EXPR, type,
4913 fold (build (MULT_EXPR, type,
4914 TREE_OPERAND (xarg0, 0),
4915 const_binop (code, c1, c3, 1))),
4916 const_binop (code, c2, c3, 1)));
4917
4918 if (! integer_onep (outer_div))
d0cb4c65 4919 t = fold (build (code, type, t, convert (type, outer_div)));
6a96fcb4
RK		 4920
4921 if (have_save_expr)
4922 t = save_expr (t);
4923
4924 return t;
4925 }
3b998c11
RK		 4926 }
4927
6d716ca8
RS		 4928 goto binary;
4929
4930 case CEIL_MOD_EXPR:
4931 case FLOOR_MOD_EXPR:
4932 case ROUND_MOD_EXPR:
4933 case TRUNC_MOD_EXPR:
4934 if (integer_onep (arg1))
4935 return omit_one_operand (type, integer_zero_node, arg0);
4936 if (integer_zerop (arg1))
4937 return t;
6a96fcb4
RK		 4938
4939 /* Look for ((a * C1) % C3) or (((a * C1) + C2) % C3),
4940 where C1 % C3 == 0. Handle similarly to the division case,
4941 but don't bother with SAVE_EXPRs. */
4942
4943 if (TREE_CODE (arg1) == INTEGER_CST
4944 && ! integer_zerop (arg1))
4945 {
4946 tree c2 = integer_zero_node;
4947 tree xarg0 = arg0;
4948
4949 if (TREE_CODE (xarg0) == PLUS_EXPR
4950 && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST)
4951 c2 = TREE_OPERAND (xarg0, 1), xarg0 = TREE_OPERAND (xarg0, 0);
4952 else if (TREE_CODE (xarg0) == MINUS_EXPR
aae67841
RK		 4953 && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST
4954 && ! TREE_UNSIGNED (type))
6a96fcb4
RK		 4955 {
4956 c2 = fold (build1 (NEGATE_EXPR, type, TREE_OPERAND (xarg0, 1)));
4957 xarg0 = TREE_OPERAND (xarg0, 0);
4958 }
4959
4960 STRIP_NOPS (xarg0);
4961
4962 if (TREE_CODE (xarg0) == MULT_EXPR
4963 && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST
4964 && integer_zerop (const_binop (TRUNC_MOD_EXPR,
4965 TREE_OPERAND (xarg0, 1),
aae67841 4966 arg1, 1))
d0cb4c65 4967 && tree_int_cst_sgn (c2) >= 0)
6a96fcb4
RK		 4968 /* The result is (C2%C3). */
4969 return omit_one_operand (type, const_binop (code, c2, arg1, 1),
4970 TREE_OPERAND (xarg0, 0));
4971 }
4972
6d716ca8
RS		 4973 goto binary;
4974
4975 case LSHIFT_EXPR:
4976 case RSHIFT_EXPR:
4977 case LROTATE_EXPR:
4978 case RROTATE_EXPR:
4979 if (integer_zerop (arg1))
4980 return non_lvalue (convert (type, arg0));
4981 /* Since negative shift count is not well-defined,
4982 don't try to compute it in the compiler. */
4d39710e 4983 if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
6d716ca8 4984 return t;
4d39710e
RK		 4985 /* Rewrite an LROTATE_EXPR by a constant into an
4986 RROTATE_EXPR by a new constant. */
4987 if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
4988 {
4989 TREE_SET_CODE (t, RROTATE_EXPR);
4990 code = RROTATE_EXPR;
4991 TREE_OPERAND (t, 1) = arg1
4992 = const_binop
4993 (MINUS_EXPR,
4994 convert (TREE_TYPE (arg1),
4995 build_int_2 (GET_MODE_BITSIZE (TYPE_MODE (type)), 0)),
4996 arg1, 0);
4997 if (tree_int_cst_sgn (arg1) < 0)
4998 return t;
4999 }
5000
5001 /* If we have a rotate of a bit operation with the rotate count and
5002 the second operand of the bit operation both constant,
5003 permute the two operations. */
5004 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
5005 && (TREE_CODE (arg0) == BIT_AND_EXPR
5006 || TREE_CODE (arg0) == BIT_ANDTC_EXPR
5007 || TREE_CODE (arg0) == BIT_IOR_EXPR
5008 || TREE_CODE (arg0) == BIT_XOR_EXPR)
5009 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
5010 return fold (build (TREE_CODE (arg0), type,
5011 fold (build (code, type,
5012 TREE_OPERAND (arg0, 0), arg1)),
5013 fold (build (code, type,
5014 TREE_OPERAND (arg0, 1), arg1))));
5015
5016 /* Two consecutive rotates adding up to the width of the mode can
5017 be ignored. */
5018 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
5019 && TREE_CODE (arg0) == RROTATE_EXPR
5020 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5021 && TREE_INT_CST_HIGH (arg1) == 0
5022 && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
5023 && ((TREE_INT_CST_LOW (arg1)
5024 + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
5025 == GET_MODE_BITSIZE (TYPE_MODE (type))))
5026 return TREE_OPERAND (arg0, 0);
5027
6d716ca8
RS		 5028 goto binary;
5029
5030 case MIN_EXPR:
5031 if (operand_equal_p (arg0, arg1, 0))
5032 return arg0;
7178e3af 5033 if (INTEGRAL_TYPE_P (type)
6d716ca8
RS		 5034 && operand_equal_p (arg1, TYPE_MIN_VALUE (type), 1))
5035 return omit_one_operand (type, arg1, arg0);
5036 goto associate;
5037
5038 case MAX_EXPR:
5039 if (operand_equal_p (arg0, arg1, 0))
5040 return arg0;
7178e3af 5041 if (INTEGRAL_TYPE_P (type)
e1ee5cdc 5042 && TYPE_MAX_VALUE (type)
6d716ca8
RS		 5043 && operand_equal_p (arg1, TYPE_MAX_VALUE (type), 1))
5044 return omit_one_operand (type, arg1, arg0);
5045 goto associate;
5046
5047 case TRUTH_NOT_EXPR:
5048 /* Note that the operand of this must be an int
5049 and its values must be 0 or 1.
5050 ("true" is a fixed value perhaps depending on the language,
5051 but we don't handle values other than 1 correctly yet.) */
1180eb10
JM		 5052 tem = invert_truthvalue (arg0);
5053 /* Avoid infinite recursion. */
5054 if (TREE_CODE (tem) == TRUTH_NOT_EXPR)
5055 return t;
5056 return convert (type, tem);
6d716ca8
RS		 5057
5058 case TRUTH_ANDIF_EXPR:
5059 /* Note that the operands of this must be ints
5060 and their values must be 0 or 1.
5061 ("true" is a fixed value perhaps depending on the language.) */
5062 /* If first arg is constant zero, return it. */
772447c5 5063 if (integer_zerop (arg0))
6d716ca8
RS		 5064 return arg0;
5065 case TRUTH_AND_EXPR:
5066 /* If either arg is constant true, drop it. */
5067 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5068 return non_lvalue (arg1);
5069 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
5070 return non_lvalue (arg0);
772447c5
RK		 5071 /* If second arg is constant zero, result is zero, but first arg
5072 must be evaluated. */
5073 if (integer_zerop (arg1))
5074 return omit_one_operand (type, arg1, arg0);
80906567
RK		 5075 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
5076 case will be handled here. */
5077 if (integer_zerop (arg0))
5078 return omit_one_operand (type, arg0, arg1);
6d716ca8
RS		 5079
5080 truth_andor:
e9b5e15f
RK		 5081 /* We only do these simplifications if we are optimizing. */
5082 if (!optimize)
5083 return t;
5084
5085 /* Check for things like (A || B) && (A || C). We can convert this
5086 to A || (B && C). Note that either operator can be any of the four
5087 truth and/or operations and the transformation will still be
5088 valid. Also note that we only care about order for the
96f06cb6
RK		 5089 ANDIF and ORIF operators. If B contains side effects, this
5090 might change the truth-value of A. */
e9b5e15f
RK		 5091 if (TREE_CODE (arg0) == TREE_CODE (arg1)
5092 && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
5093 || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
5094 || TREE_CODE (arg0) == TRUTH_AND_EXPR
96f06cb6
RK		 5095 || TREE_CODE (arg0) == TRUTH_OR_EXPR)
5096 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
e9b5e15f
RK		 5097 {
5098 tree a00 = TREE_OPERAND (arg0, 0);
5099 tree a01 = TREE_OPERAND (arg0, 1);
5100 tree a10 = TREE_OPERAND (arg1, 0);
5101 tree a11 = TREE_OPERAND (arg1, 1);
5102 int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
5103 || TREE_CODE (arg0) == TRUTH_AND_EXPR)
5104 && (code == TRUTH_AND_EXPR
5105 || code == TRUTH_OR_EXPR));
5106
5107 if (operand_equal_p (a00, a10, 0))
5108 return fold (build (TREE_CODE (arg0), type, a00,
5109 fold (build (code, type, a01, a11))));
5110 else if (commutative && operand_equal_p (a00, a11, 0))
5111 return fold (build (TREE_CODE (arg0), type, a00,
5112 fold (build (code, type, a01, a10))));
5113 else if (commutative && operand_equal_p (a01, a10, 0))
5114 return fold (build (TREE_CODE (arg0), type, a01,
5115 fold (build (code, type, a00, a11))));
5116
5117 /* This case if tricky because we must either have commutative
5118 operators or else A10 must not have side-effects. */
5119
5120 else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
5121 && operand_equal_p (a01, a11, 0))
5122 return fold (build (TREE_CODE (arg0), type,
5123 fold (build (code, type, a00, a10)),
5124 a01));
5125 }
5126
ebde8a27
RK		 5127 /* See if we can build a range comparison. */
5128 if (0 != (tem = fold_range_test (t)))
5129 return tem;
5130
6d716ca8
RS		 5131 /* Check for the possibility of merging component references. If our
5132 lhs is another similar operation, try to merge its rhs with our
5133 rhs. Then try to merge our lhs and rhs. */
e9b5e15f
RK		 5134 if (TREE_CODE (arg0) == code
5135 && 0 != (tem = fold_truthop (code, type,
5136 TREE_OPERAND (arg0, 1), arg1)))
5137 return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6d716ca8 5138
e9b5e15f
RK		 5139 if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
5140 return tem;
61f275ff 5141
6d716ca8
RS		 5142 return t;
5143
5144 case TRUTH_ORIF_EXPR:
5145 /* Note that the operands of this must be ints
5146 and their values must be 0 or true.
5147 ("true" is a fixed value perhaps depending on the language.) */
5148 /* If first arg is constant true, return it. */
5149 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5150 return arg0;
5151 case TRUTH_OR_EXPR:
5152 /* If either arg is constant zero, drop it. */
5153 if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
5154 return non_lvalue (arg1);
5155 if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1))
5156 return non_lvalue (arg0);
772447c5
RK		 5157 /* If second arg is constant true, result is true, but we must
5158 evaluate first arg. */
5159 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
5160 return omit_one_operand (type, arg1, arg0);
80906567
RK		 5161 /* Likewise for first arg, but note this only occurs here for
5162 TRUTH_OR_EXPR. */
5163 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5164 return omit_one_operand (type, arg0, arg1);
6d716ca8
RS		 5165 goto truth_andor;
5166
772447c5
RK		 5167 case TRUTH_XOR_EXPR:
5168 /* If either arg is constant zero, drop it. */
5169 if (integer_zerop (arg0))
5170 return non_lvalue (arg1);
5171 if (integer_zerop (arg1))
5172 return non_lvalue (arg0);
5173 /* If either arg is constant true, this is a logical inversion. */
5174 if (integer_onep (arg0))
5175 return non_lvalue (invert_truthvalue (arg1));
5176 if (integer_onep (arg1))
5177 return non_lvalue (invert_truthvalue (arg0));
62d8b51e 5178 return t;
772447c5 5179
6d716ca8
RS		 5180 case EQ_EXPR:
5181 case NE_EXPR:
5182 case LT_EXPR:
5183 case GT_EXPR:
5184 case LE_EXPR:
5185 case GE_EXPR:
5186 /* If one arg is a constant integer, put it last. */
5187 if (TREE_CODE (arg0) == INTEGER_CST
5188 && TREE_CODE (arg1) != INTEGER_CST)
5189 {
5190 TREE_OPERAND (t, 0) = arg1;
5191 TREE_OPERAND (t, 1) = arg0;
5192 arg0 = TREE_OPERAND (t, 0);
5193 arg1 = TREE_OPERAND (t, 1);
c05a9b68 5194 code = swap_tree_comparison (code);
6d716ca8
RS		 5195 TREE_SET_CODE (t, code);
5196 }
5197
5198 /* Convert foo++ == CONST into ++foo == CONST + INCR.
5199 First, see if one arg is constant; find the constant arg
5200 and the other one. */
5201 {
4e86caed 5202 tree constop = 0, varop = NULL_TREE;
cd7ece66 5203 int constopnum = -1;
6d716ca8
RS		 5204
5205 if (TREE_CONSTANT (arg1))
cd7ece66 5206 constopnum = 1, constop = arg1, varop = arg0;
6d716ca8 5207 if (TREE_CONSTANT (arg0))
cd7ece66 5208 constopnum = 0, constop = arg0, varop = arg1;
6d716ca8
RS		 5209
5210 if (constop && TREE_CODE (varop) == POSTINCREMENT_EXPR)
5211 {
6d716ca8
RS		 5212 /* This optimization is invalid for ordered comparisons
5213 if CONST+INCR overflows or if foo+incr might overflow.
c05a9b68 5214 This optimization is invalid for floating point due to rounding.
6d716ca8 5215 For pointer types we assume overflow doesn't happen. */
e5e809f4 5216 if (POINTER_TYPE_P (TREE_TYPE (varop))
7178e3af 5217 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
c05a9b68 5218 && (code == EQ_EXPR || code == NE_EXPR)))
6d716ca8 5219 {
c05a9b68
RS		 5220 tree newconst
5221 = fold (build (PLUS_EXPR, TREE_TYPE (varop),
5222 constop, TREE_OPERAND (varop, 1)));
5223 TREE_SET_CODE (varop, PREINCREMENT_EXPR);
cd7ece66 5224
30eca391
RK		 5225 /* If VAROP is a reference to a bitfield, we must mask
5226 the constant by the width of the field. */
5227 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
5228 && DECL_BIT_FIELD(TREE_OPERAND
5229 (TREE_OPERAND (varop, 0), 1)))
5230 {
5231 int size
5232 = TREE_INT_CST_LOW (DECL_SIZE
5233 (TREE_OPERAND
5234 (TREE_OPERAND (varop, 0), 1)));
df0e526f
AS		 5235 tree mask, unsigned_type;
5236 int precision;
5237 tree folded_compare;
5238
5239 /* First check whether the comparison would come out
5240 always the same. If we don't do that we would
5241 change the meaning with the masking. */
5242 if (constopnum == 0)
5243 folded_compare = fold (build (code, type, constop,
5244 TREE_OPERAND (varop, 0)));
5245 else
5246 folded_compare = fold (build (code, type,
5247 TREE_OPERAND (varop, 0),
5248 constop));
5249 if (integer_zerop (folded_compare)
5250 || integer_onep (folded_compare))
5251 return omit_one_operand (type, folded_compare, varop);
5252
5253 unsigned_type = type_for_size (size, 1);
5254 precision = TYPE_PRECISION (unsigned_type);
5255 mask = build_int_2 (~0, ~0);
5256 TREE_TYPE (mask) = unsigned_type;
5257 force_fit_type (mask, 0);
5258 mask = const_binop (RSHIFT_EXPR, mask,
5259 size_int (precision - size), 0);
30eca391
RK		 5260 newconst = fold (build (BIT_AND_EXPR,
5261 TREE_TYPE (varop), newconst,
5262 convert (TREE_TYPE (varop),
df0e526f 5263 mask)));
30eca391
RK		 5264 }
5265
5266
cd7ece66
RK		 5267 t = build (code, type, TREE_OPERAND (t, 0),
5268 TREE_OPERAND (t, 1));
5269 TREE_OPERAND (t, constopnum) = newconst;
c05a9b68 5270 return t;
6d716ca8
RS		 5271 }
5272 }
5273 else if (constop && TREE_CODE (varop) == POSTDECREMENT_EXPR)
5274 {
e5e809f4 5275 if (POINTER_TYPE_P (TREE_TYPE (varop))
7178e3af 5276 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
c05a9b68 5277 && (code == EQ_EXPR || code == NE_EXPR)))
6d716ca8 5278 {
c05a9b68
RS		 5279 tree newconst
5280 = fold (build (MINUS_EXPR, TREE_TYPE (varop),
5281 constop, TREE_OPERAND (varop, 1)));
5282 TREE_SET_CODE (varop, PREDECREMENT_EXPR);
30eca391
RK		 5283
5284 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
5285 && DECL_BIT_FIELD(TREE_OPERAND
5286 (TREE_OPERAND (varop, 0), 1)))
5287 {
5288 int size
5289 = TREE_INT_CST_LOW (DECL_SIZE
5290 (TREE_OPERAND
5291 (TREE_OPERAND (varop, 0), 1)));
df0e526f
AS		 5292 tree mask, unsigned_type;
5293 int precision;
5294 tree folded_compare;
5295
5296 if (constopnum == 0)
5297 folded_compare = fold (build (code, type, constop,
5298 TREE_OPERAND (varop, 0)));
5299 else
5300 folded_compare = fold (build (code, type,
5301 TREE_OPERAND (varop, 0),
5302 constop));
5303 if (integer_zerop (folded_compare)
5304 || integer_onep (folded_compare))
5305 return omit_one_operand (type, folded_compare, varop);
5306
5307 unsigned_type = type_for_size (size, 1);
5308 precision = TYPE_PRECISION (unsigned_type);
5309 mask = build_int_2 (~0, ~0);
5310 TREE_TYPE (mask) = TREE_TYPE (varop);
5311 force_fit_type (mask, 0);
5312 mask = const_binop (RSHIFT_EXPR, mask,
5313 size_int (precision - size), 0);
30eca391
RK		 5314 newconst = fold (build (BIT_AND_EXPR,
5315 TREE_TYPE (varop), newconst,
5316 convert (TREE_TYPE (varop),
df0e526f 5317 mask)));
30eca391
RK		 5318 }
5319
5320
cd7ece66
RK		 5321 t = build (code, type, TREE_OPERAND (t, 0),
5322 TREE_OPERAND (t, 1));
5323 TREE_OPERAND (t, constopnum) = newconst;
c05a9b68 5324 return t;
6d716ca8
RS		 5325 }
5326 }
5327 }
5328
5329 /* Change X >= CST to X > (CST - 1) if CST is positive. */
5330 if (TREE_CODE (arg1) == INTEGER_CST
5331 && TREE_CODE (arg0) != INTEGER_CST
d0cb4c65 5332 && tree_int_cst_sgn (arg1) > 0)
6d716ca8
RS		 5333 {
5334 switch (TREE_CODE (t))
5335 {
5336 case GE_EXPR:
5337 code = GT_EXPR;
91d33e36 5338 arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
cd7ece66 5339 t = build (code, type, TREE_OPERAND (t, 0), arg1);
6d716ca8
RS		 5340 break;
5341
5342 case LT_EXPR:
5343 code = LE_EXPR;
91d33e36 5344 arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
cd7ece66
RK		 5345 t = build (code, type, TREE_OPERAND (t, 0), arg1);
5346 break;
e9a25f70
JL		 5347
5348 default:
5349 break;
6d716ca8
RS		 5350 }
5351 }
5352
6d716ca8
RS		 5353 /* If this is an EQ or NE comparison with zero and ARG0 is
5354 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
5355 two operations, but the latter can be done in one less insn
e9a25f70 5356 on machines that have only two-operand insns or on which a
6d716ca8
RS		 5357 constant cannot be the first operand. */
5358 if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
5359 && TREE_CODE (arg0) == BIT_AND_EXPR)
5360 {
5361 if (TREE_CODE (TREE_OPERAND (arg0, 0)) == LSHIFT_EXPR
5362 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 0), 0)))
5363 return
5364 fold (build (code, type,
5365 build (BIT_AND_EXPR, TREE_TYPE (arg0),
5366 build (RSHIFT_EXPR,
5367 TREE_TYPE (TREE_OPERAND (arg0, 0)),
5368 TREE_OPERAND (arg0, 1),
5369 TREE_OPERAND (TREE_OPERAND (arg0, 0), 1)),
5370 convert (TREE_TYPE (arg0),
5371 integer_one_node)),
5372 arg1));
5373 else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
5374 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
5375 return
5376 fold (build (code, type,
5377 build (BIT_AND_EXPR, TREE_TYPE (arg0),
5378 build (RSHIFT_EXPR,
5379 TREE_TYPE (TREE_OPERAND (arg0, 1)),
5380 TREE_OPERAND (arg0, 0),
5381 TREE_OPERAND (TREE_OPERAND (arg0, 1), 1)),
5382 convert (TREE_TYPE (arg0),
5383 integer_one_node)),
5384 arg1));
5385 }
5386
05a0d5ea 5387 /* If this is an NE or EQ comparison of zero against the result of a
79bf94d3
RK		 5388 signed MOD operation whose second operand is a power of 2, make
5389 the MOD operation unsigned since it is simpler and equivalent. */
05a0d5ea
RK		 5390 if ((code == NE_EXPR || code == EQ_EXPR)
5391 && integer_zerop (arg1)
5392 && ! TREE_UNSIGNED (TREE_TYPE (arg0))
5393 && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
5394 || TREE_CODE (arg0) == CEIL_MOD_EXPR
5395 || TREE_CODE (arg0) == FLOOR_MOD_EXPR
79bf94d3
RK		 5396 || TREE_CODE (arg0) == ROUND_MOD_EXPR)
5397 && integer_pow2p (TREE_OPERAND (arg0, 1)))
05a0d5ea
RK		 5398 {
5399 tree newtype = unsigned_type (TREE_TYPE (arg0));
5400 tree newmod = build (TREE_CODE (arg0), newtype,
5401 convert (newtype, TREE_OPERAND (arg0, 0)),
5402 convert (newtype, TREE_OPERAND (arg0, 1)));
5403
5404 return build (code, type, newmod, convert (newtype, arg1));
5405 }
5406
6d716ca8
RS		 5407 /* If this is an NE comparison of zero with an AND of one, remove the
5408 comparison since the AND will give the correct value. */
5409 if (code == NE_EXPR && integer_zerop (arg1)
5410 && TREE_CODE (arg0) == BIT_AND_EXPR
5411 && integer_onep (TREE_OPERAND (arg0, 1)))
5412 return convert (type, arg0);
5413
5414 /* If we have (A & C) == C where C is a power of 2, convert this into
5415 (A & C) != 0. Similarly for NE_EXPR. */
5416 if ((code == EQ_EXPR || code == NE_EXPR)
5417 && TREE_CODE (arg0) == BIT_AND_EXPR
5418 && integer_pow2p (TREE_OPERAND (arg0, 1))
5419 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
5420 return build (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
5421 arg0, integer_zero_node);
5422
e92d3048 5423 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
34b1b41f 5424 and similarly for >= into !=. */
e92d3048
RK		 5425 if ((code == LT_EXPR || code == GE_EXPR)
5426 && TREE_UNSIGNED (TREE_TYPE (arg0))
5427 && TREE_CODE (arg1) == LSHIFT_EXPR
5428 && integer_onep (TREE_OPERAND (arg1, 0)))
5429 return build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
5430 build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
5431 TREE_OPERAND (arg1, 1)),
5432 convert (TREE_TYPE (arg0), integer_zero_node));
5433
5434 else if ((code == LT_EXPR || code == GE_EXPR)
5435 && TREE_UNSIGNED (TREE_TYPE (arg0))
5436 && (TREE_CODE (arg1) == NOP_EXPR
5437 || TREE_CODE (arg1) == CONVERT_EXPR)
5438 && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
5439 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
5440 return
5441 build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
5442 convert (TREE_TYPE (arg0),
5443 build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
5444 TREE_OPERAND (TREE_OPERAND (arg1, 0), 1))),
5445 convert (TREE_TYPE (arg0), integer_zero_node));
5446
c05a9b68
RS		 5447 /* Simplify comparison of something with itself. (For IEEE
5448 floating-point, we can only do some of these simplifications.) */
5449 if (operand_equal_p (arg0, arg1, 0))
6d716ca8
RS		 5450 {
5451 switch (code)
5452 {
5453 case EQ_EXPR:
5454 case GE_EXPR:
5455 case LE_EXPR:
7178e3af 5456 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
f628873f 5457 return constant_boolean_node (1, type);
c05a9b68
RS		 5458 code = EQ_EXPR;
5459 TREE_SET_CODE (t, code);
5460 break;
5461
6d716ca8 5462 case NE_EXPR:
c05a9b68 5463 /* For NE, we can only do this simplification if integer. */
7178e3af 5464 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
c05a9b68 5465 break;
0f41302f 5466 /* ... fall through ... */
6d716ca8
RS		 5467 case GT_EXPR:
5468 case LT_EXPR:
f628873f 5469 return constant_boolean_node (0, type);
e9a25f70
JL		 5470 default:
5471 abort ();
6d716ca8
RS		 5472 }
5473 }
5474
5475 /* An unsigned comparison against 0 can be simplified. */
5476 if (integer_zerop (arg1)
7178e3af 5477 && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
e5e809f4 5478 || POINTER_TYPE_P (TREE_TYPE (arg1)))
6d716ca8
RS		 5479 && TREE_UNSIGNED (TREE_TYPE (arg1)))
5480 {
5481 switch (TREE_CODE (t))
5482 {
5483 case GT_EXPR:
c05a9b68 5484 code = NE_EXPR;
6d716ca8
RS		 5485 TREE_SET_CODE (t, NE_EXPR);
5486 break;
5487 case LE_EXPR:
c05a9b68 5488 code = EQ_EXPR;
6d716ca8
RS		 5489 TREE_SET_CODE (t, EQ_EXPR);
5490 break;
5491 case GE_EXPR:
56f8e5e6
RK		 5492 return omit_one_operand (type,
5493 convert (type, integer_one_node),
5494 arg0);
6d716ca8 5495 case LT_EXPR:
56f8e5e6
RK		 5496 return omit_one_operand (type,
5497 convert (type, integer_zero_node),
5498 arg0);
e9a25f70
JL		 5499 default:
5500 break;
6d716ca8
RS		 5501 }
5502 }
5503
e9a25f70
JL		 5504 /* An unsigned <= 0x7fffffff can be simplified. */
5505 {
5506 int width = TYPE_PRECISION (TREE_TYPE (arg1));
5507 if (TREE_CODE (arg1) == INTEGER_CST
5508 && ! TREE_CONSTANT_OVERFLOW (arg1)
5509 && width <= HOST_BITS_PER_WIDE_INT
5510 && TREE_INT_CST_LOW (arg1) == ((HOST_WIDE_INT) 1 << (width - 1)) - 1
5511 && TREE_INT_CST_HIGH (arg1) == 0
5512 && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
e5e809f4 5513 || POINTER_TYPE_P (TREE_TYPE (arg1)))
e9a25f70
JL		 5514 && TREE_UNSIGNED (TREE_TYPE (arg1)))
5515 {
5516 switch (TREE_CODE (t))
5517 {
5518 case LE_EXPR:
5519 return fold (build (GE_EXPR, type,
5520 convert (signed_type (TREE_TYPE (arg0)),
5521 arg0),
5522 convert (signed_type (TREE_TYPE (arg1)),
5523 integer_zero_node)));
5524 case GT_EXPR:
5525 return fold (build (LT_EXPR, type,
5526 convert (signed_type (TREE_TYPE (arg0)),
5527 arg0),
5528 convert (signed_type (TREE_TYPE (arg1)),
5529 integer_zero_node)));
1d300e19
KG		 5530 default:
5531 break;
e9a25f70
JL		 5532 }
5533 }
5534 }
5535
c05a9b68
RS		 5536 /* If we are comparing an expression that just has comparisons
5537 of two integer values, arithmetic expressions of those comparisons,
5538 and constants, we can simplify it. There are only three cases
5539 to check: the two values can either be equal, the first can be
5540 greater, or the second can be greater. Fold the expression for
5541 those three values. Since each value must be 0 or 1, we have
5542 eight possibilities, each of which corresponds to the constant 0
5543 or 1 or one of the six possible comparisons.
5544
5545 This handles common cases like (a > b) == 0 but also handles
5546 expressions like ((x > y) - (y > x)) > 0, which supposedly
5547 occur in macroized code. */
5548
5549 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
5550 {
5551 tree cval1 = 0, cval2 = 0;
35e66bd1 5552 int save_p = 0;
c05a9b68 5553
35e66bd1 5554 if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
c05a9b68
RS		 5555 /* Don't handle degenerate cases here; they should already
5556 have been handled anyway. */
5557 && cval1 != 0 && cval2 != 0
5558 && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
5559 && TREE_TYPE (cval1) == TREE_TYPE (cval2)
7178e3af 5560 && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
e1ee5cdc
RH		 5561 && TYPE_MAX_VALUE (TREE_TYPE (cval1))
5562 && TYPE_MAX_VALUE (TREE_TYPE (cval2))
c05a9b68
RS		 5563 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
5564 TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
5565 {
5566 tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
5567 tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
5568
5569 /* We can't just pass T to eval_subst in case cval1 or cval2
5570 was the same as ARG1. */
5571
5572 tree high_result
5573 = fold (build (code, type,
5574 eval_subst (arg0, cval1, maxval, cval2, minval),
5575 arg1));
5576 tree equal_result
5577 = fold (build (code, type,
5578 eval_subst (arg0, cval1, maxval, cval2, maxval),
5579 arg1));
5580 tree low_result
5581 = fold (build (code, type,
5582 eval_subst (arg0, cval1, minval, cval2, maxval),
5583 arg1));
5584
5585 /* All three of these results should be 0 or 1. Confirm they
5586 are. Then use those values to select the proper code
5587 to use. */
5588
5589 if ((integer_zerop (high_result)
5590 || integer_onep (high_result))
5591 && (integer_zerop (equal_result)
5592 || integer_onep (equal_result))
5593 && (integer_zerop (low_result)
5594 || integer_onep (low_result)))
5595 {
5596 /* Make a 3-bit mask with the high-order bit being the
5597 value for `>', the next for '=', and the low for '<'. */
5598 switch ((integer_onep (high_result) * 4)
5599 + (integer_onep (equal_result) * 2)
5600 + integer_onep (low_result))
5601 {
5602 case 0:
5603 /* Always false. */
13837058 5604 return omit_one_operand (type, integer_zero_node, arg0);
c05a9b68
RS		 5605 case 1:
5606 code = LT_EXPR;
5607 break;
5608 case 2:
5609 code = EQ_EXPR;
5610 break;
5611 case 3:
5612 code = LE_EXPR;
5613 break;
5614 case 4:
5615 code = GT_EXPR;
5616 break;
5617 case 5:
5618 code = NE_EXPR;
5619 break;
5620 case 6:
5621 code = GE_EXPR;
5622 break;
5623 case 7:
5624 /* Always true. */
13837058 5625 return omit_one_operand (type, integer_one_node, arg0);
c05a9b68
RS		 5626 }
5627
35e66bd1
RK		 5628 t = build (code, type, cval1, cval2);
5629 if (save_p)
5630 return save_expr (t);
5631 else
5632 return fold (t);
c05a9b68
RS		 5633 }
5634 }
5635 }
5636
5637 /* If this is a comparison of a field, we may be able to simplify it. */
5638 if ((TREE_CODE (arg0) == COMPONENT_REF
ebde8a27
RK		 5639 || TREE_CODE (arg0) == BIT_FIELD_REF)
5640 && (code == EQ_EXPR || code == NE_EXPR)
5641 /* Handle the constant case even without -O
5642 to make sure the warnings are given. */
5643 && (optimize || TREE_CODE (arg1) == INTEGER_CST))
c05a9b68
RS		 5644 {
5645 t1 = optimize_bit_field_compare (code, type, arg0, arg1);
5646 return t1 ? t1 : t;
5647 }
5648
95aa28ae
RK		 5649 /* If this is a comparison of complex values and either or both
5650 sizes are a COMPLEX_EXPR, it is best to split up the comparisons
5651 and join them with a TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR. This
5652 may prevent needless evaluations. */
5653 if ((code == EQ_EXPR || code == NE_EXPR)
5654 && TREE_CODE (TREE_TYPE (arg0)) == COMPLEX_TYPE
5655 && (TREE_CODE (arg0) == COMPLEX_EXPR
5656 || TREE_CODE (arg1) == COMPLEX_EXPR))
5657 {
5658 tree subtype = TREE_TYPE (TREE_TYPE (arg0));
f0b8d9aa
AS		 5659 tree real0, imag0, real1, imag1;
5660
5661 arg0 = save_expr (arg0);
5662 arg1 = save_expr (arg1);
5663 real0 = fold (build1 (REALPART_EXPR, subtype, arg0));
5664 imag0 = fold (build1 (IMAGPART_EXPR, subtype, arg0));
5665 real1 = fold (build1 (REALPART_EXPR, subtype, arg1));
5666 imag1 = fold (build1 (IMAGPART_EXPR, subtype, arg1));
95aa28ae
RK		 5667
5668 return fold (build ((code == EQ_EXPR ? TRUTH_ANDIF_EXPR
5669 : TRUTH_ORIF_EXPR),
5670 type,
5671 fold (build (code, type, real0, real1)),
5672 fold (build (code, type, imag0, imag1))));
5673 }
5674
c05a9b68
RS		 5675 /* From here on, the only cases we handle are when the result is
5676 known to be a constant.
5677
5678 To compute GT, swap the arguments and do LT.
6d716ca8
RS		 5679 To compute GE, do LT and invert the result.
5680 To compute LE, swap the arguments, do LT and invert the result.
c05a9b68
RS		 5681 To compute NE, do EQ and invert the result.
5682
5683 Therefore, the code below must handle only EQ and LT. */
5684
6d716ca8
RS		 5685 if (code == LE_EXPR || code == GT_EXPR)
5686 {
c05a9b68
RS		 5687 tem = arg0, arg0 = arg1, arg1 = tem;
5688 code = swap_tree_comparison (code);
5689 }
5690
5691 /* Note that it is safe to invert for real values here because we
5692 will check below in the one case that it matters. */
5693
5694 invert = 0;
5695 if (code == NE_EXPR || code == GE_EXPR)
5696 {
5697 invert = 1;
5698 code = invert_tree_comparison (code);
6d716ca8
RS		 5699 }
5700
5701 /* Compute a result for LT or EQ if args permit;
5702 otherwise return T. */
c05a9b68 5703 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
6d716ca8 5704 {
c05a9b68
RS		 5705 if (code == EQ_EXPR)
5706 t1 = build_int_2 ((TREE_INT_CST_LOW (arg0)
5707 == TREE_INT_CST_LOW (arg1))
5708 && (TREE_INT_CST_HIGH (arg0)
5709 == TREE_INT_CST_HIGH (arg1)),
5710 0);
6d716ca8 5711 else
c05a9b68
RS		 5712 t1 = build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0))
5713 ? INT_CST_LT_UNSIGNED (arg0, arg1)
5714 : INT_CST_LT (arg0, arg1)),
5715 0);
6d716ca8 5716 }
c05a9b68 5717
e80c9ccb 5718#if 0 /* This is no longer useful, but breaks some real code. */
6d716ca8
RS		 5719 /* Assume a nonexplicit constant cannot equal an explicit one,
5720 since such code would be undefined anyway.
5721 Exception: on sysvr4, using #pragma weak,
5722 a label can come out as 0. */
5723 else if (TREE_CODE (arg1) == INTEGER_CST
5724 && !integer_zerop (arg1)
5725 && TREE_CONSTANT (arg0)
5726 && TREE_CODE (arg0) == ADDR_EXPR
c05a9b68
RS		 5727 && code == EQ_EXPR)
5728 t1 = build_int_2 (0, 0);
e80c9ccb 5729#endif
6d716ca8 5730 /* Two real constants can be compared explicitly. */
c05a9b68 5731 else if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
6d716ca8 5732 {
c05a9b68
RS		 5733 /* If either operand is a NaN, the result is false with two
5734 exceptions: First, an NE_EXPR is true on NaNs, but that case
5735 is already handled correctly since we will be inverting the
5736 result for NE_EXPR. Second, if we had inverted a LE_EXPR
5737 or a GE_EXPR into a LT_EXPR, we must return true so that it
5738 will be inverted into false. */
5739
5740 if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
5741 || REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
5742 t1 = build_int_2 (invert && code == LT_EXPR, 0);
5743
5744 else if (code == EQ_EXPR)
5745 t1 = build_int_2 (REAL_VALUES_EQUAL (TREE_REAL_CST (arg0),
5746 TREE_REAL_CST (arg1)),
5747 0);
6d716ca8 5748 else
c05a9b68
RS		 5749 t1 = build_int_2 (REAL_VALUES_LESS (TREE_REAL_CST (arg0),
5750 TREE_REAL_CST (arg1)),
5751 0);
6d716ca8
RS		 5752 }
5753
c05a9b68
RS		 5754 if (t1 == NULL_TREE)
5755 return t;
5756
5757 if (invert)
5758 TREE_INT_CST_LOW (t1) ^= 1;
5759
5760 TREE_TYPE (t1) = type;
c651e1e0
MM		 5761 if (TREE_CODE (type) == BOOLEAN_TYPE)
5762 return truthvalue_conversion (t1);
c05a9b68 5763 return t1;
6d716ca8
RS		 5764
5765 case COND_EXPR:
a5e9b124
JW		 5766 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
5767 so all simple results must be passed through pedantic_non_lvalue. */
6d716ca8 5768 if (TREE_CODE (arg0) == INTEGER_CST)
a5e9b124
JW		 5769 return pedantic_non_lvalue
5770 (TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1)));
6d716ca8 5771 else if (operand_equal_p (arg1, TREE_OPERAND (expr, 2), 0))
4ab3cb65 5772 return pedantic_omit_one_operand (type, arg1, arg0);
6d716ca8 5773
c05a9b68
RS		 5774 /* If the second operand is zero, invert the comparison and swap
5775 the second and third operands. Likewise if the second operand
5776 is constant and the third is not or if the third operand is
5777 equivalent to the first operand of the comparison. */
6d716ca8 5778
c05a9b68
RS		 5779 if (integer_zerop (arg1)
5780 || (TREE_CONSTANT (arg1) && ! TREE_CONSTANT (TREE_OPERAND (t, 2)))
5781 || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
5782 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
5783 TREE_OPERAND (t, 2),
5784 TREE_OPERAND (arg0, 1))))
5785 {
5786 /* See if this can be inverted. If it can't, possibly because
5787 it was a floating-point inequality comparison, don't do
5788 anything. */
5789 tem = invert_truthvalue (arg0);
6d716ca8 5790
c05a9b68
RS		 5791 if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
5792 {
cd7ece66
RK		 5793 t = build (code, type, tem,
5794 TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
5795 arg0 = tem;
3a96b5eb 5796 arg1 = TREE_OPERAND (t, 2);
3a96b5eb 5797 STRIP_NOPS (arg1);
c05a9b68
RS		 5798 }
5799 }
6d716ca8 5800
c05a9b68
RS		 5801 /* If we have A op B ? A : C, we may be able to convert this to a
5802 simpler expression, depending on the operation and the values
b5c52586
RS		 5803 of B and C. IEEE floating point prevents this though,
5804 because A or B might be -0.0 or a NaN. */
6d716ca8 5805
c05a9b68 5806 if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
b5c52586 5807 && (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
fab446b8
RK		 5808 || ! FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 0)))
5809 || flag_fast_math)
c05a9b68
RS		 5810 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
5811 arg1, TREE_OPERAND (arg0, 1)))
6d716ca8 5812 {
c05a9b68
RS		 5813 tree arg2 = TREE_OPERAND (t, 2);
5814 enum tree_code comp_code = TREE_CODE (arg0);
5815
3a96b5eb
RK		 5816 STRIP_NOPS (arg2);
5817
c05a9b68
RS		 5818 /* If we have A op 0 ? A : -A, this is A, -A, abs (A), or abs (-A),
5819 depending on the comparison operation. */
68c6b3a9
DE		 5820 if ((FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 1)))
5821 ? real_zerop (TREE_OPERAND (arg0, 1))
5822 : integer_zerop (TREE_OPERAND (arg0, 1)))
c05a9b68
RS		 5823 && TREE_CODE (arg2) == NEGATE_EXPR
5824 && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
5825 switch (comp_code)
5826 {
5827 case EQ_EXPR:
a5e9b124
JW		 5828 return pedantic_non_lvalue
5829 (fold (build1 (NEGATE_EXPR, type, arg1)));
c05a9b68 5830 case NE_EXPR:
a5e9b124 5831 return pedantic_non_lvalue (convert (type, arg1));
c05a9b68
RS		 5832 case GE_EXPR:
5833 case GT_EXPR:
a5e9b124 5834 return pedantic_non_lvalue
21403f14
RK		 5835 (convert (type, fold (build1 (ABS_EXPR,
5836 TREE_TYPE (arg1), arg1))));
c05a9b68
RS		 5837 case LE_EXPR:
5838 case LT_EXPR:
a5e9b124
JW		 5839 return pedantic_non_lvalue
5840 (fold (build1 (NEGATE_EXPR, type,
21403f14
RK		 5841 convert (type,
5842 fold (build1 (ABS_EXPR,
5843 TREE_TYPE (arg1),
5844 arg1))))));
e9a25f70
JL		 5845 default:
5846 abort ();
c05a9b68 5847 }
6d716ca8 5848
c05a9b68
RS		 5849 /* If this is A != 0 ? A : 0, this is simply A. For ==, it is
5850 always zero. */
6d716ca8 5851
29ebe69a 5852 if (integer_zerop (TREE_OPERAND (arg0, 1)) && integer_zerop (arg2))
c05a9b68
RS		 5853 {
5854 if (comp_code == NE_EXPR)
a5e9b124 5855 return pedantic_non_lvalue (convert (type, arg1));
c05a9b68 5856 else if (comp_code == EQ_EXPR)
a5e9b124 5857 return pedantic_non_lvalue (convert (type, integer_zero_node));
c05a9b68
RS		 5858 }
5859
5860 /* If this is A op B ? A : B, this is either A, B, min (A, B),
5861 or max (A, B), depending on the operation. */
5862
5863 if (operand_equal_for_comparison_p (TREE_OPERAND (arg0, 1),
5864 arg2, TREE_OPERAND (arg0, 0)))
3a96b5eb
RK		 5865 {
5866 tree comp_op0 = TREE_OPERAND (arg0, 0);
5867 tree comp_op1 = TREE_OPERAND (arg0, 1);
5868 tree comp_type = TREE_TYPE (comp_op0);
5869
5870 switch (comp_code)
5871 {
5872 case EQ_EXPR:
5873 return pedantic_non_lvalue (convert (type, arg2));
5874 case NE_EXPR:
5875 return pedantic_non_lvalue (convert (type, arg1));
5876 case LE_EXPR:
5877 case LT_EXPR:
e9a25f70
JL		 5878 /* In C++ a ?: expression can be an lvalue, so put the
5879 operand which will be used if they are equal first
5880 so that we can convert this back to the
5881 corresponding COND_EXPR. */
5882 return pedantic_non_lvalue
5883 (convert (type, (fold (build (MIN_EXPR, comp_type,
5884 (comp_code == LE_EXPR
5885 ? comp_op0 : comp_op1),
5886 (comp_code == LE_EXPR
5887 ? comp_op1 : comp_op0))))));
88a5cdb8 5888 break;
3a96b5eb
RK		 5889 case GE_EXPR:
5890 case GT_EXPR:
e9a25f70
JL		 5891 return pedantic_non_lvalue
5892 (convert (type, fold (build (MAX_EXPR, comp_type,
5893 (comp_code == GE_EXPR
5894 ? comp_op0 : comp_op1),
5895 (comp_code == GE_EXPR
5896 ? comp_op1 : comp_op0)))));
88a5cdb8 5897 break;
e9a25f70
JL		 5898 default:
5899 abort ();
3a96b5eb
RK		 5900 }
5901 }
c05a9b68
RS		 5902
5903 /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
5904 we might still be able to simplify this. For example,
5905 if C1 is one less or one more than C2, this might have started
53d2fb4f 5906 out as a MIN or MAX and been transformed by this function.
7178e3af 5907 Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE. */
c05a9b68 5908
7178e3af 5909 if (INTEGRAL_TYPE_P (type)
53d2fb4f 5910 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
c05a9b68
RS		 5911 && TREE_CODE (arg2) == INTEGER_CST)
5912 switch (comp_code)
5913 {
5914 case EQ_EXPR:
5915 /* We can replace A with C1 in this case. */
cd7ece66
RK		 5916 arg1 = convert (type, TREE_OPERAND (arg0, 1));
5917 t = build (code, type, TREE_OPERAND (t, 0), arg1,
5918 TREE_OPERAND (t, 2));
c05a9b68
RS		 5919 break;
5920
5921 case LT_EXPR:
5922 /* If C1 is C2 + 1, this is min(A, C2). */
5923 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
5924 && operand_equal_p (TREE_OPERAND (arg0, 1),
5925 const_binop (PLUS_EXPR, arg2,
91d33e36 5926 integer_one_node, 0), 1))
a5e9b124
JW		 5927 return pedantic_non_lvalue
5928 (fold (build (MIN_EXPR, type, arg1, arg2)));
c05a9b68
RS		 5929 break;
5930
5931 case LE_EXPR:
5932 /* If C1 is C2 - 1, this is min(A, C2). */
5933 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
5934 && operand_equal_p (TREE_OPERAND (arg0, 1),
5935 const_binop (MINUS_EXPR, arg2,
91d33e36 5936 integer_one_node, 0), 1))
a5e9b124
JW		 5937 return pedantic_non_lvalue
5938 (fold (build (MIN_EXPR, type, arg1, arg2)));
c05a9b68
RS		 5939 break;
5940
5941 case GT_EXPR:
5942 /* If C1 is C2 - 1, this is max(A, C2). */
5943 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
5944 && operand_equal_p (TREE_OPERAND (arg0, 1),
5945 const_binop (MINUS_EXPR, arg2,
91d33e36 5946 integer_one_node, 0), 1))
a5e9b124
JW		 5947 return pedantic_non_lvalue
5948 (fold (build (MAX_EXPR, type, arg1, arg2)));
c05a9b68
RS		 5949 break;
5950
5951 case GE_EXPR:
5952 /* If C1 is C2 + 1, this is max(A, C2). */
5953 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
5954 && operand_equal_p (TREE_OPERAND (arg0, 1),
5955 const_binop (PLUS_EXPR, arg2,
91d33e36 5956 integer_one_node, 0), 1))
a5e9b124
JW		 5957 return pedantic_non_lvalue
5958 (fold (build (MAX_EXPR, type, arg1, arg2)));
c05a9b68 5959 break;
e9a25f70
JL		 5960 case NE_EXPR:
5961 break;
5962 default:
5963 abort ();
c05a9b68 5964 }
6d716ca8
RS		 5965 }
5966
e1f56f62
RK		 5967 /* If the second operand is simpler than the third, swap them
5968 since that produces better jump optimization results. */
5969 if ((TREE_CONSTANT (arg1) || TREE_CODE_CLASS (TREE_CODE (arg1)) == 'd'
5970 || TREE_CODE (arg1) == SAVE_EXPR)
5971 && ! (TREE_CONSTANT (TREE_OPERAND (t, 2))
5972 || TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t, 2))) == 'd'
5973 || TREE_CODE (TREE_OPERAND (t, 2)) == SAVE_EXPR))
5974 {
5975 /* See if this can be inverted. If it can't, possibly because
5976 it was a floating-point inequality comparison, don't do
5977 anything. */
5978 tem = invert_truthvalue (arg0);
5979
5980 if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
5981 {
cd7ece66
RK		 5982 t = build (code, type, tem,
5983 TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
5984 arg0 = tem;
3a96b5eb 5985 arg1 = TREE_OPERAND (t, 2);
3a96b5eb 5986 STRIP_NOPS (arg1);
e1f56f62
RK		 5987 }
5988 }
5989
c05a9b68
RS		 5990 /* Convert A ? 1 : 0 to simply A. */
5991 if (integer_onep (TREE_OPERAND (t, 1))
5992 && integer_zerop (TREE_OPERAND (t, 2))
5993 /* If we try to convert TREE_OPERAND (t, 0) to our type, the
5994 call to fold will try to move the conversion inside
5995 a COND, which will recurse. In that case, the COND_EXPR
5996 is probably the best choice, so leave it alone. */
5997 && type == TREE_TYPE (arg0))
a5e9b124 5998 return pedantic_non_lvalue (arg0);
6d716ca8 5999
c05a9b68
RS		 6000 /* Look for expressions of the form A & 2 ? 2 : 0. The result of this
6001 operation is simply A & 2. */
6d716ca8
RS		 6002
6003 if (integer_zerop (TREE_OPERAND (t, 2))
6004 && TREE_CODE (arg0) == NE_EXPR
6005 && integer_zerop (TREE_OPERAND (arg0, 1))
c05a9b68
RS		 6006 && integer_pow2p (arg1)
6007 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
6008 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
6009 arg1, 1))
a5e9b124 6010 return pedantic_non_lvalue (convert (type, TREE_OPERAND (arg0, 0)));
6d716ca8 6011
6d716ca8
RS		 6012 return t;
6013
6014 case COMPOUND_EXPR:
b7647895
JW		 6015 /* When pedantic, a compound expression can be neither an lvalue
6016 nor an integer constant expression. */
6017 if (TREE_SIDE_EFFECTS (arg0) || pedantic)
d023bff9
RS		 6018 return t;
6019 /* Don't let (0, 0) be null pointer constant. */
6020 if (integer_zerop (arg1))
6021 return non_lvalue (arg1);
6022 return arg1;
6d716ca8 6023
1cc1b11a
RS		 6024 case COMPLEX_EXPR:
6025 if (wins)
214d5b84 6026 return build_complex (type, arg0, arg1);
1cc1b11a
RS		 6027 return t;
6028
6029 case REALPART_EXPR:
a333b79f 6030 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
1cc1b11a
RS		 6031 return t;
6032 else if (TREE_CODE (arg0) == COMPLEX_EXPR)
6033 return omit_one_operand (type, TREE_OPERAND (arg0, 0),
6034 TREE_OPERAND (arg0, 1));
6035 else if (TREE_CODE (arg0) == COMPLEX_CST)
6036 return TREE_REALPART (arg0);
6037 else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
a3279355
RK		 6038 return fold (build (TREE_CODE (arg0), type,
6039 fold (build1 (REALPART_EXPR, type,
6040 TREE_OPERAND (arg0, 0))),
6041 fold (build1 (REALPART_EXPR,
6042 type, TREE_OPERAND (arg0, 1)))));
1cc1b11a
RS		 6043 return t;
6044
6045 case IMAGPART_EXPR:
a333b79f 6046 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
1cc1b11a
RS		 6047 return convert (type, integer_zero_node);
6048 else if (TREE_CODE (arg0) == COMPLEX_EXPR)
6049 return omit_one_operand (type, TREE_OPERAND (arg0, 1),
6050 TREE_OPERAND (arg0, 0));
6051 else if (TREE_CODE (arg0) == COMPLEX_CST)
6052 return TREE_IMAGPART (arg0);
6053 else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
a3279355
RK		 6054 return fold (build (TREE_CODE (arg0), type,
6055 fold (build1 (IMAGPART_EXPR, type,
6056 TREE_OPERAND (arg0, 0))),
6057 fold (build1 (IMAGPART_EXPR, type,
6058 TREE_OPERAND (arg0, 1)))));
1cc1b11a
RS		 6059 return t;
6060
56c98e5b
JM		 6061 /* Pull arithmetic ops out of the CLEANUP_POINT_EXPR where
6062 appropriate. */
6063 case CLEANUP_POINT_EXPR:
b7f6588d 6064 if (! has_cleanups (arg0))
3ffcb234 6065 return TREE_OPERAND (t, 0);
56c98e5b
JM		 6066
6067 {
6068 enum tree_code code0 = TREE_CODE (arg0);
6069 int kind0 = TREE_CODE_CLASS (code0);
6070 tree arg00 = TREE_OPERAND (arg0, 0);
6071 tree arg01;
6072
0982a4b8 6073 if (kind0 == '1' || code0 == TRUTH_NOT_EXPR)
56c98e5b
JM		 6074 return fold (build1 (code0, type,
6075 fold (build1 (CLEANUP_POINT_EXPR,
6076 TREE_TYPE (arg00), arg00))));
0982a4b8
JM		 6077
6078 if (kind0 == '<' || kind0 == '2'
6079 || code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR
6080 || code0 == TRUTH_AND_EXPR || code0 == TRUTH_OR_EXPR
6081 || code0 == TRUTH_XOR_EXPR)
6082 {
6083 arg01 = TREE_OPERAND (arg0, 1);
6084
b7f6588d
JM		 6085 if (TREE_CONSTANT (arg00)
6086 || ((code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR)
6087 && ! has_cleanups (arg00)))
0982a4b8
JM		 6088 return fold (build (code0, type, arg00,
6089 fold (build1 (CLEANUP_POINT_EXPR,
6090 TREE_TYPE (arg01), arg01))));
6091
b7f6588d 6092 if (TREE_CONSTANT (arg01))
0982a4b8
JM		 6093 return fold (build (code0, type,
6094 fold (build1 (CLEANUP_POINT_EXPR,
6095 TREE_TYPE (arg00), arg00)),
6096 arg01));
6097 }
56c98e5b
JM		 6098
6099 return t;
6100 }
6101
6d716ca8
RS		 6102 default:
6103 return t;
6104 } /* switch (code) */
6105}
39dfb55a
JL		 6106
6107/* Determine if first argument is a multiple of second argument.
6108 Return 0 if it is not, or is not easily determined to so be.
6109
6110 An example of the sort of thing we care about (at this point --
6111 this routine could surely be made more general, and expanded
6112 to do what the *_DIV_EXPR's fold() cases do now) is discovering
6113 that
6114
6115 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
6116
6117 is a multiple of
6118
6119 SAVE_EXPR (J * 8)
6120
6121 when we know that the two `SAVE_EXPR (J * 8)' nodes are the
6122 same node (which means they will have the same value at run
6123 time, even though we don't know when they'll be assigned).
6124
6125 This code also handles discovering that
6126
6127 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
6128
6129 is a multiple of
6130
6131 8
6132
6133 (of course) so we don't have to worry about dealing with a
6134 possible remainder.
6135
6136 Note that we _look_ inside a SAVE_EXPR only to determine
6137 how it was calculated; it is not safe for fold() to do much
6138 of anything else with the internals of a SAVE_EXPR, since
6139 fold() cannot know when it will be evaluated at run time.
6140 For example, the latter example above _cannot_ be implemented
6141 as
6142
6143 SAVE_EXPR (I) * J
6144
6145 or any variant thereof, since the value of J at evaluation time
6146 of the original SAVE_EXPR is not necessarily the same at the time
6147 the new expression is evaluated. The only optimization of this
6148 sort that would be valid is changing
6149
6150 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
6151 divided by
6152 8
6153
6154 to
6155
6156 SAVE_EXPR (I) * SAVE_EXPR (J)
6157
6158 (where the same SAVE_EXPR (J) is used in the original and the
6159 transformed version). */
6160
6161static int
6162multiple_of_p (type, top, bottom)
6163 tree type;
6164 tree top;
6165 tree bottom;
6166{
6167 if (operand_equal_p (top, bottom, 0))
6168 return 1;
6169
6170 if (TREE_CODE (type) != INTEGER_TYPE)
6171 return 0;
6172
6173 switch (TREE_CODE (top))
6174 {
6175 case MULT_EXPR:
6176 return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
6177 || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
6178
6179 case PLUS_EXPR:
6180 case MINUS_EXPR:
6181 return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
6182 && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
6183
6184 case NOP_EXPR:
6185 /* Punt if conversion from non-integral or wider integral type. */
6186 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
6187 || (TYPE_PRECISION (type)
6188 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
6189 return 0;
6190 /* Fall through. */
6191 case SAVE_EXPR:
6192 return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
6193
6194 case INTEGER_CST:
6195 if ((TREE_CODE (bottom) != INTEGER_CST)
6196 || (tree_int_cst_sgn (top) < 0)
6197 || (tree_int_cst_sgn (bottom) < 0))
6198 return 0;
6199 return integer_zerop (const_binop (TRUNC_MOD_EXPR,
6200 top, bottom, 0));
6201
6202 default:
6203 return 0;
6204 }
6205}
6206\f
GNU Compiler Collection
This page took 1.365095 seconds and 5 git commands to generate.