[RFA] stabs: octal negative numbers

[Jerome Guitton <guitton@act-europe.fr>]

[-- Attachment #1: Type: text/plain, Size: 892 bytes --]

The patch in attachment adds support for parsing stabs that contains
negative numbers in octal, two's complement form. I have never
experienced the problem with C programs, but GCC generates those kind
of numbers for some Ada subtypes:

procedure Test_Case is

   type Base_Fixed_Point_Type is
     delta 1.0 / 16.0
       range (System.Min_Int / 2) * 1.0 / 16.0 ..
       (System.Max_Int / 2) * 1.0 / 16.0;

     subtype Fixed_Point_Subtype is
       Base_Fixed_Point_Type range -50.0 .. 50.0;

begin
   null;
end Test_Case;

The stabs generated for Fixed_Point_Subtype is:

.stabs  "test_case__fixed_point_subtype___XF_1_16:t(0,14)=@s64;r(0,12);01777777777777777776340;0000000001440;",128,0,10,0

(01777777777777777776340 is -800 on 64-bits).

Tested on an i686-linux host, with stabs+ format, no regressions.
Worth submitting an Ada test case, I guess.

Comments? OK to apply?

-- 
Jerome

[-- Attachment #2: stabsread.dif --]
[-- Type: text/plain, Size: 11149 bytes --]

2004-10-26  Jerome Guitton  <guitton@gnat.com>

	* stabsread.c (read_huge_number): Add support for reading octal
	signed number in twos complement, based on the size of this
	number.
	(read_range_type): Add support for reading octal signed bounds
	in twos complements, based on the size of the type.
	(read_type_number, read_cpp_abbrev, read_member_functions,
        read_cpp_abbrev, read_one_struct_field, read_baseclasses,
        read_struct_type, read_array_type, read_enum_type,
        read_sun_builtin_type, read_sun_floating_type): Update calls to
        read_huge_number.
        (read_type): Update call to read_range_type.

Index: stabsread.c
===================================================================
RCS file: /cvs/src/src/gdb/stabsread.c,v
retrieving revision 1.77
diff -u -p -r1.77 stabsread.c
--- stabsread.c	30 Apr 2004 14:40:54 -0000	1.77
+++ stabsread.c	26 Oct 2004 17:11:31 -0000
@@ -92,7 +92,7 @@ read_one_struct_field (struct field_info
 
 static struct type *dbx_alloc_type (int[2], struct objfile *);
 
-static long read_huge_number (char **, int, int *);
+static long read_huge_number (char **, int, int *, int);
 
 static struct type *error_type (char **, struct objfile *);
 
@@ -106,7 +106,7 @@ static int read_type_number (char **, in
 
 static struct type *read_type (char **, struct objfile *);
 
-static struct type *read_range_type (char **, int[2], struct objfile *);
+static struct type *read_range_type (char **, int[2], int, struct objfile *);
 
 static struct type *read_sun_builtin_type (char **, int[2], struct objfile *);
 
@@ -435,17 +435,17 @@ read_type_number (char **pp, int *typenu
   if (**pp == '(')
     {
       (*pp)++;
-      typenums[0] = read_huge_number (pp, ',', &nbits);
+      typenums[0] = read_huge_number (pp, ',', &nbits, 0);
       if (nbits != 0)
 	return -1;
-      typenums[1] = read_huge_number (pp, ')', &nbits);
+      typenums[1] = read_huge_number (pp, ')', &nbits, 0);
       if (nbits != 0)
 	return -1;
     }
   else
     {
       typenums[0] = 0;
-      typenums[1] = read_huge_number (pp, 0, &nbits);
+      typenums[1] = read_huge_number (pp, 0, &nbits, 0);
       if (nbits != 0)
 	return -1;
     }
@@ -1811,7 +1811,7 @@ again:
       break;
 
     case 'r':			/* Range type */
-      type = read_range_type (pp, typenums, objfile);
+      type = read_range_type (pp, typenums, type_size, objfile);
       if (typenums[0] != -1)
 	*dbx_lookup_type (typenums) = type;
       break;
@@ -2291,7 +2291,7 @@ read_member_functions (struct field_info
 		   the sign bit out, and usable as a valid index into
 		   the array.  Remove the sign bit here.  */
 		new_sublist->fn_field.voffset =
-		  (0x7fffffff & read_huge_number (pp, ';', &nbits)) + 2;
+		  (0x7fffffff & read_huge_number (pp, ';', &nbits, 0)) + 2;
 		if (nbits != 0)
 		  return 0;
 
@@ -2656,7 +2656,8 @@ read_cpp_abbrev (struct field_info *fip,
 
       {
 	int nbits;
-	FIELD_BITPOS (fip->list->field) = read_huge_number (pp, ';', &nbits);
+	FIELD_BITPOS (fip->list->field) = read_huge_number (pp, ';', &nbits,
+                                                            0);
 	if (nbits != 0)
 	  return 0;
       }
@@ -2729,13 +2730,13 @@ read_one_struct_field (struct field_info
 
   {
     int nbits;
-    FIELD_BITPOS (fip->list->field) = read_huge_number (pp, ',', &nbits);
+    FIELD_BITPOS (fip->list->field) = read_huge_number (pp, ',', &nbits, 0);
     if (nbits != 0)
       {
 	stabs_general_complaint ("bad structure-type format");
 	return;
       }
-    FIELD_BITSIZE (fip->list->field) = read_huge_number (pp, ';', &nbits);
+    FIELD_BITSIZE (fip->list->field) = read_huge_number (pp, ';', &nbits, 0);
     if (nbits != 0)
       {
 	stabs_general_complaint ("bad structure-type format");
@@ -2931,7 +2932,7 @@ read_baseclasses (struct field_info *fip
   ALLOCATE_CPLUS_STRUCT_TYPE (type);
   {
     int nbits;
-    TYPE_N_BASECLASSES (type) = read_huge_number (pp, ',', &nbits);
+    TYPE_N_BASECLASSES (type) = read_huge_number (pp, ',', &nbits, 0);
     if (nbits != 0)
       return 0;
   }
@@ -3005,7 +3006,7 @@ read_baseclasses (struct field_info *fip
 	   corresponding to this baseclass.  Always zero in the absence of
 	   multiple inheritance.  */
 
-	FIELD_BITPOS (new->field) = read_huge_number (pp, ',', &nbits);
+	FIELD_BITPOS (new->field) = read_huge_number (pp, ',', &nbits, 0);
 	if (nbits != 0)
 	  return 0;
       }
@@ -3310,7 +3311,7 @@ read_struct_type (char **pp, struct type
 
   {
     int nbits;
-    TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits);
+    TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits, 0);
     if (nbits != 0)
       return error_type (pp, objfile);
   }
@@ -3368,7 +3369,7 @@ read_array_type (char **pp, struct type 
       (*pp)++;
       adjustable = 1;
     }
-  lower = read_huge_number (pp, ';', &nbits);
+  lower = read_huge_number (pp, ';', &nbits, 0);
 
   if (nbits != 0)
     return error_type (pp, objfile);
@@ -3378,7 +3379,7 @@ read_array_type (char **pp, struct type 
       (*pp)++;
       adjustable = 1;
     }
-  upper = read_huge_number (pp, ';', &nbits);
+  upper = read_huge_number (pp, ';', &nbits, 0);
   if (nbits != 0)
     return error_type (pp, objfile);
 
@@ -3452,7 +3453,7 @@ read_enum_type (char **pp, struct type *
 	p++;
       name = obsavestring (*pp, p - *pp, &objfile->objfile_obstack);
       *pp = p + 1;
-      n = read_huge_number (pp, ',', &nbits);
+      n = read_huge_number (pp, ',', &nbits, 0);
       if (nbits != 0)
 	return error_type (pp, objfile);
 
@@ -3564,17 +3565,17 @@ read_sun_builtin_type (char **pp, int ty
      by this type, except that unsigned short is 4 instead of 2.
      Since this information is redundant with the third number,
      we will ignore it.  */
-  read_huge_number (pp, ';', &nbits);
+  read_huge_number (pp, ';', &nbits, 0);
   if (nbits != 0)
     return error_type (pp, objfile);
 
   /* The second number is always 0, so ignore it too. */
-  read_huge_number (pp, ';', &nbits);
+  read_huge_number (pp, ';', &nbits, 0);
   if (nbits != 0)
     return error_type (pp, objfile);
 
   /* The third number is the number of bits for this type. */
-  type_bits = read_huge_number (pp, 0, &nbits);
+  type_bits = read_huge_number (pp, 0, &nbits, 0);
   if (nbits != 0)
     return error_type (pp, objfile);
   /* The type *should* end with a semicolon.  If it are embedded
@@ -3607,12 +3608,12 @@ read_sun_floating_type (char **pp, int t
 
   /* The first number has more details about the type, for example
      FN_COMPLEX.  */
-  details = read_huge_number (pp, ';', &nbits);
+  details = read_huge_number (pp, ';', &nbits, 0);
   if (nbits != 0)
     return error_type (pp, objfile);
 
   /* The second number is the number of bytes occupied by this type */
-  nbytes = read_huge_number (pp, ';', &nbits);
+  nbytes = read_huge_number (pp, ';', &nbits, 0);
   if (nbits != 0)
     return error_type (pp, objfile);
 
@@ -3635,22 +3636,30 @@ read_sun_floating_type (char **pp, int t
    and that character is skipped if it does match.
    If END is zero, *PP is left pointing to that character.
 
+   If TWOS_COMPLEMENT_BITS is set to a strictly positive value and if
+   the number is represented in an octal representation, assume that
+   it is represented in a 2's complement representation with a size of
+   TWOS_COMPLEMENT_BITS.
+
    If the number fits in a long, set *BITS to 0 and return the value.
    If not, set *BITS to be the number of bits in the number and return 0.
 
    If encounter garbage, set *BITS to -1 and return 0.  */
 
 static long
-read_huge_number (char **pp, int end, int *bits)
+read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
 {
   char *p = *pp;
   int sign = 1;
+  int sign_bit;
   long n = 0;
+  long sn = 0;
   int radix = 10;
   char overflow = 0;
   int nbits = 0;
   int c;
   long upper_limit;
+  int twos_complement_representation = radix == 8 && twos_complement_bits > 0;
 
   if (*p == '-')
     {
@@ -3671,12 +3680,36 @@ read_huge_number (char **pp, int end, in
   while ((c = *p++) >= '0' && c < ('0' + radix))
     {
       if (n <= upper_limit)
-	{
-	  n *= radix;
-	  n += c - '0';		/* FIXME this overflows anyway */
-	}
+        {
+          if (twos_complement_representation)
+            {
+              /* Octal, signed, twos complement representation. In this case,
+                 sn is the signed value, n is the corresponding absolute
+                 value. signed_bit is the position of the sign bit in the
+                 first three bits.  */
+              if (sn == 0)
+                {
+                  sign_bit = (twos_complement_bits % 3 + 2) % 3;
+                  sn = c - '0' - ((2 * (c - '0')) | (2 << sign_bit));
+                }
+              else
+                {
+                  sn *= radix;
+                  sn += c - '0';
+                }
+
+              if (sn < 0)
+                n = -sn;
+            }
+          else
+            {
+              /* unsigned representation */
+              n *= radix;
+              n += c - '0';		/* FIXME this overflows anyway */
+            }
+        }
       else
-	overflow = 1;
+        overflow = 1;
 
       /* This depends on large values being output in octal, which is
          what GCC does. */
@@ -3733,14 +3766,18 @@ read_huge_number (char **pp, int end, in
     {
       if (bits)
 	*bits = 0;
-      return n * sign;
+      if (twos_complement_representation)
+        return sn;
+      else
+        return n * sign;
     }
   /* It's *BITS which has the interesting information.  */
   return 0;
 }
 
 static struct type *
-read_range_type (char **pp, int typenums[2], struct objfile *objfile)
+read_range_type (char **pp, int typenums[2], int type_size,
+                 struct objfile *objfile)
 {
   char *orig_pp = *pp;
   int rangenums[2];
@@ -3769,8 +3806,8 @@ read_range_type (char **pp, int typenums
 
   /* The remaining two operands are usually lower and upper bounds
      of the range.  But in some special cases they mean something else.  */
-  n2 = read_huge_number (pp, ';', &n2bits);
-  n3 = read_huge_number (pp, ';', &n3bits);
+  n2 = read_huge_number (pp, ';', &n2bits, type_size);
+  n3 = read_huge_number (pp, ';', &n3bits, type_size);
 
   if (n2bits == -1 || n3bits == -1)
     return error_type (pp, objfile);
@@ -3786,8 +3823,19 @@ read_range_type (char **pp, int typenums
       /* Number of bits in the type.  */
       int nbits = 0;
 
+      /* If a type size attribute has been specified, the bounds of
+         the range should fit in this size. If the lower bounds needs
+         more bits than the upper bound, then the type is signed.  */
+      if (n2bits <= type_size && n3bits <= type_size)
+        {
+          if (n2bits == type_size && n2bits > n3bits)
+            got_signed = 1;
+          else
+            got_unsigned = 1;
+          nbits = type_size;
+        }
       /* Range from 0 to <large number> is an unsigned large integral type.  */
-      if ((n2bits == 0 && n2 == 0) && n3bits != 0)
+      else if ((n2bits == 0 && n2 == 0) && n3bits != 0)
 	{
 	  got_unsigned = 1;
 	  nbits = n3bits;