Skip to content

R
riscv-gcc-1
Commit 906c4e36 by Richard Kenner
Options

*** empty log message *** 

From-SVN: r1473
parent b1ec3c92
Showing with 820 additions and 690 deletions
gcc/cse.c
......@@ -326,7 +326,7 @@ static int cse_basic_block_end;
The cuids are like uids but increase monotonically always.
We use them to see whether a reg is used outside a given basic block. */
static short *uid_cuid;
static int *uid_cuid;
/* Get the cuid of an insn. */
......@@ -863,7 +863,7 @@ mention_regs (x)
{
if (GET_CODE (XEXP (x, 0)) == REG
&& ! REGNO_QTY_VALID_P (REGNO (XEXP (x, 0))))
if (insert_regs (XEXP (x, 0), 0, 0))
if (insert_regs (XEXP (x, 0), NULL_PTR, 0))
{
rehash_using_reg (XEXP (x, 0));
changed = 1;
......@@ -871,7 +871,7 @@ mention_regs (x)
if (GET_CODE (XEXP (x, 1)) == REG
&& ! REGNO_QTY_VALID_P (REGNO (XEXP (x, 1))))
if (insert_regs (XEXP (x, 1), 0, 0))
if (insert_regs (XEXP (x, 1), NULL_PTR, 0))
{
rehash_using_reg (XEXP (x, 1));
changed = 1;
......@@ -939,7 +939,7 @@ insert_regs (x, classp, modified)
else if (GET_CODE (x) == SUBREG && GET_CODE (SUBREG_REG (x)) == REG
&& ! REGNO_QTY_VALID_P (REGNO (SUBREG_REG (x))))
{
insert_regs (SUBREG_REG (x), 0, 0);
insert_regs (SUBREG_REG (x), NULL_PTR, 0);
mention_regs (SUBREG_REG (x));
return 1;
}
......@@ -1297,7 +1297,7 @@ insert (x, classp, hash, mode)
subhash = safe_hash (subexp, mode) % NBUCKETS;
subelt = lookup (subexp, subhash, mode);
if (subelt == 0)
subelt = insert (subexp, 0, subhash, mode);
subelt = insert (subexp, NULL_PTR, subhash, mode);
/* Initialize SUBELT's circular chain if it has none. */
if (subelt->related_value == 0)
subelt->related_value = subelt;
......@@ -1387,7 +1387,7 @@ invalidate (x)
register int i;
register struct table_elt *p;
register rtx base;
register int start, end;
register HOST_WIDE_INT start, end;
/* If X is a register, dependencies on its contents
are recorded through the qty number mechanism.
......@@ -1527,7 +1527,7 @@ remove_invalid_refs (regno)
{
next = p->next_same_hash;
if (GET_CODE (p->exp) != REG
&& refers_to_regno_p (regno, regno + 1, p->exp, 0))
&& refers_to_regno_p (regno, regno + 1, p->exp, NULL_PTR))
remove_from_table (p, i);
}
}
......@@ -1675,7 +1675,7 @@ use_related_value (x, elt)
{
register struct table_elt *relt = 0;
register struct table_elt *p, *q;
int offset;
HOST_WIDE_INT offset;
/* First, is there anything related known?
If we have a table element, we can tell from that.
......@@ -1952,7 +1952,7 @@ exp_equiv_p (x, y, validate, equal_values)
int validate;
int equal_values;
{
register int i;
register int i, j;
register enum rtx_code code;
register char *fmt;
......@@ -2052,34 +2052,45 @@ exp_equiv_p (x, y, validate, equal_values)
fmt = GET_RTX_FORMAT (code);
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
if (fmt[i] == 'e')
switch (fmt[i])
{
case 'e':
if (! exp_equiv_p (XEXP (x, i), XEXP (y, i), validate, equal_values))
return 0;
}
else if (fmt[i] == 'E')
{
int j;
break;
case 'E':
if (XVECLEN (x, i) != XVECLEN (y, i))
return 0;
for (j = 0; j < XVECLEN (x, i); j++)
if (! exp_equiv_p (XVECEXP (x, i, j), XVECEXP (y, i, j),
validate, equal_values))
return 0;
}
else if (fmt[i] == 's')
{
break;
case 's':
if (strcmp (XSTR (x, i), XSTR (y, i)))
return 0;
}
else if (fmt[i] == 'i')
{
break;
case 'i':
if (XINT (x, i) != XINT (y, i))
return 0;
break;
case 'w':
if (XWINT (x, i) != XWINT (y, i))
return 0;
break;
case '0':
break;
default:
abort ();
}
else if (fmt[i] != '0')
abort ();
}
}
return 1;
}
......@@ -2152,9 +2163,9 @@ refers_to_p (x, y)
int
refers_to_mem_p (x, base, start, end)
rtx x, base;
int start, end;
HOST_WIDE_INT start, end;
{
register int i;
register HOST_WIDE_INT i;
register enum rtx_code code;
register char *fmt;
......@@ -2221,7 +2232,7 @@ refers_to_mem_p (x, base, start, end)
if (GET_CODE (base) == PLUS
&& GET_CODE (XEXP (base, 1)) == CONST_INT)
{
int tem = INTVAL (XEXP (base, 1));
HOST_WIDE_INT tem = INTVAL (XEXP (base, 1));
start += tem;
end += tem;
base = XEXP (base, 0);
......@@ -2236,7 +2247,7 @@ refers_to_mem_p (x, base, start, end)
if (GET_CODE (base) == PLUS
&& GET_CODE (XEXP (base, 1)) == CONST_INT)
{
int tem = INTVAL (XEXP (base, 1));
HOST_WIDE_INT tem = INTVAL (XEXP (base, 1));
start += tem;
end += tem;
base = XEXP (base, 0);
......@@ -2477,7 +2488,7 @@ find_best_addr (insn, loc)
&& (GET_CODE (elt->exp) == REG
|| exp_equiv_p (elt->exp, elt->exp, 1, 0))
&& validate_change (insn, loc,
canon_reg (copy_rtx (elt->exp), 0), 0))
canon_reg (copy_rtx (elt->exp), NULL_RTX), 0))
return;
}
#else
......@@ -2516,7 +2527,8 @@ find_best_addr (insn, loc)
if (found_better)
{
if (validate_change (insn, loc,
canon_reg (copy_rtx (best_elt->exp), 0), 0))
canon_reg (copy_rtx (best_elt->exp),
NULL_RTX), 0))
return;
else
best_elt->flag = 1;
......@@ -2593,7 +2605,8 @@ find_best_addr (insn, loc)
if (found_better)
{
if (validate_change (insn, loc,
canon_reg (copy_rtx (best_rtx), 0), 0))
canon_reg (copy_rtx (best_rtx),
NULL_RTX), 0))
return;
else
best_elt->flag = 1;
......@@ -2698,9 +2711,11 @@ find_comparison_args (code, parg1, parg2)
|| ((code == NE
|| (code == LT
&& GET_MODE_CLASS (inner_mode) == MODE_INT
&& GET_MODE_BITSIZE (inner_mode) <= HOST_BITS_PER_INT
&& (GET_MODE_BITSIZE (inner_mode)
<= HOST_BITS_PER_WIDE_INT)
&& (STORE_FLAG_VALUE
& (1 << (GET_MODE_BITSIZE (inner_mode) - 1))))
& ((HOST_WIDE_INT) 1
<< (GET_MODE_BITSIZE (inner_mode) - 1))))
#ifdef FLOAT_STORE_FLAG_VALUE
|| (code == LT
&& GET_MODE_CLASS (inner_mode) == MODE_FLOAT
......@@ -2715,9 +2730,11 @@ find_comparison_args (code, parg1, parg2)
else if ((code == EQ
|| (code == GE
&& GET_MODE_CLASS (inner_mode) == MODE_INT
&& GET_MODE_BITSIZE (inner_mode) <= HOST_BITS_PER_INT
&& (GET_MODE_BITSIZE (inner_mode)
<= HOST_BITS_PER_WIDE_INT)
&& (STORE_FLAG_VALUE
& (1 << (GET_MODE_BITSIZE (inner_mode) - 1))))
& ((HOST_WIDE_INT) 1
<< (GET_MODE_BITSIZE (inner_mode) - 1))))
#ifdef FLOAT_STORE_FLAG_VALUE
|| (code == GE
&& GET_MODE_CLASS (inner_mode) == MODE_FLOAT
......@@ -2811,17 +2828,17 @@ simplify_unary_operation (code, mode, op, op_mode)
if (CONST_DOUBLE_HIGH (op) < 0)
{
d = (double) (~ CONST_DOUBLE_HIGH (op));
d *= ((double) (1 << (HOST_BITS_PER_INT / 2))
* (double) (1 << (HOST_BITS_PER_INT / 2)));
d += (double) (unsigned) (~ CONST_DOUBLE_LOW (op));
d *= ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
* (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
d += (double) (unsigned HOST_WIDE_INT) (~ CONST_DOUBLE_LOW (op));
d = (- d - 1.0);
}
else
{
d = (double) CONST_DOUBLE_HIGH (op);
d *= ((double) (1 << (HOST_BITS_PER_INT / 2))
* (double) (1 << (HOST_BITS_PER_INT / 2)));
d += (double) (unsigned) CONST_DOUBLE_LOW (op);
d *= ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
* (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
d += (double) (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (op);
}
#endif /* REAL_ARITHMETIC */
return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
......@@ -2836,19 +2853,19 @@ simplify_unary_operation (code, mode, op, op_mode)
CONST_DOUBLE_HIGH (op));
#else
d = (double) CONST_DOUBLE_HIGH (op);
d *= ((double) (1 << (HOST_BITS_PER_INT / 2))
* (double) (1 << (HOST_BITS_PER_INT / 2)));
d += (double) (unsigned) CONST_DOUBLE_LOW (op);
d *= ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
* (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
d += (double) (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (op);
#endif /* REAL_ARITHMETIC */
return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
}
#endif
else if (GET_CODE (op) == CONST_INT
&& width <= HOST_BITS_PER_INT && width > 0)
&& width <= HOST_BITS_PER_WIDE_INT && width > 0)
{
register int arg0 = INTVAL (op);
register int val;
register HOST_WIDE_INT arg0 = INTVAL (op);
register HOST_WIDE_INT val;
switch (code)
{
......@@ -2926,11 +2943,12 @@ simplify_unary_operation (code, mode, op, op_mode)
unless they and our sign bit are all one.
So we get either a reasonable negative value or a reasonable
unsigned value for this mode. */
if (width < HOST_BITS_PER_INT
&& ((val & ((-1) << (width - 1))) != ((-1) << (width - 1))))
if (width < HOST_BITS_PER_WIDE_INT
&& ((val & ((HOST_WIDE_INT) (-1) << (width - 1)))
!= ((HOST_WIDE_INT) (-1) << (width - 1))))
val &= (1 << width) - 1;
return gen_rtx (CONST_INT, VOIDmode, val);
return GEN_INT (val);
}
/* We can do some operations on integer CONST_DOUBLEs. Also allow
......@@ -2938,7 +2956,7 @@ simplify_unary_operation (code, mode, op, op_mode)
else if (GET_MODE (op) == VOIDmode
&& (GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT))
{
int l1, h1, lv, hv;
HOST_WIDE_INT l1, h1, lv, hv;
if (GET_CODE (op) == CONST_DOUBLE)
l1 = CONST_DOUBLE_LOW (op), h1 = CONST_DOUBLE_HIGH (op);
......@@ -2966,21 +2984,21 @@ simplify_unary_operation (code, mode, op, op_mode)
case FFS:
hv = 0;
if (l1 == 0)
lv = HOST_BITS_PER_INT + exact_log2 (h1 & (-h1)) + 1;
lv = HOST_BITS_PER_WIDE_INT + exact_log2 (h1 & (-h1)) + 1;
else
lv = exact_log2 (l1 & (-l1)) + 1;
break;
case TRUNCATE:
if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT)
return gen_rtx (CONST_INT, VOIDmode, l1 & GET_MODE_MASK (mode));
if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
return GEN_INT (l1 & GET_MODE_MASK (mode));
else
return 0;
break;
case ZERO_EXTEND:
if (op_mode == VOIDmode
|| GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_INT)
|| GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT)
return 0;
hv = 0;
......@@ -2989,16 +3007,17 @@ simplify_unary_operation (code, mode, op, op_mode)
case SIGN_EXTEND:
if (op_mode == VOIDmode
|| GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_INT)
|| GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT)
return 0;
else
{
lv = l1 & GET_MODE_MASK (op_mode);
if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_INT
&& (lv & (1 << (GET_MODE_BITSIZE (op_mode) - 1))) != 0)
lv -= 1 << GET_MODE_BITSIZE (op_mode);
if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT
&& (lv & ((HOST_WIDE_INT) 1
<< (GET_MODE_BITSIZE (op_mode) - 1))) != 0)
lv -= (HOST_WIDE_INT) 1 << GET_MODE_BITSIZE (op_mode);
hv = (lv < 0) ? ~0 : 0;
hv = (lv < 0) ? ~ (HOST_WIDE_INT) 0 : 0;
}
break;
......@@ -3065,16 +3084,16 @@ simplify_unary_operation (code, mode, op, op_mode)
}
x = immed_real_const_1 (d, mode);
set_float_handler (0);
set_float_handler (NULL_PTR);
return x;
}
else if (GET_CODE (op) == CONST_DOUBLE && GET_MODE_CLASS (mode) == MODE_INT
&& width <= HOST_BITS_PER_INT && width > 0)
&& width <= HOST_BITS_PER_WIDE_INT && width > 0)
{
REAL_VALUE_TYPE d;
jmp_buf handler;
rtx x;
int val;
HOST_WIDE_INT val;
if (setjmp (handler))
return 0;
......@@ -3097,17 +3116,18 @@ simplify_unary_operation (code, mode, op, op_mode)
abort ();
}
set_float_handler (0);
set_float_handler (NULL_PTR);
/* Clear the bits that don't belong in our mode,
unless they and our sign bit are all one.
So we get either a reasonable negative value or a reasonable
unsigned value for this mode. */
if (width < HOST_BITS_PER_INT
&& ((val & ((-1) << (width - 1))) != ((-1) << (width - 1))))
val &= (1 << width) - 1;
if (width < HOST_BITS_PER_WIDE_INT
&& ((val & ((HOST_WIDE_INT) (-1) << (width - 1)))
!= ((HOST_WIDE_INT) (-1) << (width - 1))))
val &= ((HOST_WIDE_INT) 1 << width) - 1;
return gen_rtx (CONST_INT, VOIDmode, val);
return GEN_INT (val);
}
#endif
/* This was formerly used only for non-IEEE float.
......@@ -3155,8 +3175,8 @@ simplify_binary_operation (code, mode, op0, op1)
enum machine_mode mode;
rtx op0, op1;
{
register int arg0, arg1, arg0s, arg1s;
int val;
register HOST_WIDE_INT arg0, arg1, arg0s, arg1s;
HOST_WIDE_INT val;
int width = GET_MODE_BITSIZE (mode);
/* Relational operations don't work here. We must know the mode
......@@ -3217,7 +3237,7 @@ simplify_binary_operation (code, mode, op0, op1)
}
#endif
set_float_handler (0);
set_float_handler (NULL_PTR);
value = real_value_truncate (mode, value);
return immed_real_const_1 (value, mode);
}
......@@ -3227,7 +3247,7 @@ simplify_binary_operation (code, mode, op0, op1)
&& GET_CODE (op0) == CONST_DOUBLE
&& (GET_CODE (op1) == CONST_DOUBLE || GET_CODE (op1) == CONST_INT))
{
int l1, l2, h1, h2, lv, hv;
HOST_WIDE_INT l1, l2, h1, h2, lv, hv;
l1 = CONST_DOUBLE_LOW (op0), h1 = CONST_DOUBLE_HIGH (op0);
......@@ -3271,30 +3291,40 @@ simplify_binary_operation (code, mode, op0, op1)
break;
case SMIN:
if (h1 < h2 || (h1 == h2 && (unsigned) l1 < (unsigned) l2))
if (h1 < h2
|| (h1 == h2
&& ((unsigned HOST_WIDE_INT) l1
< (unsigned HOST_WIDE_INT) l2)))
lv = l1, hv = h1;
else
lv = l2, hv = h2;
break;
case SMAX:
if (h1 > h2 || (h1 == h2 && (unsigned) l1 > (unsigned) l2))
if (h1 > h2
|| (h1 == h2
&& ((unsigned HOST_WIDE_INT) l1
> (unsigned HOST_WIDE_INT) l2)))
lv = l1, hv = h1;
else
lv = l2, hv = h2;
break;
case UMIN:
if ((unsigned) h1 < (unsigned) h2
|| (h1 == h2 && (unsigned) l1 < (unsigned) l2))
if ((unsigned HOST_WIDE_INT) h1 < (unsigned HOST_WIDE_INT) h2
|| (h1 == h2
&& ((unsigned HOST_WIDE_INT) l1
< (unsigned HOST_WIDE_INT) l2)))
lv = l1, hv = h1;
else
lv = l2, hv = h2;
break;
case UMAX:
if ((unsigned) h1 > (unsigned) h2
|| (h1 == h2 && (unsigned) l1 > (unsigned) l2))
if ((unsigned HOST_WIDE_INT) h1 > (unsigned HOST_WIDE_INT) h2
|| (h1 == h2
&& ((unsigned HOST_WIDE_INT) l1
> (unsigned HOST_WIDE_INT) l2)))
lv = l1, hv = h1;
else
lv = l2, hv = h2;
......@@ -3331,7 +3361,7 @@ simplify_binary_operation (code, mode, op0, op1)
#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
if (GET_CODE (op0) != CONST_INT || GET_CODE (op1) != CONST_INT
|| width > HOST_BITS_PER_INT || width == 0)
|| width > HOST_BITS_PER_WIDE_INT || width == 0)
{
/* Even if we can't compute a constant result,
there are some cases worth simplifying. */
......@@ -3633,8 +3663,7 @@ simplify_binary_operation (code, mode, op0, op1)
/* Convert multiply by constant power of two into shift. */
if (GET_CODE (op1) == CONST_INT
&& (val = exact_log2 (INTVAL (op1))) >= 0)
return gen_rtx (ASHIFT, mode, op0,
gen_rtx (CONST_INT, VOIDmode, val));
return gen_rtx (ASHIFT, mode, op0, GEN_INT (val));
if (GET_CODE (op1) == CONST_DOUBLE
&& GET_MODE_CLASS (GET_MODE (op1)) == MODE_FLOAT)
......@@ -3698,8 +3727,7 @@ simplify_binary_operation (code, mode, op0, op1)
below). */
if (GET_CODE (op1) == CONST_INT
&& (arg1 = exact_log2 (INTVAL (op1))) > 0)
return gen_rtx (LSHIFTRT, mode, op0,
gen_rtx (CONST_INT, VOIDmode, arg1));
return gen_rtx (LSHIFTRT, mode, op0, GEN_INT (arg1));
/* ... fall through ... */
......@@ -3737,8 +3765,7 @@ simplify_binary_operation (code, mode, op0, op1)
/* Handle modulus by power of two (mod with 1 handled below). */
if (GET_CODE (op1) == CONST_INT
&& exact_log2 (INTVAL (op1)) > 0)
return gen_rtx (AND, mode, op0,
gen_rtx (CONST_INT, VOIDmode, INTVAL (op1) - 1));
return gen_rtx (AND, mode, op0, GEN_INT (INTVAL (op1) - 1));
/* ... fall through ... */
......@@ -3751,7 +3778,7 @@ simplify_binary_operation (code, mode, op0, op1)
case ROTATERT:
case ROTATE:
/* Rotating ~0 always results in ~0. */
if (GET_CODE (op0) == CONST_INT && width <= HOST_BITS_PER_INT
if (GET_CODE (op0) == CONST_INT && width <= HOST_BITS_PER_WIDE_INT
&& INTVAL (op0) == GET_MODE_MASK (mode)
&& ! side_effects_p (op1))
return op0;
......@@ -3769,8 +3796,8 @@ simplify_binary_operation (code, mode, op0, op1)
break;
case SMIN:
if (width <= HOST_BITS_PER_INT && GET_CODE (op1) == CONST_INT
&& INTVAL (op1) == 1 << (width -1)
if (width <= HOST_BITS_PER_WIDE_INT && GET_CODE (op1) == CONST_INT
&& INTVAL (op1) == (HOST_WIDE_INT) 1 << (width -1)
&& ! side_effects_p (op0))
return op1;
else if (rtx_equal_p (op0, op1) && ! side_effects_p (op0))
......@@ -3778,7 +3805,7 @@ simplify_binary_operation (code, mode, op0, op1)
break;
case SMAX:
if (width <= HOST_BITS_PER_INT && GET_CODE (op1) == CONST_INT
if (width <= HOST_BITS_PER_WIDE_INT && GET_CODE (op1) == CONST_INT
&& INTVAL (op1) == GET_MODE_MASK (mode) >> 1
&& ! side_effects_p (op0))
return op1;
......@@ -3813,18 +3840,18 @@ simplify_binary_operation (code, mode, op0, op1)
arg0 = INTVAL (op0);
arg1 = INTVAL (op1);
if (width < HOST_BITS_PER_INT)
if (width < HOST_BITS_PER_WIDE_INT)
{
arg0 &= (1 << width) - 1;
arg1 &= (1 << width) - 1;
arg0 &= ((HOST_WIDE_INT) 1 << width) - 1;
arg1 &= ((HOST_WIDE_INT) 1 << width) - 1;
arg0s = arg0;
if (arg0s & (1 << (width - 1)))
arg0s |= ((-1) << width);
if (arg0s & ((HOST_WIDE_INT) 1 << (width - 1)))
arg0s |= ((HOST_WIDE_INT) (-1) << width);
arg1s = arg1;
if (arg1s & (1 << (width - 1)))
arg1s |= ((-1) << width);
if (arg1s & ((HOST_WIDE_INT) 1 << (width - 1)))
arg1s |= ((HOST_WIDE_INT) (-1) << width);
}
else
{
......@@ -3863,13 +3890,13 @@ simplify_binary_operation (code, mode, op0, op1)
case UDIV:
if (arg1 == 0)
return 0;
val = (unsigned) arg0 / arg1;
val = (unsigned HOST_WIDE_INT) arg0 / arg1;
break;
case UMOD:
if (arg1 == 0)
return 0;
val = (unsigned) arg0 % arg1;
val = (unsigned HOST_WIDE_INT) arg0 % arg1;
break;
case AND:
......@@ -3897,7 +3924,7 @@ simplify_binary_operation (code, mode, op0, op1)
if (arg1 >= width)
return 0;
val = ((unsigned) arg0) >> arg1;
val = ((unsigned HOST_WIDE_INT) arg0) >> arg1;
break;
case ASHIFT:
......@@ -3912,7 +3939,7 @@ simplify_binary_operation (code, mode, op0, op1)
if (arg1 >= width)
return 0;
val = ((unsigned) arg0) << arg1;
val = ((unsigned HOST_WIDE_INT) arg0) << arg1;
break;
case ASHIFTRT:
......@@ -3934,8 +3961,8 @@ simplify_binary_operation (code, mode, op0, op1)
return 0;
arg1 %= width;
val = ((((unsigned) arg0) << (width - arg1))
| (((unsigned) arg0) >> arg1));
val = ((((unsigned HOST_WIDE_INT) arg0) << (width - arg1))
| (((unsigned HOST_WIDE_INT) arg0) >> arg1));
break;
case ROTATE:
......@@ -3943,8 +3970,8 @@ simplify_binary_operation (code, mode, op0, op1)
return 0;
arg1 %= width;
val = ((((unsigned) arg0) << arg1)
| (((unsigned) arg0) >> (width - arg1)));
val = ((((unsigned HOST_WIDE_INT) arg0) << arg1)
| (((unsigned HOST_WIDE_INT) arg0) >> (width - arg1)));
break;
case COMPARE:
......@@ -3956,7 +3983,8 @@ simplify_binary_operation (code, mode, op0, op1)
break;
case UMIN:
val = (unsigned int)arg0 <= (unsigned int)arg1 ? arg0 : arg1;
val = ((unsigned HOST_WIDE_INT) arg0
<= (unsigned HOST_WIDE_INT) arg1 ? arg0 : arg1);
break;
case SMAX:
......@@ -3964,7 +3992,8 @@ simplify_binary_operation (code, mode, op0, op1)
break;
case UMAX:
val = (unsigned int)arg0 > (unsigned int)arg1 ? arg0 : arg1;
val = ((unsigned HOST_WIDE_INT) arg0
> (unsigned HOST_WIDE_INT) arg1 ? arg0 : arg1);
break;
default:
......@@ -3974,11 +4003,12 @@ simplify_binary_operation (code, mode, op0, op1)
/* Clear the bits that don't belong in our mode, unless they and our sign
bit are all one. So we get either a reasonable negative value or a
reasonable unsigned value for this mode. */
if (width < HOST_BITS_PER_INT
&& ((val & ((-1) << (width - 1))) != ((-1) << (width - 1))))
val &= (1 << width) - 1;
return gen_rtx (CONST_INT, VOIDmode, val);
if (width < HOST_BITS_PER_WIDE_INT
&& ((val & ((HOST_WIDE_INT) (-1) << (width - 1)))
!= ((HOST_WIDE_INT) (-1) << (width - 1))))
val &= ((HOST_WIDE_INT) 1 << width) - 1;
return GEN_INT (val);
}
/* Like simplify_binary_operation except used for relational operators.
......@@ -3990,8 +4020,8 @@ simplify_relational_operation (code, mode, op0, op1)
enum machine_mode mode;
rtx op0, op1;
{
register int arg0, arg1, arg0s, arg1s;
int val;
register HOST_WIDE_INT arg0, arg1, arg0s, arg1s;
HOST_WIDE_INT val;
int width = GET_MODE_BITSIZE (mode);
/* If op0 is a compare, extract the comparison arguments from it. */
......@@ -3999,7 +4029,7 @@ simplify_relational_operation (code, mode, op0, op1)
op1 = XEXP (op0, 1), op0 = XEXP (op0, 0);
if (GET_CODE (op0) != CONST_INT || GET_CODE (op1) != CONST_INT
|| width > HOST_BITS_PER_INT || width == 0)
|| width > HOST_BITS_PER_WIDE_INT || width == 0)
{
/* Even if we can't compute a constant result,
there are some cases worth simplifying. */
......@@ -4016,7 +4046,6 @@ simplify_relational_operation (code, mode, op0, op1)
&& GET_MODE_CLASS (GET_MODE (op0)) == MODE_FLOAT)
{
REAL_VALUE_TYPE d0, d1;
int value;
jmp_buf handler;
int op0lt, op1lt, equal;
......@@ -4029,7 +4058,7 @@ simplify_relational_operation (code, mode, op0, op1)
equal = REAL_VALUES_EQUAL (d0, d1);
op0lt = REAL_VALUES_LESS (d0, d1);
op1lt = REAL_VALUES_LESS (d1, d0);
set_float_handler (0);
set_float_handler (NULL_PTR);
switch (code)
{
......@@ -4116,18 +4145,18 @@ simplify_relational_operation (code, mode, op0, op1)
arg0 = INTVAL (op0);
arg1 = INTVAL (op1);
if (width < HOST_BITS_PER_INT)
if (width < HOST_BITS_PER_WIDE_INT)
{
arg0 &= (1 << width) - 1;
arg1 &= (1 << width) - 1;
arg0 &= ((HOST_WIDE_INT) 1 << width) - 1;
arg1 &= ((HOST_WIDE_INT) 1 << width) - 1;
arg0s = arg0;
if (arg0s & (1 << (width - 1)))
arg0s |= ((-1) << width);
if (arg0s & ((HOST_WIDE_INT) 1 << (width - 1)))
arg0s |= ((HOST_WIDE_INT) (-1) << width);
arg1s = arg1;
if (arg1s & (1 << (width - 1)))
arg1s |= ((-1) << width);
if (arg1s & ((HOST_WIDE_INT) 1 << (width - 1)))
arg1s |= ((HOST_WIDE_INT) (-1) << width);
}
else
{
......@@ -4164,19 +4193,23 @@ simplify_relational_operation (code, mode, op0, op1)
break;
case LEU:
val = ((unsigned) arg0) <= ((unsigned) arg1) ? STORE_FLAG_VALUE : 0;
val = (((unsigned HOST_WIDE_INT) arg0)
<= ((unsigned HOST_WIDE_INT) arg1) ? STORE_FLAG_VALUE : 0);
break;
case LTU:
val = ((unsigned) arg0) < ((unsigned) arg1) ? STORE_FLAG_VALUE : 0;
val = (((unsigned HOST_WIDE_INT) arg0)
< ((unsigned HOST_WIDE_INT) arg1) ? STORE_FLAG_VALUE : 0);
break;
case GEU:
val = ((unsigned) arg0) >= ((unsigned) arg1) ? STORE_FLAG_VALUE : 0;
val = (((unsigned HOST_WIDE_INT) arg0)
>= ((unsigned HOST_WIDE_INT) arg1) ? STORE_FLAG_VALUE : 0);
break;
case GTU:
val = ((unsigned) arg0) > ((unsigned) arg1) ? STORE_FLAG_VALUE : 0;
val = (((unsigned HOST_WIDE_INT) arg0)
> ((unsigned HOST_WIDE_INT) arg1) ? STORE_FLAG_VALUE : 0);
break;
default:
......@@ -4186,11 +4219,12 @@ simplify_relational_operation (code, mode, op0, op1)
/* Clear the bits that don't belong in our mode, unless they and our sign
bit are all one. So we get either a reasonable negative value or a
reasonable unsigned value for this mode. */
if (width < HOST_BITS_PER_INT
&& ((val & ((-1) << (width - 1))) != ((-1) << (width - 1))))
val &= (1 << width) - 1;
if (width < HOST_BITS_PER_WIDE_INT
&& ((val & ((HOST_WIDE_INT) (-1) << (width - 1)))
!= ((HOST_WIDE_INT) (-1) << (width - 1))))
val &= ((HOST_WIDE_INT) 1 << width) - 1;
return gen_rtx (CONST_INT, VOIDmode, val);
return GEN_INT (val);
}
/* Simplify CODE, an operation with result mode MODE and three operands,
......@@ -4207,7 +4241,7 @@ simplify_ternary_operation (code, mode, op0_mode, op0, op1, op2)
/* VOIDmode means "infinite" precision. */
if (width == 0)
width = HOST_BITS_PER_INT;
width = HOST_BITS_PER_WIDE_INT;
switch (code)
{
......@@ -4217,34 +4251,36 @@ simplify_ternary_operation (code, mode, op0_mode, op0, op1, op2)
&& GET_CODE (op1) == CONST_INT
&& GET_CODE (op2) == CONST_INT
&& INTVAL (op1) + INTVAL (op2) <= GET_MODE_BITSIZE (op0_mode)
&& width <= HOST_BITS_PER_INT)
&& width <= HOST_BITS_PER_WIDE_INT)
{
/* Extracting a bit-field from a constant */
int val = INTVAL (op0);
HOST_WIDE_INT val = INTVAL (op0);
#if BITS_BIG_ENDIAN
val >>= (GET_MODE_BITSIZE (op0_mode) - INTVAL (op2) - INTVAL (op1));
#else
val >>= INTVAL (op2);
#endif
if (HOST_BITS_PER_INT != INTVAL (op1))
if (HOST_BITS_PER_WIDE_INT != INTVAL (op1))
{
/* First zero-extend. */
val &= (1 << INTVAL (op1)) - 1;
val &= ((HOST_WIDE_INT) 1 << INTVAL (op1)) - 1;
/* If desired, propagate sign bit. */
if (code == SIGN_EXTRACT && (val & (1 << (INTVAL (op1) - 1))))
val |= ~ ((1 << INTVAL (op1)) - 1);
if (code == SIGN_EXTRACT
&& (val & ((HOST_WIDE_INT) 1 << (INTVAL (op1) - 1))))
val |= ~ (((HOST_WIDE_INT) 1 << INTVAL (op1)) - 1);
}
/* Clear the bits that don't belong in our mode,
unless they and our sign bit are all one.
So we get either a reasonable negative value or a reasonable
unsigned value for this mode. */
if (width < HOST_BITS_PER_INT
&& ((val & ((-1) << (width - 1))) != ((-1) << (width - 1))))
val &= (1 << width) - 1;
if (width < HOST_BITS_PER_WIDE_INT
&& ((val & ((HOST_WIDE_INT) (-1) << (width - 1)))
!= ((HOST_WIDE_INT) (-1) << (width - 1))))
val &= ((HOST_WIDE_INT) 1 << width) - 1;
return gen_rtx (CONST_INT, VOIDmode, val);
return GEN_INT (val);
}
break;
......@@ -4281,7 +4317,7 @@ fold_rtx (x, insn)
register enum rtx_code code;
register enum machine_mode mode;
register char *fmt;
register int i, val;
register int i;
rtx new = 0;
int copied = 0;
int must_swap = 0;
......@@ -4367,7 +4403,7 @@ fold_rtx (x, insn)
elt; elt = elt->next_same_value)
if (GET_CODE (elt->exp) == SUBREG
&& GET_MODE (SUBREG_REG (elt->exp)) == mode
&& exp_equiv_p (elt->exp, elt->exp, 1))
&& exp_equiv_p (elt->exp, elt->exp, 1, 0))
return copy_rtx (SUBREG_REG (elt->exp));
}
......@@ -4439,7 +4475,7 @@ fold_rtx (x, insn)
rtx op0 = SUBREG_REG (XEXP (elt->exp, 0));
if (GET_CODE (op0) != REG && ! CONSTANT_P (op0))
op0 = fold_rtx (op0, 0);
op0 = fold_rtx (op0, NULL_RTX);
op0 = equiv_constant (op0);
if (op0)
......@@ -4461,13 +4497,13 @@ fold_rtx (x, insn)
rtx op1 = gen_lowpart_common (mode, XEXP (elt->exp, 1));
if (op0 && GET_CODE (op0) != REG && ! CONSTANT_P (op0))
op0 = fold_rtx (op0, 0);
op0 = fold_rtx (op0, NULL_RTX);
if (op0)
op0 = equiv_constant (op0);
if (op1 && GET_CODE (op1) != REG && ! CONSTANT_P (op1))
op1 = fold_rtx (op1, 0);
op1 = fold_rtx (op1, NULL_RTX);
if (op1)
op1 = equiv_constant (op1);
......@@ -4481,7 +4517,7 @@ fold_rtx (x, insn)
&& GET_MODE (SUBREG_REG (elt->exp)) == mode
&& (GET_MODE_SIZE (GET_MODE (folded_arg0))
<= UNITS_PER_WORD)
&& exp_equiv_p (elt->exp, elt->exp, 1))
&& exp_equiv_p (elt->exp, elt->exp, 1, 0))
new = copy_rtx (SUBREG_REG (elt->exp));
if (new)
......@@ -4510,9 +4546,9 @@ fold_rtx (x, insn)
{
/* Even if we don't fold in the insn itself,
we can safely do so here, in hopes of getting a constant. */
rtx addr = fold_rtx (XEXP (x, 0), 0);
rtx addr = fold_rtx (XEXP (x, 0), NULL_RTX);
rtx base = 0;
int offset = 0;
HOST_WIDE_INT offset = 0;
if (GET_CODE (addr) == REG
&& REGNO_QTY_VALID_P (REGNO (addr))
......@@ -4912,8 +4948,9 @@ fold_rtx (x, insn)
&& INTVAL (inner_const) != 0)
{
int sign_bitnum = GET_MODE_BITSIZE (mode_arg0) - 1;
int has_sign = (HOST_BITS_PER_INT >= sign_bitnum
&& (INTVAL (inner_const) & (1 << sign_bitnum)));
int has_sign = (HOST_BITS_PER_WIDE_INT >= sign_bitnum
&& (INTVAL (inner_const)
& ((HOST_WIDE_INT) 1 << sign_bitnum)));
rtx true = const_true_rtx, false = const0_rtx;
#ifdef FLOAT_STORE_FLAG_VALUE
......@@ -5110,7 +5147,7 @@ equiv_constant (x)
{
struct table_elt *elt;
x = fold_rtx (x, 0);
x = fold_rtx (x, NULL_RTX);
if (CONSTANT_P (x))
return x;
......@@ -5340,13 +5377,13 @@ record_jump_cond (code, mode, op0, op1, reversed_nonequality)
new quantity number. */
if (op0_elt == 0)
{
if (insert_regs (op0, 0, 0))
if (insert_regs (op0, NULL_PTR, 0))
{
rehash_using_reg (op0);
op0_hash_code = HASH (op0, mode);
}
op0_elt = insert (op0, 0, op0_hash_code, mode);
op0_elt = insert (op0, NULL_PTR, op0_hash_code, mode);
op0_elt->in_memory = op0_in_memory;
op0_elt->in_struct = op0_in_struct;
}
......@@ -5357,13 +5394,13 @@ record_jump_cond (code, mode, op0, op1, reversed_nonequality)
/* Put OP1 in the hash table so it gets a new quantity number. */
if (op1_elt == 0)
{
if (insert_regs (op1, 0, 0))
if (insert_regs (op1, NULL_PTR, 0))
{
rehash_using_reg (op1);
op1_hash_code = HASH (op1, mode);
}
op1_elt = insert (op1, 0, op1_hash_code, mode);
op1_elt = insert (op1, NULL_PTR, op1_hash_code, mode);
op1_elt->in_memory = op1_in_memory;
op1_elt->in_struct = op1_in_struct;
}
......@@ -5580,14 +5617,14 @@ cse_insn (insn, in_libcall_block)
because we have already invalidated the reg. */
if (GET_CODE (XEXP (y, 0)) == MEM)
{
canon_reg (XEXP (y, 0), 0);
canon_reg (XEXP (y, 0), NULL_RTX);
note_mem_written (XEXP (y, 0), &writes_memory);
}
}
else if (GET_CODE (y) == USE
&& ! (GET_CODE (XEXP (y, 0)) == REG
&& REGNO (XEXP (y, 0)) < FIRST_PSEUDO_REGISTER))
canon_reg (y, 0);
canon_reg (y, NULL_RTX);
else if (GET_CODE (y) == CALL)
{
canon_reg (y, insn);
......@@ -5600,7 +5637,7 @@ cse_insn (insn, in_libcall_block)
{
if (GET_CODE (XEXP (x, 0)) == MEM)
{
canon_reg (XEXP (x, 0), 0);
canon_reg (XEXP (x, 0), NULL_RTX);
note_mem_written (XEXP (x, 0), &writes_memory);
}
}
......@@ -5609,7 +5646,7 @@ cse_insn (insn, in_libcall_block)
else if (GET_CODE (x) == USE
&& ! (GET_CODE (XEXP (x, 0)) == REG
&& REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER))
canon_reg (XEXP (x, 0), 0);
canon_reg (XEXP (x, 0), NULL_RTX);
else if (GET_CODE (x) == CALL)
{
canon_reg (x, insn);
......@@ -5620,10 +5657,10 @@ cse_insn (insn, in_libcall_block)
if (n_sets == 1 && REG_NOTES (insn) != 0)
{
/* Store the equivalent value in SRC_EQV, if different. */
rtx tem = find_reg_note (insn, REG_EQUAL, 0);
rtx tem = find_reg_note (insn, REG_EQUAL, NULL_RTX);
if (tem && ! rtx_equal_p (XEXP (tem, 0), SET_SRC (sets[0].rtl)))
src_eqv = canon_reg (XEXP (tem, 0), 0);
src_eqv = canon_reg (XEXP (tem, 0), NULL_RTX);
}
/* Canonicalize sources and addresses of destinations.
......@@ -5750,10 +5787,11 @@ cse_insn (insn, in_libcall_block)
if (GET_CODE (src) == CONST_INT
&& GET_CODE (width) == CONST_INT
&& INTVAL (width) < HOST_BITS_PER_INT
&& (INTVAL (src) & ((-1) << INTVAL (width))))
src_folded = gen_rtx (CONST_INT, VOIDmode,
INTVAL (src) & ((1 << INTVAL (width)) - 1));
&& INTVAL (width) < HOST_BITS_PER_WIDE_INT
&& (INTVAL (src) & ((HOST_WIDE_INT) (-1) << INTVAL (width))))
src_folded
= GEN_INT (INTVAL (src) & (((HOST_WIDE_INT) 1
<< INTVAL (width)) - 1));
}
/* Compute SRC's hash code, and also notice if it
......@@ -5932,7 +5970,7 @@ cse_insn (insn, in_libcall_block)
&& GET_MODE_SIZE (mode) < UNITS_PER_WORD)
{
enum machine_mode tmode;
rtx new_and = gen_rtx (AND, VOIDmode, 0, XEXP (src, 1));
rtx new_and = gen_rtx (AND, VOIDmode, NULL_RTX, XEXP (src, 1));
for (tmode = GET_MODE_WIDER_MODE (mode);
GET_MODE_SIZE (tmode) <= UNITS_PER_WORD;
......@@ -6202,7 +6240,7 @@ cse_insn (insn, in_libcall_block)
if (n_sets == 1 && src_const && GET_CODE (dest) == REG
&& GET_CODE (src_const) != REG)
{
rtx tem = find_reg_note (insn, REG_EQUAL, 0);
rtx tem = find_reg_note (insn, REG_EQUAL, NULL_RTX);
/* Record the actual constant value in a REG_EQUAL note, making
a new one if one does not already exist. */
......@@ -6227,7 +6265,7 @@ cse_insn (insn, in_libcall_block)
&& qty_const[reg_qty[REGNO (dest)]] == const0_rtx)
{
/* See if we previously had a REG_WAS_0 note. */
rtx note = find_reg_note (insn, REG_WAS_0, 0);
rtx note = find_reg_note (insn, REG_WAS_0, NULL_RTX);
rtx const_insn = qty_const_insn[reg_qty[REGNO (dest)]];
if ((tem = single_set (const_insn)) != 0
......@@ -6287,8 +6325,9 @@ cse_insn (insn, in_libcall_block)
if (src_const != 0 && GET_CODE (src_const) == CONST_INT
&& GET_CODE (width) == CONST_INT
&& INTVAL (width) < HOST_BITS_PER_INT
&& ! (INTVAL (src_const) & ((-1) << INTVAL (width))))
&& INTVAL (width) < HOST_BITS_PER_WIDE_INT
&& ! (INTVAL (src_const)
& ((HOST_WIDE_INT) (-1) << INTVAL (width))))
/* Exception: if the value is constant,
and it won't be truncated, record it. */
;
......@@ -6696,7 +6735,7 @@ cse_insn (insn, in_libcall_block)
&& SET_DEST (PATTERN (prev)) == SET_SRC (sets[0].rtl))
{
rtx dest = SET_DEST (sets[0].rtl);
rtx note = find_reg_note (prev, REG_EQUIV, 0);
rtx note = find_reg_note (prev, REG_EQUIV, NULL_RTX);
validate_change (prev, & SET_DEST (PATTERN (prev)), dest, 1);
validate_change (insn, & SET_DEST (sets[0].rtl),
......@@ -6710,11 +6749,11 @@ cse_insn (insn, in_libcall_block)
/* If there was a REG_WAS_0 note on PREV, remove it. Move
any REG_WAS_0 note on INSN to PREV. */
note = find_reg_note (prev, REG_WAS_0, 0);
note = find_reg_note (prev, REG_WAS_0, NULL_RTX);
if (note)
remove_note (prev, note);
note = find_reg_note (insn, REG_WAS_0, 0);
note = find_reg_note (insn, REG_WAS_0, NULL_RTX);
if (note)
{
remove_note (insn, note);
......@@ -6889,9 +6928,9 @@ cse_process_notes (x, object)
case EXPR_LIST:
case INSN_LIST:
if (REG_NOTE_KIND (x) == REG_EQUAL)
XEXP (x, 0) = cse_process_notes (XEXP (x, 0), 0);
XEXP (x, 0) = cse_process_notes (XEXP (x, 0), NULL_RTX);
if (XEXP (x, 1))
XEXP (x, 1) = cse_process_notes (XEXP (x, 1), 0);
XEXP (x, 1) = cse_process_notes (XEXP (x, 1), NULL_RTX);
return x;
case SIGN_EXTEND:
......@@ -6920,13 +6959,13 @@ cse_process_notes (x, object)
}
/* Otherwise, canonicalize this register. */
return canon_reg (x, 0);
return canon_reg (x, NULL_RTX);
}
for (i = 0; i < GET_RTX_LENGTH (code); i++)
if (fmt[i] == 'e')
validate_change (object, &XEXP (x, i),
cse_process_notes (XEXP (x, i), object), 0);
cse_process_notes (XEXP (x, i), object), NULL_RTX);
return x;
}
......@@ -7478,8 +7517,8 @@ cse_main (f, nregs, after_loop, file)
/* Find the largest uid. */
i = get_max_uid ();
uid_cuid = (short *) alloca ((i + 1) * sizeof (short));
bzero (uid_cuid, (i + 1) * sizeof (short));
uid_cuid = (int *) alloca ((i + 1) * sizeof (int));
bzero (uid_cuid, (i + 1) * sizeof (int));
/* Compute the mapping from uids to cuids.
CUIDs are numbers assigned to insns, like uids,
......@@ -7678,7 +7717,7 @@ cse_basic_block (from, to, next_branch, around_loop)
looking for duplicate operations. */
if (REG_NOTES (insn))
REG_NOTES (insn) = cse_process_notes (REG_NOTES (insn), 0);
REG_NOTES (insn) = cse_process_notes (REG_NOTES (insn), NULL_RTX);
/* Track when we are inside in LIBCALL block. Inside such a block,
we do not want to record destinations. The last insn of a
......@@ -7686,9 +7725,9 @@ cse_basic_block (from, to, next_branch, around_loop)
its destination is the result of the block and hence should be
recorded. */
if (find_reg_note (insn, REG_LIBCALL, 0))
if (find_reg_note (insn, REG_LIBCALL, NULL_RTX))
in_libcall_block = 1;
else if (find_reg_note (insn, REG_RETVAL, 0))
else if (find_reg_note (insn, REG_RETVAL, NULL_RTX))
in_libcall_block = 0;
cse_insn (insn, in_libcall_block);
......@@ -7893,7 +7932,7 @@ delete_dead_from_cse (insns, nreg)
/* Don't delete any insns that are part of a libcall block.
Flow or loop might get confused if we did that. Remember
that we are scanning backwards. */
if (find_reg_note (insn, REG_RETVAL, 0))
if (find_reg_note (insn, REG_RETVAL, NULL_RTX))
in_libcall = 1;
if (in_libcall)
......@@ -7958,7 +7997,7 @@ delete_dead_from_cse (insns, nreg)
delete_insn (insn);
}
if (find_reg_note (insn, REG_LIBCALL, 0))
if (find_reg_note (insn, REG_LIBCALL, NULL_RTX))
in_libcall = 0;
}
}
gcc/dwarfout.c
......@@ -1498,7 +1498,7 @@ output_bound_representation (bound, dim_num, u_or_l)
if (! optimize)
output_loc_descriptor
(eliminate_regs (SAVE_EXPR_RTL (bound), 0, 0));
(eliminate_regs (SAVE_EXPR_RTL (bound), 0, NULL_RTX));
ASM_OUTPUT_LABEL (asm_out_file, end_label);
}
......@@ -1573,7 +1573,7 @@ location_attribute (rtl)
declaration, but not a definition. So sayeth the PLSIG. */
if (! is_pseudo_reg (rtl))
output_loc_descriptor (eliminate_regs (rtl, 0, 0));
output_loc_descriptor (eliminate_regs (rtl, 0, NULL_RTX));
ASM_OUTPUT_LABEL (asm_out_file, end_label);
}
......@@ -1783,8 +1783,8 @@ const_value_attribute (rtl)
simplicity we always just output CONST_DOUBLEs using 8 bytes. */
ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
(unsigned) CONST_DOUBLE_HIGH (rtl),
(unsigned) CONST_DOUBLE_LOW (rtl));
(unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (rtl),
(unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (rtl));
break;
case CONST_STRING:
......@@ -4320,7 +4320,7 @@ dwarfout_file_scope_decl (decl, set_finalizing)
fputc ('\n', asm_out_file);
ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SECTION);
finalizing = set_finalizing;
output_decl (decl, NULL);
output_decl (decl, NULL_TREE);
/* NOTE: The call above to `output_decl' may have caused one or more
file-scope named types (i.e. tagged types) to be placed onto the
......@@ -4333,7 +4333,7 @@ dwarfout_file_scope_decl (decl, set_finalizing)
`output_pending_types_for_scope' takes them off of the list and un-sets
their TREE_ASM_WRITTEN flags. */
output_pending_types_for_scope (NULL);
output_pending_types_for_scope (NULL_TREE);
/* The above call should have totally emptied the pending_types_list. */
......
gcc/emit-rtl.c
......@@ -247,7 +247,7 @@ gen_rtx (va_alist)
if (code == CONST_INT)
{
int arg = va_arg (p, int);
HOST_WIDE_INT arg = va_arg (p, HOST_WIDE_INT);
if (arg >= - MAX_SAVED_CONST_INT && arg <= MAX_SAVED_CONST_INT)
return const_int_rtx[arg + MAX_SAVED_CONST_INT];
......@@ -306,6 +306,10 @@ gen_rtx (va_alist)
XINT (rt_val, i) = va_arg (p, int);
break;
case 'w': /* A wide integer? */
XWINT (rt_val, i) = va_arg (p, HOST_WIDE_INT);
break;
case 's': /* A string? */
XSTR (rt_val, i) = va_arg (p, char *);
break;
......@@ -538,25 +542,26 @@ gen_lowpart_common (mode, x)
either a reasonable negative value or a reasonable unsigned value
for this mode. */
if (GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_INT)
if (GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT)
return x;
else if (GET_MODE_BITSIZE (mode) > HOST_BITS_PER_INT)
else if (GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT)
return 0;
else if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_INT)
else if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT)
return (GET_CODE (x) == CONST_INT ? x
: gen_rtx (CONST_INT, VOIDmode, CONST_DOUBLE_LOW (x)));
: GEN_INT (CONST_DOUBLE_LOW (x)));
else
{
/* MODE must be narrower than HOST_BITS_PER_INT. */
int width = GET_MODE_BITSIZE (mode);
int val = (GET_CODE (x) == CONST_INT ? INTVAL (x)
: CONST_DOUBLE_LOW (x));
HOST_WIDE_INT val = (GET_CODE (x) == CONST_INT ? INTVAL (x)
: CONST_DOUBLE_LOW (x));
if (((val & ((-1) << (width - 1))) != ((-1) << (width - 1))))
val &= (1 << width) - 1;
if (((val & ((HOST_WIDE_INT) (-1) << (width - 1)))
!= ((HOST_WIDE_INT) (-1) << (width - 1))))
val &= ((HOST_WIDE_INT) 1 << width) - 1;
return (GET_CODE (x) == CONST_INT && INTVAL (x) == val ? x
: gen_rtx (CONST_INT, VOIDmode, val));
: GEN_INT (val));
}
}
......@@ -567,33 +572,34 @@ gen_lowpart_common (mode, x)
different. */
else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
&& HOST_BITS_PER_INT == BITS_PER_WORD)
&& HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
|| flag_pretend_float)
&& GET_MODE_CLASS (mode) == MODE_FLOAT
&& GET_MODE_SIZE (mode) == UNITS_PER_WORD
&& GET_CODE (x) == CONST_INT
&& sizeof (float) * HOST_BITS_PER_CHAR == HOST_BITS_PER_INT)
&& sizeof (float) * HOST_BITS_PER_CHAR == HOST_BITS_PER_WIDE_INT)
{
union {int i; float d; } u;
union {HOST_WIDE_INT i; float d; } u;
u.i = INTVAL (x);
return immed_real_const_1 (u.d, mode);
}
else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
&& HOST_BITS_PER_INT == BITS_PER_WORD)
&& HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
|| flag_pretend_float)
&& GET_MODE_CLASS (mode) == MODE_FLOAT
&& GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
&& (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE)
&& GET_MODE (x) == VOIDmode
&& sizeof (double) * HOST_BITS_PER_CHAR == 2 * HOST_BITS_PER_INT)
&& (sizeof (double) * HOST_BITS_PER_CHAR
== 2 * HOST_BITS_PER_WIDE_INT))
{
union {int i[2]; double d; } u;
int low, high;
union {HOST_WIDE_INT i[2]; double d; } u;
HOST_WIDE_INT low, high;
if (GET_CODE (x) == CONST_INT)
low = INTVAL (x), high = low >> (HOST_BITS_PER_INT -1);
low = INTVAL (x), high = low >> (HOST_BITS_PER_WIDE_INT -1);
else
low = CONST_DOUBLE_LOW (x), high = CONST_DOUBLE_HIGH (x);
......@@ -611,7 +617,7 @@ gen_lowpart_common (mode, x)
compatible. */
else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
&& HOST_BITS_PER_INT == BITS_PER_WORD)
&& HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
|| flag_pretend_float)
&& GET_MODE_CLASS (mode) == MODE_INT
&& GET_CODE (x) == CONST_DOUBLE
......@@ -625,7 +631,7 @@ gen_lowpart_common (mode, x)
compatible. */
else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
&& HOST_BITS_PER_INT == BITS_PER_WORD)
&& HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
|| flag_pretend_float)
&& GET_MODE_CLASS (mode) == MODE_INT
&& GET_CODE (x) == CONST_DOUBLE
......@@ -725,8 +731,8 @@ operand_subword (op, i, validate_address, mode)
int validate_address;
enum machine_mode mode;
{
int val;
int size_ratio = HOST_BITS_PER_INT / BITS_PER_WORD;
HOST_WIDE_INT val;
int size_ratio = HOST_BITS_PER_WIDE_INT / BITS_PER_WORD;
if (mode == VOIDmode)
mode = GET_MODE (op);
......@@ -793,13 +799,12 @@ operand_subword (op, i, validate_address, mode)
target floating formats are the same, handling two-word floating
constants are easy. */
if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
&& HOST_BITS_PER_INT == BITS_PER_WORD)
&& HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
|| flag_pretend_float)
&& GET_MODE_CLASS (mode) == MODE_FLOAT
&& GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
&& GET_CODE (op) == CONST_DOUBLE)
return gen_rtx (CONST_INT, VOIDmode,
i ^ (WORDS_BIG_ENDIAN !=
return GEN_INT (i ^ (WORDS_BIG_ENDIAN !=
/* The constant is stored in the host's word-ordering,
but we want to access it in the target's word-ordering. */
#ifdef HOST_WORDS_BIG_ENDIAN
......@@ -813,19 +818,19 @@ operand_subword (op, i, validate_address, mode)
values often do not have the same high-order bits. We have already
verified that we want the only defined word of the single-word value. */
if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
&& HOST_BITS_PER_INT == BITS_PER_WORD)
&& HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
|| flag_pretend_float)
&& GET_MODE_CLASS (mode) == MODE_FLOAT
&& GET_MODE_SIZE (mode) == UNITS_PER_WORD
&& GET_CODE (op) == CONST_DOUBLE)
{
double d;
union {float f; int i; } u;
union {float f; HOST_WIDE_INT i; } u;
REAL_VALUE_FROM_CONST_DOUBLE (d, op);
u.f = d;
return gen_rtx (CONST_INT, VOIDmode, u.i);
return GEN_INT (u.i);
}
/* The only remaining cases that we can handle are integers.
......@@ -854,11 +859,12 @@ operand_subword (op, i, validate_address, mode)
? (INTVAL (op) < 0 ? ~0 : 0) : CONST_DOUBLE_HIGH (op)));
/* If BITS_PER_WORD is smaller than an int, get the appropriate bits. */
if (BITS_PER_WORD < HOST_BITS_PER_INT)
if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT)
val = ((val >> ((i % size_ratio) * BITS_PER_WORD))
& ((1 << (BITS_PER_WORD % HOST_BITS_PER_INT)) - 1));
& (((HOST_WIDE_INT) 1
<< (BITS_PER_WORD % HOST_BITS_PER_WIDE_INT)) - 1));
return gen_rtx (CONST_INT, VOIDmode, val);
return GEN_INT (val);
}
/* Similar to `operand_subword', but never return 0. If we can't extract
......@@ -965,7 +971,8 @@ change_address (memref, mode, addr)
rtx
gen_label_rtx ()
{
register rtx label = gen_rtx (CODE_LABEL, VOIDmode, 0, 0, 0, label_num++, 0);
register rtx label = gen_rtx (CODE_LABEL, VOIDmode, 0, 0, 0,
label_num++, NULL_PTR);
LABEL_NUSES (label) = 0;
return label;
}
......@@ -991,7 +998,7 @@ gen_inline_header_rtx (first_insn, first_parm_insn, first_labelno,
rtx original_decl_initial;
{
rtx header = gen_rtx (INLINE_HEADER, VOIDmode,
cur_insn_uid++, NULL,
cur_insn_uid++, NULL_RTX,
first_insn, first_parm_insn,
first_labelno, last_labelno,
max_parm_regnum, max_regnum, args_size, pops_args,
......@@ -1577,7 +1584,7 @@ rtx
next_cc0_user (insn)
rtx insn;
{
rtx note = find_reg_note (insn, REG_CC_USER, 0);
rtx note = find_reg_note (insn, REG_CC_USER, NULL_RTX);
if (note)
return XEXP (note, 0);
......@@ -1600,7 +1607,7 @@ rtx
prev_cc0_setter (insn)
rtx insn;
{
rtx note = find_reg_note (insn, REG_CC_SETTER, 0);
rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
rtx link;
if (note)
......@@ -1903,7 +1910,7 @@ emit_insn_before (pattern, before)
}
else
{
insn = make_insn_raw (pattern, 0);
insn = make_insn_raw (pattern, NULL_RTVEC);
add_insn_after (insn, PREV_INSN (before));
}
......@@ -1923,7 +1930,7 @@ emit_jump_insn_before (pattern, before)
insn = emit_insn_before (pattern, before);
else
{
insn = make_jump_insn_raw (pattern, 0);
insn = make_jump_insn_raw (pattern, NULL_RTVEC);
add_insn_after (insn, PREV_INSN (before));
}
......@@ -1997,7 +2004,7 @@ emit_insn_after (pattern, after)
}
else
{
insn = make_insn_raw (pattern, 0);
insn = make_insn_raw (pattern, NULL_RTVEC);
add_insn_after (insn, after);
}
......@@ -2017,7 +2024,7 @@ emit_jump_insn_after (pattern, after)
insn = emit_insn_after (pattern, after);
else
{
insn = make_jump_insn_raw (pattern, 0);
insn = make_jump_insn_raw (pattern, NULL_RTVEC);
add_insn_after (insn, after);
}
......@@ -2123,7 +2130,7 @@ emit_insn (pattern)
}
else
{
insn = make_insn_raw (pattern, NULL);
insn = make_insn_raw (pattern, NULL_RTVEC);
add_insn (insn);
}
......@@ -2182,7 +2189,7 @@ emit_jump_insn (pattern)
return emit_insn (pattern);
else
{
register rtx insn = make_jump_insn_raw (pattern, NULL);
register rtx insn = make_jump_insn_raw (pattern, NULL_RTVEC);
add_insn (insn);
return insn;
}
......@@ -2199,7 +2206,7 @@ emit_call_insn (pattern)
return emit_insn (pattern);
else
{
register rtx insn = make_insn_raw (pattern, NULL);
register rtx insn = make_insn_raw (pattern, NULL_RTVEC);
add_insn (insn);
PUT_CODE (insn, CALL_INSN);
return insn;
......@@ -2712,13 +2719,13 @@ init_emit_once (line_numbers)
}
/* These four calls obtain some of the rtx expressions made above. */
const0_rtx = gen_rtx (CONST_INT, VOIDmode, 0);
const1_rtx = gen_rtx (CONST_INT, VOIDmode, 1);
const2_rtx = gen_rtx (CONST_INT, VOIDmode, 2);
constm1_rtx = gen_rtx (CONST_INT, VOIDmode, -1);
const0_rtx = GEN_INT (0);
const1_rtx = GEN_INT (1);
const2_rtx = GEN_INT (2);
constm1_rtx = GEN_INT (-1);
/* This will usually be one of the above constants, but may be a new rtx. */
const_true_rtx = gen_rtx (CONST_INT, VOIDmode, STORE_FLAG_VALUE);
const_true_rtx = GEN_INT (STORE_FLAG_VALUE);
dconst0 = REAL_VALUE_ATOF ("0");
dconst1 = REAL_VALUE_ATOF ("1");
......@@ -2743,11 +2750,11 @@ init_emit_once (line_numbers)
const_tiny_rtx[i][(int) mode] = tem;
}
const_tiny_rtx[i][(int) VOIDmode] = gen_rtx (CONST_INT, VOIDmode, i);
const_tiny_rtx[i][(int) VOIDmode] = GEN_INT (i);
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
const_tiny_rtx[i][(int) mode] = gen_rtx (CONST_INT, VOIDmode, i);
const_tiny_rtx[i][(int) mode] = GEN_INT (i);
}
stack_pointer_rtx = gen_rtx (REG, Pmode, STACK_POINTER_REGNUM);
......
gcc/expr.c
......@@ -242,7 +242,7 @@ enqueue_insn (var, body)
rtx var, body;
{
pending_chain = gen_rtx (QUEUED, GET_MODE (var),
var, 0, 0, body, pending_chain);
var, NULL_RTX, NULL_RTX, body, pending_chain);
return pending_chain;
}
......@@ -601,7 +601,8 @@ convert_move (to, from, unsignedp)
&& insn_operand_mode[(int) CODE_FOR_slt][0] == word_mode
&& STORE_FLAG_VALUE == -1)
{
emit_cmp_insn (lowfrom, const0_rtx, NE, 0, lowpart_mode, 0, 0);
emit_cmp_insn (lowfrom, const0_rtx, NE, NULL_RTX,
lowpart_mode, 0, 0);
fill_value = gen_reg_rtx (word_mode);
emit_insn (gen_slt (fill_value));
}
......@@ -611,7 +612,7 @@ convert_move (to, from, unsignedp)
fill_value
= expand_shift (RSHIFT_EXPR, lowpart_mode, lowfrom,
size_int (GET_MODE_BITSIZE (lowpart_mode) - 1),
0, 0);
NULL_RTX, 0);
fill_value = convert_to_mode (word_mode, fill_value, 1);
}
}
......@@ -632,7 +633,7 @@ convert_move (to, from, unsignedp)
insns = get_insns ();
end_sequence ();
emit_no_conflict_block (insns, to, from, 0,
emit_no_conflict_block (insns, to, from, NULL_RTX,
gen_rtx (equiv_code, to_mode, from));
return;
}
......@@ -844,15 +845,15 @@ convert_to_mode (mode, x, unsignedp)
return x;
/* There is one case that we must handle specially: If we are converting
a CONST_INT into a mode whose size is twice HOST_BITS_PER_INT and
a CONST_INT into a mode whose size is twice HOST_BITS_PER_WIDE_INT and
we are to interpret the constant as unsigned, gen_lowpart will do
the wrong if the constant appears negative. What we want to do is
make the high-order word of the constant zero, not all ones. */
if (unsignedp && GET_MODE_CLASS (mode) == MODE_INT
&& GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_INT
&& GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT
&& GET_CODE (x) == CONST_INT && INTVAL (x) < 0)
return immed_double_const (INTVAL (x), 0, mode);
return immed_double_const (INTVAL (x), (HOST_WIDE_INT) 0, mode);
/* We can do this with a gen_lowpart if both desired and current modes
are integer, and this is either a constant integer, a register, or a
......@@ -1074,21 +1075,17 @@ move_by_pieces_1 (genfun, mode, data)
#ifdef HAVE_PRE_DECREMENT
if (data->explicit_inc_to < 0)
emit_insn (gen_add2_insn (data->to_addr,
gen_rtx (CONST_INT, VOIDmode, -size)));
emit_insn (gen_add2_insn (data->to_addr, GEN_INT (-size)));
if (data->explicit_inc_from < 0)
emit_insn (gen_add2_insn (data->from_addr,
gen_rtx (CONST_INT, VOIDmode, -size)));
emit_insn (gen_add2_insn (data->from_addr, GEN_INT (-size)));
#endif
emit_insn ((*genfun) (to1, from1));
#ifdef HAVE_POST_INCREMENT
if (data->explicit_inc_to > 0)
emit_insn (gen_add2_insn (data->to_addr,
gen_rtx (CONST_INT, VOIDmode, size)));
emit_insn (gen_add2_insn (data->to_addr, GEN_INT (size)));
if (data->explicit_inc_from > 0)
emit_insn (gen_add2_insn (data->from_addr,
gen_rtx (CONST_INT, VOIDmode, size)));
emit_insn (gen_add2_insn (data->from_addr, GEN_INT (size)));
#endif
if (! data->reverse) data->offset += size;
......@@ -1130,8 +1127,7 @@ emit_block_move (x, y, size, align)
abort ();
if (GET_CODE (size) == CONST_INT
&& (move_by_pieces_ninsns ((unsigned) INTVAL (size), align)
< MOVE_RATIO))
&& (move_by_pieces_ninsns (INTVAL (size), align) < MOVE_RATIO))
move_by_pieces (x, y, INTVAL (size), align);
else
{
......@@ -1144,8 +1140,7 @@ emit_block_move (x, y, size, align)
&& ((unsigned) INTVAL (size)
< (1 << (GET_MODE_BITSIZE (QImode) - 1))))
{
rtx insn = gen_movstrqi (x, y, size,
gen_rtx (CONST_INT, VOIDmode, align));
rtx insn = gen_movstrqi (x, y, size, GEN_INT (align));
if (insn)
{
emit_insn (insn);
......@@ -1159,8 +1154,7 @@ emit_block_move (x, y, size, align)
&& ((unsigned) INTVAL (size)
< (1 << (GET_MODE_BITSIZE (HImode) - 1))))
{
rtx insn = gen_movstrhi (x, y, size,
gen_rtx (CONST_INT, VOIDmode, align));
rtx insn = gen_movstrhi (x, y, size, GEN_INT (align));
if (insn)
{
emit_insn (insn);
......@@ -1171,8 +1165,7 @@ emit_block_move (x, y, size, align)
#ifdef HAVE_movstrsi
if (HAVE_movstrsi)
{
rtx insn = gen_movstrsi (x, y, size,
gen_rtx (CONST_INT, VOIDmode, align));
rtx insn = gen_movstrsi (x, y, size, GEN_INT (align));
if (insn)
{
emit_insn (insn);
......@@ -1183,8 +1176,7 @@ emit_block_move (x, y, size, align)
#ifdef HAVE_movstrdi
if (HAVE_movstrdi)
{
rtx insn = gen_movstrdi (x, y, size,
gen_rtx (CONST_INT, VOIDmode, align));
rtx insn = gen_movstrdi (x, y, size, GEN_INT (align));
if (insn)
{
emit_insn (insn);
......@@ -1227,7 +1219,7 @@ move_block_to_reg (regno, x, nregs, mode)
#ifdef HAVE_load_multiple
last = get_last_insn ();
pat = gen_load_multiple (gen_rtx (REG, word_mode, regno), x,
gen_rtx (CONST_INT, VOIDmode, nregs));
GEN_INT (nregs));
if (pat)
{
emit_insn (pat);
......@@ -1258,7 +1250,7 @@ move_block_from_reg (regno, x, nregs)
#ifdef HAVE_store_multiple
last = get_last_insn ();
pat = gen_store_multiple (x, gen_rtx (REG, word_mode, regno),
gen_rtx (CONST_INT, VOIDmode, nregs));
GEN_INT (nregs));
if (pat)
{
emit_insn (pat);
......@@ -1306,12 +1298,12 @@ clear_storage (object, size)
emit_library_call (memset_libfunc, 1,
VOIDmode, 3,
XEXP (object, 0), Pmode, const0_rtx, Pmode,
gen_rtx (CONST_INT, VOIDmode, size), Pmode);
GEN_INT (size), Pmode);
#else
emit_library_call (bzero_libfunc, 1,
VOIDmode, 2,
XEXP (object, 0), Pmode,
gen_rtx (CONST_INT, VOIDmode, size), Pmode);
GEN_INT (size), Pmode);
#endif
}
else
......@@ -1424,9 +1416,7 @@ push_block (size, extra, below)
{
rtx temp = copy_to_mode_reg (Pmode, size);
if (extra != 0)
temp = expand_binop (Pmode, add_optab,
temp,
gen_rtx (CONST_INT, VOIDmode, extra),
temp = expand_binop (Pmode, add_optab, temp, GEN_INT (extra),
temp, 0, OPTAB_LIB_WIDEN);
anti_adjust_stack (temp);
}
......@@ -1568,7 +1558,7 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
But if space already allocated, this has already been done. */
if (extra && args_addr == 0
&& where_pad != none && where_pad != stack_direction)
anti_adjust_stack (gen_rtx (CONST_INT, VOIDmode, extra));
anti_adjust_stack (GEN_INT (extra));
move_by_pieces (gen_rtx (MEM, BLKmode, gen_push_operand ()), xinner,
INTVAL (size) - used, align);
......@@ -1583,11 +1573,11 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
if (partial != 0)
{
if (GET_CODE (size) == CONST_INT)
size = gen_rtx (CONST_INT, VOIDmode, INTVAL (size) - used);
size = GEN_INT (INTVAL (size) - used);
else
size = expand_binop (GET_MODE (size), sub_optab, size,
gen_rtx (CONST_INT, VOIDmode, used),
0, 0, OPTAB_LIB_WIDEN);
GEN_INT (used), NULL_RTX, 0,
OPTAB_LIB_WIDEN);
}
/* Get the address of the stack space.
......@@ -1627,8 +1617,7 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
< (1 << (GET_MODE_BITSIZE (QImode) - 1))))
{
emit_insn (gen_movstrqi (gen_rtx (MEM, BLKmode, temp),
xinner, size,
gen_rtx (CONST_INT, VOIDmode, align)));
xinner, size, GEN_INT (align)));
goto ret;
}
#endif
......@@ -1639,8 +1628,7 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
< (1 << (GET_MODE_BITSIZE (HImode) - 1))))
{
emit_insn (gen_movstrhi (gen_rtx (MEM, BLKmode, temp),
xinner, size,
gen_rtx (CONST_INT, VOIDmode, align)));
xinner, size, GEN_INT (align)));
goto ret;
}
#endif
......@@ -1648,8 +1636,7 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
if (HAVE_movstrsi)
{
emit_insn (gen_movstrsi (gen_rtx (MEM, BLKmode, temp),
xinner, size,
gen_rtx (CONST_INT, VOIDmode, align)));
xinner, size, GEN_INT (align)));
goto ret;
}
#endif
......@@ -1657,8 +1644,7 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
if (HAVE_movstrdi)
{
emit_insn (gen_movstrdi (gen_rtx (MEM, BLKmode, temp),
xinner, size,
gen_rtx (CONST_INT, VOIDmode, align)));
xinner, size, GEN_INT (align)));
goto ret;
}
#endif
......@@ -1706,7 +1692,7 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
But if space already allocated, this has already been done. */
if (extra && args_addr == 0
&& where_pad != none && where_pad != stack_direction)
anti_adjust_stack (gen_rtx (CONST_INT, VOIDmode, extra));
anti_adjust_stack (GEN_INT (extra));
/* If we make space by pushing it, we might as well push
the real data. Otherwise, we can leave OFFSET nonzero
......@@ -1747,9 +1733,9 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
#endif
if (i >= not_stack + offset)
emit_push_insn (operand_subword_force (x, i, mode),
word_mode, 0, 0, align, 0, 0, 0, args_addr,
gen_rtx (CONST_INT, VOIDmode,
args_offset + ((i - not_stack + skip)
word_mode, NULL_TREE, NULL_RTX, align, 0, NULL_RTX,
0, args_addr,
GEN_INT (args_offset + ((i - not_stack + skip)
* UNITS_PER_WORD)));
}
else
......@@ -1761,7 +1747,7 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
But if space already allocated, this has already been done. */
if (extra && args_addr == 0
&& where_pad != none && where_pad != stack_direction)
anti_adjust_stack (gen_rtx (CONST_INT, VOIDmode, extra));
anti_adjust_stack (GEN_INT (extra));
#ifdef PUSH_ROUNDING
if (args_addr == 0)
......@@ -1787,7 +1773,7 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
move_block_to_reg (REGNO (reg), x, partial, mode);
if (extra && args_addr == 0 && where_pad == stack_direction)
anti_adjust_stack (gen_rtx (CONST_INT, VOIDmode, extra));
anti_adjust_stack (GEN_INT (extra));
}
/* Output a library call to function FUN (a SYMBOL_REF rtx)
......@@ -1864,29 +1850,29 @@ emit_library_call (va_alist)
/* Make sure it is a reasonable operand for a move or push insn. */
if (GET_CODE (val) != REG && GET_CODE (val) != MEM
&& ! (CONSTANT_P (val) && LEGITIMATE_CONSTANT_P (val)))
val = force_operand (val, 0);
val = force_operand (val, NULL_RTX);
argvec[count].value = val;
argvec[count].mode = mode;
#ifdef FUNCTION_ARG_PASS_BY_REFERENCE
if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, mode, (tree)0, 1))
if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, mode, NULL_TREE, 1))
abort ();
#endif
argvec[count].reg = FUNCTION_ARG (args_so_far, mode, (tree)0, 1);
argvec[count].reg = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1);
if (argvec[count].reg && GET_CODE (argvec[count].reg) == EXPR_LIST)
abort ();
#ifdef FUNCTION_ARG_PARTIAL_NREGS
argvec[count].partial
= FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, (tree)0, 1);
= FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, NULL_TREE, 1);
#else
argvec[count].partial = 0;
#endif
locate_and_pad_parm (mode, 0,
locate_and_pad_parm (mode, NULL_TREE,
argvec[count].reg && argvec[count].partial == 0,
0, &args_size, &argvec[count].offset,
NULL_TREE, &args_size, &argvec[count].offset,
&argvec[count].size);
if (argvec[count].size.var)
......@@ -1942,8 +1928,7 @@ emit_library_call (va_alist)
#endif
#ifndef PUSH_ROUNDING
argblock = push_block (gen_rtx (CONST_INT, VOIDmode, args_size.constant),
0, 0);
argblock = push_block (GEN_INT (args_size.constant), 0, 0);
#endif
#ifdef PUSH_ARGS_REVERSED
......@@ -1964,9 +1949,8 @@ emit_library_call (va_alist)
int partial = argvec[argnum].partial;
if (! (reg != 0 && partial == 0))
emit_push_insn (val, mode, 0, 0, 0, partial, reg, 0, argblock,
gen_rtx (CONST_INT, VOIDmode,
argvec[count].offset.constant));
emit_push_insn (val, mode, NULL_TREE, NULL_RTX, 0, partial, reg, 0,
argblock, GEN_INT (argvec[count].offset.constant));
NO_DEFER_POP;
}
......@@ -2003,7 +1987,7 @@ emit_library_call (va_alist)
use_insns = get_insns ();
end_sequence ();
fun = prepare_call_address (fun, 0, &use_insns);
fun = prepare_call_address (fun, NULL_TREE, &use_insns);
/* Don't allow popping to be deferred, since then
cse'ing of library calls could delete a call and leave the pop. */
......@@ -2014,7 +1998,7 @@ emit_library_call (va_alist)
emit_call_1 (fun, get_identifier (XSTR (orgfun, 0)), args_size.constant, 0,
FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
outmode != VOIDmode ? hard_libcall_value (outmode) : 0,
outmode != VOIDmode ? hard_libcall_value (outmode) : NULL_RTX,
old_inhibit_defer_pop + 1, use_insns, no_queue);
/* Now restore inhibit_defer_pop to its actual original value. */
......@@ -2045,7 +2029,7 @@ expand_assignment (to, from, want_value, suggest_reg)
/* Don't crash if the lhs of the assignment was erroneous. */
if (TREE_CODE (to) == ERROR_MARK)
return expand_expr (from, 0, VOIDmode, 0);
return expand_expr (from, NULL_RTX, VOIDmode, 0);
/* Assignment of a structure component needs special treatment
if the structure component's rtx is not simply a MEM.
......@@ -2073,10 +2057,10 @@ expand_assignment (to, from, want_value, suggest_reg)
if (mode1 == VOIDmode && want_value)
tem = stabilize_reference (tem);
to_rtx = expand_expr (tem, 0, VOIDmode, 0);
to_rtx = expand_expr (tem, NULL_RTX, VOIDmode, 0);
if (offset != 0)
{
rtx offset_rtx = expand_expr (offset, 0, VOIDmode, 0);
rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
if (GET_CODE (to_rtx) != MEM)
abort ();
......@@ -2115,7 +2099,7 @@ expand_assignment (to, from, want_value, suggest_reg)
Don't re-expand if it was expanded already (in COMPONENT_REF case). */
if (to_rtx == 0)
to_rtx = expand_expr (to, 0, VOIDmode, 0);
to_rtx = expand_expr (to, NULL_RTX, VOIDmode, 0);
/* In case we are returning the contents of an object which overlaps
the place the value is being stored, use a safe function when copying
......@@ -2124,7 +2108,7 @@ expand_assignment (to, from, want_value, suggest_reg)
&& current_function_returns_struct
&& !current_function_returns_pcc_struct)
{
rtx from_rtx = expand_expr (from, 0, VOIDmode, 0);
rtx from_rtx = expand_expr (from, NULL_RTX, VOIDmode, 0);
rtx size = expr_size (from);
#ifdef TARGET_MEM_FUNCTIONS
......@@ -2211,7 +2195,7 @@ store_expr (exp, target, suggest_reg)
if EXP is another assignment, SUGGEST_REG will be nonzero for it.
We know expand_expr will not use the target in that case. */
{
temp = expand_expr (exp, cse_not_expected ? 0 : target,
temp = expand_expr (exp, cse_not_expected ? NULL_RTX : target,
GET_MODE (target), 0);
if (GET_MODE (temp) != BLKmode && GET_MODE (temp) != VOIDmode)
temp = copy_to_reg (temp);
......@@ -2231,7 +2215,7 @@ store_expr (exp, target, suggest_reg)
temp = expand_expr (exp, temp, GET_MODE (target), 0);
}
else
temp = expand_expr (exp, 0, GET_MODE (target), 0);
temp = expand_expr (exp, NULL_RTX, GET_MODE (target), 0);
dont_return_target = 1;
}
else
......@@ -2291,7 +2275,8 @@ store_expr (exp, target, suggest_reg)
size_int (BITS_PER_UNIT)),
convert (sizetype,
build_int_2 (TREE_STRING_LENGTH (exp), 0))));
rtx copy_size_rtx = expand_expr (copy_size, 0, VOIDmode, 0);
rtx copy_size_rtx = expand_expr (copy_size, NULL_RTX,
VOIDmode, 0);
rtx label = 0;
/* Copy that much. */
......@@ -2313,12 +2298,14 @@ store_expr (exp, target, suggest_reg)
temp = force_reg (Pmode, XEXP (target, 0));
temp = expand_binop (size_mode, add_optab, temp,
copy_size_rtx, 0, 0, OPTAB_LIB_WIDEN);
copy_size_rtx, NULL_RTX, 0,
OPTAB_LIB_WIDEN);
size = expand_binop (size_mode, sub_optab, size,
copy_size_rtx, 0, 0, OPTAB_LIB_WIDEN);
copy_size_rtx, NULL_RTX, 0,
OPTAB_LIB_WIDEN);
emit_cmp_insn (size, const0_rtx, LT, 0,
emit_cmp_insn (size, const0_rtx, LT, NULL_RTX,
GET_MODE (size), 0, 0);
label = gen_label_rtx ();
emit_jump_insn (gen_blt (label));
......@@ -2438,8 +2425,8 @@ store_constructor (exp, target)
register tree elt;
register int i;
tree domain = TYPE_DOMAIN (type);
int minelt = TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain));
int maxelt = TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain));
HOST_WIDE_INT minelt = TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain));
HOST_WIDE_INT maxelt = TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain));
tree elttype = TREE_TYPE (type);
/* If the constructor has fewer fields than the structure,
......@@ -2511,10 +2498,10 @@ store_field (target, bitsize, bitpos, mode, exp, value_mode,
int align;
int total_size;
{
int width_mask = 0;
HOST_WIDE_INT width_mask = 0;
if (bitsize < HOST_BITS_PER_INT)
width_mask = (1 << bitsize) - 1;
if (bitsize < HOST_BITS_PER_WIDE_INT)
width_mask = ((HOST_WIDE_INT) 1 << bitsize) - 1;
/* If we are storing into an unaligned field of an aligned union that is
in a register, we may have the mode of TARGET being an integer mode but
......@@ -2556,7 +2543,7 @@ store_field (target, bitsize, bitpos, mode, exp, value_mode,
|| GET_CODE (target) == REG
|| GET_CODE (target) == SUBREG)
{
rtx temp = expand_expr (exp, 0, VOIDmode, 0);
rtx temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
/* Store the value in the bitfield. */
store_bit_field (target, bitsize, bitpos, mode, temp, align, total_size);
if (value_mode != VOIDmode)
......@@ -2565,10 +2552,10 @@ store_field (target, bitsize, bitpos, mode, exp, value_mode,
/* If possible, avoid refetching from the bitfield itself. */
if (width_mask != 0
&& ! (GET_CODE (target) == MEM && MEM_VOLATILE_P (target)))
return expand_and (temp,
gen_rtx (CONST_INT, VOIDmode, width_mask), 0);
return expand_and (temp, GEN_INT (width_mask), NULL_RTX);
return extract_bit_field (target, bitsize, bitpos, unsignedp,
0, value_mode, 0, align, total_size);
NULL_RTX, value_mode, 0, align,
total_size);
}
return const0_rtx;
}
......@@ -2785,7 +2772,7 @@ force_operand (value, target)
subtarget = 0;
tmp = force_operand (XEXP (value, 0), subtarget);
return expand_mult (GET_MODE (value), tmp,
force_operand (op2, 0),
force_operand (op2, NULL_RTX),
target, 0);
}
......@@ -2823,7 +2810,7 @@ force_operand (value, target)
tmp = force_operand (XEXP (value, 0), subtarget);
return expand_binop (GET_MODE (value), binoptab, tmp,
force_operand (op2, 0),
force_operand (op2, NULL_RTX),
target, 0, OPTAB_LIB_WIDEN);
/* We give UNSIGNEP = 0 to expand_binop
because the only operations we are expanding here are signed ones. */
......@@ -2851,13 +2838,14 @@ save_noncopied_parts (lhs, list)
{
tree part = TREE_VALUE (tail);
tree part_type = TREE_TYPE (part);
tree to_be_saved = build (COMPONENT_REF, part_type, lhs, part, 0);
tree to_be_saved = build (COMPONENT_REF, part_type, lhs, part);
rtx target = assign_stack_temp (TYPE_MODE (part_type),
int_size_in_bytes (part_type), 0);
if (! memory_address_p (TYPE_MODE (part_type), XEXP (target, 0)))
target = change_address (target, TYPE_MODE (part_type), 0);
target = change_address (target, TYPE_MODE (part_type), NULL_RTX);
parts = tree_cons (to_be_saved,
build (RTL_EXPR, part_type, 0, (tree) target),
build (RTL_EXPR, part_type, NULL_TREE,
(tree) target),
parts);
store_expr (TREE_PURPOSE (parts), RTL_EXPR_RTL (TREE_VALUE (parts)), 0);
}
......@@ -2883,7 +2871,7 @@ init_noncopied_parts (lhs, list)
{
tree part = TREE_VALUE (tail);
tree part_type = TREE_TYPE (part);
tree to_be_initialized = build (COMPONENT_REF, part_type, lhs, part, 0);
tree to_be_initialized = build (COMPONENT_REF, part_type, lhs, part);
parts = tree_cons (TREE_PURPOSE (tail), to_be_initialized, parts);
}
return parts;
......@@ -3304,8 +3292,8 @@ expand_expr (exp, target, tmode, modifier)
/* Exit the current loop if the body-expression is true. */
{
rtx label = gen_label_rtx ();
do_jump (TREE_OPERAND (exp, 0), label, 0);
expand_exit_loop (0);
do_jump (TREE_OPERAND (exp, 0), label, NULL_RTX);
expand_exit_loop (NULL_PTR);
emit_label (label);
}
return const0_rtx;
......@@ -3416,14 +3404,15 @@ expand_expr (exp, target, tmode, modifier)
&& TYPE_MODE (TREE_TYPE (exp1)) == Pmode
&& TYPE_MODE (TREE_TYPE (exp2)) == Pmode)
{
temp = expand_expr (TREE_OPERAND (exp1, 0), 0, VOIDmode, EXPAND_SUM);
temp = expand_expr (TREE_OPERAND (exp1, 0), NULL_RTX,
VOIDmode, EXPAND_SUM);
op0 = memory_address (mode, temp);
op0 = copy_all_regs (op0);
SAVE_EXPR_RTL (exp1) = op0;
}
else
{
op0 = expand_expr (exp1, 0, VOIDmode, EXPAND_SUM);
op0 = expand_expr (exp1, NULL_RTX, VOIDmode, EXPAND_SUM);
op0 = memory_address (mode, op0);
}
......@@ -3577,8 +3566,7 @@ expand_expr (exp, target, tmode, modifier)
else if (TREE_CODE (init) == STRING_CST
&& i < TREE_STRING_LENGTH (init))
{
temp = gen_rtx (CONST_INT, VOIDmode,
TREE_STRING_POINTER (init)[i]);
temp = GEN_INT (TREE_STRING_POINTER (init)[i]);
return convert_to_mode (mode, temp, 0);
}
}
......@@ -3612,7 +3600,7 @@ expand_expr (exp, target, tmode, modifier)
/* In some cases, we will be offsetting OP0's address by a constant.
So get it as a sum, if possible. If we will be using it
directly in an insn, we validate it. */
op0 = expand_expr (tem, 0, VOIDmode, EXPAND_SUM);
op0 = expand_expr (tem, NULL_RTX, VOIDmode, EXPAND_SUM);
/* If this is a constant, put it into a register if it is a
legimate constant and memory if it isn't. */
......@@ -3627,7 +3615,7 @@ expand_expr (exp, target, tmode, modifier)
if (offset != 0)
{
rtx offset_rtx = expand_expr (offset, 0, VOIDmode, 0);
rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
if (GET_CODE (op0) != MEM)
abort ();
......@@ -3701,7 +3689,7 @@ expand_expr (exp, target, tmode, modifier)
{
tree base = build_unary_op (ADDR_EXPR, TREE_OPERAND (exp, 0), 0);
tree addr = build (PLUS_EXPR, type, base, TREE_OPERAND (exp, 1));
op0 = expand_expr (addr, 0, VOIDmode, EXPAND_SUM);
op0 = expand_expr (addr, NULL_RTX, VOIDmode, EXPAND_SUM);
temp = gen_rtx (MEM, mode, memory_address (mode, op0));
MEM_IN_STRUCT_P (temp) = 1;
MEM_VOLATILE_P (temp) = TREE_THIS_VOLATILE (exp) || flag_volatile;
......@@ -3724,7 +3712,8 @@ expand_expr (exp, target, tmode, modifier)
{
RTL_EXPR_RTL (exp)
= expand_expr (TREE_OPERAND (exp, 0), target, tmode, modifier);
cleanups_this_call = tree_cons (0, TREE_OPERAND (exp, 2), cleanups_this_call);
cleanups_this_call
= tree_cons (NULL_TREE, TREE_OPERAND (exp, 2), cleanups_this_call);
/* That's it for this cleanup. */
TREE_OPERAND (exp, 2) = 0;
}
......@@ -3774,7 +3763,8 @@ expand_expr (exp, target, tmode, modifier)
if (GET_CODE (target) == MEM)
/* Store data into beginning of memory target. */
store_expr (TREE_OPERAND (exp, 0),
change_address (target, TYPE_MODE (valtype), 0), 0);
change_address (target, TYPE_MODE (valtype), 0),
NULL_RTX);
else if (GET_CODE (target) == REG)
/* Store this field into a union of the proper type. */
store_field (target, GET_MODE_BITSIZE (TYPE_MODE (valtype)), 0,
......@@ -3787,7 +3777,7 @@ expand_expr (exp, target, tmode, modifier)
/* Return the entire union. */
return target;
}
op0 = expand_expr (TREE_OPERAND (exp, 0), 0, mode, 0);
op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, mode, 0);
if (GET_MODE (op0) == mode || GET_MODE (op0) == VOIDmode)
return op0;
if (flag_force_mem && GET_CODE (op0) == MEM)
......@@ -3837,7 +3827,7 @@ expand_expr (exp, target, tmode, modifier)
If this is an EXPAND_SUM call, always return the sum. */
if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST
&& GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT
&& GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
&& (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER
|| mode == Pmode))
{
......@@ -3874,7 +3864,7 @@ expand_expr (exp, target, tmode, modifier)
subtarget = 0;
op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, modifier);
op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, modifier);
op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, modifier);
/* Make sure any term that's a sum with a constant comes last. */
if (GET_CODE (op0) == PLUS
......@@ -3929,8 +3919,10 @@ expand_expr (exp, target, tmode, modifier)
&& really_constant_p (TREE_OPERAND (exp, 0))
&& really_constant_p (TREE_OPERAND (exp, 1)))
{
rtx op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, modifier);
rtx op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, modifier);
rtx op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX,
VOIDmode, modifier);
rtx op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
VOIDmode, modifier);
return gen_rtx (MINUS, mode, op0, op1);
}
/* Convert A - const to A + (-const). */
......@@ -3961,7 +3953,7 @@ expand_expr (exp, target, tmode, modifier)
if (modifier == EXPAND_SUM && mode == Pmode
&& TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
&& GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT)
&& GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
{
op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, EXPAND_SUM);
......@@ -3970,20 +3962,17 @@ expand_expr (exp, target, tmode, modifier)
&& GET_CODE (XEXP (op0, 1)) == CONST_INT)
return gen_rtx (PLUS, mode,
gen_rtx (MULT, mode, XEXP (op0, 0),
gen_rtx (CONST_INT, VOIDmode,
TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))),
gen_rtx (CONST_INT, VOIDmode,
(TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))
* INTVAL (XEXP (op0, 1)))));
GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))),
GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))
* INTVAL (XEXP (op0, 1))));
if (GET_CODE (op0) != REG)
op0 = force_operand (op0, 0);
op0 = force_operand (op0, NULL_RTX);
if (GET_CODE (op0) != REG)
op0 = copy_to_mode_reg (mode, op0);
return gen_rtx (MULT, mode, op0,
gen_rtx (CONST_INT, VOIDmode,
TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))));
GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))));
}
if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1)))
......@@ -4002,7 +3991,7 @@ expand_expr (exp, target, tmode, modifier)
TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
/* Don't use a widening multiply if a shift will do. */
&& ((GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1))))
> HOST_BITS_PER_INT)
> HOST_BITS_PER_WIDE_INT)
|| exact_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))) < 0))
||
(TREE_CODE (TREE_OPERAND (exp, 1)) == NOP_EXPR
......@@ -4023,17 +4012,18 @@ expand_expr (exp, target, tmode, modifier)
&& this_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
{
op0 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
0, VOIDmode, 0);
NULL_RTX, VOIDmode, 0);
if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0);
op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
VOIDmode, 0);
else
op1 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 1), 0),
0, VOIDmode, 0);
NULL_RTX, VOIDmode, 0);
goto binop2;
}
}
op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0);
op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
return expand_mult (mode, op0, op1, target, unsignedp);
case TRUNC_DIV_EXPR:
......@@ -4048,7 +4038,7 @@ expand_expr (exp, target, tmode, modifier)
then if the divisor is constant can optimize the case
where some terms of the dividend have coeffs divisible by it. */
op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0);
op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
return expand_divmod (0, code, mode, op0, op1, target, unsignedp);
case RDIV_EXPR:
......@@ -4063,7 +4053,7 @@ expand_expr (exp, target, tmode, modifier)
if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1)))
subtarget = 0;
op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0);
op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
return expand_divmod (1, code, mode, op0, op1, target, unsignedp);
case FIX_ROUND_EXPR:
......@@ -4072,14 +4062,14 @@ expand_expr (exp, target, tmode, modifier)
abort (); /* Not used for C. */
case FIX_TRUNC_EXPR:
op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
if (target == 0)
target = gen_reg_rtx (mode);
expand_fix (target, op0, unsignedp);
return target;
case FLOAT_EXPR:
op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
if (target == 0)
target = gen_reg_rtx (mode);
/* expand_float can't figure out what to do if FROM has VOIDmode.
......@@ -4119,7 +4109,7 @@ expand_expr (exp, target, tmode, modifier)
{
rtx extended = expand_shift (RSHIFT_EXPR, mode, op0,
size_int (GET_MODE_BITSIZE (mode) - 1),
0, 0);
NULL_RTX, 0);
temp = expand_binop (mode, xor_optab, extended, op0, target, 0,
OPTAB_LIB_WIDEN);
......@@ -4141,8 +4131,8 @@ expand_expr (exp, target, tmode, modifier)
emit_move_insn (target, op0);
emit_cmp_insn (target,
expand_expr (convert (type, integer_zero_node),
0, VOIDmode, 0),
GE, 0, mode, 0, 0);
NULL_RTX, VOIDmode, 0),
GE, NULL_RTX, mode, 0, 0);
NO_DEFER_POP;
emit_jump_insn (gen_bge (temp));
op0 = expand_unop (mode, neg_optab, target, target, 0);
......@@ -4159,7 +4149,7 @@ expand_expr (exp, target, tmode, modifier)
|| (GET_CODE (target) == REG
&& REGNO (target) < FIRST_PSEUDO_REGISTER))
target = gen_reg_rtx (mode);
op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0);
op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
/* First try to do it with a special MIN or MAX instruction.
......@@ -4179,12 +4169,12 @@ expand_expr (exp, target, tmode, modifier)
op0 = gen_label_rtx ();
if (code == MAX_EXPR)
temp = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1)))
? compare_from_rtx (target, op1, GEU, 1, mode, 0, 0)
: compare_from_rtx (target, op1, GE, 0, mode, 0, 0));
? compare_from_rtx (target, op1, GEU, 1, mode, NULL_RTX, 0)
: compare_from_rtx (target, op1, GE, 0, mode, NULL_RTX, 0));
else
temp = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1)))
? compare_from_rtx (target, op1, LEU, 1, mode, 0, 0)
: compare_from_rtx (target, op1, LE, 0, mode, 0, 0));
? compare_from_rtx (target, op1, LEU, 1, mode, NULL_RTX, 0)
: compare_from_rtx (target, op1, LE, 0, mode, NULL_RTX, 0));
if (temp == const0_rtx)
emit_move_insn (target, op1);
else if (temp != const_true_rtx)
......@@ -4278,7 +4268,7 @@ expand_expr (exp, target, tmode, modifier)
if (temp != original_target)
temp = copy_to_reg (temp);
op1 = gen_label_rtx ();
emit_cmp_insn (temp, const0_rtx, EQ, 0,
emit_cmp_insn (temp, const0_rtx, EQ, NULL_RTX,
GET_MODE (temp), unsignedp, 0);
emit_jump_insn (gen_beq (op1));
emit_move_insn (temp, const1_rtx);
......@@ -4308,8 +4298,7 @@ expand_expr (exp, target, tmode, modifier)
op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
/* The parser is careful to generate TRUTH_NOT_EXPR
only with operands that are always zero or one. */
temp = expand_binop (mode, xor_optab, op0,
gen_rtx (CONST_INT, mode, 1),
temp = expand_binop (mode, xor_optab, op0, const1_rtx,
target, 1, OPTAB_LIB_WIDEN);
if (temp == 0)
abort ();
......@@ -4430,12 +4419,13 @@ expand_expr (exp, target, tmode, modifier)
= invert_truthvalue (TREE_OPERAND (exp, 0));
result = do_store_flag (TREE_OPERAND (exp, 0),
safe_from_p (temp, singleton) ? temp : 0,
(safe_from_p (temp, singleton)
? temp : NULL_RTX),
mode, BRANCH_COST <= 1);
if (result)
{
op1 = expand_expr (singleton, 0, VOIDmode, 0);
op1 = expand_expr (singleton, NULL_RTX, VOIDmode, 0);
return expand_binop (mode, boptab, op1, result, temp,
unsignedp, OPTAB_LIB_WIDEN);
}
......@@ -4463,7 +4453,8 @@ expand_expr (exp, target, tmode, modifier)
store_expr (singleton, temp, 0);
}
else
expand_expr (singleton, ignore ? const1_rtx : 0, VOIDmode, 0);
expand_expr (singleton,
ignore ? const1_rtx : NULL_RTX, VOIDmode, 0);
if (cleanups_this_call)
{
sorry ("aggregate value in COND_EXPR");
......@@ -4477,7 +4468,7 @@ expand_expr (exp, target, tmode, modifier)
if (binary_op && temp == 0)
/* Just touch the other operand. */
expand_expr (TREE_OPERAND (binary_op, 1),
ignore ? const0_rtx : 0, VOIDmode, 0);
ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
else if (binary_op)
store_expr (build (TREE_CODE (binary_op), type,
make_tree (type, temp),
......@@ -4560,8 +4551,8 @@ expand_expr (exp, target, tmode, modifier)
if (temp != 0)
store_expr (TREE_OPERAND (exp, 1), temp, 0);
else
expand_expr (TREE_OPERAND (exp, 1), ignore ? const0_rtx : 0,
VOIDmode, 0);
expand_expr (TREE_OPERAND (exp, 1),
ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
if (cleanups_this_call)
{
sorry ("aggregate value in COND_EXPR");
......@@ -4575,8 +4566,8 @@ expand_expr (exp, target, tmode, modifier)
if (temp != 0)
store_expr (TREE_OPERAND (exp, 2), temp, 0);
else
expand_expr (TREE_OPERAND (exp, 2), ignore ? const0_rtx : 0,
VOIDmode, 0);
expand_expr (TREE_OPERAND (exp, 2),
ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
}
if (cleanups_this_call)
......@@ -4631,8 +4622,8 @@ expand_expr (exp, target, tmode, modifier)
if (TREE_OPERAND (exp, 2) == 0)
TREE_OPERAND (exp, 2) = maybe_build_cleanup (slot);
if (TREE_OPERAND (exp, 2))
cleanups_this_call = tree_cons (0, TREE_OPERAND (exp, 2),
cleanups_this_call);
cleanups_this_call = tree_cons (NULL_TREE, TREE_OPERAND (exp, 2),
cleanups_this_call);
#endif
}
else
......@@ -4755,7 +4746,7 @@ expand_expr (exp, target, tmode, modifier)
}
else
{
op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode,
op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode,
(modifier == EXPAND_INITIALIZER
? modifier : EXPAND_CONST_ADDRESS));
if (GET_CODE (op0) != MEM)
......@@ -4786,7 +4777,7 @@ expand_expr (exp, target, tmode, modifier)
if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1)))
subtarget = 0;
op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0);
op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
binop2:
temp = expand_binop (mode, this_optab, op0, op1, target,
unsignedp, OPTAB_LIB_WIDEN);
......@@ -5041,7 +5032,7 @@ expand_builtin (exp, target, subtarget, mode, ignore)
{
/* By checking op > 0 we are able to catch all of the
IEEE special cases with a single if conditional. */
emit_cmp_insn (op0, CONST0_RTX (GET_MODE (op0)), GT, 0,
emit_cmp_insn (op0, CONST0_RTX (GET_MODE (op0)), GT, NULL_RTX,
GET_MODE (op0), 0, 0);
emit_jump_insn (gen_bgt (lab1));
......@@ -5162,7 +5153,7 @@ expand_builtin (exp, target, subtarget, mode, ignore)
if (wordnum < 0 || wordnum >= nwords)
error ("argument of __builtin_args_info out of range");
else
return gen_rtx (CONST_INT, VOIDmode, word_ptr[wordnum]);
return GEN_INT (word_ptr[wordnum]);
}
}
else
......@@ -5181,7 +5172,7 @@ expand_builtin (exp, target, subtarget, mode, ignore)
TREE_STATIC (result) = 1;
result = build (INDIRECT_REF, build_pointer_type (type), result);
TREE_CONSTANT (result) = 1;
return expand_expr (result, 0, VOIDmode, 0);
return expand_expr (result, NULL_RTX, VOIDmode, 0);
#endif
}
......@@ -5201,7 +5192,7 @@ expand_builtin (exp, target, subtarget, mode, ignore)
return expand_binop (Pmode, add_optab,
current_function_internal_arg_pointer,
current_function_arg_offset_rtx,
0, 0, OPTAB_LIB_WIDEN);
NULL_RTX, 0, OPTAB_LIB_WIDEN);
case BUILT_IN_CLASSIFY_TYPE:
if (arglist != 0)
......@@ -5209,45 +5200,45 @@ expand_builtin (exp, target, subtarget, mode, ignore)
tree type = TREE_TYPE (TREE_VALUE (arglist));
enum tree_code code = TREE_CODE (type);
if (code == VOID_TYPE)
return gen_rtx (CONST_INT, VOIDmode, void_type_class);
return GEN_INT (void_type_class);
if (code == INTEGER_TYPE)
return gen_rtx (CONST_INT, VOIDmode, integer_type_class);
return GEN_INT (integer_type_class);
if (code == CHAR_TYPE)
return gen_rtx (CONST_INT, VOIDmode, char_type_class);
return GEN_INT (char_type_class);
if (code == ENUMERAL_TYPE)
return gen_rtx (CONST_INT, VOIDmode, enumeral_type_class);
return GEN_INT (enumeral_type_class);
if (code == BOOLEAN_TYPE)
return gen_rtx (CONST_INT, VOIDmode, boolean_type_class);
return GEN_INT (boolean_type_class);
if (code == POINTER_TYPE)
return gen_rtx (CONST_INT, VOIDmode, pointer_type_class);
return GEN_INT (pointer_type_class);
if (code == REFERENCE_TYPE)
return gen_rtx (CONST_INT, VOIDmode, reference_type_class);
return GEN_INT (reference_type_class);
if (code == OFFSET_TYPE)
return gen_rtx (CONST_INT, VOIDmode, offset_type_class);
return GEN_INT (offset_type_class);
if (code == REAL_TYPE)
return gen_rtx (CONST_INT, VOIDmode, real_type_class);
return GEN_INT (real_type_class);
if (code == COMPLEX_TYPE)
return gen_rtx (CONST_INT, VOIDmode, complex_type_class);
return GEN_INT (complex_type_class);
if (code == FUNCTION_TYPE)
return gen_rtx (CONST_INT, VOIDmode, function_type_class);
return GEN_INT (function_type_class);
if (code == METHOD_TYPE)
return gen_rtx (CONST_INT, VOIDmode, method_type_class);
return GEN_INT (method_type_class);
if (code == RECORD_TYPE)
return gen_rtx (CONST_INT, VOIDmode, record_type_class);
return GEN_INT (record_type_class);
if (code == UNION_TYPE)
return gen_rtx (CONST_INT, VOIDmode, union_type_class);
return GEN_INT (union_type_class);
if (code == ARRAY_TYPE)
return gen_rtx (CONST_INT, VOIDmode, array_type_class);
return GEN_INT (array_type_class);
if (code == STRING_TYPE)
return gen_rtx (CONST_INT, VOIDmode, string_type_class);
return GEN_INT (string_type_class);
if (code == SET_TYPE)
return gen_rtx (CONST_INT, VOIDmode, set_type_class);
return GEN_INT (set_type_class);
if (code == FILE_TYPE)
return gen_rtx (CONST_INT, VOIDmode, file_type_class);
return GEN_INT (file_type_class);
if (code == LANG_TYPE)
return gen_rtx (CONST_INT, VOIDmode, lang_type_class);
return GEN_INT (lang_type_class);
}
return gen_rtx (CONST_INT, VOIDmode, no_type_class);
return GEN_INT (no_type_class);
case BUILT_IN_CONSTANT_P:
if (arglist == 0)
......@@ -5317,14 +5308,14 @@ expand_builtin (exp, target, subtarget, mode, ignore)
return const0_rtx;
current_function_calls_alloca = 1;
/* Compute the argument. */
op0 = expand_expr (TREE_VALUE (arglist), 0, VOIDmode, 0);
op0 = expand_expr (TREE_VALUE (arglist), NULL_RTX, VOIDmode, 0);
/* Allocate the desired space. */
target = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT);
/* Record the new stack level for nonlocal gotos. */
if (nonlocal_goto_handler_slot != 0)
emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, 0);
emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
return target;
case BUILT_IN_FFS:
......@@ -5403,7 +5394,7 @@ expand_builtin (exp, target, subtarget, mode, ignore)
result = gen_reg_rtx (insn_mode);
src_rtx = memory_address (BLKmode,
expand_expr (src, 0, Pmode,
expand_expr (src, NULL_RTX, Pmode,
EXPAND_NORMAL));
if (! (*insn_operand_predicate[(int)icode][1]) (src_rtx, Pmode))
src_rtx = copy_to_mode_reg (Pmode, src_rtx);
......@@ -5415,8 +5406,7 @@ expand_builtin (exp, target, subtarget, mode, ignore)
emit_insn (GEN_FCN (icode) (result,
gen_rtx (MEM, BLKmode, src_rtx),
char_rtx,
gen_rtx (CONST_INT, VOIDmode, align)));
char_rtx, GEN_INT (align)));
/* Return the value in the proper mode for this function. */
if (GET_MODE (result) == value_mode)
......@@ -5450,7 +5440,7 @@ expand_builtin (exp, target, subtarget, mode, ignore)
len = size_binop (PLUS_EXPR, len, integer_one_node);
chainon (arglist, build_tree_list (0, len));
chainon (arglist, build_tree_list (NULL_TREE, len));
}
/* Drops in. */
......@@ -5488,16 +5478,17 @@ expand_builtin (exp, target, subtarget, mode, ignore)
break;
}
dest_rtx = expand_expr (dest, 0, Pmode, EXPAND_NORMAL);
dest_rtx = expand_expr (dest, NULL_RTX, Pmode, EXPAND_NORMAL);
/* Copy word part most expediently. */
emit_block_move (gen_rtx (MEM, BLKmode,
memory_address (BLKmode, dest_rtx)),
gen_rtx (MEM, BLKmode,
memory_address (BLKmode,
expand_expr (src, 0, Pmode,
expand_expr (src, NULL_RTX,
Pmode,
EXPAND_NORMAL))),
expand_expr (len, 0, VOIDmode, 0),
expand_expr (len, NULL_RTX, VOIDmode, 0),
MIN (src_align, dest_align));
return dest_rtx;
}
......@@ -5555,7 +5546,7 @@ expand_builtin (exp, target, subtarget, mode, ignore)
len = len2;
}
chainon (arglist, build_tree_list (0, len));
chainon (arglist, build_tree_list (NULL_TREE, len));
}
/* Drops in. */
......@@ -5604,12 +5595,13 @@ expand_builtin (exp, target, subtarget, mode, ignore)
emit_insn (gen_cmpstrsi (result,
gen_rtx (MEM, BLKmode,
expand_expr (arg1, 0, Pmode, EXPAND_NORMAL)),
expand_expr (arg1, NULL_RTX, Pmode,
EXPAND_NORMAL)),
gen_rtx (MEM, BLKmode,
expand_expr (arg2, 0, Pmode, EXPAND_NORMAL)),
expand_expr (len, 0, VOIDmode, 0),
gen_rtx (CONST_INT, VOIDmode,
MIN (arg1_align, arg2_align))));
expand_expr (arg2, NULL_RTX, Pmode,
EXPAND_NORMAL)),
expand_expr (len, NULL_RTX, VOIDmode, 0),
GEN_INT (MIN (arg1_align, arg2_align))));
/* Return the value in the proper mode for this function. */
mode = TYPE_MODE (TREE_TYPE (exp));
......@@ -5670,10 +5662,10 @@ expand_increment (exp, post)
I believe it is a copy iff it is a register or subreg
and insns were generated in computing it. */
temp = get_last_insn ();
op0 = expand_expr (incremented, 0, VOIDmode, 0);
op0 = expand_expr (incremented, NULL_RTX, VOIDmode, 0);
op0_is_copy = ((GET_CODE (op0) == SUBREG || GET_CODE (op0) == REG)
&& temp != get_last_insn ());
op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0);
op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
/* Decide whether incrementing or decrementing. */
if (TREE_CODE (exp) == POSTDECREMENT_EXPR
......@@ -5705,7 +5697,7 @@ expand_increment (exp, post)
if (this_optab == sub_optab
&& GET_CODE (op1) == CONST_INT)
{
op1 = gen_rtx (CONST_INT, VOIDmode, - INTVAL (op1));
op1 = GEN_INT (- INTVAL (op1));
this_optab = add_optab;
}
......@@ -5784,7 +5776,7 @@ preexpand_calls (exp)
if (TREE_CODE (TREE_OPERAND (exp, 0)) != ADDR_EXPR
|| TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) != FUNCTION_DECL
|| ! DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
CALL_EXPR_RTL (exp) = expand_call (exp, 0, 0);
CALL_EXPR_RTL (exp) = expand_call (exp, NULL_RTX, 0);
return;
case COMPOUND_EXPR:
......@@ -5851,7 +5843,7 @@ do_pending_stack_adjust ()
if (inhibit_defer_pop == 0)
{
if (pending_stack_adjust != 0)
adjust_stack (gen_rtx (CONST_INT, VOIDmode, pending_stack_adjust));
adjust_stack (GEN_INT (pending_stack_adjust));
pending_stack_adjust = 0;
}
}
......@@ -5865,7 +5857,7 @@ expand_cleanups_to (old_cleanups)
{
while (cleanups_this_call != old_cleanups)
{
expand_expr (TREE_VALUE (cleanups_this_call), 0, VOIDmode, 0);
expand_expr (TREE_VALUE (cleanups_this_call), NULL_RTX, VOIDmode, 0);
cleanups_this_call = TREE_CHAIN (cleanups_this_call);
}
}
......@@ -5881,7 +5873,7 @@ jumpifnot (exp, label)
tree exp;
rtx label;
{
do_jump (exp, label, 0);
do_jump (exp, label, NULL_RTX);
}
/* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */
......@@ -5891,7 +5883,7 @@ jumpif (exp, label)
tree exp;
rtx label;
{
do_jump (exp, 0, label);
do_jump (exp, NULL_RTX, label);
}
/* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
......@@ -5994,7 +5986,7 @@ do_jump (exp, if_false_label, if_true_label)
if (! SLOW_BYTE_ACCESS
&& TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
&& TYPE_PRECISION (TREE_TYPE (exp)) <= HOST_BITS_PER_INT
&& TYPE_PRECISION (TREE_TYPE (exp)) <= HOST_BITS_PER_WIDE_INT
&& (i = floor_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))) >= 0
&& (type = type_for_size (i + 1, 1)) != 0
&& TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
......@@ -6013,14 +6005,14 @@ do_jump (exp, if_false_label, if_true_label)
case TRUTH_ANDIF_EXPR:
if (if_false_label == 0)
if_false_label = drop_through_label = gen_label_rtx ();
do_jump (TREE_OPERAND (exp, 0), if_false_label, 0);
do_jump (TREE_OPERAND (exp, 0), if_false_label, NULL_RTX);
do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
break;
case TRUTH_ORIF_EXPR:
if (if_true_label == 0)
if_true_label = drop_through_label = gen_label_rtx ();
do_jump (TREE_OPERAND (exp, 0), 0, if_true_label);
do_jump (TREE_OPERAND (exp, 0), NULL_RTX, if_true_label);
do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
break;
......@@ -6074,7 +6066,7 @@ do_jump (exp, if_false_label, if_true_label)
{
register rtx label1 = gen_label_rtx ();
drop_through_label = gen_label_rtx ();
do_jump (TREE_OPERAND (exp, 0), label1, 0);
do_jump (TREE_OPERAND (exp, 0), label1, NULL_RTX);
/* Now the THEN-expression. */
do_jump (TREE_OPERAND (exp, 1),
if_false_label ? if_false_label : drop_through_label,
......@@ -6151,7 +6143,7 @@ do_jump (exp, if_false_label, if_true_label)
default:
normal:
temp = expand_expr (exp, 0, VOIDmode, 0);
temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
#if 0
/* This is not needed any more and causes poor code since it causes
comparisons and tests from non-SI objects to have different code
......@@ -6172,7 +6164,7 @@ do_jump (exp, if_false_label, if_true_label)
do_jump_by_parts_equality_rtx (temp, if_true_label, if_false_label);
else if (GET_MODE (temp) != VOIDmode)
comparison = compare_from_rtx (temp, CONST0_RTX (GET_MODE (temp)),
NE, 1, GET_MODE (temp), 0, 0);
NE, 1, GET_MODE (temp), NULL_RTX, 0);
else
abort ();
}
......@@ -6220,8 +6212,8 @@ do_jump_by_parts_greater (exp, swap, if_false_label, if_true_label)
int swap;
rtx if_false_label, if_true_label;
{
rtx op0 = expand_expr (TREE_OPERAND (exp, swap), 0, VOIDmode, 0);
rtx op1 = expand_expr (TREE_OPERAND (exp, !swap), 0, VOIDmode, 0);
rtx op0 = expand_expr (TREE_OPERAND (exp, swap), NULL_RTX, VOIDmode, 0);
rtx op1 = expand_expr (TREE_OPERAND (exp, !swap), NULL_RTX, VOIDmode, 0);
enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
rtx drop_through_label = 0;
......@@ -6255,19 +6247,19 @@ do_jump_by_parts_greater (exp, swap, if_false_label, if_true_label)
/* All but high-order word must be compared as unsigned. */
comp = compare_from_rtx (op0_word, op1_word,
(unsignedp || i > 0) ? GTU : GT,
unsignedp, word_mode, 0, 0);
unsignedp, word_mode, NULL_RTX, 0);
if (comp == const_true_rtx)
emit_jump (if_true_label);
else if (comp != const0_rtx)
do_jump_for_compare (comp, 0, if_true_label);
do_jump_for_compare (comp, NULL_RTX, if_true_label);
/* Consider lower words only if these are equal. */
comp = compare_from_rtx (op0_word, op1_word, NE, unsignedp, word_mode,
0, 0);
NULL_RTX, 0);
if (comp == const_true_rtx)
emit_jump (if_false_label);
else if (comp != const0_rtx)
do_jump_for_compare (comp, 0, if_false_label);
do_jump_for_compare (comp, NULL_RTX, if_false_label);
}
if (if_false_label)
......@@ -6284,8 +6276,8 @@ do_jump_by_parts_equality (exp, if_false_label, if_true_label)
tree exp;
rtx if_false_label, if_true_label;
{
rtx op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
rtx op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0);
rtx op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
rtx op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
int i;
......@@ -6298,11 +6290,11 @@ do_jump_by_parts_equality (exp, if_false_label, if_true_label)
{
rtx comp = compare_from_rtx (operand_subword_force (op0, i, mode),
operand_subword_force (op1, i, mode),
EQ, 0, word_mode, 0, 0);
EQ, 0, word_mode, NULL_RTX, 0);
if (comp == const_true_rtx)
emit_jump (if_false_label);
else if (comp != const0_rtx)
do_jump_for_compare (comp, if_false_label, 0);
do_jump_for_compare (comp, if_false_label, NULL_RTX);
}
if (if_true_label)
......@@ -6331,11 +6323,11 @@ do_jump_by_parts_equality_rtx (op0, if_false_label, if_true_label)
{
rtx comp = compare_from_rtx (operand_subword_force (op0, i,
GET_MODE (op0)),
const0_rtx, EQ, 0, word_mode, 0, 0);
const0_rtx, EQ, 0, word_mode, NULL_RTX, 0);
if (comp == const_true_rtx)
emit_jump (if_false_label);
else if (comp != const0_rtx)
do_jump_for_compare (comp, if_false_label, 0);
do_jump_for_compare (comp, if_false_label, NULL_RTX);
}
if (if_true_label)
......@@ -6422,8 +6414,10 @@ compare (exp, signed_code, unsigned_code)
register tree exp;
enum rtx_code signed_code, unsigned_code;
{
register rtx op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
register rtx op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0);
register rtx op0
= expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
register rtx op1
= expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
register tree type = TREE_TYPE (TREE_OPERAND (exp, 0));
register enum machine_mode mode = TYPE_MODE (type);
int unsignedp = TREE_UNSIGNED (type);
......@@ -6431,7 +6425,7 @@ compare (exp, signed_code, unsigned_code)
return compare_from_rtx (op0, op1, code, unsignedp, mode,
((mode == BLKmode)
? expr_size (TREE_OPERAND (exp, 0)) : 0),
? expr_size (TREE_OPERAND (exp, 0)) : NULL_RTX),
TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
}
......@@ -6482,12 +6476,11 @@ compare_from_rtx (op0, op1, code, unsignedp, mode, size, align)
sign-extension is. If we are comparing against a constant, we must
convert it to what it would look like unsigned. */
if ((code == EQ || code == NE) && ! unsignedp
&& GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_INT)
&& GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT)
{
if (GET_CODE (op1) == CONST_INT
&& (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0))) != INTVAL (op1))
op1 = gen_rtx (CONST_INT, VOIDmode,
INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0)));
op1 = GEN_INT (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0)));
unsignedp = 1;
}
......@@ -6618,10 +6611,10 @@ do_store_flag (exp, target, mode, only_cheap)
if ((code == NE || code == EQ)
&& TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
&& integer_pow2p (TREE_OPERAND (arg0, 1))
&& TYPE_PRECISION (type) <= HOST_BITS_PER_INT)
&& TYPE_PRECISION (type) <= HOST_BITS_PER_WIDE_INT)
{
int bitnum = exact_log2 (INTVAL (expand_expr (TREE_OPERAND (arg0, 1),
0, VOIDmode, 0)));
NULL_RTX, VOIDmode, 0)));
if (subtarget == 0 || GET_CODE (subtarget) != REG
|| GET_MODE (subtarget) != operand_mode
......@@ -6678,7 +6671,7 @@ do_store_flag (exp, target, mode, only_cheap)
subtarget = 0;
op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
op1 = expand_expr (arg1, 0, VOIDmode, 0);
op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
if (target == 0)
target = gen_reg_rtx (mode);
......@@ -6700,7 +6693,8 @@ do_store_flag (exp, target, mode, only_cheap)
target = gen_reg_rtx (GET_MODE (target));
emit_move_insn (target, invert ? const0_rtx : const1_rtx);
result = compare_from_rtx (op0, op1, code, unsignedp, operand_mode, 0, 0);
result = compare_from_rtx (op0, op1, code, unsignedp,
operand_mode, NULL_RTX, 0);
if (GET_CODE (result) == CONST_INT)
return (((result == const0_rtx && ! invert)
|| (result != const0_rtx && invert))
......@@ -6745,7 +6739,7 @@ do_tablejump (index, mode, range, table_label, default_label)
or equal to the minimum value of the range and less than or equal to
the maximum value of the range. */
emit_cmp_insn (range, index, LTU, 0, mode, 0, 0);
emit_cmp_insn (range, index, LTU, NULL_RTX, mode, 0, 0);
emit_jump_insn (gen_bltu (default_label));
/* If index is in range, it must fit in Pmode.
......@@ -6765,8 +6759,7 @@ do_tablejump (index, mode, range, table_label, default_label)
(CASE_VECTOR_MODE,
gen_rtx (PLUS, Pmode,
gen_rtx (MULT, Pmode, index,
gen_rtx (CONST_INT, VOIDmode,
GET_MODE_SIZE (CASE_VECTOR_MODE))),
GEN_INT (GET_MODE_SIZE (CASE_VECTOR_MODE))),
gen_rtx (LABEL_REF, Pmode, table_label)));
temp = gen_reg_rtx (CASE_VECTOR_MODE);
vector = gen_rtx (MEM, CASE_VECTOR_MODE, index);
......
gcc/final.c
......@@ -283,8 +283,7 @@ end_final (filename)
assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1);
ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 2);
assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1);
assemble_integer (gen_rtx (CONST_INT, VOIDmode, count_basic_blocks),
UNITS_PER_WORD, 1);
assemble_integer (GEN_INT (count_basic_blocks), UNITS_PER_WORD, 1);
assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 3);
assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1);
......@@ -600,7 +599,8 @@ asm_insn_count (body)
char *template;
int count = 1;
for (template = decode_asm_operands (body, 0, 0, 0, 0);
for (template = decode_asm_operands (body, NULL_PTR, NULL_PTR,
NULL_PTR, NULL_PTR);
*template; template++)
if (*template == ';' || *template == '\n')
count++;
......@@ -1174,7 +1174,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes)
of the insn that branched here. So recover the cc status
from the insn that set it. */
note = find_reg_note (insn, REG_CC_SETTER, 0);
note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
if (note)
{
NOTICE_UPDATE_CC (PATTERN (XEXP (note, 0)), XEXP (note, 0));
......@@ -1277,7 +1277,8 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes)
}
/* Get out the operand values. */
string = decode_asm_operands (body, ops, 0, 0, 0);
string = decode_asm_operands (body, ops, NULL_PTR,
NULL_PTR, NULL_PTR);
/* Inhibit aborts on what would otherwise be compiler bugs. */
insn_noperands = noperands;
this_is_asm_operands = insn;
......@@ -1982,7 +1983,13 @@ output_asm_insn (template, operands)
else if (letter == 'n')
{
if (GET_CODE (operands[c]) == CONST_INT)
fprintf (asm_out_file, "%d", - INTVAL (operands[c]));
fprintf (asm_out_file,
#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
"%d",
#else
"%ld",
#endif
- INTVAL (operands[c]));
else
{
putc ('-', asm_out_file);
......@@ -2009,7 +2016,7 @@ output_asm_insn (template, operands)
The PRINT_OPERAND macro decides what is actually done. */
#ifdef PRINT_OPERAND_PUNCT_VALID_P
else if (PRINT_OPERAND_PUNCT_VALID_P (*p))
output_operand (0, *p++);
output_operand (NULL_RTX, *p++);
#endif
else
output_operand_lossage ("invalid %%-code");
......@@ -2123,7 +2130,13 @@ output_addr_const (file, x)
break;
case CONST_INT:
fprintf (file, "%d", INTVAL (x));
fprintf (file,
#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
"%d",
#else
"%ld",
#endif
INTVAL (x));
break;
case CONST:
......@@ -2135,12 +2148,31 @@ output_addr_const (file, x)
case CONST_DOUBLE:
if (GET_MODE (x) == VOIDmode)
{
/* We can use %d if the number is <32 bits and positive. */
/* We can use %d if the number is one word and positive. */
if (CONST_DOUBLE_HIGH (x) || CONST_DOUBLE_LOW (x) < 0)
fprintf (file, "0x%x%08x",
fprintf (file,
#if HOST_BITS_PER_WIDE_INT == 64
#if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
" 0x%lx%016lx",
#else
" 0x%x%016x",
#endif
#else
#if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
" 0x%lx%08lx",
#else
" 0x%x%08x",
#endif
#endif
CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
else
fprintf (file, "%d", CONST_DOUBLE_LOW (x));
fprintf (file,
#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
"%d",
#else
"%ld",
#endif
CONST_DOUBLE_LOW (x));
}
else
/* We can't handle floating point constants;
......@@ -2320,27 +2352,27 @@ split_double (value, first, second)
/* In an integer, the words are defined as most and least significant.
So order them by the target's convention. */
#if WORDS_BIG_ENDIAN
*first = gen_rtx (CONST_INT, VOIDmode, CONST_DOUBLE_HIGH (value));
*second = gen_rtx (CONST_INT, VOIDmode, CONST_DOUBLE_LOW (value));
*first = GEN_INT (CONST_DOUBLE_HIGH (value));
*second = GEN_INT (CONST_DOUBLE_LOW (value));
#else
*first = gen_rtx (CONST_INT, VOIDmode, CONST_DOUBLE_LOW (value));
*second = gen_rtx (CONST_INT, VOIDmode, CONST_DOUBLE_HIGH (value));
*first = GEN_INT (CONST_DOUBLE_LOW (value));
*second = GEN_INT (CONST_DOUBLE_HIGH (value));
#endif
}
else
{
if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
|| HOST_BITS_PER_INT != BITS_PER_WORD)
|| HOST_BITS_PER_WIDE_INT != BITS_PER_WORD)
&& ! flag_pretend_float)
abort ();
#if defined (HOST_WORDS_BIG_ENDIAN) == WORDS_BIG_ENDIAN
/* Host and target agree => no need to swap. */
*first = gen_rtx (CONST_INT, VOIDmode, CONST_DOUBLE_LOW (value));
*second = gen_rtx (CONST_INT, VOIDmode, CONST_DOUBLE_HIGH (value));
*first = GEN_INT (CONST_DOUBLE_LOW (value));
*second = GEN_INT (CONST_DOUBLE_HIGH (value));
#else
*second = gen_rtx (CONST_INT, VOIDmode, CONST_DOUBLE_LOW (value));
*first = gen_rtx (CONST_INT, VOIDmode, CONST_DOUBLE_HIGH (value));
*second = GEN_INT (CONST_DOUBLE_LOW (value));
*first = GEN_INT (CONST_DOUBLE_HIGH (value));
#endif
}
}
......
gcc/fold-const.c
......@@ -58,44 +58,47 @@ static tree const_binop ();
#define BRANCH_COST 1
#endif
/* To do constant folding on INTEGER_CST nodes requires 64-bit arithmetic.
We do that by representing the 64-bit integer as 8 shorts,
/* To do constant folding on INTEGER_CST nodes requires two-word arithmetic.
We do that by representing the two-word integer as MAX_SHORTS shorts,
with only 8 bits stored in each short, as a positive number. */
/* Unpack a 64-bit integer into 8 shorts.
LOW and HI are the integer, as two `int' pieces.
/* Unpack a two-word integer into MAX_SHORTS shorts.
LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
SHORTS points to the array of shorts. */
static void
encode (shorts, low, hi)
short *shorts;
int low, hi;
HOST_WIDE_INT low, hi;
{
shorts[0] = low & 0xff;
shorts[1] = (low >> 8) & 0xff;
shorts[2] = (low >> 16) & 0xff;
shorts[3] = (low >> 24) & 0xff;
shorts[4] = hi & 0xff;
shorts[5] = (hi >> 8) & 0xff;
shorts[6] = (hi >> 16) & 0xff;
shorts[7] = (hi >> 24) & 0xff;
register int i;
for (i = 0; i < MAX_SHORTS / 2; i++)
{
shorts[i] = (low >> (i * 8)) & 0xff;
shorts[i + MAX_SHORTS / 2] = (hi >> (i * 8) & 0xff);
}
}
/* Pack an array of 8 shorts into a 64-bit integer.
/* Pack an array of MAX_SHORTS shorts into a two-word integer.
SHORTS points to the array of shorts.
The integer is stored into *LOW and *HI as two `int' pieces. */
The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces. */
static void
decode (shorts, low, hi)
short *shorts;
int *low, *hi;
HOST_WIDE_INT *low, *hi;
{
/* The casts in the following statement should not be
needed, but they get around bugs in some C compilers. */
*low = (((long)shorts[3] << 24) | ((long)shorts[2] << 16)
| ((long)shorts[1] << 8) | (long)shorts[0]);
*hi = (((long)shorts[7] << 24) | ((long)shorts[6] << 16)
| ((long)shorts[5] << 8) | (long)shorts[4]);
register int i;
HOST_WIDE_INT lv = 0, hv = 0;
for (i = 0; i < MAX_SHORTS / 2; i++)
{
lv |= (HOST_WIDE_INT) shorts[i] << (i * 8);
hv |= (HOST_WIDE_INT) shorts[i + MAX_SHORTS / 2] << (i * 8);
}
*low = lv, *hi = hv;
}
/* Make the integer constant T valid for its type
......@@ -113,66 +116,65 @@ force_fit_type (t)
/* First clear all bits that are beyond the type's precision. */
if (prec == 2 * HOST_BITS_PER_INT)
if (prec == 2 * HOST_BITS_PER_WIDE_INT)
;
else if (prec > HOST_BITS_PER_INT)
else if (prec > HOST_BITS_PER_WIDE_INT)
{
TREE_INT_CST_HIGH (t)
&= ~((-1) << (prec - HOST_BITS_PER_INT));
&= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
}
else
{
TREE_INT_CST_HIGH (t) = 0;
if (prec < HOST_BITS_PER_INT)
TREE_INT_CST_LOW (t)
&= ~((-1) << prec);
if (prec < HOST_BITS_PER_WIDE_INT)
TREE_INT_CST_LOW (t) &= ~((HOST_WIDE_INT) (-1) << prec);
}
/* If it's a signed type and value's sign bit is set, extend the sign. */
if (! TREE_UNSIGNED (TREE_TYPE (t))
&& prec != 2 * HOST_BITS_PER_INT
&& (prec > HOST_BITS_PER_INT
? TREE_INT_CST_HIGH (t) & (1 << (prec - HOST_BITS_PER_INT - 1))
: TREE_INT_CST_LOW (t) & (1 << (prec - 1))))
&& prec != 2 * HOST_BITS_PER_WIDE_INT
&& (prec > HOST_BITS_PER_WIDE_INT
? (TREE_INT_CST_HIGH (t)
& ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)))
: TREE_INT_CST_LOW (t) & ((HOST_WIDE_INT) 1 << (prec - 1))))
{
/* Value is negative:
set to 1 all the bits that are outside this type's precision. */
if (prec > HOST_BITS_PER_INT)
if (prec > HOST_BITS_PER_WIDE_INT)
{
TREE_INT_CST_HIGH (t)
|= ((-1) << (prec - HOST_BITS_PER_INT));
|= ((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
}
else
{
TREE_INT_CST_HIGH (t) = -1;
if (prec < HOST_BITS_PER_INT)
TREE_INT_CST_LOW (t)
|= ((-1) << prec);
if (prec < HOST_BITS_PER_WIDE_INT)
TREE_INT_CST_LOW (t) |= ((HOST_WIDE_INT) (-1) << prec);
}
}
}
/* Add two 64-bit integers with 64-bit result.
Each argument is given as two `int' pieces.
/* Add two doubleword integers with doubleword result.
Each argument is given as two `HOST_WIDE_INT' pieces.
One argument is L1 and H1; the other, L2 and H2.
The value is stored as two `int' pieces in *LV and *HV.
The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.
We use the 8-shorts representation internally. */
void
add_double (l1, h1, l2, h2, lv, hv)
int l1, h1, l2, h2;
int *lv, *hv;
HOST_WIDE_INT l1, h1, l2, h2;
HOST_WIDE_INT *lv, *hv;
{
short arg1[8];
short arg2[8];
short arg1[MAX_SHORTS];
short arg2[MAX_SHORTS];
register int carry = 0;
register int i;
encode (arg1, l1, h1);
encode (arg2, l2, h2);
for (i = 0; i < 8; i++)
for (i = 0; i < MAX_SHORTS; i++)
{
carry += arg1[i] + arg2[i];
arg1[i] = carry & 0xff;
......@@ -182,15 +184,15 @@ add_double (l1, h1, l2, h2, lv, hv)
decode (arg1, lv, hv);
}
/* Negate a 64-bit integers with 64-bit result.
The argument is given as two `int' pieces in L1 and H1.
The value is stored as two `int' pieces in *LV and *HV.
/* Negate a doubleword integer with doubleword result.
The argument is given as two `HOST_WIDE_INT' pieces in L1 and H1.
The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.
We use the 8-shorts representation internally. */
void
neg_double (l1, h1, lv, hv)
int l1, h1;
int *lv, *hv;
HOST_WIDE_INT l1, h1;
HOST_WIDE_INT *lv, *hv;
{
if (l1 == 0)
{
......@@ -204,20 +206,20 @@ neg_double (l1, h1, lv, hv)
}
}
/* Multiply two 64-bit integers with 64-bit result.
Each argument is given as two `int' pieces.
/* Multiply two doubleword integers with doubleword result.
Each argument is given as two `HOST_WIDE_INT' pieces.
One argument is L1 and H1; the other, L2 and H2.
The value is stored as two `int' pieces in *LV and *HV.
The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.
We use the 8-shorts representation internally. */
void
mul_double (l1, h1, l2, h2, lv, hv)
int l1, h1, l2, h2;
int *lv, *hv;
HOST_WIDE_INT l1, h1, l2, h2;
HOST_WIDE_INT *lv, *hv;
{
short arg1[8];
short arg2[8];
short prod[16];
short arg1[MAX_SHORTS];
short arg2[MAX_SHORTS];
short prod[MAX_SHORTS * 2];
register int carry = 0;
register int i, j, k;
......@@ -227,14 +229,14 @@ mul_double (l1, h1, l2, h2, lv, hv)
{
if (l2 == 2)
{
unsigned temp = l1 + l1;
unsigned HOST_WIDE_INT temp = l1 + l1;
*hv = h1 * 2 + (temp < l1);
*lv = temp;
return;
}
if (l2 == 4)
{
unsigned temp = l1 + l1;
unsigned HOST_WIDE_INT temp = l1 + l1;
h1 = h1 * 4 + ((temp < l1) << 1);
l1 = temp;
temp += temp;
......@@ -245,7 +247,7 @@ mul_double (l1, h1, l2, h2, lv, hv)
}
if (l2 == 8)
{
unsigned temp = l1 + l1;
unsigned HOST_WIDE_INT temp = l1 + l1;
h1 = h1 * 8 + ((temp < l1) << 2);
l1 = temp;
temp += temp;
......@@ -264,8 +266,8 @@ mul_double (l1, h1, l2, h2, lv, hv)
bzero (prod, sizeof prod);
for (i = 0; i < 8; i++)
for (j = 0; j < 8; j++)
for (i = 0; i < MAX_SHORTS; i++)
for (j = 0; j < MAX_SHORTS; j++)
{
k = i + j;
carry = arg1[i] * arg2[j];
......@@ -278,22 +280,24 @@ mul_double (l1, h1, l2, h2, lv, hv)
}
}
decode (prod, lv, hv); /* @@decode ignores prod[8] -> prod[15] */
decode (prod, lv, hv); /* ?? decode ignores
prod[MAX_SHORTS] -> prod[MAX_SHORTS*2-1] */
}
/* Shift the 64-bit integer in L1, H1 left by COUNT places
/* Shift the doubleword integer in L1, H1 left by COUNT places
keeping only PREC bits of result.
Shift right if COUNT is negative.
ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
Store the value as two `int' pieces in *LV and *HV. */
Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
void
lshift_double (l1, h1, count, prec, lv, hv, arith)
int l1, h1, count, prec;
int *lv, *hv;
HOST_WIDE_INT l1, h1;
int count, prec;
HOST_WIDE_INT *lv, *hv;
int arith;
{
short arg1[8];
short arg1[MAX_SHORTS];
register int i;
register int carry;
......@@ -311,7 +315,7 @@ lshift_double (l1, h1, count, prec, lv, hv, arith)
while (count > 0)
{
carry = 0;
for (i = 0; i < 8; i++)
for (i = 0; i < MAX_SHORTS; i++)
{
carry += arg1[i] << 1;
arg1[i] = carry & 0xff;
......@@ -323,18 +327,18 @@ lshift_double (l1, h1, count, prec, lv, hv, arith)
decode (arg1, lv, hv);
}
/* Shift the 64-bit integer in L1, H1 right by COUNT places
/* Shift the doubleword integer in L1, H1 right by COUNT places
keeping only PREC bits of result. COUNT must be positive.
ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
Store the value as two `int' pieces in *LV and *HV. */
Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
void
rshift_double (l1, h1, count, prec, lv, hv, arith)
int l1, h1, count, prec;
int *lv, *hv;
HOST_WIDE_INT l1, h1, count, prec;
HOST_WIDE_INT *lv, *hv;
int arith;
{
short arg1[8];
short arg1[MAX_SHORTS];
register int i;
register int carry;
......@@ -346,7 +350,7 @@ rshift_double (l1, h1, count, prec, lv, hv, arith)
while (count > 0)
{
carry = arith && arg1[7] >> 7;
for (i = 7; i >= 0; i--)
for (i = MAX_SHORTS - 1; i >= 0; i--)
{
carry <<= 8;
carry += arg1[i];
......@@ -358,17 +362,17 @@ rshift_double (l1, h1, count, prec, lv, hv, arith)
decode (arg1, lv, hv);
}
/* Rotate the 64-bit integer in L1, H1 left by COUNT places
/* Rotate the doubldword integer in L1, H1 left by COUNT places
keeping only PREC bits of result.
Rotate right if COUNT is negative.
Store the value as two `int' pieces in *LV and *HV. */
Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
void
lrotate_double (l1, h1, count, prec, lv, hv)
int l1, h1, count, prec;
int *lv, *hv;
HOST_WIDE_INT l1, h1, count, prec;
HOST_WIDE_INT *lv, *hv;
{
short arg1[8];
short arg1[MAX_SHORTS];
register int i;
register int carry;
......@@ -383,10 +387,10 @@ lrotate_double (l1, h1, count, prec, lv, hv)
if (count > prec)
count = prec;
carry = arg1[7] >> 7;
carry = arg1[MAX_SHORTS - 1] >> 7;
while (count > 0)
{
for (i = 0; i < 8; i++)
for (i = 0; i < MAX_SHORTS; i++)
{
carry += arg1[i] << 1;
arg1[i] = carry & 0xff;
......@@ -398,16 +402,16 @@ lrotate_double (l1, h1, count, prec, lv, hv)
decode (arg1, lv, hv);
}
/* Rotate the 64-bit integer in L1, H1 left by COUNT places
/* Rotate the doubleword integer in L1, H1 left by COUNT places
keeping only PREC bits of result. COUNT must be positive.
Store the value as two `int' pieces in *LV and *HV. */
Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
void
rrotate_double (l1, h1, count, prec, lv, hv)
int l1, h1, count, prec;
int *lv, *hv;
HOST_WIDE_INT l1, h1, count, prec;
HOST_WIDE_INT *lv, *hv;
{
short arg1[8];
short arg1[MAX_SHORTS];
register int i;
register int carry;
......@@ -419,7 +423,7 @@ rrotate_double (l1, h1, count, prec, lv, hv)
carry = arg1[0] & 1;
while (count > 0)
{
for (i = 7; i >= 0; i--)
for (i = MAX_SHORTS - 1; i >= 0; i--)
{
carry <<= 8;
carry += arg1[i];
......@@ -431,7 +435,7 @@ rrotate_double (l1, h1, count, prec, lv, hv)
decode (arg1, lv, hv);
}
/* Divide 64 bit integer LNUM, HNUM by 64 bit integer LDEN, HDEN
/* Divide doubleword integer LNUM, HNUM by doubleword integer LDEN, HDEN
for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
CODE is a tree code for a kind of division, one of
TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR, ROUND_DIV_EXPR
......@@ -445,12 +449,13 @@ div_and_round_double (code, uns,
lquo, hquo, lrem, hrem)
enum tree_code code;
int uns;
int lnum_orig, hnum_orig; /* num == numerator == dividend */
int lden_orig, hden_orig; /* den == denominator == divisor */
int *lquo, *hquo, *lrem, *hrem;
HOST_WIDE_INT lnum_orig, hnum_orig; /* num == numerator == dividend */
HOST_WIDE_INT lden_orig, hden_orig; /* den == denominator == divisor */
HOST_WIDE_INT *lquo, *hquo, *lrem, *hrem;
{
int quo_neg = 0;
short num[9], den[8], quo[8]; /* extra element for scaling. */
short num[MAX_SHORTS + 1]; /* extra element for scaling. */
short den[MAX_SHORTS], quo[MAX_SHORTS];
register int i, j, work;
register int carry = 0;
unsigned int lnum = lnum_orig;
......@@ -507,7 +512,7 @@ div_and_round_double (code, uns,
if (hden == 0 && ((lden << 8) >> 8) == lden)
{ /* simpler algorithm */
/* hnum != 0 already checked. */
for (i = 7; i >= 0; i--)
for (i = MAX_SHORTS - 1; i >= 0; i--)
{
work = num[i] + (carry << 8);
quo[i] = work / lden;
......@@ -521,12 +526,12 @@ div_and_round_double (code, uns,
int quo_est, scale, num_hi_sig, den_hi_sig, quo_hi_sig;
/* Find the highest non-zero divisor digit. */
for (i = 7; ; i--)
for (i = MAX_SHORTS - 1; ; i--)
if (den[i] != 0) {
den_hi_sig = i;
break;
}
for (i = 7; ; i--)
for (i = MAX_SHORTS - 1; ; i--)
if (num[i] != 0) {
num_hi_sig = i;
break;
......@@ -539,14 +544,14 @@ div_and_round_double (code, uns,
scale = BASE / (den[den_hi_sig] + 1);
if (scale > 1) { /* scale divisor and dividend */
carry = 0;
for (i = 0; i <= 8; i++) {
for (i = 0; i <= MAX_SHORTS - 1; i++) {
work = (num[i] * scale) + carry;
num[i] = work & 0xff;
carry = work >> 8;
if (num[i] != 0) num_hi_sig = i;
}
carry = 0;
for (i = 0; i <= 7; i++) {
for (i = 0; i <= MAX_SHORTS - 1; i++) {
work = (den[i] * scale) + carry;
den[i] = work & 0xff;
carry = work >> 8;
......@@ -652,7 +657,8 @@ div_and_round_double (code, uns,
if (quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio < 0 && rem != 0 */
{
/* quo = quo - 1; */
add_double (*lquo, *hquo, -1, -1, lquo, hquo);
add_double (*lquo, *hquo, (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1,
lquo, hquo);
}
else return;
break;
......@@ -661,7 +667,8 @@ div_and_round_double (code, uns,
case CEIL_MOD_EXPR: /* round toward positive infinity */
if (!quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio > 0 && rem != 0 */
{
add_double (*lquo, *hquo, 1, 0, lquo, hquo);
add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
lquo, hquo);
}
else return;
break;
......@@ -669,25 +676,31 @@ div_and_round_double (code, uns,
case ROUND_DIV_EXPR:
case ROUND_MOD_EXPR: /* round to closest integer */
{
int labs_rem = *lrem, habs_rem = *hrem;
int labs_den = lden, habs_den = hden, ltwice, htwice;
HOST_WIDE_INT labs_rem = *lrem, habs_rem = *hrem;
HOST_WIDE_INT labs_den = lden, habs_den = hden, ltwice, htwice;
/* get absolute values */
if (*hrem < 0) neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
if (hden < 0) neg_double (lden, hden, &labs_den, &habs_den);
/* if (2 * abs (lrem) >= abs (lden)) */
mul_double (2, 0, labs_rem, habs_rem, &ltwice, &htwice);
if (((unsigned) habs_den < (unsigned) htwice)
|| (((unsigned) habs_den == (unsigned) htwice)
&& ((unsigned) labs_den < (unsigned) ltwice)))
mul_double ((HOST_WIDE_INT) 2, (HOST_WIDE_INT) 0,
labs_rem, habs_rem, &ltwice, &htwice);
if (((unsigned HOST_WIDE_INT) habs_den
< (unsigned HOST_WIDE_INT) htwice)
|| (((unsigned HOST_WIDE_INT) habs_den
== (unsigned HOST_WIDE_INT) htwice)
&& ((HOST_WIDE_INT unsigned) labs_den
< (unsigned HOST_WIDE_INT) ltwice)))
{
if (*hquo < 0)
/* quo = quo - 1; */
add_double (*lquo, *hquo, -1, -1, lquo, hquo);
add_double (*lquo, *hquo,
(HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1, lquo, hquo);
else
/* quo = quo + 1; */
add_double (*lquo, *hquo, 1, 0, lquo, hquo);
add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
lquo, hquo);
}
else return;
}
......@@ -728,7 +741,7 @@ real_value_truncate (mode, arg)
}
set_float_handler (handler);
value = REAL_VALUE_TRUNCATE (mode, arg);
set_float_handler (0);
set_float_handler (NULL_PTR);
return value;
}
......@@ -981,12 +994,12 @@ const_binop (code, arg1, arg2)
{
if (TREE_CODE (arg1) == INTEGER_CST)
{
register int int1l = TREE_INT_CST_LOW (arg1);
register int int1h = TREE_INT_CST_HIGH (arg1);
int int2l = TREE_INT_CST_LOW (arg2);
int int2h = TREE_INT_CST_HIGH (arg2);
int low, hi;
int garbagel, garbageh;
register HOST_WIDE_INT int1l = TREE_INT_CST_LOW (arg1);
register HOST_WIDE_INT int1h = TREE_INT_CST_HIGH (arg1);
HOST_WIDE_INT int2l = TREE_INT_CST_LOW (arg2);
HOST_WIDE_INT int2h = TREE_INT_CST_HIGH (arg2);
HOST_WIDE_INT low, hi;
HOST_WIDE_INT garbagel, garbageh;
register tree t;
int uns = TREE_UNSIGNED (TREE_TYPE (arg1));
......@@ -1031,7 +1044,7 @@ const_binop (code, arg1, arg2)
if (int1h == 0)
{
int2l += int1l;
if ((unsigned) int2l < int1l)
if ((unsigned HOST_WIDE_INT) int2l < int1l)
int2h += 1;
t = build_int_2 (int2l, int2h);
break;
......@@ -1039,7 +1052,7 @@ const_binop (code, arg1, arg2)
if (int2h == 0)
{
int1l += int2l;
if ((unsigned) int1l < int2l)
if ((unsigned HOST_WIDE_INT) int1l < int2l)
int1h += 1;
t = build_int_2 (int1l, int1h);
break;
......@@ -1063,7 +1076,7 @@ const_binop (code, arg1, arg2)
/* Optimize simple cases. */
if (int1h == 0)
{
unsigned temp;
unsigned HOST_WIDE_INT temp;
switch (int1l)
{
......@@ -1168,15 +1181,19 @@ const_binop (code, arg1, arg2)
case MAX_EXPR:
if (uns)
{
low = (((unsigned) int1h < (unsigned) int2h)
|| (((unsigned) int1h == (unsigned) int2h)
&& ((unsigned) int1l < (unsigned) int2l)));
low = (((unsigned HOST_WIDE_INT) int1h
< (unsigned HOST_WIDE_INT) int2h)
|| (((unsigned HOST_WIDE_INT) int1h
== (unsigned HOST_WIDE_INT) int2h)
&& ((unsigned HOST_WIDE_INT) int1l
< (unsigned HOST_WIDE_INT) int2l)));
}
else
{
low = ((int1h < int2h)
|| ((int1h == int2h)
&& ((unsigned) int1l < (unsigned) int2l)));
&& ((unsigned HOST_WIDE_INT) int1l
< (unsigned HOST_WIDE_INT) int2l)));
}
if (low == (code == MIN_EXPR))
t = build_int_2 (int1l, int1h);
......@@ -1249,7 +1266,7 @@ const_binop (code, arg1, arg2)
#endif /* no REAL_ARITHMETIC */
t = build_real (TREE_TYPE (arg1),
real_value_truncate (TYPE_MODE (TREE_TYPE (arg1)), value));
set_float_handler (0);
set_float_handler (NULL_PTR);
return t;
}
#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
......@@ -1318,11 +1335,12 @@ size_int (number)
{
register tree t;
/* Type-size nodes already made for small sizes. */
static tree size_table[2*HOST_BITS_PER_INT+1];
static tree size_table[2*HOST_BITS_PER_WIDE_INT + 1];
if (number >= 0 && number < 2*HOST_BITS_PER_INT+1 && size_table[number] != 0)
if (number >= 0 && number < 2*HOST_BITS_PER_WIDE_INT + 1
&& size_table[number] != 0)
return size_table[number];
if (number >= 0 && number < 2*HOST_BITS_PER_INT+1)
if (number >= 0 && number < 2*HOST_BITS_PER_WIDE_INT + 1)
{
push_obstacks_nochange ();
/* Make this a permanent node. */
......@@ -1423,23 +1441,24 @@ fold_convert (t, arg1)
#ifndef REAL_ARITHMETIC
{
REAL_VALUE_TYPE d;
int low, high;
int half_word = 1 << (HOST_BITS_PER_INT / 2);
HOST_WIDE_INT low, high;
HOST_WIDE_INT half_word
= (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2);
d = TREE_REAL_CST (arg1);
if (d < 0)
d = -d;
high = (int) (d / half_word / half_word);
high = (HOST_WIDE_INT) (d / half_word / half_word);
d -= (REAL_VALUE_TYPE) high * half_word * half_word;
low = (unsigned) d;
low = (unsigned HOST_WIDE_INT) d;
if (TREE_REAL_CST (arg1) < 0)
neg_double (low, high, &low, &high);
t = build_int_2 (low, high);
}
#else
{
int low, high;
HOST_WIDE_INT low, high;
REAL_VALUE_TO_INT (low, high, TREE_REAL_CST (arg1));
t = build_int_2 (low, high);
}
......@@ -1467,7 +1486,7 @@ fold_convert (t, arg1)
t = build_real (type, real_value_truncate (TYPE_MODE (type),
TREE_REAL_CST (arg1)));
set_float_handler (0);
set_float_handler (NULL_PTR);
return t;
}
}
......@@ -3377,16 +3396,18 @@ fold (expr)
&& TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1, 0))))
{
int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0)));
if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_INT
&& (~TREE_INT_CST_LOW (arg0) & ((1 << prec) - 1)) == 0)
if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
&& (~TREE_INT_CST_LOW (arg0)
& (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
return build1 (NOP_EXPR, type, TREE_OPERAND (arg1, 0));
}
if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
&& TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
{
int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_INT
&& (~TREE_INT_CST_LOW (arg1) & ((1 << prec) - 1)) == 0)
if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
&& (~TREE_INT_CST_LOW (arg1)
& (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
return build1 (NOP_EXPR, type, TREE_OPERAND (arg0, 0));
}
goto associate;
......@@ -3429,7 +3450,7 @@ fold (expr)
{
tree new_op
= build_int_2 (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1))
/ TREE_INT_CST_LOW (arg1));
/ TREE_INT_CST_LOW (arg1), 0);
TREE_TYPE (new_op) = type;
return build (MULT_EXPR, type, TREE_OPERAND (arg0, 0), new_op);
......@@ -3450,7 +3471,7 @@ fold (expr)
{
tree new_op
= build_int_2 (TREE_INT_CST_LOW (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1))
/ TREE_INT_CST_LOW (arg1));
/ TREE_INT_CST_LOW (arg1), 0);
TREE_TYPE (new_op) = type;
return build (MULT_EXPR, type,
......
gcc/gcc.c
......@@ -47,6 +47,14 @@ compilation is specified by a string called a "spec". */
#define X_OK 1
#endif
#ifndef NULL
#define NULL 0
#endif
#ifndef NULL_PTR
#define NULL_PTR (char *) NULL
#endif
#ifdef USG
#define vfork fork
#endif /* USG */
......@@ -1716,8 +1724,8 @@ process_command (argc, argv)
if (gcc_exec_prefix)
{
add_prefix (&exec_prefix, gcc_exec_prefix, 0, 0, 0);
add_prefix (&startfile_prefix, gcc_exec_prefix, 0, 0, 0);
add_prefix (&exec_prefix, gcc_exec_prefix, 0, 0, NULL_PTR);
add_prefix (&startfile_prefix, gcc_exec_prefix, 0, 0, NULL_PTR);
}
/* COMPILER_PATH and LIBRARY_PATH have values
......@@ -1746,7 +1754,7 @@ process_command (argc, argv)
}
else
nstore[endp-startp] = 0;
add_prefix (&exec_prefix, nstore, 0, 0, 0);
add_prefix (&exec_prefix, nstore, 0, 0, NULL_PTR);
if (*endp == 0)
break;
endp = startp = endp + 1;
......@@ -1779,9 +1787,9 @@ process_command (argc, argv)
}
else
nstore[endp-startp] = 0;
add_prefix (&startfile_prefix, nstore, 0, 0, 0);
add_prefix (&startfile_prefix, nstore, 0, 0, NULL_PTR);
/* Make separate list of dirs that came from LIBRARY_PATH. */
add_prefix (&library_prefix, nstore, 0, 0, 0);
add_prefix (&library_prefix, nstore, 0, 0, NULL_PTR);
if (*endp == 0)
break;
endp = startp = endp + 1;
......@@ -1815,9 +1823,9 @@ process_command (argc, argv)
}
else
nstore[endp-startp] = 0;
add_prefix (&startfile_prefix, nstore, 0, 0, 0);
add_prefix (&startfile_prefix, nstore, 0, 0, NULL_PTR);
/* Make separate list of dirs that came from LIBRARY_PATH. */
add_prefix (&library_prefix, nstore, 0, 0, 0);
add_prefix (&library_prefix, nstore, 0, 0, NULL_PTR);
if (*endp == 0)
break;
endp = startp = endp + 1;
......@@ -1947,11 +1955,11 @@ process_command (argc, argv)
/* These come before the md prefixes so that we will find gcc's subcommands
(such as cpp) rather than those of the host system. */
add_prefix (&exec_prefix, standard_exec_prefix, 0, 1, 0);
add_prefix (&exec_prefix, standard_exec_prefix_1, 0, 1, 0);
add_prefix (&exec_prefix, standard_exec_prefix, 0, 1, NULL_PTR);
add_prefix (&exec_prefix, standard_exec_prefix_1, 0, 1, NULL_PTR);
add_prefix (&startfile_prefix, standard_exec_prefix, 0, 1, 0);
add_prefix (&startfile_prefix, standard_exec_prefix_1, 0, 1, 0);
add_prefix (&startfile_prefix, standard_exec_prefix, 0, 1, NULL_PTR);
add_prefix (&startfile_prefix, standard_exec_prefix_1, 0, 1, NULL_PTR);
/* More prefixes are enabled in main, after we read the specs file
and determine whether this is cross-compilation or not. */
......@@ -2115,7 +2123,7 @@ do_spec (spec)
this_is_output_file = 0;
this_is_library_file = 0;
value = do_spec_1 (spec, 0, NULL);
value = do_spec_1 (spec, 0, NULL_PTR);
/* Force out any unfinished command.
If -pipe, this forces out the last command if it ended in `|'. */
......@@ -2287,11 +2295,11 @@ do_spec_1 (spec, inswitch, soft_matched_part)
{
if (is_linker_dir (pl->prefix, machine_suffix))
{
do_spec_1 ("-L", 0, 0);
do_spec_1 ("-L", 0, NULL_PTR);
#ifdef SPACE_AFTER_L_OPTION
do_spec_1 (" ", 0, 0);
do_spec_1 (" ", 0, NULL_PTR);
#endif
do_spec_1 (pl->prefix, 1, 0);
do_spec_1 (pl->prefix, 1, NULL_PTR);
/* Remove slash from machine_suffix. */
if (strlen (machine_suffix) >= bufsize)
bufsize = strlen (machine_suffix) * 2 + 1;
......@@ -2300,18 +2308,18 @@ do_spec_1 (spec, inswitch, soft_matched_part)
idx = strlen (buffer);
if (buffer[idx - 1] == '/')
buffer[idx - 1] = 0;
do_spec_1 (buffer, 1, 0);
do_spec_1 (buffer, 1, NULL_PTR);
/* Make this a separate argument. */
do_spec_1 (" ", 0, 0);
do_spec_1 (" ", 0, NULL_PTR);
}
}
if (!pl->require_machine_suffix)
{
if (is_linker_dir (pl->prefix, ""))
{
do_spec_1 ("-L", 0, 0);
do_spec_1 ("-L", 0, NULL_PTR);
#ifdef SPACE_AFTER_L_OPTION
do_spec_1 (" ", 0, 0);
do_spec_1 (" ", 0, NULL_PTR);
#endif
/* Remove slash from pl->prefix. */
if (strlen (pl->prefix) >= bufsize)
......@@ -2321,9 +2329,9 @@ do_spec_1 (spec, inswitch, soft_matched_part)
idx = strlen (buffer);
if (buffer[idx - 1] == '/')
buffer[idx - 1] = 0;
do_spec_1 (buffer, 1, 0);
do_spec_1 (buffer, 1, NULL_PTR);
/* Make this a separate argument. */
do_spec_1 (" ", 0, 0);
do_spec_1 (" ", 0, NULL_PTR);
}
}
}
......@@ -2444,9 +2452,9 @@ do_spec_1 (spec, inswitch, soft_matched_part)
case 'X':
for (i = 0; i < n_linker_options; i++)
{
do_spec_1 (linker_options[i], 1, NULL);
do_spec_1 (linker_options[i], 1, NULL_PTR);
/* Make each accumulated option a separate argument. */
do_spec_1 (" ", 0, NULL);
do_spec_1 (" ", 0, NULL_PTR);
}
break;
......@@ -2454,39 +2462,39 @@ do_spec_1 (spec, inswitch, soft_matched_part)
a certain constant string as a spec. */
case '1':
do_spec_1 (cc1_spec, 0, NULL);
do_spec_1 (cc1_spec, 0, NULL_PTR);
break;
case '2':
do_spec_1 (cc1plus_spec, 0, NULL);
do_spec_1 (cc1plus_spec, 0, NULL_PTR);
break;
case 'a':
do_spec_1 (asm_spec, 0, NULL);
do_spec_1 (asm_spec, 0, NULL_PTR);
break;
case 'A':
do_spec_1 (asm_final_spec, 0, NULL);
do_spec_1 (asm_final_spec, 0, NULL_PTR);
break;
case 'c':
do_spec_1 (signed_char_spec, 0, NULL);
do_spec_1 (signed_char_spec, 0, NULL_PTR);
break;
case 'C':
do_spec_1 (cpp_spec, 0, NULL);
do_spec_1 (cpp_spec, 0, NULL_PTR);
break;
case 'E':
do_spec_1 (endfile_spec, 0, NULL);
do_spec_1 (endfile_spec, 0, NULL_PTR);
break;
case 'l':
do_spec_1 (link_spec, 0, NULL);
do_spec_1 (link_spec, 0, NULL_PTR);
break;
case 'L':
do_spec_1 (lib_spec, 0, NULL);
do_spec_1 (lib_spec, 0, NULL_PTR);
break;
case 'p':
......@@ -2513,7 +2521,7 @@ do_spec_1 (spec, inswitch, soft_matched_part)
*x = 0;
do_spec_1 (buf, 0, NULL);
do_spec_1 (buf, 0, NULL_PTR);
}
break;
......@@ -2619,12 +2627,12 @@ do_spec_1 (spec, inswitch, soft_matched_part)
*x = 0;
do_spec_1 (buf, 0, NULL);
do_spec_1 (buf, 0, NULL_PTR);
}
break;
case 'S':
do_spec_1 (startfile_spec, 0, NULL);
do_spec_1 (startfile_spec, 0, NULL_PTR);
break;
/* Here we define characters other than letters and digits. */
......@@ -2640,8 +2648,8 @@ do_spec_1 (spec, inswitch, soft_matched_part)
break;
case '*':
do_spec_1 (soft_matched_part, 1, NULL);
do_spec_1 (" ", 0, NULL);
do_spec_1 (soft_matched_part, 1, NULL_PTR);
do_spec_1 (" ", 0, NULL_PTR);
break;
/* Process a string found as the value of a spec given by name.
......@@ -2672,7 +2680,7 @@ do_spec_1 (spec, inswitch, soft_matched_part)
if (sl)
{
if (c == '(')
do_spec_1 (name, 0, NULL);
do_spec_1 (name, 0, NULL_PTR);
else
{
char *x = (char *) alloca (strlen (name) * 2 + 1);
......@@ -2705,7 +2713,7 @@ do_spec_1 (spec, inswitch, soft_matched_part)
}
*x = 0;
do_spec_1 (buf, 0, NULL);
do_spec_1 (buf, 0, NULL_PTR);
}
}
......@@ -2797,7 +2805,7 @@ handle_braces (p)
abort ();
if (negate != found
&& do_spec_1 (save_string (p + 1, q - p - 2), 0, NULL) < 0)
&& do_spec_1 (save_string (p + 1, q - p - 2), 0, NULL_PTR) < 0)
return 0;
return q;
......@@ -2895,7 +2903,7 @@ handle_braces (p)
}
else
{
if (do_spec_1 (save_string (p + 1, q - p - 2), 0, NULL) < 0)
if (do_spec_1 (save_string (p + 1, q - p - 2), 0, NULL_PTR) < 0)
return 0;
}
}
......@@ -2903,7 +2911,7 @@ handle_braces (p)
{
/* Here if a %{|...} conditional fails: output a minus sign,
which means "standard output" or "standard input". */
do_spec_1 ("-", 0, NULL);
do_spec_1 ("-", 0, NULL_PTR);
}
}
......@@ -2925,17 +2933,17 @@ give_switch (switchnum, omit_first_word)
{
if (!omit_first_word)
{
do_spec_1 ("-", 0, NULL);
do_spec_1 (switches[switchnum].part1, 1, NULL);
do_spec_1 ("-", 0, NULL_PTR);
do_spec_1 (switches[switchnum].part1, 1, NULL_PTR);
}
do_spec_1 (" ", 0, NULL);
do_spec_1 (" ", 0, NULL_PTR);
if (switches[switchnum].args != 0)
{
char **p;
for (p = switches[switchnum].args; *p; p++)
{
do_spec_1 (*p, 1, NULL);
do_spec_1 (" ", 0, NULL);
do_spec_1 (*p, 1, NULL_PTR);
do_spec_1 (" ", 0, NULL_PTR);
}
}
switches[switchnum].valid = 1;
......@@ -3072,23 +3080,26 @@ main (argc, argv)
if (!cross_compile)
{
#ifdef MD_EXEC_PREFIX
add_prefix (&exec_prefix, md_exec_prefix, 0, 0, 0);
add_prefix (&startfile_prefix, md_exec_prefix, 0, 0, 0);
add_prefix (&exec_prefix, md_exec_prefix, 0, 0, NULL_PTR);
add_prefix (&startfile_prefix, md_exec_prefix, 0, 0, NULL_PTR);
#endif
#ifdef MD_STARTFILE_PREFIX
add_prefix (&startfile_prefix, md_startfile_prefix, 0, 0, 0);
add_prefix (&startfile_prefix, md_startfile_prefix, 0, 0, NULL_PTR);
#endif
#ifdef MD_STARTFILE_PREFIX_1
add_prefix (&startfile_prefix, md_startfile_prefix_1, 0, 0, 0);
add_prefix (&startfile_prefix, md_startfile_prefix_1, 0, 0, NULL_PTR);
#endif
add_prefix (&startfile_prefix, standard_startfile_prefix, 0, 0, 0);
add_prefix (&startfile_prefix, standard_startfile_prefix_1, 0, 0, 0);
add_prefix (&startfile_prefix, standard_startfile_prefix_2, 0, 0, 0);
add_prefix (&startfile_prefix, standard_startfile_prefix, 0, 0,
NULL_PTR);
add_prefix (&startfile_prefix, standard_startfile_prefix_1, 0, 0,
NULL_PTR);
add_prefix (&startfile_prefix, standard_startfile_prefix_2, 0, 0,
NULL_PTR);
#if 0 /* Can cause surprises, and one can use -B./ instead. */
add_prefix (&startfile_prefix, "./", 0, 1, 0);
add_prefix (&startfile_prefix, "./", 0, 1, NULL_PTR);
#endif
}
......@@ -3315,7 +3326,7 @@ lookup_compiler (name, length, language)
language = cp->spec + 1;
new = (struct compiler *) xmalloc (sizeof (struct compiler));
new->suffix = cp->suffix;
new->spec = lookup_compiler (0, 0, language)->spec;
new->spec = lookup_compiler (NULL_PTR, 0, language)->spec;
return new;
}
/* A non-alias entry: return it. */
......
gcc/print-tree.c
......@@ -79,8 +79,8 @@ print_node_brief (file, prefix, node, indent)
name if any. */
if (indent > 0)
fprintf (file, " ");
fprintf (file, "%s <%s %x", prefix,
tree_code_name[(int) TREE_CODE (node)], (int) node);
fprintf (file, "%s <%s ", prefix, tree_code_name[(int) TREE_CODE (node)]);
fprintf (file, HOST_PTR_PRINTF, node);
if (class == 'd')
{
......@@ -110,9 +110,21 @@ print_node_brief (file, prefix, node, indent)
&& TREE_INT_CST_LOW (node) != 0)
fprintf (file, " -%1u", -TREE_INT_CST_LOW (node));
else
fprintf (file, " 0x%x%08x",
TREE_INT_CST_HIGH (node),
TREE_INT_CST_LOW (node));
fprintf (file,
#if HOST_BITS_PER_WIDE_INT == 64
#if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
" 0x%lx%016lx",
#else
" 0x%x%016x",
#endif
#else
#if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
" 0x%lx%08lx",
#else
" 0x%x%08x",
#endif
#endif
TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
}
if (TREE_CODE (node) == REAL_CST)
{
......@@ -213,8 +225,8 @@ print_node (file, prefix, node, indent)
indent_to (file, indent);
/* Print the slot this node is in, and its code, and address. */
fprintf (file, "%s <%s %x", prefix,
tree_code_name[(int) TREE_CODE (node)], (int) node);
fprintf (file, "%s <%s ", prefix, tree_code_name[(int) TREE_CODE (node)]);
fprintf (file, HOST_PTR_PRINTF, node);
/* Print the name, if any. */
if (class == 'd')
......@@ -374,7 +386,10 @@ print_node (file, prefix, node, indent)
print_rtl (file, DECL_INCOMING_RTL (node));
}
else if (TREE_CODE (node) == FUNCTION_DECL)
fprintf (file, "saved-insns 0x%x", DECL_SAVED_INSNS (node));
{
fprintf (file, "saved-insns ");
fprintf (file, HOST_PTR_PRINTF, DECL_SAVED_INSNS (node));
}
}
/* Print the decl chain only if decl is at second level. */
......@@ -525,9 +540,21 @@ print_node (file, prefix, node, indent)
&& TREE_INT_CST_LOW (node) != 0)
fprintf (file, " -%1u", -TREE_INT_CST_LOW (node));
else
fprintf (file, " 0x%x%08x",
TREE_INT_CST_HIGH (node),
TREE_INT_CST_LOW (node));
fprintf (file,
#if HOST_BITS_PER_WIDE_INT == 64
#if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
" 0x%lx%016lx",
#else
" 0x%x%016x",
#endif
#else
#if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
" 0x%lx%08lx",
#else
" 0x%x%08x",
#endif
#endif
TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
break;
case REAL_CST:
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment