Commit cc144655 by Gavin Romig-Koch Committed by Gavin Romig-Koch

For gcc:

	* c-lex.c (yylex) : Correct the test for overflow when lexing
	integer literals.

For gcc/cp:
	* lex.c (real_yylex) : Correct the test for overflow when lexing
	integer literals.

From-SVN: r28206
parent 0f037763
Wed Jul 21 08:39:22 1999 Gavin Romig-Koch <gavin@cygnus.com>
* c-lex.c (yylex) : Correct the test for overflow when lexing
integer literals.
Tue Jul 20 18:02:42 1999 Richard Henderson <rth@cygnus.com> Tue Jul 20 18:02:42 1999 Richard Henderson <rth@cygnus.com>
* haifa-sched.c (insn_cost): FREE implies cost 0 and vice versa. * haifa-sched.c (insn_cost): FREE implies cost 0 and vice versa.
......
...@@ -1477,16 +1477,19 @@ yylex () ...@@ -1477,16 +1477,19 @@ yylex ()
int count = 0; int count = 0;
int largest_digit = 0; int largest_digit = 0;
int numdigits = 0; int numdigits = 0;
/* for multi-precision arithmetic,
we actually store only HOST_BITS_PER_CHAR bits in each part.
The number of parts is chosen so as to be sufficient to hold
the enough bits to fit into the two HOST_WIDE_INTs that contain
the integer value (this is always at least as many bits as are
in a target `long long' value, but may be wider). */
#define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
int parts[TOTAL_PARTS];
int overflow = 0; int overflow = 0;
/* We actually store only HOST_BITS_PER_CHAR bits in each part.
The code below which fills the parts array assumes that a host
int is at least twice as wide as a host char, and that
HOST_BITS_PER_WIDE_INT is an even multiple of HOST_BITS_PER_CHAR.
Two HOST_WIDE_INTs is the largest int literal we can store.
In order to detect overflow below, the number of parts (TOTAL_PARTS)
must be exactly the number of parts needed to hold the bits
of two HOST_WIDE_INTs. */
#define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2)
unsigned int parts[TOTAL_PARTS];
enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS, AFTER_EXPON} enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS, AFTER_EXPON}
floatflag = NOT_FLOAT; floatflag = NOT_FLOAT;
...@@ -1616,11 +1619,16 @@ yylex () ...@@ -1616,11 +1619,16 @@ yylex ()
else else
parts[0] += c; parts[0] += c;
} }
/* If the extra highest-order part ever gets anything in it, /* If the highest-order part overflows (gets larger than
the number is certainly too big. */ a host char will hold) then the whole number has
if (parts[TOTAL_PARTS - 1] != 0) overflowed. Record this and truncate the highest-order
overflow = 1; part. */
if (parts[TOTAL_PARTS - 1] >> HOST_BITS_PER_CHAR)
{
overflow = 1;
parts[TOTAL_PARTS - 1] &= (1 << HOST_BITS_PER_CHAR) - 1;
}
if (p >= token_buffer + maxtoken - 3) if (p >= token_buffer + maxtoken - 3)
p = extend_token_buffer (p); p = extend_token_buffer (p);
...@@ -1772,12 +1780,12 @@ yylex () ...@@ -1772,12 +1780,12 @@ yylex ()
c = GETC(); c = GETC();
} }
/* If it won't fit in the host's representation for integers, /* If the literal overflowed, pedwarn about it now. */
then pedwarn. */ if (overflow)
{
warn = overflow; warn = 1;
if (warn) pedwarn ("integer constant is too large for this configuration of the compiler - truncated to %d bits", HOST_BITS_PER_WIDE_INT * 2);
pedwarn ("integer constant is too large for this configuration of the compiler - truncated to %d bits", HOST_BITS_PER_WIDE_INT * 2); }
/* This is simplified by the fact that our constant /* This is simplified by the fact that our constant
is always positive. */ is always positive. */
......
1999-07-21 Gavin Romig-Koch <gavin@cygnus.com>
* lex.c (real_yylex) : Correct the test for overflow when lexing
integer literals.
1999-07-20 Jason Merrill <jason@yorick.cygnus.com> 1999-07-20 Jason Merrill <jason@yorick.cygnus.com>
* decl.c (warn_extern_redeclared_static): Check DECL_ARTIFICIAL, * decl.c (warn_extern_redeclared_static): Check DECL_ARTIFICIAL,
......
...@@ -3578,16 +3578,19 @@ real_yylex () ...@@ -3578,16 +3578,19 @@ real_yylex ()
int count = 0; int count = 0;
int largest_digit = 0; int largest_digit = 0;
int numdigits = 0; int numdigits = 0;
/* for multi-precision arithmetic,
we actually store only HOST_BITS_PER_CHAR bits in each part.
The number of parts is chosen so as to be sufficient to hold
the enough bits to fit into the two HOST_WIDE_INTs that contain
the integer value (this is always at least as many bits as are
in a target `long long' value, but may be wider). */
#define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
int parts[TOTAL_PARTS];
int overflow = 0; int overflow = 0;
/* We actually store only HOST_BITS_PER_CHAR bits in each part.
The code below which fills the parts array assumes that a host
int is at least twice as wide as a host char, and that
HOST_BITS_PER_WIDE_INT is an even multiple of HOST_BITS_PER_CHAR.
Two HOST_WIDE_INTs is the largest int literal we can store.
In order to detect overflow below, the number of parts (TOTAL_PARTS)
must be exactly the number of parts needed to hold the bits
of two HOST_WIDE_INTs. */
#define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2)
unsigned int parts[TOTAL_PARTS];
enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag
= NOT_FLOAT; = NOT_FLOAT;
...@@ -3694,10 +3697,15 @@ real_yylex () ...@@ -3694,10 +3697,15 @@ real_yylex ()
parts[0] += c; parts[0] += c;
} }
/* If the extra highest-order part ever gets anything in it, /* If the highest-order part overflows (gets larger than
the number is certainly too big. */ a host char will hold) then the whole number has
if (parts[TOTAL_PARTS - 1] != 0) overflowed. Record this and truncate the highest-order
overflow = 1; part. */
if (parts[TOTAL_PARTS - 1] >> HOST_BITS_PER_CHAR)
{
overflow = 1;
parts[TOTAL_PARTS - 1] &= (1 << HOST_BITS_PER_CHAR) - 1;
}
if (p >= token_buffer + maxtoken - 3) if (p >= token_buffer + maxtoken - 3)
p = extend_token_buffer (p); p = extend_token_buffer (p);
...@@ -3850,12 +3858,12 @@ real_yylex () ...@@ -3850,12 +3858,12 @@ real_yylex ()
c = token_getch (); c = token_getch ();
} }
/* If it won't fit in the host's representation for integers, /* If the literal overflowed, pedwarn about it now. */
then pedwarn. */ if (overflow)
{
warn = overflow; warn = 1;
if (warn) pedwarn ("integer constant is too large for this configuration of the compiler - truncated to %d bits", HOST_BITS_PER_WIDE_INT * 2);
pedwarn ("integer constant is too large for this configuration of the compiler - truncated to %d bits", HOST_BITS_PER_WIDE_INT * 2); }
/* This is simplified by the fact that our constant /* This is simplified by the fact that our constant
is always positive. */ is always positive. */
......
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