OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

* stabsread.c (define_symbol, case 't'): Only set the name if it 

is not a pointer type.

	* stabsread.c (define_symbol): Clean up logic; move the read_type
	calls to inside the switch statement (this improves the error
	handling).
This commit is contained in:
Jim Kingdon 1993-05-26 17:17:02 +00:00
parent 18ef91468f
commit 59d69506fb
2 changed files with 123 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
gdb/ChangeLog
View File

@ -1,5 +1,12 @@
Wed May 26 10:28:14 1993 Jim Kingdon (kingdon@lioth.cygnus.com)
* stabsread.c (define_symbol, case 't'): Only set the name if it
is not a pointer type.
* stabsread.c (define_symbol): Clean up logic; move the read_type
calls to inside the switch statement (this improves the error
handling).
* mipsread.c (parse_symbol, parse_partial_symbols): Deal with Fortran
common blocks.

189
gdb/stabsread.c
View File

@ -142,6 +142,11 @@ static const char vb_name[] = { '_','v','b',CPLUS_MARKER,'\0' };
#define BELIEVE_PCC_PROMOTION 0
#endif
#if 0
/* I think this can go away, all current uses have been removed.
GCC emits a few crazy types which can only be distinguished by the
name (complex, long long on some machines), but I'd say fix GCC. */
/* During some calls to read_type (and thus to read_range_type), this
contains the name of the type being defined. Range types are only
used in C as basic types. We use the name to distinguish the otherwise
@ -149,6 +154,7 @@ static const char vb_name[] = { '_','v','b',CPLUS_MARKER,'\0' };
FIXME, this should disappear with better type management. */
static char *long_kludge_name;
#endif
#if 0
struct complaint dbx_class_complaint =
@ -209,6 +215,9 @@ static int undef_types_length;
} while (0)
/* This is used by other symbol readers besides stabs, so for cleanliness
should probably be in buildsym.c. */
int
hashname (name)
char *name;
@ -607,14 +616,15 @@ define_symbol (valu, string, desc, type, objfile)
else
deftype = *p++;
/* c is a special case, not followed by a type-number.
SYMBOL:c=iVALUE for an integer constant symbol.
SYMBOL:c=rVALUE for a floating constant symbol.
SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
e.g. "b:c=e6,0" for "const b = blob1"
(where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
if (deftype == 'c')
switch (deftype)
{
case 'c':
/* c is a special case, not followed by a type-number.
SYMBOL:c=iVALUE for an integer constant symbol.
SYMBOL:c=rVALUE for a floating constant symbol.
SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
e.g. "b:c=e6,0" for "const b = blob1"
(where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
if (*p != '=')
{
SYMBOL_CLASS (sym) = LOC_CONST;
@ -715,52 +725,10 @@ define_symbol (valu, string, desc, type, objfile)
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
add_symbol_to_list (sym, &file_symbols);
return sym;
}
/* Now usually comes a number that says which data type,
and possibly more stuff to define the type
(all of which is handled by read_type) */
if (deftype == 'p' && *p == 'F')
/* pF is a two-letter code that means a function parameter in Fortran.
The type-number specifies the type of the return value.
Translate it into a pointer-to-function type. */
{
p++;
SYMBOL_TYPE (sym)
= lookup_pointer_type (lookup_function_type (read_type (&p, objfile)));
}
else
{
/* The symbol class letter is followed by a type (typically the
type of the symbol, or its return-type, or etc). Read it. */
synonym = *p == 't';
if (synonym)
{
p++;
type_synonym_name = obsavestring (SYMBOL_NAME (sym),
strlen (SYMBOL_NAME (sym)),
&objfile -> symbol_obstack);
}
/* Here we save the name of the symbol for read_range_type, which
ends up reading in the basic types. In stabs, unfortunately there
is no distinction between "int" and "long" types except their
names. Until we work out a saner type policy (eliminating most
builtin types and using the names specified in the files), we
save away the name so that far away from here in read_range_type,
we can examine it to decide between "int" and "long". FIXME. */
long_kludge_name = SYMBOL_NAME (sym);
SYMBOL_TYPE (sym) = read_type (&p, objfile);
}
switch (deftype)
{
case 'C':
/* The name of a caught exception. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_CLASS (sym) = LOC_LABEL;
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
SYMBOL_VALUE_ADDRESS (sym) = valu;
@ -769,6 +737,7 @@ define_symbol (valu, string, desc, type, objfile)
case 'f':
/* A static function definition. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_CLASS (sym) = LOC_BLOCK;
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
add_symbol_to_list (sym, &file_symbols);
@ -811,6 +780,7 @@ define_symbol (valu, string, desc, type, objfile)
case 'F':
/* A global function definition. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_CLASS (sym) = LOC_BLOCK;
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
add_symbol_to_list (sym, &global_symbols);
@ -821,6 +791,7 @@ define_symbol (valu, string, desc, type, objfile)
value is not correct. It is necessary to search for the
corresponding linker definition to find the value.
These definitions appear at the end of the namelist. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
i = hashname (SYMBOL_NAME (sym));
SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
global_sym_chain[i] = sym;
@ -833,6 +804,7 @@ define_symbol (valu, string, desc, type, objfile)
when there is no code letter in the dbx data.
Dbx data never actually contains 'l'. */
case 'l':
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_CLASS (sym) = LOC_LOCAL;
SYMBOL_VALUE (sym) = valu;
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
@ -840,11 +812,25 @@ define_symbol (valu, string, desc, type, objfile)
break;
case 'p':
if (*p == 'F')
/* pF is a two-letter code that means a function parameter in Fortran.
The type-number specifies the type of the return value.
Translate it into a pointer-to-function type. */
{
p++;
SYMBOL_TYPE (sym)
= lookup_pointer_type
(lookup_function_type (read_type (&p, objfile)));
}
else
SYMBOL_TYPE (sym) = read_type (&p, objfile);
/* Normally this is a parameter, a LOC_ARG. On the i960, it
can also be a LOC_LOCAL_ARG depending on symbol type. */
#ifndef DBX_PARM_SYMBOL_CLASS
#define DBX_PARM_SYMBOL_CLASS(type) LOC_ARG
#endif
SYMBOL_CLASS (sym) = DBX_PARM_SYMBOL_CLASS (type);
SYMBOL_VALUE (sym) = valu;
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
@ -940,11 +926,15 @@ define_symbol (valu, string, desc, type, objfile)
are referenced by this file. gdb is not prepared to deal
with this extra information. FIXME, it ought to. */
if (type == N_FUN)
goto process_prototype_types;
{
read_type (&p, objfile);
goto process_prototype_types;
}
/*FALLTHROUGH*/
case 'R':
/* Parameter which is in a register. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_CLASS (sym) = LOC_REGPARM;
SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu);
if (SYMBOL_VALUE (sym) >= NUM_REGS)
@ -958,6 +948,7 @@ define_symbol (valu, string, desc, type, objfile)
case 'r':
/* Register variable (either global or local). */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_CLASS (sym) = LOC_REGISTER;
SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu);
if (SYMBOL_VALUE (sym) >= NUM_REGS)
@ -998,6 +989,7 @@ define_symbol (valu, string, desc, type, objfile)
case 'S':
/* Static symbol at top level of file */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_CLASS (sym) = LOC_STATIC;
SYMBOL_VALUE_ADDRESS (sym) = valu;
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
@ -1005,6 +997,19 @@ define_symbol (valu, string, desc, type, objfile)
break;
case 't':
#if 0
/* See comment where long_kludge_name is declared. */
/* Here we save the name of the symbol for read_range_type, which
ends up reading in the basic types. In stabs, unfortunately there
is no distinction between "int" and "long" types except their
names. Until we work out a saner type policy (eliminating most
builtin types and using the names specified in the files), we
save away the name so that far away from here in read_range_type,
we can examine it to decide between "int" and "long". FIXME. */
long_kludge_name = SYMBOL_NAME (sym);
#endif
SYMBOL_TYPE (sym) = read_type (&p, objfile);
/* For a nameless type, we don't want a create a symbol, thus we
did not use `sym'. Return without further processing. */
if (nameless) return NULL;
@ -1013,28 +1018,65 @@ define_symbol (valu, string, desc, type, objfile)
SYMBOL_VALUE (sym) = valu;
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
/* C++ vagaries: we may have a type which is derived from
a base type which did not have its name defined when the
derived class was output. We fill in the derived class's
base part member's name here in that case. */
a base type which did not have its name defined when the
derived class was output. We fill in the derived class's
base part member's name here in that case. */
if (TYPE_NAME (SYMBOL_TYPE (sym)) != NULL)
if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
|| TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION)
&& TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)))
{
int j;
for (j = TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)) - 1; j >= 0; j--)
if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) == 0)
TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) =
type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym), j));
}
if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
|| TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION)
&& TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)))
{
int j;
for (j = TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)) - 1; j >= 0; j--)
if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) == 0)
TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) =
type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym), j));
}
if (TYPE_NAME (SYMBOL_TYPE (sym)) == NULL)
TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_NAME (sym);
{
if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR)
{
/* If we are giving a name to a type such as "pointer
to foo", we better not set the TYPE_NAME. If the
program contains "typedef char *caddr_t;", we don't
want all variables of type char * to print as
caddr_t. This is not just a consequence of GDB's
type management; PCC and GCC (at least through
version 2.4) both output variables of either type
char * or caddr_t with the type number defined in
the 't' symbol for caddr_t. If a future compiler
cleans this up it GDB is not ready for it yet, but
if it becomes ready we somehow need to disable this
check (without breaking the PCC/GCC2.4 case).
Sigh.
Fortunately, this check seems not to be necessary
for anything except pointers. */
}
else
TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_NAME (sym);
}
add_symbol_to_list (sym, &file_symbols);
break;
case 'T':
/* Struct, union, or enum tag. For GNU C++, this can be be followed
by 't' which means we are typedef'ing it as well. */
synonym = *p == 't';
if (synonym)
{
p++;
type_synonym_name = obsavestring (SYMBOL_NAME (sym),
strlen (SYMBOL_NAME (sym)),
&objfile -> symbol_obstack);
}
SYMBOL_TYPE (sym) = read_type (&p, objfile);
/* For a nameless type, we don't want a create a symbol, thus we
did not use `sym'. Return without further processing. */
if (nameless) return NULL;
@ -1067,6 +1109,7 @@ define_symbol (valu, string, desc, type, objfile)
case 'V':
/* Static symbol of local scope */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_CLASS (sym) = LOC_STATIC;
SYMBOL_VALUE_ADDRESS (sym) = valu;
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
@ -1075,6 +1118,7 @@ define_symbol (valu, string, desc, type, objfile)
case 'v':
/* Reference parameter */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_CLASS (sym) = LOC_REF_ARG;
SYMBOL_VALUE (sym) = valu;
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
@ -1086,6 +1130,7 @@ define_symbol (valu, string, desc, type, objfile)
Sun claims ("dbx and dbxtool interfaces", 2nd ed)
that Pascal uses it too, but when I tried it Pascal used
"x:3" (local symbol) instead. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_CLASS (sym) = LOC_LOCAL;
SYMBOL_VALUE (sym) = valu;
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
@ -1093,9 +1138,9 @@ define_symbol (valu, string, desc, type, objfile)
break;
default:
SYMBOL_TYPE (sym) = error_type (&p);
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;
@ -1177,13 +1222,11 @@ error_type (pp)
}
/* Read a dbx type reference or definition;
return the type that is meant.
This can be just a number, in which case it references
a type already defined and placed in type_vector.
Or the number can be followed by an =, in which case
it means to define a new type according to the text that
follows the =. */
/* Read type information or a type definition; return the type. Even
though this routine accepts either type information or a type
definition, the distinction is relevant--some parts of stabsread.c
assume that type information starts with a digit, '-', or '(' in
deciding whether to call read_type. */
struct type *
read_type (pp, objfile)