git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

2012-06-2 Kenneth Zadeck <zadeck@naturalbridge.com> 

* expmed.c (expand_mult, choose_multiplier): Change "2 *
	HOST_BITS_PER_WIDE_INT" to "HOST_BITS_PER_DOUBLE_INT".
	* expr.c (convert_modes): Likewise.
	* explow.c (plus_constant): Likewise.
	* fixed-value.c (fixed_saturate1, fixed_saturate2)
	(do_fixed_add, do_fixed_multiply, do_fixed_multiply)
	(do_fixed_multiply, do_fixed_multiply, do_fixed_divide)
	(do_fixed_divide, do_fixed_divide, do_fixed_divide)
	(do_fixed_divide, do_fixed_divide, do_fixed_shift, do_fixed_shift)
	(do_fixed_shift, fixed_convert, fixed_convert)
	(fixed_convert_from_int, fixed_convert_from_int)
	(fixed_convert_from_real): Likewise.
	* fold-const.c (fold_convert_const_int_from_fixed, sign_bit_p)
	(native_interpret_int, fold_binary_loc, fold_ternary_loc): Likewise.
	* varasm.c (output_constructor_bitfield): Likewise.
	* tree-vrp.c (register_edge_assert_for_2): Likewise.
	* double-int.c (rshift_double, lshift_double): Likewise.
	* double-int.h (double_int_fits_in_uhwi_p, double_int, double_int): Likewise.
	* simplify-rtx.c (mode_signbit_p)
	(simplify_const_unary_operation, simplify_binary_operation_1)
	(simplify_immed_subreg): Likewise.
	* builtins.c (c_readstr, fold_builtin_bitop): Likewise.
	* tree-vect-generic.c (build_replicated_const): Likewise.
	* dbxout.c (stabstr_O): Likewise.
	* emit-rtl.c (immed_double_int_const, immed_double_const)
	(gen_lowpart_common, init_emit_once): Likewise.
	* tree.c (integer_pow2p, tree_log2, tree_floor_log2)
	(widest_int_cst_value, upper_bound_in_type): Likewise.
	* stor-layout.c (initialize_sizetypes, fixup_signed_type)
	(fixup_unsigned_type): Likewise.
	* real.c (real_to_integer2, real_from_integer): Likewise.
	* dwarf2out.c (size_of_loc_descr, size_of_die, output_die)
	(clz_loc_descriptor, mem_loc_descriptor): Likewise.

From-SVN: r188139
This commit is contained in:
Kenneth Zadeck 2012-06-02 16:08:39 +00:00 committed by Kenneth Zadeck
parent e3c888eb0e
commit 49ab6098ee
19 changed files with 130 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
gcc/ChangeLog
View File

@ -1,3 +1,39 @@
2012-06-2 Kenneth Zadeck <zadeck@naturalbridge.com>
* expmed.c (expand_mult, choose_multiplier): Change "2 *
HOST_BITS_PER_WIDE_INT" to "HOST_BITS_PER_DOUBLE_INT".
* expr.c (convert_modes): Likewise.
* explow.c (plus_constant): Likewise.
* fixed-value.c (fixed_saturate1, fixed_saturate2)
(do_fixed_add, do_fixed_multiply, do_fixed_multiply)
(do_fixed_multiply, do_fixed_multiply, do_fixed_divide)
(do_fixed_divide, do_fixed_divide, do_fixed_divide)
(do_fixed_divide, do_fixed_divide, do_fixed_shift, do_fixed_shift)
(do_fixed_shift, fixed_convert, fixed_convert)
(fixed_convert_from_int, fixed_convert_from_int)
(fixed_convert_from_real): Likewise.
* fold-const.c (fold_convert_const_int_from_fixed, sign_bit_p)
(native_interpret_int, fold_binary_loc, fold_ternary_loc): Likewise.
* varasm.c (output_constructor_bitfield): Likewise.
* tree-vrp.c (register_edge_assert_for_2): Likewise.
* double-int.c (rshift_double, lshift_double): Likewise.
* double-int.h (double_int_fits_in_uhwi_p, double_int, double_int): Likewise.
* simplify-rtx.c (mode_signbit_p)
(simplify_const_unary_operation, simplify_binary_operation_1)
(simplify_immed_subreg): Likewise.
* builtins.c (c_readstr, fold_builtin_bitop): Likewise.
* tree-vect-generic.c (build_replicated_const): Likewise.
* dbxout.c (stabstr_O): Likewise.
* emit-rtl.c (immed_double_int_const, immed_double_const)
(gen_lowpart_common, init_emit_once): Likewise.
* tree.c (integer_pow2p, tree_log2, tree_floor_log2)
(widest_int_cst_value, upper_bound_in_type): Likewise.
* stor-layout.c (initialize_sizetypes, fixup_signed_type)
(fixup_unsigned_type): Likewise.
* real.c (real_to_integer2, real_from_integer): Likewise.
* dwarf2out.c (size_of_loc_descr, size_of_die, output_die)
(clz_loc_descriptor, mem_loc_descriptor): Likewise.
2012-06-01 Eric Botcazou <ebotcazou@adacore.com> 2012-06-01 Eric Botcazou <ebotcazou@adacore.com>
PR middle-end/53501 PR middle-end/53501

4
gcc/builtins.c
View File

@ -713,7 +713,7 @@ c_readstr (const char *str, enum machine_mode mode)
&& GET_MODE_SIZE (mode) >= UNITS_PER_WORD) && GET_MODE_SIZE (mode) >= UNITS_PER_WORD)
j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1; j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
j *= BITS_PER_UNIT; j *= BITS_PER_UNIT;
gcc_assert (j < 2 * HOST_BITS_PER_WIDE_INT); gcc_assert (j < HOST_BITS_PER_DOUBLE_INT);
if (ch) if (ch)
ch = (unsigned char) str[i]; ch = (unsigned char) str[i];
@ -8143,7 +8143,7 @@ fold_builtin_bitop (tree fndecl, tree arg)
if (width > HOST_BITS_PER_WIDE_INT) if (width > HOST_BITS_PER_WIDE_INT)
{ {
hi = TREE_INT_CST_HIGH (arg); hi = TREE_INT_CST_HIGH (arg);
if (width < 2 * HOST_BITS_PER_WIDE_INT) if (width < HOST_BITS_PER_DOUBLE_INT)
hi &= ~((unsigned HOST_WIDE_INT) (-1) hi &= ~((unsigned HOST_WIDE_INT) (-1)
<< (width - HOST_BITS_PER_WIDE_INT)); << (width - HOST_BITS_PER_WIDE_INT));
} }

2
gcc/dbxout.c
View File

@ -703,7 +703,7 @@ stabstr_O (tree cst)
present. */ present. */
{ {
const unsigned int width = TYPE_PRECISION (TREE_TYPE (cst)); const unsigned int width = TYPE_PRECISION (TREE_TYPE (cst));
if (width == HOST_BITS_PER_WIDE_INT * 2) if (width == HOST_BITS_PER_DOUBLE_INT)
; ;
else if (width > HOST_BITS_PER_WIDE_INT) else if (width > HOST_BITS_PER_WIDE_INT)
high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1); high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);

8
gcc/double-int.c
View File

@ -206,7 +206,7 @@ rshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
if (SHIFT_COUNT_TRUNCATED) if (SHIFT_COUNT_TRUNCATED)
count %= prec; count %= prec;
if (count >= 2 * HOST_BITS_PER_WIDE_INT) if (count >= HOST_BITS_PER_DOUBLE_INT)
{ {
/* Shifting by the host word size is undefined according to the /* Shifting by the host word size is undefined according to the
ANSI standard, so we must handle this as a special case. */ ANSI standard, so we must handle this as a special case. */
@ -233,7 +233,7 @@ rshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
*hv = signmask; *hv = signmask;
*lv = signmask; *lv = signmask;
} }
else if ((prec - count) >= 2 * HOST_BITS_PER_WIDE_INT) else if ((prec - count) >= HOST_BITS_PER_DOUBLE_INT)
; ;
else if ((prec - count) >= HOST_BITS_PER_WIDE_INT) else if ((prec - count) >= HOST_BITS_PER_WIDE_INT)
{ {
@ -270,7 +270,7 @@ lshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
if (SHIFT_COUNT_TRUNCATED) if (SHIFT_COUNT_TRUNCATED)
count %= prec; count %= prec;
if (count >= 2 * HOST_BITS_PER_WIDE_INT) if (count >= HOST_BITS_PER_DOUBLE_INT)
{ {
/* Shifting by the host word size is undefined according to the /* Shifting by the host word size is undefined according to the
ANSI standard, so we must handle this as a special case. */ ANSI standard, so we must handle this as a special case. */
@ -296,7 +296,7 @@ lshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
>> (prec - HOST_BITS_PER_WIDE_INT - 1)) >> (prec - HOST_BITS_PER_WIDE_INT - 1))
: (*lv >> (prec - 1))) & 1); : (*lv >> (prec - 1))) & 1);
if (prec >= 2 * HOST_BITS_PER_WIDE_INT) if (prec >= HOST_BITS_PER_DOUBLE_INT)
; ;
else if (prec >= HOST_BITS_PER_WIDE_INT) else if (prec >= HOST_BITS_PER_WIDE_INT)
{ {

6
gcc/double-int.h
View File

@ -129,7 +129,7 @@ double_int_fits_in_uhwi_p (double_int cst)
/* The following operations perform arithmetics modulo 2^precision, /* The following operations perform arithmetics modulo 2^precision,
so you do not need to call double_int_ext between them, even if so you do not need to call double_int_ext between them, even if
you are representing numbers with precision less than you are representing numbers with precision less than
2 * HOST_BITS_PER_WIDE_INT bits. */ HOST_BITS_PER_DOUBLE_INT bits. */
double_int double_int_mul (double_int, double_int); double_int double_int_mul (double_int, double_int);
double_int double_int_mul_with_sign (double_int, double_int, bool, int *); double_int double_int_mul_with_sign (double_int, double_int, bool, int *);
@ -139,7 +139,7 @@ double_int double_int_neg (double_int);
/* You must ensure that double_int_ext is called on the operands /* You must ensure that double_int_ext is called on the operands
of the following operations, if the precision of the numbers of the following operations, if the precision of the numbers
is less than 2 * HOST_BITS_PER_WIDE_INT bits. */ is less than HOST_BITS_PER_DOUBLE_INT bits. */
double_int double_int_div (double_int, double_int, bool, unsigned); double_int double_int_div (double_int, double_int, bool, unsigned);
double_int double_int_sdiv (double_int, double_int, unsigned); double_int double_int_sdiv (double_int, double_int, unsigned);
double_int double_int_udiv (double_int, double_int, unsigned); double_int double_int_udiv (double_int, double_int, unsigned);
@ -249,7 +249,7 @@ double_int double_int_min_value (unsigned int, bool);
/* The operands of the following comparison functions must be processed /* The operands of the following comparison functions must be processed
with double_int_ext, if their precision is less than with double_int_ext, if their precision is less than
2 * HOST_BITS_PER_WIDE_INT bits. */ HOST_BITS_PER_DOUBLE_INT bits. */
/* Returns true if CST is zero. */ /* Returns true if CST is zero. */

12
gcc/dwarf2out.c
View File

@ -1578,7 +1578,7 @@ size_of_loc_descr (dw_loc_descr_ref loc)
size += HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT; size += HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT;
break; break;
case dw_val_class_const_double: case dw_val_class_const_double:
size += 2 * HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT; size += HOST_BITS_PER_DOUBLE_INT / BITS_PER_UNIT;
break; break;
default: default:
gcc_unreachable (); gcc_unreachable ();
@ -7133,7 +7133,7 @@ size_of_die (dw_die_ref die)
} }
break; break;
case dw_val_class_const_double: case dw_val_class_const_double:
size += 2 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; size += HOST_BITS_PER_DOUBLE_INT / HOST_BITS_PER_CHAR;
if (HOST_BITS_PER_WIDE_INT >= 64) if (HOST_BITS_PER_WIDE_INT >= 64)
size++; /* block */ size++; /* block */
break; break;
@ -7772,7 +7772,7 @@ output_die (dw_die_ref die)
if (HOST_BITS_PER_WIDE_INT >= 64) if (HOST_BITS_PER_WIDE_INT >= 64)
dw2_asm_output_data (1, dw2_asm_output_data (1,
2 * HOST_BITS_PER_WIDE_INT HOST_BITS_PER_DOUBLE_INT
/ HOST_BITS_PER_CHAR, / HOST_BITS_PER_CHAR,
NULL); NULL);
@ -10629,7 +10629,7 @@ clz_loc_descriptor (rtx rtl, enum machine_mode mode,
if (GET_MODE_CLASS (mode) != MODE_INT if (GET_MODE_CLASS (mode) != MODE_INT
|| GET_MODE (XEXP (rtl, 0)) != mode || GET_MODE (XEXP (rtl, 0)) != mode
|| (GET_CODE (rtl) == CLZ || (GET_CODE (rtl) == CLZ
&& GET_MODE_BITSIZE (mode) > 2 * HOST_BITS_PER_WIDE_INT)) && GET_MODE_BITSIZE (mode) > HOST_BITS_PER_DOUBLE_INT))
return NULL; return NULL;
op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
@ -11545,7 +11545,7 @@ mem_loc_descriptor (rtx rtl, enum machine_mode mode,
} }
if (!dwarf_strict if (!dwarf_strict
&& (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT && (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT
|| GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT)) || GET_MODE_BITSIZE (mode) == HOST_BITS_PER_DOUBLE_INT))
{ {
dw_die_ref type_die = base_type_for_mode (mode, 1); dw_die_ref type_die = base_type_for_mode (mode, 1);
enum machine_mode amode; enum machine_mode amode;
@ -11597,7 +11597,7 @@ mem_loc_descriptor (rtx rtl, enum machine_mode mode,
adequately represented. We output CONST_DOUBLEs as blocks. */ adequately represented. We output CONST_DOUBLEs as blocks. */
if (mode == VOIDmode if (mode == VOIDmode
|| (GET_MODE (rtl) == VOIDmode || (GET_MODE (rtl) == VOIDmode
&& GET_MODE_BITSIZE (mode) != 2 * HOST_BITS_PER_WIDE_INT)) && GET_MODE_BITSIZE (mode) != HOST_BITS_PER_DOUBLE_INT))
break; break;
type_die = base_type_for_mode (mode, type_die = base_type_for_mode (mode,
GET_MODE_CLASS (mode) == MODE_INT); GET_MODE_CLASS (mode) == MODE_INT);

10
gcc/emit-rtl.c
View File

@ -517,7 +517,7 @@ immed_double_int_const (double_int i, enum machine_mode mode)
/* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair
of ints: I0 is the low-order word and I1 is the high-order word. of ints: I0 is the low-order word and I1 is the high-order word.
For values that are larger than 2*HOST_BITS_PER_WIDE_INT, the For values that are larger than HOST_BITS_PER_DOUBLE_INT, the
implied upper bits are copies of the high bit of i1. The value implied upper bits are copies of the high bit of i1. The value
itself is neither signed nor unsigned. Do not use this routine for itself is neither signed nor unsigned. Do not use this routine for
non-integer modes; convert to REAL_VALUE_TYPE and use non-integer modes; convert to REAL_VALUE_TYPE and use
@ -530,7 +530,7 @@ immed_double_const (HOST_WIDE_INT i0, HOST_WIDE_INT i1, enum machine_mode mode)
unsigned int i; unsigned int i;
/* There are the following cases (note that there are no modes with /* There are the following cases (note that there are no modes with
HOST_BITS_PER_WIDE_INT < GET_MODE_BITSIZE (mode) < 2 * HOST_BITS_PER_WIDE_INT): HOST_BITS_PER_WIDE_INT < GET_MODE_BITSIZE (mode) < HOST_BITS_PER_DOUBLE_INT):
1) If GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT, then we use 1) If GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT, then we use
gen_int_mode. gen_int_mode.
@ -1206,7 +1206,7 @@ gen_lowpart_common (enum machine_mode mode, rtx x)
&& msize * BITS_PER_UNIT <= HOST_BITS_PER_WIDE_INT) && msize * BITS_PER_UNIT <= HOST_BITS_PER_WIDE_INT)
innermode = mode_for_size (HOST_BITS_PER_WIDE_INT, MODE_INT, 0); innermode = mode_for_size (HOST_BITS_PER_WIDE_INT, MODE_INT, 0);
else if (innermode == VOIDmode) else if (innermode == VOIDmode)
innermode = mode_for_size (HOST_BITS_PER_WIDE_INT * 2, MODE_INT, 0); innermode = mode_for_size (HOST_BITS_PER_DOUBLE_INT, MODE_INT, 0);
xsize = GET_MODE_SIZE (innermode); xsize = GET_MODE_SIZE (innermode);
@ -5787,7 +5787,7 @@ init_emit_once (void)
FCONST1(mode).data.low = 0; FCONST1(mode).data.low = 0;
FCONST1(mode).mode = mode; FCONST1(mode).mode = mode;
lshift_double (1, 0, GET_MODE_FBIT (mode), lshift_double (1, 0, GET_MODE_FBIT (mode),
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&FCONST1(mode).data.low, &FCONST1(mode).data.low,
&FCONST1(mode).data.high, &FCONST1(mode).data.high,
SIGNED_FIXED_POINT_MODE_P (mode)); SIGNED_FIXED_POINT_MODE_P (mode));
@ -5810,7 +5810,7 @@ init_emit_once (void)
FCONST1(mode).data.low = 0; FCONST1(mode).data.low = 0;
FCONST1(mode).mode = mode; FCONST1(mode).mode = mode;
lshift_double (1, 0, GET_MODE_FBIT (mode), lshift_double (1, 0, GET_MODE_FBIT (mode),
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&FCONST1(mode).data.low, &FCONST1(mode).data.low,
&FCONST1(mode).data.high, &FCONST1(mode).data.high,
SIGNED_FIXED_POINT_MODE_P (mode)); SIGNED_FIXED_POINT_MODE_P (mode));

2
gcc/explow.c
View File

@ -127,7 +127,7 @@ plus_constant (enum machine_mode mode, rtx x, HOST_WIDE_INT c)
if (add_double_with_sign (l1, h1, l2, h2, &lv, &hv, false)) if (add_double_with_sign (l1, h1, l2, h2, &lv, &hv, false))
/* Sorry, we have no way to represent overflows this wide. /* Sorry, we have no way to represent overflows this wide.
To fix, add constant support wider than CONST_DOUBLE. */ To fix, add constant support wider than CONST_DOUBLE. */
gcc_assert (GET_MODE_BITSIZE (mode) <= 2 * HOST_BITS_PER_WIDE_INT); gcc_assert (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_DOUBLE_INT);
return immed_double_const (lv, hv, VOIDmode); return immed_double_const (lv, hv, VOIDmode);
} }

6
gcc/expmed.c
View File

@ -3155,8 +3155,8 @@ expand_mult (enum machine_mode mode, rtx op0, rtx op1, rtx target,
{ {
int shift = floor_log2 (CONST_DOUBLE_HIGH (op1)) int shift = floor_log2 (CONST_DOUBLE_HIGH (op1))
+ HOST_BITS_PER_WIDE_INT; + HOST_BITS_PER_WIDE_INT;
if (shift < 2 * HOST_BITS_PER_WIDE_INT - 1 if (shift < HOST_BITS_PER_DOUBLE_INT - 1
|| GET_MODE_BITSIZE (mode) <= 2 * HOST_BITS_PER_WIDE_INT) || GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_DOUBLE_INT)
return expand_shift (LSHIFT_EXPR, mode, op0, return expand_shift (LSHIFT_EXPR, mode, op0,
shift, target, unsignedp); shift, target, unsignedp);
} }
@ -3316,7 +3316,7 @@ choose_multiplier (unsigned HOST_WIDE_INT d, int n, int precision,
/* We could handle this with some effort, but this case is much /* We could handle this with some effort, but this case is much
better handled directly with a scc insn, so rely on caller using better handled directly with a scc insn, so rely on caller using
that. */ that. */
gcc_assert (pow != 2 * HOST_BITS_PER_WIDE_INT); gcc_assert (pow != HOST_BITS_PER_DOUBLE_INT);
/* mlow = 2^(N + lgup)/d */ /* mlow = 2^(N + lgup)/d */
if (pow >= HOST_BITS_PER_WIDE_INT) if (pow >= HOST_BITS_PER_WIDE_INT)

2
gcc/expr.c
View File

@ -723,7 +723,7 @@ convert_modes (enum machine_mode mode, enum machine_mode oldmode, rtx x, int uns
make the high-order word of the constant zero, not all ones. */ make the high-order word of the constant zero, not all ones. */
if (unsignedp && GET_MODE_CLASS (mode) == MODE_INT if (unsignedp && GET_MODE_CLASS (mode) == MODE_INT
&& GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT && GET_MODE_BITSIZE (mode) == HOST_BITS_PER_DOUBLE_INT
&& CONST_INT_P (x) && INTVAL (x) < 0) && CONST_INT_P (x) && INTVAL (x) < 0)
{ {
double_int val = uhwi_to_double_int (INTVAL (x)); double_int val = uhwi_to_double_int (INTVAL (x));

64
gcc/fixed-value.c
View File

@ -177,7 +177,7 @@ fixed_saturate1 (enum machine_mode mode, double_int a, double_int *f,
min.high = 0; min.high = 0;
min.low = 1; min.low = 1;
lshift_double (min.low, min.high, i_f_bits, lshift_double (min.low, min.high, i_f_bits,
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&min.low, &min.high, 1); &min.low, &min.high, 1);
min = double_int_ext (min, 1 + i_f_bits, 0); min = double_int_ext (min, 1 + i_f_bits, 0);
if (double_int_cmp (a, max, 0) == 1) if (double_int_cmp (a, max, 0) == 1)
@ -245,7 +245,7 @@ fixed_saturate2 (enum machine_mode mode, double_int a_high, double_int a_low,
min_s.high = 0; min_s.high = 0;
min_s.low = 1; min_s.low = 1;
lshift_double (min_s.low, min_s.high, i_f_bits, lshift_double (min_s.low, min_s.high, i_f_bits,
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&min_s.low, &min_s.high, 1); &min_s.low, &min_s.high, 1);
min_s = double_int_ext (min_s, 1 + i_f_bits, 0); min_s = double_int_ext (min_s, 1 + i_f_bits, 0);
if (double_int_cmp (a_high, max_r, 0) == 1 if (double_int_cmp (a_high, max_r, 0) == 1
@ -354,7 +354,7 @@ do_fixed_add (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a,
f->data.low = 1; f->data.low = 1;
f->data.high = 0; f->data.high = 0;
lshift_double (f->data.low, f->data.high, i_f_bits, lshift_double (f->data.low, f->data.high, i_f_bits,
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&f->data.low, &f->data.high, 1); &f->data.low, &f->data.high, 1);
if (get_fixed_sign_bit (a->data, i_f_bits) == 0) if (get_fixed_sign_bit (a->data, i_f_bits) == 0)
{ {
@ -389,7 +389,7 @@ do_fixed_multiply (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a,
f->data = double_int_mul (a->data, b->data); f->data = double_int_mul (a->data, b->data);
lshift_double (f->data.low, f->data.high, lshift_double (f->data.low, f->data.high,
(-GET_MODE_FBIT (f->mode)), (-GET_MODE_FBIT (f->mode)),
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&f->data.low, &f->data.high, !unsigned_p); &f->data.low, &f->data.high, !unsigned_p);
overflow_p = fixed_saturate1 (f->mode, f->data, &f->data, sat_p); overflow_p = fixed_saturate1 (f->mode, f->data, &f->data, sat_p);
} }
@ -451,7 +451,7 @@ do_fixed_multiply (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a,
r = double_int_sub (r, a->data); r = double_int_sub (r, a->data);
/* Shift right the result by FBIT. */ /* Shift right the result by FBIT. */
if (GET_MODE_FBIT (f->mode) == 2 * HOST_BITS_PER_WIDE_INT) if (GET_MODE_FBIT (f->mode) == HOST_BITS_PER_DOUBLE_INT)
{ {
s.low = r.low; s.low = r.low;
s.high = r.high; s.high = r.high;
@ -472,12 +472,12 @@ do_fixed_multiply (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a,
{ {
lshift_double (s.low, s.high, lshift_double (s.low, s.high,
(-GET_MODE_FBIT (f->mode)), (-GET_MODE_FBIT (f->mode)),
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&s.low, &s.high, 0); &s.low, &s.high, 0);
lshift_double (r.low, r.high, lshift_double (r.low, r.high,
(2 * HOST_BITS_PER_WIDE_INT (HOST_BITS_PER_DOUBLE_INT
- GET_MODE_FBIT (f->mode)), - GET_MODE_FBIT (f->mode)),
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&f->data.low, &f->data.high, 0); &f->data.low, &f->data.high, 0);
f->data.low = f->data.low | s.low; f->data.low = f->data.low | s.low;
f->data.high = f->data.high | s.high; f->data.high = f->data.high | s.high;
@ -485,7 +485,7 @@ do_fixed_multiply (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a,
s.high = f->data.high; s.high = f->data.high;
lshift_double (r.low, r.high, lshift_double (r.low, r.high,
(-GET_MODE_FBIT (f->mode)), (-GET_MODE_FBIT (f->mode)),
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&r.low, &r.high, !unsigned_p); &r.low, &r.high, !unsigned_p);
} }
@ -512,7 +512,7 @@ do_fixed_divide (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a,
{ {
lshift_double (a->data.low, a->data.high, lshift_double (a->data.low, a->data.high,
GET_MODE_FBIT (f->mode), GET_MODE_FBIT (f->mode),
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&f->data.low, &f->data.high, !unsigned_p); &f->data.low, &f->data.high, !unsigned_p);
f->data = double_int_div (f->data, b->data, unsigned_p, TRUNC_DIV_EXPR); f->data = double_int_div (f->data, b->data, unsigned_p, TRUNC_DIV_EXPR);
overflow_p = fixed_saturate1 (f->mode, f->data, &f->data, sat_p); overflow_p = fixed_saturate1 (f->mode, f->data, &f->data, sat_p);
@ -543,7 +543,7 @@ do_fixed_divide (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a,
pos_b = b->data; pos_b = b->data;
/* Left shift pos_a to {r, s} by FBIT. */ /* Left shift pos_a to {r, s} by FBIT. */
if (GET_MODE_FBIT (f->mode) == 2 * HOST_BITS_PER_WIDE_INT) if (GET_MODE_FBIT (f->mode) == HOST_BITS_PER_DOUBLE_INT)
{ {
r = pos_a; r = pos_a;
s.high = 0; s.high = 0;
@ -553,12 +553,12 @@ do_fixed_divide (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a,
{ {
lshift_double (pos_a.low, pos_a.high, lshift_double (pos_a.low, pos_a.high,
GET_MODE_FBIT (f->mode), GET_MODE_FBIT (f->mode),
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&s.low, &s.high, 0); &s.low, &s.high, 0);
lshift_double (pos_a.low, pos_a.high, lshift_double (pos_a.low, pos_a.high,
- (2 * HOST_BITS_PER_WIDE_INT - (HOST_BITS_PER_DOUBLE_INT
- GET_MODE_FBIT (f->mode)), - GET_MODE_FBIT (f->mode)),
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&r.low, &r.high, 0); &r.low, &r.high, 0);
} }
@ -570,13 +570,13 @@ do_fixed_divide (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a,
quo_s.high = 0; quo_s.high = 0;
quo_s.low = 0; quo_s.low = 0;
for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; i++) for (i = 0; i < HOST_BITS_PER_DOUBLE_INT; i++)
{ {
/* Record the leftmost bit of mod. */ /* Record the leftmost bit of mod. */
int leftmost_mod = (mod.high < 0); int leftmost_mod = (mod.high < 0);
/* Shift left mod by 1 bit. */ /* Shift left mod by 1 bit. */
lshift_double (mod.low, mod.high, 1, 2 * HOST_BITS_PER_WIDE_INT, lshift_double (mod.low, mod.high, 1, HOST_BITS_PER_DOUBLE_INT,
&mod.low, &mod.high, 0); &mod.low, &mod.high, 0);
/* Test the leftmost bit of s to add to mod. */ /* Test the leftmost bit of s to add to mod. */
@ -584,7 +584,7 @@ do_fixed_divide (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a,
mod.low += 1; mod.low += 1;
/* Shift left quo_s by 1 bit. */ /* Shift left quo_s by 1 bit. */
lshift_double (quo_s.low, quo_s.high, 1, 2 * HOST_BITS_PER_WIDE_INT, lshift_double (quo_s.low, quo_s.high, 1, HOST_BITS_PER_DOUBLE_INT,
&quo_s.low, &quo_s.high, 0); &quo_s.low, &quo_s.high, 0);
/* Try to calculate (mod - pos_b). */ /* Try to calculate (mod - pos_b). */
@ -597,7 +597,7 @@ do_fixed_divide (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a,
} }
/* Shift left s by 1 bit. */ /* Shift left s by 1 bit. */
lshift_double (s.low, s.high, 1, 2 * HOST_BITS_PER_WIDE_INT, lshift_double (s.low, s.high, 1, HOST_BITS_PER_DOUBLE_INT,
&s.low, &s.high, 0); &s.low, &s.high, 0);
} }
@ -645,7 +645,7 @@ do_fixed_shift (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a,
{ {
lshift_double (a->data.low, a->data.high, lshift_double (a->data.low, a->data.high,
left_p ? b->data.low : (-b->data.low), left_p ? b->data.low : (-b->data.low),
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&f->data.low, &f->data.high, !unsigned_p); &f->data.low, &f->data.high, !unsigned_p);
if (left_p) /* Only left shift saturates. */ if (left_p) /* Only left shift saturates. */
overflow_p = fixed_saturate1 (f->mode, f->data, &f->data, sat_p); overflow_p = fixed_saturate1 (f->mode, f->data, &f->data, sat_p);
@ -653,7 +653,7 @@ do_fixed_shift (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a,
else /* We need two double_int to store the left-shift result. */ else /* We need two double_int to store the left-shift result. */
{ {
double_int temp_high, temp_low; double_int temp_high, temp_low;
if (b->data.low == 2 * HOST_BITS_PER_WIDE_INT) if (b->data.low == HOST_BITS_PER_DOUBLE_INT)
{ {
temp_high = a->data; temp_high = a->data;
temp_low.high = 0; temp_low.high = 0;
@ -663,12 +663,12 @@ do_fixed_shift (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a,
{ {
lshift_double (a->data.low, a->data.high, lshift_double (a->data.low, a->data.high,
b->data.low, b->data.low,
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&temp_low.low, &temp_low.high, !unsigned_p); &temp_low.low, &temp_low.high, !unsigned_p);
/* Logical shift right to temp_high. */ /* Logical shift right to temp_high. */
lshift_double (a->data.low, a->data.high, lshift_double (a->data.low, a->data.high,
b->data.low - 2 * HOST_BITS_PER_WIDE_INT, b->data.low - HOST_BITS_PER_DOUBLE_INT,
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&temp_high.low, &temp_high.high, 0); &temp_high.low, &temp_high.high, 0);
} }
if (!unsigned_p && a->data.high < 0) /* Signed-extend temp_high. */ if (!unsigned_p && a->data.high < 0) /* Signed-extend temp_high. */
@ -837,13 +837,13 @@ fixed_convert (FIXED_VALUE_TYPE *f, enum machine_mode mode,
int amount = GET_MODE_FBIT (mode) - GET_MODE_FBIT (a->mode); int amount = GET_MODE_FBIT (mode) - GET_MODE_FBIT (a->mode);
lshift_double (a->data.low, a->data.high, lshift_double (a->data.low, a->data.high,
amount, amount,
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&temp_low.low, &temp_low.high, &temp_low.low, &temp_low.high,
SIGNED_FIXED_POINT_MODE_P (a->mode)); SIGNED_FIXED_POINT_MODE_P (a->mode));
/* Logical shift right to temp_high. */ /* Logical shift right to temp_high. */
lshift_double (a->data.low, a->data.high, lshift_double (a->data.low, a->data.high,
amount - 2 * HOST_BITS_PER_WIDE_INT, amount - HOST_BITS_PER_DOUBLE_INT,
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&temp_high.low, &temp_high.high, 0); &temp_high.low, &temp_high.high, 0);
if (SIGNED_FIXED_POINT_MODE_P (a->mode) if (SIGNED_FIXED_POINT_MODE_P (a->mode)
&& a->data.high < 0) /* Signed-extend temp_high. */ && a->data.high < 0) /* Signed-extend temp_high. */
@ -905,7 +905,7 @@ fixed_convert (FIXED_VALUE_TYPE *f, enum machine_mode mode,
double_int temp; double_int temp;
lshift_double (a->data.low, a->data.high, lshift_double (a->data.low, a->data.high,
GET_MODE_FBIT (mode) - GET_MODE_FBIT (a->mode), GET_MODE_FBIT (mode) - GET_MODE_FBIT (a->mode),
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&temp.low, &temp.high, &temp.low, &temp.high,
SIGNED_FIXED_POINT_MODE_P (a->mode)); SIGNED_FIXED_POINT_MODE_P (a->mode));
f->mode = mode; f->mode = mode;
@ -980,7 +980,7 @@ fixed_convert_from_int (FIXED_VALUE_TYPE *f, enum machine_mode mode,
/* Left shift a to temp_high, temp_low. */ /* Left shift a to temp_high, temp_low. */
double_int temp_high, temp_low; double_int temp_high, temp_low;
int amount = GET_MODE_FBIT (mode); int amount = GET_MODE_FBIT (mode);
if (amount == 2 * HOST_BITS_PER_WIDE_INT) if (amount == HOST_BITS_PER_DOUBLE_INT)
{ {
temp_high = a; temp_high = a;
temp_low.low = 0; temp_low.low = 0;
@ -990,13 +990,13 @@ fixed_convert_from_int (FIXED_VALUE_TYPE *f, enum machine_mode mode,
{ {
lshift_double (a.low, a.high, lshift_double (a.low, a.high,
amount, amount,
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&temp_low.low, &temp_low.high, 0); &temp_low.low, &temp_low.high, 0);
/* Logical shift right to temp_high. */ /* Logical shift right to temp_high. */
lshift_double (a.low, a.high, lshift_double (a.low, a.high,
amount - 2 * HOST_BITS_PER_WIDE_INT, amount - HOST_BITS_PER_DOUBLE_INT,
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&temp_high.low, &temp_high.high, 0); &temp_high.low, &temp_high.high, 0);
} }
if (!unsigned_p && a.high < 0) /* Signed-extend temp_high. */ if (!unsigned_p && a.high < 0) /* Signed-extend temp_high. */
@ -1094,7 +1094,7 @@ fixed_convert_from_real (FIXED_VALUE_TYPE *f, enum machine_mode mode,
f->data.low = 1; f->data.low = 1;
f->data.high = 0; f->data.high = 0;
lshift_double (f->data.low, f->data.high, i_f_bits, lshift_double (f->data.low, f->data.high, i_f_bits,
2 * HOST_BITS_PER_WIDE_INT, HOST_BITS_PER_DOUBLE_INT,
&f->data.low, &f->data.high, 1); &f->data.low, &f->data.high, 1);
f->data = double_int_ext (f->data, 1 + i_f_bits, 0); f->data = double_int_ext (f->data, 1 + i_f_bits, 0);
} }

10
gcc/fold-const.c
View File

@ -1590,7 +1590,7 @@ fold_convert_const_int_from_fixed (tree type, const_tree arg1)
/* Right shift FIXED_CST to temp by fbit. */ /* Right shift FIXED_CST to temp by fbit. */
temp = TREE_FIXED_CST (arg1).data; temp = TREE_FIXED_CST (arg1).data;
mode = TREE_FIXED_CST (arg1).mode; mode = TREE_FIXED_CST (arg1).mode;
if (GET_MODE_FBIT (mode) < 2 * HOST_BITS_PER_WIDE_INT) if (GET_MODE_FBIT (mode) < HOST_BITS_PER_DOUBLE_INT)
{ {
temp = double_int_rshift (temp, GET_MODE_FBIT (mode), temp = double_int_rshift (temp, GET_MODE_FBIT (mode),
HOST_BITS_PER_DOUBLE_INT, HOST_BITS_PER_DOUBLE_INT,
@ -3633,7 +3633,7 @@ sign_bit_p (tree exp, const_tree val)
lo = 0; lo = 0;
mask_hi = ((unsigned HOST_WIDE_INT) -1 mask_hi = ((unsigned HOST_WIDE_INT) -1
>> (2 * HOST_BITS_PER_WIDE_INT - width)); >> (HOST_BITS_PER_DOUBLE_INT - width));
mask_lo = -1; mask_lo = -1;
} }
else else
@ -7379,7 +7379,7 @@ native_interpret_int (tree type, const unsigned char *ptr, int len)
if (total_bytes > len) if (total_bytes > len)
return NULL_TREE; return NULL_TREE;
if (total_bytes * BITS_PER_UNIT > 2 * HOST_BITS_PER_WIDE_INT) if (total_bytes * BITS_PER_UNIT > HOST_BITS_PER_DOUBLE_INT)
return NULL_TREE; return NULL_TREE;
result = double_int_zero; result = double_int_zero;
@ -13291,7 +13291,7 @@ fold_binary_loc (location_t loc,
unsigned int width = TYPE_PRECISION (arg1_type); unsigned int width = TYPE_PRECISION (arg1_type);
if (TREE_CODE (arg1) == INTEGER_CST if (TREE_CODE (arg1) == INTEGER_CST
&& width <= 2 * HOST_BITS_PER_WIDE_INT && width <= HOST_BITS_PER_DOUBLE_INT
&& (INTEGRAL_TYPE_P (arg1_type) || POINTER_TYPE_P (arg1_type))) && (INTEGRAL_TYPE_P (arg1_type) || POINTER_TYPE_P (arg1_type)))
{ {
HOST_WIDE_INT signed_max_hi; HOST_WIDE_INT signed_max_hi;
@ -13891,7 +13891,7 @@ fold_ternary_loc (location_t loc, enum tree_code code, tree type,
if (outer_width > HOST_BITS_PER_WIDE_INT) if (outer_width > HOST_BITS_PER_WIDE_INT)
{ {
mask_hi = ((unsigned HOST_WIDE_INT) -1 mask_hi = ((unsigned HOST_WIDE_INT) -1
>> (2 * HOST_BITS_PER_WIDE_INT - outer_width)); >> (HOST_BITS_PER_DOUBLE_INT - outer_width));
mask_lo = -1; mask_lo = -1;
} }
else else

6
gcc/real.c
View File

@ -1423,10 +1423,10 @@ real_to_integer2 (HOST_WIDE_INT *plow, HOST_WIDE_INT *phigh,
undefined, so it doesn't matter what we return, and some callers undefined, so it doesn't matter what we return, and some callers
expect to be able to use this routine for both signed and expect to be able to use this routine for both signed and
unsigned conversions. */ unsigned conversions. */
if (exp > 2*HOST_BITS_PER_WIDE_INT) if (exp > HOST_BITS_PER_DOUBLE_INT)
goto overflow; goto overflow;
rshift_significand (&t, r, 2*HOST_BITS_PER_WIDE_INT - exp); rshift_significand (&t, r, HOST_BITS_PER_DOUBLE_INT - exp);
if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG) if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
{ {
high = t.sig[SIGSZ-1]; high = t.sig[SIGSZ-1];
@ -2160,7 +2160,7 @@ real_from_integer (REAL_VALUE_TYPE *r, enum machine_mode mode,
memset (r, 0, sizeof (*r)); memset (r, 0, sizeof (*r));
r->cl = rvc_normal; r->cl = rvc_normal;
r->sign = high < 0 && !unsigned_p; r->sign = high < 0 && !unsigned_p;
SET_REAL_EXP (r, 2 * HOST_BITS_PER_WIDE_INT); SET_REAL_EXP (r, HOST_BITS_PER_DOUBLE_INT);
if (r->sign) if (r->sign)
{ {

20
gcc/simplify-rtx.c
View File

@ -88,7 +88,7 @@ mode_signbit_p (enum machine_mode mode, const_rtx x)
if (width <= HOST_BITS_PER_WIDE_INT if (width <= HOST_BITS_PER_WIDE_INT
&& CONST_INT_P (x)) && CONST_INT_P (x))
val = INTVAL (x); val = INTVAL (x);
else if (width <= 2 * HOST_BITS_PER_WIDE_INT else if (width <= HOST_BITS_PER_DOUBLE_INT
&& GET_CODE (x) == CONST_DOUBLE && GET_CODE (x) == CONST_DOUBLE
&& CONST_DOUBLE_LOW (x) == 0) && CONST_DOUBLE_LOW (x) == 0)
{ {
@ -1356,7 +1356,7 @@ simplify_const_unary_operation (enum rtx_code code, enum machine_mode mode,
lv = CONST_DOUBLE_LOW (op), hv = CONST_DOUBLE_HIGH (op); lv = CONST_DOUBLE_LOW (op), hv = CONST_DOUBLE_HIGH (op);
if (op_mode == VOIDmode if (op_mode == VOIDmode
|| GET_MODE_PRECISION (op_mode) > 2 * HOST_BITS_PER_WIDE_INT) || GET_MODE_PRECISION (op_mode) > HOST_BITS_PER_DOUBLE_INT)
/* We should never get a negative number. */ /* We should never get a negative number. */
gcc_assert (hv >= 0); gcc_assert (hv >= 0);
else if (GET_MODE_PRECISION (op_mode) <= HOST_BITS_PER_WIDE_INT) else if (GET_MODE_PRECISION (op_mode) <= HOST_BITS_PER_WIDE_INT)
@ -1517,7 +1517,7 @@ simplify_const_unary_operation (enum rtx_code code, enum machine_mode mode,
/* We can do some operations on integer CONST_DOUBLEs. Also allow /* We can do some operations on integer CONST_DOUBLEs. Also allow
for a DImode operation on a CONST_INT. */ for a DImode operation on a CONST_INT. */
else if (GET_MODE (op) == VOIDmode else if (GET_MODE (op) == VOIDmode
&& width <= HOST_BITS_PER_WIDE_INT * 2 && width <= HOST_BITS_PER_DOUBLE_INT
&& (GET_CODE (op) == CONST_DOUBLE && (GET_CODE (op) == CONST_DOUBLE
|| CONST_INT_P (op))) || CONST_INT_P (op)))
{ {
@ -1713,7 +1713,7 @@ simplify_const_unary_operation (enum rtx_code code, enum machine_mode mode,
else if (GET_CODE (op) == CONST_DOUBLE else if (GET_CODE (op) == CONST_DOUBLE
&& SCALAR_FLOAT_MODE_P (GET_MODE (op)) && SCALAR_FLOAT_MODE_P (GET_MODE (op))
&& GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_CLASS (mode) == MODE_INT
&& width <= 2 * HOST_BITS_PER_WIDE_INT && width > 0) && width <= HOST_BITS_PER_DOUBLE_INT && width > 0)
{ {
/* Although the overflow semantics of RTL's FIX and UNSIGNED_FIX /* Although the overflow semantics of RTL's FIX and UNSIGNED_FIX
operators are intentionally left unspecified (to ease implementation operators are intentionally left unspecified (to ease implementation
@ -1778,7 +1778,7 @@ simplify_const_unary_operation (enum rtx_code code, enum machine_mode mode,
return const0_rtx; return const0_rtx;
/* Test against the unsigned upper bound. */ /* Test against the unsigned upper bound. */
if (width == 2 * HOST_BITS_PER_WIDE_INT) if (width == HOST_BITS_PER_DOUBLE_INT)
{ {
th = -1; th = -1;
tl = -1; tl = -1;
@ -2376,8 +2376,8 @@ simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode,
&& GET_MODE (op0) == mode && GET_MODE (op0) == mode
&& CONST_DOUBLE_LOW (trueop1) == 0 && CONST_DOUBLE_LOW (trueop1) == 0
&& (val = exact_log2 (CONST_DOUBLE_HIGH (trueop1))) >= 0 && (val = exact_log2 (CONST_DOUBLE_HIGH (trueop1))) >= 0
&& (val < 2 * HOST_BITS_PER_WIDE_INT - 1 && (val < HOST_BITS_PER_DOUBLE_INT - 1
|| GET_MODE_BITSIZE (mode) <= 2 * HOST_BITS_PER_WIDE_INT)) || GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_DOUBLE_INT))
return simplify_gen_binary (ASHIFT, mode, op0, return simplify_gen_binary (ASHIFT, mode, op0,
GEN_INT (val + HOST_BITS_PER_WIDE_INT)); GEN_INT (val + HOST_BITS_PER_WIDE_INT));
@ -5216,7 +5216,7 @@ simplify_immed_subreg (enum machine_mode outermode, rtx op,
for (i = 0; i < HOST_BITS_PER_WIDE_INT; i += value_bit) for (i = 0; i < HOST_BITS_PER_WIDE_INT; i += value_bit)
*vp++ = CONST_DOUBLE_LOW (el) >> i; *vp++ = CONST_DOUBLE_LOW (el) >> i;
while (i < HOST_BITS_PER_WIDE_INT * 2 && i < elem_bitsize) while (i < HOST_BITS_PER_DOUBLE_INT && i < elem_bitsize)
{ {
*vp++ *vp++
= CONST_DOUBLE_HIGH (el) >> (i - HOST_BITS_PER_WIDE_INT); = CONST_DOUBLE_HIGH (el) >> (i - HOST_BITS_PER_WIDE_INT);
@ -5271,7 +5271,7 @@ simplify_immed_subreg (enum machine_mode outermode, rtx op,
{ {
for (i = 0; i < HOST_BITS_PER_WIDE_INT; i += value_bit) for (i = 0; i < HOST_BITS_PER_WIDE_INT; i += value_bit)
*vp++ = CONST_FIXED_VALUE_LOW (el) >> i; *vp++ = CONST_FIXED_VALUE_LOW (el) >> i;
for (; i < 2 * HOST_BITS_PER_WIDE_INT && i < elem_bitsize; for (; i < HOST_BITS_PER_DOUBLE_INT && i < elem_bitsize;
i += value_bit) i += value_bit)
*vp++ = CONST_FIXED_VALUE_HIGH (el) *vp++ = CONST_FIXED_VALUE_HIGH (el)
>> (i - HOST_BITS_PER_WIDE_INT); >> (i - HOST_BITS_PER_WIDE_INT);
@ -5364,7 +5364,7 @@ simplify_immed_subreg (enum machine_mode outermode, rtx op,
know why. */ know why. */
if (elem_bitsize <= HOST_BITS_PER_WIDE_INT) if (elem_bitsize <= HOST_BITS_PER_WIDE_INT)
elems[elem] = gen_int_mode (lo, outer_submode); elems[elem] = gen_int_mode (lo, outer_submode);
else if (elem_bitsize <= 2 * HOST_BITS_PER_WIDE_INT) else if (elem_bitsize <= HOST_BITS_PER_DOUBLE_INT)
elems[elem] = immed_double_const (lo, hi, outer_submode); elems[elem] = immed_double_const (lo, hi, outer_submode);
else else
return NULL_RTX; return NULL_RTX;

16
gcc/stor-layout.c
View File

@ -2480,8 +2480,8 @@ initialize_sizetypes (void)
= MIN (precision + BITS_PER_UNIT_LOG + 1, MAX_FIXED_MODE_SIZE); = MIN (precision + BITS_PER_UNIT_LOG + 1, MAX_FIXED_MODE_SIZE);
bprecision bprecision
= GET_MODE_PRECISION (smallest_mode_for_size (bprecision, MODE_INT)); = GET_MODE_PRECISION (smallest_mode_for_size (bprecision, MODE_INT));
if (bprecision > HOST_BITS_PER_WIDE_INT * 2) if (bprecision > HOST_BITS_PER_DOUBLE_INT)
bprecision = HOST_BITS_PER_WIDE_INT * 2; bprecision = HOST_BITS_PER_DOUBLE_INT;
/* Create stubs for sizetype and bitsizetype so we can create constants. */ /* Create stubs for sizetype and bitsizetype so we can create constants. */
sizetype = make_node (INTEGER_TYPE); sizetype = make_node (INTEGER_TYPE);
@ -2582,10 +2582,10 @@ fixup_signed_type (tree type)
int precision = TYPE_PRECISION (type); int precision = TYPE_PRECISION (type);
/* We can not represent properly constants greater then /* We can not represent properly constants greater then
2 * HOST_BITS_PER_WIDE_INT, still we need the types HOST_BITS_PER_DOUBLE_INT, still we need the types
as they are used by i386 vector extensions and friends. */ as they are used by i386 vector extensions and friends. */
if (precision > HOST_BITS_PER_WIDE_INT * 2) if (precision > HOST_BITS_PER_DOUBLE_INT)
precision = HOST_BITS_PER_WIDE_INT * 2; precision = HOST_BITS_PER_DOUBLE_INT;
set_min_and_max_values_for_integral_type (type, precision, set_min_and_max_values_for_integral_type (type, precision,
/*is_unsigned=*/false); /*is_unsigned=*/false);
@ -2604,10 +2604,10 @@ fixup_unsigned_type (tree type)
int precision = TYPE_PRECISION (type); int precision = TYPE_PRECISION (type);
/* We can not represent properly constants greater then /* We can not represent properly constants greater then
2 * HOST_BITS_PER_WIDE_INT, still we need the types HOST_BITS_PER_DOUBLE_INT, still we need the types
as they are used by i386 vector extensions and friends. */ as they are used by i386 vector extensions and friends. */
if (precision > HOST_BITS_PER_WIDE_INT * 2) if (precision > HOST_BITS_PER_DOUBLE_INT)
precision = HOST_BITS_PER_WIDE_INT * 2; precision = HOST_BITS_PER_DOUBLE_INT;
TYPE_UNSIGNED (type) = 1; TYPE_UNSIGNED (type) = 1;

2
gcc/tree-vect-generic.c
View File

@ -64,7 +64,7 @@ build_replicated_const (tree type, tree inner_type, HOST_WIDE_INT value)
low &= ((HOST_WIDE_INT)1 << TYPE_PRECISION (type)) - 1, high = 0; low &= ((HOST_WIDE_INT)1 << TYPE_PRECISION (type)) - 1, high = 0;
else if (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT) else if (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT)
high = 0; high = 0;
else if (TYPE_PRECISION (type) == 2 * HOST_BITS_PER_WIDE_INT) else if (TYPE_PRECISION (type) == HOST_BITS_PER_DOUBLE_INT)
high = low; high = low;
else else
gcc_unreachable (); gcc_unreachable ();

4
gcc/tree-vrp.c
View File

@ -4604,7 +4604,7 @@ register_edge_assert_for_2 (tree name, edge e, gimple_stmt_iterator bsi,
&& host_integerp (cst2, 1) && host_integerp (cst2, 1)
&& INTEGRAL_TYPE_P (TREE_TYPE (name2)) && INTEGRAL_TYPE_P (TREE_TYPE (name2))
&& IN_RANGE (tree_low_cst (cst2, 1), 1, prec - 1) && IN_RANGE (tree_low_cst (cst2, 1), 1, prec - 1)
&& prec <= 2 * HOST_BITS_PER_WIDE_INT && prec <= HOST_BITS_PER_DOUBLE_INT
&& prec == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (val))) && prec == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (val)))
&& live_on_edge (e, name2) && live_on_edge (e, name2)
&& !has_single_use (name2)) && !has_single_use (name2))
@ -4681,7 +4681,7 @@ register_edge_assert_for_2 (tree name, edge e, gimple_stmt_iterator bsi,
&& INTEGRAL_TYPE_P (TREE_TYPE (name2)) && INTEGRAL_TYPE_P (TREE_TYPE (name2))
&& TREE_CODE (cst2) == INTEGER_CST && TREE_CODE (cst2) == INTEGER_CST
&& !integer_zerop (cst2) && !integer_zerop (cst2)
&& prec <= 2 * HOST_BITS_PER_WIDE_INT && prec <= HOST_BITS_PER_DOUBLE_INT
&& (prec > 1 && (prec > 1
|| TYPE_UNSIGNED (TREE_TYPE (val)))) || TYPE_UNSIGNED (TREE_TYPE (val))))
{ {

10
gcc/tree.c
View File

@ -1872,7 +1872,7 @@ integer_pow2p (const_tree expr)
/* First clear all bits that are beyond the type's precision in case /* First clear all bits that are beyond the type's precision in case
we've been sign extended. */ we've been sign extended. */
if (prec == 2 * HOST_BITS_PER_WIDE_INT) if (prec == HOST_BITS_PER_DOUBLE_INT)
; ;
else if (prec > HOST_BITS_PER_WIDE_INT) else if (prec > HOST_BITS_PER_WIDE_INT)
high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT)); high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
@ -1936,7 +1936,7 @@ tree_log2 (const_tree expr)
/* First clear all bits that are beyond the type's precision in case /* First clear all bits that are beyond the type's precision in case
we've been sign extended. */ we've been sign extended. */
if (prec == 2 * HOST_BITS_PER_WIDE_INT) if (prec == HOST_BITS_PER_DOUBLE_INT)
; ;
else if (prec > HOST_BITS_PER_WIDE_INT) else if (prec > HOST_BITS_PER_WIDE_INT)
high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT)); high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
@ -1973,7 +1973,7 @@ tree_floor_log2 (const_tree expr)
we've been sign extended. Ignore if type's precision hasn't been set we've been sign extended. Ignore if type's precision hasn't been set
since what we are doing is setting it. */ since what we are doing is setting it. */
if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0) if (prec == HOST_BITS_PER_DOUBLE_INT || prec == 0)
; ;
else if (prec > HOST_BITS_PER_WIDE_INT) else if (prec > HOST_BITS_PER_WIDE_INT)
high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT)); high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
@ -10201,7 +10201,7 @@ widest_int_cst_value (const_tree x)
unsigned HOST_WIDEST_INT val = TREE_INT_CST_LOW (x); unsigned HOST_WIDEST_INT val = TREE_INT_CST_LOW (x);
#if HOST_BITS_PER_WIDEST_INT > HOST_BITS_PER_WIDE_INT #if HOST_BITS_PER_WIDEST_INT > HOST_BITS_PER_WIDE_INT
gcc_assert (HOST_BITS_PER_WIDEST_INT >= 2 * HOST_BITS_PER_WIDE_INT); gcc_assert (HOST_BITS_PER_WIDEST_INT >= HOST_BITS_PER_DOUBLE_INT);
val |= (((unsigned HOST_WIDEST_INT) TREE_INT_CST_HIGH (x)) val |= (((unsigned HOST_WIDEST_INT) TREE_INT_CST_HIGH (x))
<< HOST_BITS_PER_WIDE_INT); << HOST_BITS_PER_WIDE_INT);
#else #else
@ -10319,7 +10319,7 @@ upper_bound_in_type (tree outer, tree inner)
else else
{ {
high.high = ((~(unsigned HOST_WIDE_INT) 0) high.high = ((~(unsigned HOST_WIDE_INT) 0)
>> (2 * HOST_BITS_PER_WIDE_INT - prec)); >> (HOST_BITS_PER_DOUBLE_INT - prec));
high.low = ~(unsigned HOST_WIDE_INT) 0; high.low = ~(unsigned HOST_WIDE_INT) 0;
} }

4
gcc/varasm.c
View File

@ -4951,7 +4951,7 @@ output_constructor_bitfield (oc_local_state *local, oc_outer_state *outer)
value = TREE_INT_CST_LOW (local->val); value = TREE_INT_CST_LOW (local->val);
else else
{ {
gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT); gcc_assert (shift < HOST_BITS_PER_DOUBLE_INT);
value = TREE_INT_CST_HIGH (local->val); value = TREE_INT_CST_HIGH (local->val);
shift -= HOST_BITS_PER_WIDE_INT; shift -= HOST_BITS_PER_WIDE_INT;
} }
@ -4983,7 +4983,7 @@ output_constructor_bitfield (oc_local_state *local, oc_outer_state *outer)
value = TREE_INT_CST_LOW (local->val); value = TREE_INT_CST_LOW (local->val);
else else
{ {
gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT); gcc_assert (shift < HOST_BITS_PER_DOUBLE_INT);
value = TREE_INT_CST_HIGH (local->val); value = TREE_INT_CST_HIGH (local->val);
shift -= HOST_BITS_PER_WIDE_INT; shift -= HOST_BITS_PER_WIDE_INT;
} }