riscv
/
binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

* stabsread.c: Remove all uses of error(). Make error_type and 

read_type_number static.
	(define_symbol): Don't try to deal with a missing symbol
	descriptor which isn't followed by digit, '(', or '-'.
	* stabsread.h: Don't declare read_type_number here.
	* gdbtypes.h: Don't declare error_type here.
	* xcoffread.c: Remove NO_TYPEDEFS code.
gdb-4_18-branch
Jim Kingdon 34 years ago
parent
2d10304ee6
commit
ea753d03d6
5 changed files with 238 additions and 242 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 12
      gdb/ChangeLog
  2. 3
      gdb/gdbtypes.h
  3. 356
      gdb/stabsread.c
  4. 3
      gdb/stabsread.h
  5. 106
      gdb/xcoffread.c

12
gdb/ChangeLog
View File

@ -1,3 +1,13 @@
Tue May 25 13:06:28 1993 Jim Kingdon (kingdon@lioth.cygnus.com)
* stabsread.c: Remove all uses of error(). Make error_type and
read_type_number static.
(define_symbol): Don't try to deal with a missing symbol
descriptor which isn't followed by digit, '(', or '-'.
* stabsread.h: Don't declare read_type_number here.
* gdbtypes.h: Don't declare error_type here.
* xcoffread.c: Remove NO_TYPEDEFS code.
Tue May 25 09:33:16 1993 Ian Lance Taylor (ian@cygnus.com)
* mips-tdep.c: Removed #include of many header files, and #define
@ -7,7 +17,7 @@ Tue May 25 09:36:13 1993 Jim Kingdon (kingdon@lioth.cygnus.com)
* Many places: replace "the inferior" in messages with "the program"
or "the program being debugged".
* inflow.c (try_writing_regs): Revove; it's been #if 0'd forever
* inflow.c (try_writing_regs): Remove; it's been #if 0'd forever
and I'm getting sick of maintaining it.
* config/i386/linux.mh: Don't use \ newline; the awk scripts don't

3
gdb/gdbtypes.h
View File

@ -634,9 +634,6 @@ gdb_mangle_name PARAMS ((struct type *, int, int));
extern struct type *
builtin_type PARAMS ((char **));
extern struct type *
error_type PARAMS ((char **));
extern struct type *
lookup_typename PARAMS ((char *, struct block *, int));

356
gdb/stabsread.c
View File

@ -65,8 +65,9 @@ struct field_info
static struct type *
dbx_alloc_type PARAMS ((int [2], struct objfile *));
static void
read_huge_number PARAMS ((char **, int, long *, int *));
static long read_huge_number PARAMS ((char **, int, int *));
static struct type *error_type PARAMS ((char **));
static void
patch_block_stabs PARAMS ((struct pending *, struct pending_stabs *,
@ -75,6 +76,9 @@ patch_block_stabs PARAMS ((struct pending *, struct pending_stabs *,
static void
fix_common_block PARAMS ((struct symbol *, int));
static int
read_type_number PARAMS ((char **, int *));
static struct type *
read_range_type PARAMS ((char **, int [2], struct objfile *));
@ -122,7 +126,7 @@ read_array_type PARAMS ((char **, struct type *, struct objfile *));
static struct type **
read_args PARAMS ((char **, int, struct objfile *));
static void
static int
read_cpp_abbrev PARAMS ((struct field_info *, char **, struct type *,
struct objfile *));
@ -256,8 +260,13 @@ dbx_lookup_type (typenums)
return 0;
if (filenum < 0 || filenum >= n_this_object_header_files)
error ("Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
filenum, index, symnum);
{
static struct complaint msg = {"\
Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
0, 0};
complain (&msg, filenum, index, symnum);
goto error_return;
}
if (filenum == 0)
{
@ -303,7 +312,16 @@ dbx_lookup_type (typenums)
if (real_filenum >= n_header_files)
{
abort ();
struct type *temp_type;
struct type **temp_type_p;
warning ("GDB internal error: bad real_filenum");
error_return:
temp_type = init_type (TYPE_CODE_ERROR, 0, 0, NULL, NULL);
temp_type_p = (struct type **) xmalloc (sizeof (struct type *));
*temp_type_p = temp_type;
return temp_type_p;
}
f = &header_files[real_filenum];
@ -431,24 +449,31 @@ patch_block_stabs (symbols, stabs, objfile)
or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
Just a single number N is equivalent to (0,N).
Return the two numbers by storing them in the vector TYPENUMS.
TYPENUMS will then be used as an argument to dbx_lookup_type. */
TYPENUMS will then be used as an argument to dbx_lookup_type.
void
Returns 0 for success, -1 for error. */
static int
read_type_number (pp, typenums)
register char **pp;
register int *typenums;
{
int nbits;
if (**pp == '(')
{
(*pp)++;
typenums[0] = read_number (pp, ',');
typenums[1] = read_number (pp, ')');
typenums[0] = read_huge_number (pp, ',', &nbits);
if (nbits != 0) return -1;
typenums[1] = read_huge_number (pp, ')', &nbits);
if (nbits != 0) return -1;
}
else
{
typenums[0] = 0;
typenums[1] = read_number (pp, 0);
typenums[1] = read_huge_number (pp, 0, &nbits);
if (nbits != 0) return -1;
}
return 0;
}
@ -566,10 +591,18 @@ define_symbol (valu, string, desc, type, objfile)
p++;
/* Determine the type of name being defined. */
#if 0
/* Getting GDB to correctly skip the symbol on an undefined symbol
descriptor and not ever dump core is a very dodgy proposition if
we do things this way. I say the acorn RISC machine can just
fix their compiler. */
/* The Acorn RISC machine's compiler can put out locals that don't
start with "234=" or "(3,4)=", so assume anything other than the
deftypes we know how to handle is a local. */
if (!strchr ("cfFGpPrStTvVXCR", *p))
#else
if (isdigit (*p) || *p == '(' || *p == '-')
#endif
deftype = 'l';
else
deftype = *p++;
@ -582,8 +615,15 @@ define_symbol (valu, string, desc, type, objfile)
(where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
if (deftype == 'c')
{
if (*p++ != '=')
error ("Invalid symbol data at symtab pos %d.", symnum);
if (*p != '=')
{
SYMBOL_CLASS (sym) = LOC_CONST;
SYMBOL_TYPE (sym) = error_type (&p);
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
add_symbol_to_list (sym, &file_symbols);
return sym;
}
++p;
switch (*p++)
{
case 'r':
@ -1053,7 +1093,12 @@ define_symbol (valu, string, desc, type, objfile)
break;
default:
error ("Invalid symbol data: unknown symbol-type code `%c' at symtab pos %d.", deftype, symnum);
SYMBOL_CLASS (sym) = LOC_CONST;
SYMBOL_VALUE (sym) = 0;
SYMBOL_TYPE (sym) = error_type (&p);
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
add_symbol_to_list (sym, &file_symbols);
break;
}
/* When passing structures to a function, some systems sometimes pass
@ -1105,7 +1150,7 @@ define_symbol (valu, string, desc, type, objfile)
can define new types and new syntaxes, and old versions of the
debugger will be able to read the new symbol tables. */
struct type *
static struct type *
error_type (pp)
char **pp;
{
@ -1157,7 +1202,8 @@ read_type (pp, objfile)
if ((**pp >= '0' && **pp <= '9')
|| **pp == '(')
{
read_type_number (pp, typenums);
if (read_type_number (pp, typenums) != 0)
return error_type (pp);
/* Type is not being defined here. Either it already exists,
or this is a forward reference to it. dbx_alloc_type handles
@ -1330,13 +1376,19 @@ read_type (pp, objfile)
putting out the debugging information to do that, however. */
(*pp)--;
read_type_number (pp, xtypenums);
type = *dbx_lookup_type (xtypenums);
if (read_type_number (pp, xtypenums) != 0)
return error_type (pp);
if (typenums[0] == xtypenums[0] && typenums[1] == xtypenums[1])
/* It's being defined as itself. That means it is "void". */
type = init_type (TYPE_CODE_VOID, 0, 0, NULL, objfile);
else
type = *dbx_lookup_type (xtypenums);
if (typenums[0] != -1)
*dbx_lookup_type (typenums) = type;
/* This can happen if we had '-' followed by a garbage character,
for example. */
if (type == NULL)
return error_type (pp);
break;
/* In the following types, we must be sure to overwrite any existing
@ -1408,9 +1460,11 @@ read_type (pp, objfile)
struct type *return_type;
struct type **args;
if (*(*pp)++ != ',')
error ("invalid member type data format, at symtab pos %d.",
symnum);
if (**pp != ',')
/* Invalid member type data format. */
return error_type (pp);
else
++(*pp);
return_type = read_type (pp, objfile);
args = read_args (pp, ';', objfile);
@ -1440,7 +1494,8 @@ read_type (pp, objfile)
case 'e': /* Enumeration type */
type = dbx_alloc_type (typenums, objfile);
type = read_enum_type (pp, type, objfile);
*dbx_lookup_type (typenums) = type;
if (typenums[0] != -1)
*dbx_lookup_type (typenums) = type;
break;
case 's': /* Struct type */
@ -1479,7 +1534,10 @@ read_type (pp, objfile)
}
if (type == 0)
abort ();
{
warning ("GDB internal error, type is NULL in stabsread.c\n");
return error_type (pp);
}
return type;
}
@ -1649,7 +1707,9 @@ rs6000_builtin_type (typenum)
For the case of overloaded operators, the format is op$::*.funcs, where
$ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
name (such as `+=') and `.' marks the end of the operator name. */
name (such as `+=') and `.' marks the end of the operator name.
Returns 1 for success, 0 for failure. */
static int
read_member_functions (fip, pp, type, objfile)
@ -1829,6 +1889,8 @@ read_member_functions (fip, pp, type, objfile)
switch (*(*pp)++)
{
case '*':
{
int nbits;
/* virtual member function, followed by index.
The sign bit is set to distinguish pointers-to-methods
from virtual function indicies. Since the array is
@ -1837,7 +1899,9 @@ read_member_functions (fip, pp, type, objfile)
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_number (pp, ';')) + 2;
(0x7fffffff & read_huge_number (pp, ';', &nbits)) + 2;
if (nbits != 0)
return 0;
STABS_CONTINUE (pp);
if (**pp == ';' || **pp == '\0')
@ -1870,7 +1934,7 @@ read_member_functions (fip, pp, type, objfile)
}
}
break;
}
case '?':
/* static member function. */
new_sublist -> fn_field.voffset = VOFFSET_STATIC;
@ -1935,9 +1999,11 @@ read_member_functions (fip, pp, type, objfile)
}
/* Special GNU C++ name.
FIXME: Still need to properly handle parse error conditions. */
static void
Returns 1 for success, 0 for failure. "failure" means that we can't
keep parsing and it's time for error_type(). */
static int
read_cpp_abbrev (fip, pp, type, objfile)
struct field_info *fip;
char **pp;
@ -1998,10 +2064,20 @@ read_cpp_abbrev (fip, pp, type, objfile)
if (p[-1] != ':')
{
complain (&invalid_cpp_abbrev_complaint, *pp);
return 0;
}
fip->list->field.type = read_type (pp, objfile);
(*pp)++; /* Skip the comma. */
fip->list->field.bitpos = read_number (pp, ';');
if (**pp == ',')
(*pp)++; /* Skip the comma. */
else
return 0;
{
int nbits;
fip->list->field.bitpos = read_huge_number (pp, ';', &nbits);
if (nbits != 0)
return 0;
}
/* This field is unpacked. */
fip->list->field.bitsize = 0;
fip->list->visibility = VISIBILITY_PRIVATE;
@ -2015,6 +2091,7 @@ read_cpp_abbrev (fip, pp, type, objfile)
{
complain (&invalid_cpp_abbrev_complaint, *pp);
}
return 1;
}
static void
@ -2089,11 +2166,24 @@ read_one_struct_field (fip, pp, p, type, objfile)
complain (&stabs_general_complaint, "bad structure-type format");
return;
}
(*pp)++; /* Skip the comma. */
fip -> list -> field.bitpos = read_number (pp, ',');
fip -> list -> field.bitsize = read_number (pp, ';');
{
int nbits;
fip -> list -> field.bitpos = read_huge_number (pp, ',', &nbits);
if (nbits != 0)
{
complain (&stabs_general_complaint, "bad structure-type format");
return;
}
fip -> list -> field.bitsize = read_huge_number (pp, ';', &nbits);
if (nbits != 0)
{
complain (&stabs_general_complaint, "bad structure-type format");
return;
}
}
#if 0
/* FIXME-tiemann: Can't the compiler put out something which
lets us distinguish these? (or maybe just not put out anything
@ -2165,7 +2255,9 @@ read_one_struct_field (fip, pp, p, type, objfile)
'/1' (VISIBILITY_PROTECTED)
'/2' (VISIBILITY_PUBLIC)
or nothing, for C style fields with public visibility. */
or nothing, for C style fields with public visibility.
Returns 1 for success, 0 for failure. */
static int
read_struct_fields (fip, pp, type, objfile)
@ -2199,7 +2291,8 @@ read_struct_fields (fip, pp, type, objfile)
p = *pp;
if (*p == CPLUS_MARKER)
{
read_cpp_abbrev (fip, pp, type, objfile);
if (!read_cpp_abbrev (fip, pp, type, objfile))
return 0;
continue;
}
@ -2208,10 +2301,12 @@ read_struct_fields (fip, pp, type, objfile)
functions are delimited by a pair of ':'s. When we hit the member
functions (if any), terminate scan loop and return. */
while (*p != ':')
while (*p != ':' && *p != '\0')
{
p++;
}
if (*p == '\0')
return 0;
/* Check to see if we have hit the member functions yet. */
if (p[1] == ':')
@ -2250,7 +2345,8 @@ read_struct_fields (fip, pp, type, objfile)
Visibility specifiers (2) _______________________________| | |
Offset in bits from start of class ________________________| |
Type number of base class ____________________________________|
*/
Return 1 for success, 0 for (error-type-inducing) failure. */
static int
read_baseclasses (fip, pp, type, objfile)
@ -2273,7 +2369,12 @@ read_baseclasses (fip, pp, type, objfile)
}
ALLOCATE_CPLUS_STRUCT_TYPE (type);
TYPE_N_BASECLASSES (type) = read_number (pp, ',');
{
int nbits;
TYPE_N_BASECLASSES (type) = read_huge_number (pp, ',', &nbits);
if (nbits != 0)
return 0;
}
#if 0
/* Some stupid compilers have trouble with the following, so break
@ -2327,20 +2428,30 @@ read_baseclasses (fip, pp, type, objfile)
return 0;
}
/* The remaining value is the bit offset of the portion of the object
corresponding to this baseclass. Always zero in the absence of
multiple inheritance. */
{
int nbits;
/* The remaining value is the bit offset of the portion of the object
corresponding to this baseclass. Always zero in the absence of
multiple inheritance. */
new -> field.bitpos = read_number (pp, ',');
new -> field.bitpos = read_huge_number (pp, ',', &nbits);
if (nbits != 0)
return 0;
}
/* The last piece of baseclass information is the type of the base
class. Read it, and remember it's type name as this field's name. */
/* The last piece of baseclass information is the type of the
base class. Read it, and remember it's type name as this
field's name. */
new -> field.type = read_type (pp, objfile);
new -> field.name = type_name_no_tag (new -> field.type);
/* skip trailing ';' and bump count of number of fields seen */
(*pp)++;
if (**pp == ';')
(*pp)++;
else
return 0;
}
return 1;
}
@ -2575,7 +2686,12 @@ read_struct_type (pp, type, objfile)
/* First comes the total size in bytes. */
TYPE_LENGTH (type) = read_number (pp, 0);
{
int nbits;
TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits);
if (nbits != 0)
return error_type (pp);
}
/* Now read the baseclasses, if any, read the regular C struct or C++
class member fields, attach the fields to the type, read the C++
@ -2611,6 +2727,7 @@ read_array_type (pp, type, objfile)
struct type *index_type, *element_type, *range_type;
int lower, upper;
int adjustable = 0;
int nbits;
/* Format of an array type:
"ar<index type>;lower;upper;<array_contents_type>". Put code in
@ -2630,14 +2747,18 @@ read_array_type (pp, type, objfile)
(*pp)++;
adjustable = 1;
}
lower = read_number (pp, ';');
lower = read_huge_number (pp, ';', &nbits);
if (nbits != 0)
return error_type (pp);
if (!(**pp >= '0' && **pp <= '9'))
{
(*pp)++;
adjustable = 1;
}
upper = read_number (pp, ';');
upper = read_huge_number (pp, ';', &nbits);
if (nbits != 0)
return error_type (pp);
element_type = read_type (pp, objfile);
@ -2699,12 +2820,15 @@ read_enum_type (pp, type, objfile)
A semicolon or comma instead of a NAME means the end. */
while (**pp && **pp != ';' && **pp != ',')
{
int nbits;
STABS_CONTINUE (pp);
p = *pp;
while (*p != ':') p++;
name = obsavestring (*pp, p - *pp, &objfile -> symbol_obstack);
*pp = p + 1;
n = read_number (pp, ',');
n = read_huge_number (pp, ',', &nbits);
if (nbits != 0)
return error_type (pp);
sym = (struct symbol *)
obstack_alloc (&objfile -> symbol_obstack, sizeof (struct symbol));
@ -2789,6 +2913,7 @@ read_sun_builtin_type (pp, typenums, objfile)
int typenums[2];
struct objfile *objfile;
{
int type_bits;
int nbits;
int signed_type;
@ -2817,23 +2942,29 @@ read_sun_builtin_type (pp, typenums, objfile)
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_number (pp, ';');
read_huge_number (pp, ';', &nbits);
if (nbits != 0)
return error_type (pp);
/* The second number is always 0, so ignore it too. */
read_number (pp, ';');
read_huge_number (pp, ';', &nbits);
if (nbits != 0)
return error_type (pp);
/* The third number is the number of bits for this type. */
nbits = read_number (pp, 0);
type_bits = read_huge_number (pp, 0, &nbits);
if (nbits != 0)
return error_type (pp);
#if 0
/* FIXME. Here we should just be able to make a type of the right
number of bits and signedness. FIXME. */
if (nbits == TARGET_LONG_LONG_BIT)
if (type_bits == TARGET_LONG_LONG_BIT)
return (lookup_fundamental_type (objfile,
signed_type? FT_LONG_LONG: FT_UNSIGNED_LONG_LONG));
if (nbits == TARGET_INT_BIT)
if (type_bits == TARGET_INT_BIT)
{
/* FIXME -- the only way to distinguish `int' from `long'
is to look at its name! */
@ -2856,21 +2987,21 @@ read_sun_builtin_type (pp, typenums, objfile)
}
}
if (nbits == TARGET_SHORT_BIT)
if (type_bits == TARGET_SHORT_BIT)
return (lookup_fundamental_type (objfile,
signed_type? FT_SHORT: FT_UNSIGNED_SHORT));
if (nbits == TARGET_CHAR_BIT)
if (type_bits == TARGET_CHAR_BIT)
return (lookup_fundamental_type (objfile,
signed_type? FT_CHAR: FT_UNSIGNED_CHAR));
if (nbits == 0)
if (type_bits == 0)
return lookup_fundamental_type (objfile, FT_VOID);
return error_type (pp);
#else
return init_type (nbits == 0 ? TYPE_CODE_VOID : TYPE_CODE_INT,
nbits / TARGET_CHAR_BIT,
return init_type (type_bits == 0 ? TYPE_CODE_VOID : TYPE_CODE_INT,
type_bits / TARGET_CHAR_BIT,
signed_type ? 0 : TYPE_FLAG_UNSIGNED, (char *)NULL,
objfile);
#endif
@ -2882,17 +3013,22 @@ read_sun_floating_type (pp, typenums, objfile)
int typenums[2];
struct objfile *objfile;
{
int nbits;
int details;
int nbytes;
/* The first number has more details about the type, for example
FN_COMPLEX. */
details = read_number (pp, ';');
details = read_huge_number (pp, ';', &nbits);
if (nbits != 0)
return error_type (pp);
/* The second number is the number of bytes occupied by this type */
nbytes = read_number (pp, ';');
nbytes = read_huge_number (pp, ';', &nbits);
if (nbits != 0)
return error_type (pp);
if (**pp != 0 || details == NF_COMPLEX || details == NF_COMPLEX16
if (details == NF_COMPLEX || details == NF_COMPLEX16
|| details == NF_COMPLEX32)
/* This is a type we can't handle, but we do know the size.
We also will be able to give it a name. */
@ -2908,16 +3044,15 @@ read_sun_floating_type (pp, typenums, objfile)
and that character is skipped if it does match.
If END is zero, *PP is left pointing to that character.
If the number fits in a long, set *VALUE and set *BITS to 0.
If not, set *BITS to be the number of bits in the number.
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. */
If encounter garbage, set *BITS to -1 and return 0. */
static void
read_huge_number (pp, end, valu, bits)
static long
read_huge_number (pp, end, bits)
char **pp;
int end;
long *valu;
int *bits;
{
char *p = *pp;
@ -3007,11 +3142,12 @@ read_huge_number (pp, end, valu, bits)
}
else
{
if (valu)
*valu = n * sign;
if (bits)
*bits = 0;
return n * sign;
}
/* It's *BITS which has the interesting information. */
return 0;
}
static struct type *
@ -3029,7 +3165,10 @@ read_range_type (pp, typenums, objfile)
/* First comes a type we are a subrange of.
In C it is usually 0, 1 or the type being defined. */
read_type_number (pp, rangenums);
/* FIXME: according to stabs.texinfo and AIX doc, this can be a type-id
not just a type number. */
if (read_type_number (pp, rangenums) != 0)
return error_type (pp);
self_subrange = (rangenums[0] == typenums[0] &&
rangenums[1] == typenums[1]);
@ -3039,8 +3178,8 @@ read_range_type (pp, typenums, objfile)
/* The remaining two operands are usually lower and upper bounds
of the range. But in some special cases they mean something else. */
read_huge_number (pp, ';', &n2, &n2bits);
read_huge_number (pp, ';', &n3, &n3bits);
n2 = read_huge_number (pp, ';', &n2bits);
n3 = read_huge_number (pp, ';', &n3bits);
if (n2bits == -1 || n3bits == -1)
return error_type (pp);
@ -3177,50 +3316,6 @@ read_range_type (pp, typenums, objfile)
return (result_type);
}
/* Read a number from the string pointed to by *PP.
The value of *PP is advanced over the number.
If END is nonzero, the character that ends the
number must match END, or an error happens;
and that character is skipped if it does match.
If END is zero, *PP is left pointing to that character. */
long
read_number (pp, end)
char **pp;
int end;
{
register char *p = *pp;
register long n = 0;
register int c;
int sign = 1;
/* Handle an optional leading minus sign. */
if (*p == '-')
{
sign = -1;
p++;
}
/* Read the digits, as far as they go. */
while ((c = *p++) >= '0' && c <= '9')
{
n *= 10;
n += c - '0';
}
if (end)
{
if (c && c != end)
error ("Invalid symbol data: invalid character \\%03o at symbol pos %d.", c, symnum);
}
else
--p;
*pp = p;
return n * sign;
}
/* Read in an argument list. This is a list of types, separated by commas
and terminated with END. Return the list of types read in, or (struct type
**)-1 if there is an error. */
@ -3331,15 +3426,14 @@ cleanup_undefined_types ()
struct pending *ppt;
int i;
/* Name of the type, without "struct" or "union" */
char *typename = TYPE_NAME (*type);
if (!strncmp (typename, "struct ", 7))
typename += 7;
if (!strncmp (typename, "union ", 6))
typename += 6;
if (!strncmp (typename, "enum ", 5))
typename += 5;
char *typename = type_name_no_tag (*type);
if (typename == NULL)
{
static struct complaint msg = {"need a type name", 0, 0};
complain (&msg);
break;
}
for (ppt = file_symbols; ppt; ppt = ppt->next)
{
for (i = 0; i < ppt->nsyms; i++)
@ -3383,9 +3477,13 @@ cleanup_undefined_types ()
}
break;
default:
badtype:
error ("GDB internal error. cleanup_undefined_types with bad type %d.", TYPE_CODE (*type));
default:
badtype:
{
static struct complaint msg = {"\
GDB internal error. cleanup_undefined_types with bad type %d.", 0, 0};
complain (&msg, TYPE_CODE (*type));
}
break;
}
}

3
gdb/stabsread.h
View File

@ -136,9 +136,6 @@ EXTERN int n_allocated_this_object_header_files;
extern struct complaint unknown_symtype_complaint;
extern struct complaint unknown_symchar_complaint;
extern void
read_type_number PARAMS ((char **, int *));
extern struct type *
read_type PARAMS ((char **, struct objfile *));

106
gdb/xcoffread.c
View File

@ -1597,116 +1597,10 @@ process_xcoff_symbol (cs, objfile)
case C_DECL: /* a type decleration?? */
#if defined(NO_TYPEDEFS)
qq = (char*) strchr (name, ':');
if (!qq) /* skip if there is no ':' */
return NULL;
nameless = (qq == name);
struct_and_type_combined = (qq[1] == 'T' && qq[2] == 't');
pp = qq + (struct_and_type_combined ? 3 : 2);
/* To handle GNU C++ typename abbreviation, we need to be able to fill
in a type's name as soon as space for that type is allocated. */
if (struct_and_type_combined && name != qq) {
int typenums[2];
struct type *tmp_type;
char *tmp_pp = pp;
read_type_number (&tmp_pp, typenums);
tmp_type = dbx_alloc_type (typenums, objfile);
if (tmp_type && !TYPE_NAME (tmp_type) && !nameless)
TYPE_NAME (tmp_type) = SYMBOL_NAME (sym) =
obsavestring (name, qq-name,
&objfile->symbol_obstack);
}
ttype = SYMBOL_TYPE (sym) = read_type (&pp, objfile);
/* if there is no name for this typedef, you don't have to keep its
symbol, since nobody could ask for it. Otherwise, build a symbol
and add it into symbol_list. */
if (nameless)
return;
/* Transarc wants to eliminate type definitions from the symbol table.
Limited debugging capabilities, but faster symbol table processing
and less memory usage. Note that tag definitions (starting with
'T') will remain intact. */
if (qq[1] != 'T' && (!TYPE_NAME (ttype) || *(TYPE_NAME (ttype)) == '\0')) {
if (SYMBOL_NAME (sym))
TYPE_NAME (ttype) = SYMBOL_NAME (sym);
else
TYPE_NAME (ttype) = obsavestring (name, qq-name);
return;
}
/* read_type() will return null if type (or tag) definition was
unnnecessarily duplicated. Also, if the symbol doesn't have a name,
there is no need to keep it in symbol table. */
/* The above argument no longer valid. read_type() never returns NULL. */
if (!ttype)
return NULL;
/* if there is no name for this typedef, you don't have to keep its
symbol, since nobody could ask for it. Otherwise, build a symbol
and add it into symbol_list. */
if (qq[1] == 'T')
SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
else if (qq[1] == 't')
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
else {
warning ("Unrecognized stab string.\n");
return NULL;
}
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
if (!SYMBOL_NAME (sym))
SYMBOL_NAME (sym) = obsavestring (name, qq-name);
SYMBOL_DUP (sym, sym2);
add_symbol_to_list
(sym2, within_function ? &local_symbols : &file_symbols);
/* For a combination of struct and type, add one more symbol
for the type. */
if (struct_and_type_combined) {
SYMBOL_DUP (sym, sym2);
SYMBOL_NAMESPACE (sym2) = VAR_NAMESPACE;
add_symbol_to_list
(sym2, within_function ? &local_symbols : &file_symbols);
}
/* assign a name to the type node. */
if (!TYPE_NAME (ttype) || *(TYPE_NAME (ttype)) == '\0') {
if (struct_and_type_combined)
TYPE_NAME (ttype) = SYMBOL_NAME (sym);
else if (qq[1] == 'T') /* struct namespace */
TYPE_NAME (ttype) = concat (
TYPE_CODE (ttype) == TYPE_CODE_UNION ? "union " :
TYPE_CODE (ttype) == TYPE_CODE_STRUCT? "struct " : "enum ",
SYMBOL_NAME (sym), NULL);
}
break;
#else /* !NO_TYPEDEFS */
sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
if (sym != NULL)
SYMBOL_SECTION (sym) = cs->c_secnum;
return sym;
#endif
case C_GSYM:
add_stab_to_list (name, &global_stabs);

Write Preview
Loading…
Cancel
Save