* Check in Fred Fish's changes in these modules. Fred
will make ChangeLog entries for all of them.
This commit is contained in:
John Gilmore
parent
8e48d87af6
commit
1ab3bf1b14
50 changed files with 5270 additions and 1385 deletions
956
gdb/gdbtypes.c
Normal file
956
gdb/gdbtypes.c
Normal file
|
|
@ -0,0 +1,956 @@
|
|||
/* Support routines for manipulating internal types for GDB.
|
||||
Copyright (C) 1992 Free Software Foundation, Inc.
|
||||
Contributed by Cygnus Support, using pieces from other GDB modules.
|
||||
|
||||
This file is part of GDB.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||
|
||||
#include <stdio.h>
|
||||
#include "defs.h"
|
||||
#include "bfd.h"
|
||||
#include "symtab.h"
|
||||
#include "symfile.h"
|
||||
#include "gdbtypes.h"
|
||||
#include "expression.h"
|
||||
#include "language.h"
|
||||
#include "target.h"
|
||||
#include "value.h"
|
||||
|
||||
/* Alloc a new type structure and fill it with some defaults. If
|
||||
OBJFILE is non-NULL, then allocate the space for the type structure
|
||||
in that objfile's type_obstack. */
|
||||
|
||||
struct type *
|
||||
alloc_type (objfile)
|
||||
struct objfile *objfile;
|
||||
{
|
||||
register struct type *type;
|
||||
|
||||
/* Alloc the structure and start off with all fields zeroed. */
|
||||
|
||||
if (objfile == NULL)
|
||||
{
|
||||
type = (struct type *) xmalloc (sizeof (struct type));
|
||||
}
|
||||
else
|
||||
{
|
||||
type = (struct type *) obstack_alloc (&objfile -> type_obstack,
|
||||
sizeof (struct type));
|
||||
}
|
||||
(void) memset (type, 0, sizeof (struct type));
|
||||
|
||||
/* Initialize the fields that might not be zero. */
|
||||
|
||||
TYPE_CODE (type) = TYPE_CODE_UNDEF;
|
||||
TYPE_OBJFILE (type) = objfile;
|
||||
TYPE_VPTR_FIELDNO (type) = -1;
|
||||
|
||||
return (type);
|
||||
}
|
||||
|
||||
/* Given a type TYPE, return a type of pointers to that type.
|
||||
May need to construct such a type if this is the first use. */
|
||||
|
||||
struct type *
|
||||
lookup_pointer_type (type)
|
||||
struct type *type;
|
||||
{
|
||||
register struct type *ptype;
|
||||
|
||||
if ((ptype = TYPE_POINTER_TYPE (type)) == NULL)
|
||||
{
|
||||
/* This is the first time anyone wanted a pointer to a TYPE. */
|
||||
|
||||
ptype = alloc_type (TYPE_OBJFILE (type));
|
||||
TYPE_TARGET_TYPE (ptype) = type;
|
||||
TYPE_POINTER_TYPE (type) = ptype;
|
||||
|
||||
/* We assume the machine has only one representation for pointers! */
|
||||
/* FIXME: This confuses host<->target data representations, and is a
|
||||
poor assumption besides. */
|
||||
|
||||
TYPE_LENGTH (ptype) = sizeof (char *);
|
||||
TYPE_CODE (ptype) = TYPE_CODE_PTR;
|
||||
|
||||
}
|
||||
return (ptype);
|
||||
}
|
||||
|
||||
struct type *
|
||||
lookup_reference_type (type)
|
||||
struct type *type;
|
||||
{
|
||||
register struct type *rtype;
|
||||
|
||||
if ((rtype = TYPE_REFERENCE_TYPE (type)) == NULL)
|
||||
{
|
||||
/* This is the first time anyone wanted a pointer to a TYPE. */
|
||||
|
||||
rtype = alloc_type (TYPE_OBJFILE (type));
|
||||
TYPE_TARGET_TYPE (rtype) = type;
|
||||
TYPE_REFERENCE_TYPE (type) = rtype;
|
||||
|
||||
/* We assume the machine has only one representation for pointers! */
|
||||
/* FIXME: This confuses host<->target data representations, and is a
|
||||
poor assumption besides. */
|
||||
|
||||
TYPE_LENGTH (rtype) = sizeof (char *);
|
||||
TYPE_CODE (rtype) = TYPE_CODE_REF;
|
||||
|
||||
}
|
||||
return (rtype);
|
||||
}
|
||||
|
||||
/* Given a type TYPE, return a type of functions that return that type.
|
||||
May need to construct such a type if this is the first use. */
|
||||
|
||||
struct type *
|
||||
lookup_function_type (type)
|
||||
struct type *type;
|
||||
{
|
||||
register struct type *ptype;
|
||||
|
||||
if ((ptype = TYPE_FUNCTION_TYPE (type)) == NULL)
|
||||
{
|
||||
/* This is the first time anyone wanted a function returning a TYPE. */
|
||||
|
||||
ptype = alloc_type (TYPE_OBJFILE (type));
|
||||
TYPE_TARGET_TYPE (ptype) = type;
|
||||
TYPE_FUNCTION_TYPE (type) = ptype;
|
||||
|
||||
TYPE_LENGTH (ptype) = 1;
|
||||
TYPE_CODE (ptype) = TYPE_CODE_FUNC;
|
||||
}
|
||||
return (ptype);
|
||||
}
|
||||
|
||||
/* Implement direct support for MEMBER_TYPE in GNU C++.
|
||||
May need to construct such a type if this is the first use.
|
||||
The TYPE is the type of the member. The DOMAIN is the type
|
||||
of the aggregate that the member belongs to. */
|
||||
|
||||
struct type *
|
||||
lookup_member_type (type, domain)
|
||||
struct type *type;
|
||||
struct type *domain;
|
||||
{
|
||||
register struct type *mtype;
|
||||
|
||||
mtype = alloc_type (TYPE_OBJFILE (type));
|
||||
smash_to_member_type (mtype, domain, type);
|
||||
return (mtype);
|
||||
}
|
||||
|
||||
/* Allocate a stub method whose return type is TYPE.
|
||||
This apparently happens for speed of symbol reading, since parsing
|
||||
out the arguments to the method is cpu-intensive, the way we are doing
|
||||
it. So, we will fill in arguments later.
|
||||
This always returns a fresh type. */
|
||||
|
||||
struct type *
|
||||
allocate_stub_method (type)
|
||||
struct type *type;
|
||||
{
|
||||
struct type *mtype;
|
||||
|
||||
mtype = alloc_type (TYPE_OBJFILE (type));
|
||||
TYPE_TARGET_TYPE (mtype) = type;
|
||||
/* _DOMAIN_TYPE (mtype) = unknown yet */
|
||||
/* _ARG_TYPES (mtype) = unknown yet */
|
||||
TYPE_FLAGS (mtype) = TYPE_FLAG_STUB;
|
||||
TYPE_CODE (mtype) = TYPE_CODE_METHOD;
|
||||
TYPE_LENGTH (mtype) = 1;
|
||||
return (mtype);
|
||||
}
|
||||
|
||||
/* Create an array type. Elements will be of type TYPE, and there will
|
||||
be NUM of them.
|
||||
|
||||
Eventually this should be extended to take two more arguments which
|
||||
specify the bounds of the array and the type of the index.
|
||||
It should also be changed to be a "lookup" function, with the
|
||||
appropriate data structures added to the type field.
|
||||
Then read array type should call here. */
|
||||
|
||||
struct type *
|
||||
create_array_type (element_type, number)
|
||||
struct type *element_type;
|
||||
int number;
|
||||
{
|
||||
struct type *result_type;
|
||||
struct type *range_type;
|
||||
|
||||
result_type = alloc_type (TYPE_OBJFILE (element_type));
|
||||
|
||||
TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
|
||||
TYPE_TARGET_TYPE (result_type) = element_type;
|
||||
TYPE_LENGTH (result_type) = number * TYPE_LENGTH (element_type);
|
||||
TYPE_NFIELDS (result_type) = 1;
|
||||
TYPE_FIELDS (result_type) = (struct field *)
|
||||
obstack_alloc (&TYPE_OBJFILE (result_type) -> type_obstack,
|
||||
sizeof (struct field));
|
||||
|
||||
{
|
||||
/* Create range type. */
|
||||
range_type = alloc_type (TYPE_OBJFILE (result_type));
|
||||
TYPE_CODE (range_type) = TYPE_CODE_RANGE;
|
||||
TYPE_TARGET_TYPE (range_type) = builtin_type_int; /* FIXME */
|
||||
|
||||
/* This should never be needed. */
|
||||
TYPE_LENGTH (range_type) = sizeof (int);
|
||||
|
||||
TYPE_NFIELDS (range_type) = 2;
|
||||
TYPE_FIELDS (range_type) = (struct field *)
|
||||
obstack_alloc (&TYPE_OBJFILE (range_type) -> type_obstack,
|
||||
2 * sizeof (struct field));
|
||||
TYPE_FIELD_BITPOS (range_type, 0) = 0; /* FIXME */
|
||||
TYPE_FIELD_BITPOS (range_type, 1) = number-1; /* FIXME */
|
||||
TYPE_FIELD_TYPE (range_type, 0) = builtin_type_int; /* FIXME */
|
||||
TYPE_FIELD_TYPE (range_type, 1) = builtin_type_int; /* FIXME */
|
||||
}
|
||||
TYPE_FIELD_TYPE(result_type,0)=range_type;
|
||||
TYPE_VPTR_FIELDNO (result_type) = -1;
|
||||
|
||||
return (result_type);
|
||||
}
|
||||
|
||||
|
||||
/* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
|
||||
A MEMBER is a wierd thing -- it amounts to a typed offset into
|
||||
a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
|
||||
include the offset (that's the value of the MEMBER itself), but does
|
||||
include the structure type into which it points (for some reason).
|
||||
|
||||
FIXME: When "smashing" the type, we preserve the objfile that the
|
||||
old type pointed to, since we aren't changing where the type is actually
|
||||
allocated. If the two types aren't associated with the same objfile,
|
||||
then we are in deep-s**t anyway... */
|
||||
|
||||
void
|
||||
smash_to_member_type (type, domain, to_type)
|
||||
struct type *type;
|
||||
struct type *domain;
|
||||
struct type *to_type;
|
||||
{
|
||||
struct objfile *objfile;
|
||||
|
||||
objfile = TYPE_OBJFILE (type);
|
||||
|
||||
(void) memset (type, 0, sizeof (struct type));
|
||||
TYPE_OBJFILE (type) = objfile;
|
||||
TYPE_TARGET_TYPE (type) = to_type;
|
||||
TYPE_DOMAIN_TYPE (type) = domain;
|
||||
TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
|
||||
TYPE_CODE (type) = TYPE_CODE_MEMBER;
|
||||
}
|
||||
|
||||
/* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
|
||||
METHOD just means `function that gets an extra "this" argument'.
|
||||
|
||||
FIXME: When "smashing" the type, we preserve the objfile that the
|
||||
old type pointed to, since we aren't changing where the type is actually
|
||||
allocated. If the two types aren't associated with the same objfile,
|
||||
then we are in deep-s**t anyway... */
|
||||
|
||||
void
|
||||
smash_to_method_type (type, domain, to_type, args)
|
||||
struct type *type;
|
||||
struct type *domain;
|
||||
struct type *to_type;
|
||||
struct type **args;
|
||||
{
|
||||
struct objfile *objfile;
|
||||
|
||||
objfile = TYPE_OBJFILE (type);
|
||||
|
||||
(void) memset (type, 0, sizeof (struct type));
|
||||
TYPE_OBJFILE (type) = objfile;
|
||||
TYPE_TARGET_TYPE (type) = to_type;
|
||||
TYPE_DOMAIN_TYPE (type) = domain;
|
||||
TYPE_ARG_TYPES (type) = args;
|
||||
TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
|
||||
TYPE_CODE (type) = TYPE_CODE_METHOD;
|
||||
}
|
||||
|
||||
/* Return a typename for a struct/union/enum type
|
||||
without the tag qualifier. If the type has a NULL name,
|
||||
NULL is returned. */
|
||||
|
||||
char *
|
||||
type_name_no_tag (type)
|
||||
register const struct type *type;
|
||||
{
|
||||
register char *name;
|
||||
|
||||
if ((name = TYPE_NAME (type)) != NULL)
|
||||
{
|
||||
switch (TYPE_CODE (type))
|
||||
{
|
||||
case TYPE_CODE_STRUCT:
|
||||
if(!strncmp (name, "struct ", 7))
|
||||
{
|
||||
name += 7;
|
||||
}
|
||||
break;
|
||||
case TYPE_CODE_UNION:
|
||||
if(!strncmp (name, "union ", 6))
|
||||
{
|
||||
name += 6;
|
||||
}
|
||||
break;
|
||||
case TYPE_CODE_ENUM:
|
||||
if(!strncmp (name, "enum ", 5))
|
||||
{
|
||||
name += 5;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
return (name);
|
||||
}
|
||||
|
||||
/* Lookup a primitive type named NAME.
|
||||
Return zero if NAME is not a primitive type.*/
|
||||
|
||||
struct type *
|
||||
lookup_primitive_typename (name)
|
||||
char *name;
|
||||
{
|
||||
struct type ** const *p;
|
||||
|
||||
for (p = current_language -> la_builtin_type_vector; *p != NULL; p++)
|
||||
{
|
||||
if (!strcmp ((**p) -> name, name))
|
||||
{
|
||||
return (**p);
|
||||
}
|
||||
}
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
/* Lookup a typedef or primitive type named NAME,
|
||||
visible in lexical block BLOCK.
|
||||
If NOERR is nonzero, return zero if NAME is not suitably defined. */
|
||||
|
||||
struct type *
|
||||
lookup_typename (name, block, noerr)
|
||||
char *name;
|
||||
struct block *block;
|
||||
int noerr;
|
||||
{
|
||||
register struct symbol *sym;
|
||||
register struct type *tmp;
|
||||
|
||||
sym = lookup_symbol (name, block, VAR_NAMESPACE, 0, (struct symtab **) NULL);
|
||||
if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
|
||||
{
|
||||
tmp = lookup_primitive_typename (name);
|
||||
if (tmp)
|
||||
{
|
||||
return (tmp);
|
||||
}
|
||||
else if (!tmp && noerr)
|
||||
{
|
||||
return (NULL);
|
||||
}
|
||||
else
|
||||
{
|
||||
error ("No type named %s.", name);
|
||||
}
|
||||
}
|
||||
return (SYMBOL_TYPE (sym));
|
||||
}
|
||||
|
||||
struct type *
|
||||
lookup_unsigned_typename (name)
|
||||
char *name;
|
||||
{
|
||||
char *uns = alloca (strlen (name) + 10);
|
||||
|
||||
strcpy (uns, "unsigned ");
|
||||
strcpy (uns + 9, name);
|
||||
return (lookup_typename (uns, (struct block *) NULL, 0));
|
||||
}
|
||||
|
||||
/* Lookup a structure type named "struct NAME",
|
||||
visible in lexical block BLOCK. */
|
||||
|
||||
struct type *
|
||||
lookup_struct (name, block)
|
||||
char *name;
|
||||
struct block *block;
|
||||
{
|
||||
register struct symbol *sym;
|
||||
|
||||
sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
|
||||
(struct symtab **) NULL);
|
||||
|
||||
if (sym == NULL)
|
||||
{
|
||||
error ("No struct type named %s.", name);
|
||||
}
|
||||
if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
|
||||
{
|
||||
error ("This context has class, union or enum %s, not a struct.", name);
|
||||
}
|
||||
return (SYMBOL_TYPE (sym));
|
||||
}
|
||||
|
||||
/* Lookup a union type named "union NAME",
|
||||
visible in lexical block BLOCK. */
|
||||
|
||||
struct type *
|
||||
lookup_union (name, block)
|
||||
char *name;
|
||||
struct block *block;
|
||||
{
|
||||
register struct symbol *sym;
|
||||
|
||||
sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
|
||||
(struct symtab **) NULL);
|
||||
|
||||
if (sym == NULL)
|
||||
{
|
||||
error ("No union type named %s.", name);
|
||||
}
|
||||
if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_UNION)
|
||||
{
|
||||
error ("This context has class, struct or enum %s, not a union.", name);
|
||||
}
|
||||
return (SYMBOL_TYPE (sym));
|
||||
}
|
||||
|
||||
/* Lookup an enum type named "enum NAME",
|
||||
visible in lexical block BLOCK. */
|
||||
|
||||
struct type *
|
||||
lookup_enum (name, block)
|
||||
char *name;
|
||||
struct block *block;
|
||||
{
|
||||
register struct symbol *sym;
|
||||
|
||||
sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
|
||||
(struct symtab **) NULL);
|
||||
if (sym == NULL)
|
||||
{
|
||||
error ("No enum type named %s.", name);
|
||||
}
|
||||
if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
|
||||
{
|
||||
error ("This context has class, struct or union %s, not an enum.", name);
|
||||
}
|
||||
return (SYMBOL_TYPE (sym));
|
||||
}
|
||||
|
||||
/* Lookup a template type named "template NAME<TYPE>",
|
||||
visible in lexical block BLOCK. */
|
||||
|
||||
struct type *
|
||||
lookup_template_type (name, type, block)
|
||||
char *name;
|
||||
struct type *type;
|
||||
struct block *block;
|
||||
{
|
||||
struct symbol *sym;
|
||||
char *nam = (char*) alloca(strlen(name) + strlen(type->name) + 4);
|
||||
strcpy (nam, name);
|
||||
strcat (nam, "<");
|
||||
strcat (nam, type->name);
|
||||
strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
|
||||
|
||||
sym = lookup_symbol (nam, block, VAR_NAMESPACE, 0, (struct symtab **)NULL);
|
||||
|
||||
if (sym == NULL)
|
||||
{
|
||||
error ("No template type named %s.", name);
|
||||
}
|
||||
if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
|
||||
{
|
||||
error ("This context has class, union or enum %s, not a struct.", name);
|
||||
}
|
||||
return (SYMBOL_TYPE (sym));
|
||||
}
|
||||
|
||||
/* Given a type TYPE, lookup the type of the component of type named
|
||||
NAME.
|
||||
If NOERR is nonzero, return zero if NAME is not suitably defined. */
|
||||
|
||||
struct type *
|
||||
lookup_struct_elt_type (type, name, noerr)
|
||||
struct type *type;
|
||||
char *name;
|
||||
int noerr;
|
||||
{
|
||||
int i;
|
||||
|
||||
if (TYPE_CODE (type) != TYPE_CODE_STRUCT &&
|
||||
TYPE_CODE (type) != TYPE_CODE_UNION)
|
||||
{
|
||||
target_terminal_ours ();
|
||||
fflush (stdout);
|
||||
fprintf (stderr, "Type ");
|
||||
type_print (type, "", stderr, -1);
|
||||
error (" is not a structure or union type.");
|
||||
}
|
||||
|
||||
check_stub_type (type);
|
||||
|
||||
for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
|
||||
{
|
||||
char *t_field_name = TYPE_FIELD_NAME (type, i);
|
||||
|
||||
if (t_field_name && !strcmp (t_field_name, name))
|
||||
{
|
||||
return TYPE_FIELD_TYPE (type, i);
|
||||
}
|
||||
}
|
||||
|
||||
/* OK, it's not in this class. Recursively check the baseclasses. */
|
||||
for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
|
||||
{
|
||||
struct type *t;
|
||||
|
||||
t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 0);
|
||||
if (t != NULL)
|
||||
{
|
||||
return t;
|
||||
}
|
||||
}
|
||||
|
||||
if (noerr)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
target_terminal_ours ();
|
||||
fflush (stdout);
|
||||
fprintf (stderr, "Type ");
|
||||
type_print (type, "", stderr, -1);
|
||||
fprintf (stderr, " has no component named ");
|
||||
fputs_filtered (name, stderr);
|
||||
error (".");
|
||||
return (struct type *)-1; /* For lint */
|
||||
}
|
||||
|
||||
/* This function is really horrible, but to avoid it, there would need
|
||||
to be more filling in of forward references. */
|
||||
|
||||
void
|
||||
fill_in_vptr_fieldno (type)
|
||||
struct type *type;
|
||||
{
|
||||
if (TYPE_VPTR_FIELDNO (type) < 0)
|
||||
{
|
||||
int i;
|
||||
for (i = 1; i < TYPE_N_BASECLASSES (type); i++)
|
||||
{
|
||||
fill_in_vptr_fieldno (TYPE_BASECLASS (type, i));
|
||||
if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i)) >= 0)
|
||||
{
|
||||
TYPE_VPTR_FIELDNO (type)
|
||||
= TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i));
|
||||
TYPE_VPTR_BASETYPE (type)
|
||||
= TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type, i));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
|
||||
|
||||
If this is a stubbed struct (i.e. declared as struct foo *), see if
|
||||
we can find a full definition in some other file. If so, copy this
|
||||
definition, so we can use it in future. If not, set a flag so we
|
||||
don't waste too much time in future. (FIXME, this doesn't seem
|
||||
to be happening...)
|
||||
|
||||
This used to be coded as a macro, but I don't think it is called
|
||||
often enough to merit such treatment.
|
||||
*/
|
||||
|
||||
struct complaint stub_noname_complaint =
|
||||
{"stub type has NULL name", 0, 0};
|
||||
|
||||
void
|
||||
check_stub_type (type)
|
||||
struct type *type;
|
||||
{
|
||||
if (TYPE_FLAGS(type) & TYPE_FLAG_STUB)
|
||||
{
|
||||
char* name = type_name_no_tag (type);
|
||||
struct symbol *sym;
|
||||
if (name == NULL)
|
||||
{
|
||||
complain (&stub_noname_complaint, 0);
|
||||
return;
|
||||
}
|
||||
sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0,
|
||||
(struct symtab **) NULL);
|
||||
if (sym)
|
||||
{
|
||||
memcpy (type, SYMBOL_TYPE(sym), sizeof (struct type));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Ugly hack to convert method stubs into method types.
|
||||
|
||||
He ain't kiddin'. This demangles the name of the method into a string
|
||||
including argument types, parses out each argument type, generates
|
||||
a string casting a zero to that type, evaluates the string, and stuffs
|
||||
the resulting type into an argtype vector!!! Then it knows the type
|
||||
of the whole function (including argument types for overloading),
|
||||
which info used to be in the stab's but was removed to hack back
|
||||
the space required for them. */
|
||||
|
||||
void
|
||||
check_stub_method (type, i, j)
|
||||
struct type *type;
|
||||
int i;
|
||||
int j;
|
||||
{
|
||||
struct fn_field *f;
|
||||
char *mangled_name = gdb_mangle_name (type, i, j);
|
||||
char *demangled_name = cplus_demangle (mangled_name, 0);
|
||||
char *argtypetext, *p;
|
||||
int depth = 0, argcount = 1;
|
||||
struct type **argtypes;
|
||||
struct type *mtype;
|
||||
|
||||
if (demangled_name == NULL)
|
||||
{
|
||||
error ("Internal: Cannot demangle mangled name `%s'.", mangled_name);
|
||||
}
|
||||
|
||||
/* Now, read in the parameters that define this type. */
|
||||
argtypetext = strchr (demangled_name, '(') + 1;
|
||||
p = argtypetext;
|
||||
while (*p)
|
||||
{
|
||||
if (*p == '(')
|
||||
{
|
||||
depth += 1;
|
||||
}
|
||||
else if (*p == ')')
|
||||
{
|
||||
depth -= 1;
|
||||
}
|
||||
else if (*p == ',' && depth == 0)
|
||||
{
|
||||
argcount += 1;
|
||||
}
|
||||
|
||||
p += 1;
|
||||
}
|
||||
|
||||
/* We need two more slots: one for the THIS pointer, and one for the
|
||||
NULL [...] or void [end of arglist]. */
|
||||
|
||||
argtypes = (struct type **)
|
||||
obstack_alloc (&TYPE_OBJFILE (type) -> type_obstack,
|
||||
(argcount+2) * sizeof (struct type *));
|
||||
p = argtypetext;
|
||||
argtypes[0] = lookup_pointer_type (type);
|
||||
argcount = 1;
|
||||
|
||||
if (*p != ')') /* () means no args, skip while */
|
||||
{
|
||||
depth = 0;
|
||||
while (*p)
|
||||
{
|
||||
if (depth <= 0 && (*p == ',' || *p == ')'))
|
||||
{
|
||||
argtypes[argcount] =
|
||||
parse_and_eval_type (argtypetext, p - argtypetext);
|
||||
argcount += 1;
|
||||
argtypetext = p + 1;
|
||||
}
|
||||
|
||||
if (*p == '(')
|
||||
{
|
||||
depth += 1;
|
||||
}
|
||||
else if (*p == ')')
|
||||
{
|
||||
depth -= 1;
|
||||
}
|
||||
|
||||
p += 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (p[-2] != '.') /* ... */
|
||||
{
|
||||
argtypes[argcount] = builtin_type_void; /* Ellist terminator */
|
||||
}
|
||||
else
|
||||
{
|
||||
argtypes[argcount] = NULL; /* List terminator */
|
||||
}
|
||||
|
||||
free (demangled_name);
|
||||
|
||||
f = TYPE_FN_FIELDLIST1 (type, i);
|
||||
TYPE_FN_FIELD_PHYSNAME (f, j) = mangled_name;
|
||||
|
||||
/* Now update the old "stub" type into a real type. */
|
||||
mtype = TYPE_FN_FIELD_TYPE (f, j);
|
||||
TYPE_DOMAIN_TYPE (mtype) = type;
|
||||
TYPE_ARG_TYPES (mtype) = argtypes;
|
||||
TYPE_FLAGS (mtype) &= ~TYPE_FLAG_STUB;
|
||||
TYPE_FN_FIELD_STUB (f, j) = 0;
|
||||
}
|
||||
|
||||
const struct cplus_struct_type cplus_struct_default;
|
||||
|
||||
void
|
||||
allocate_cplus_struct_type (type)
|
||||
struct type *type;
|
||||
{
|
||||
if (!HAVE_CPLUS_STRUCT (type))
|
||||
{
|
||||
TYPE_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
|
||||
obstack_alloc (¤t_objfile -> type_obstack,
|
||||
sizeof (struct cplus_struct_type));
|
||||
*(TYPE_CPLUS_SPECIFIC(type)) = cplus_struct_default;
|
||||
}
|
||||
}
|
||||
|
||||
/* Helper function to initialize the standard scalar types. */
|
||||
|
||||
struct type *
|
||||
init_type (code, length, flags, name, objfile)
|
||||
enum type_code code;
|
||||
int length;
|
||||
int flags;
|
||||
char *name;
|
||||
struct objfile *objfile;
|
||||
{
|
||||
register struct type *type;
|
||||
|
||||
type = alloc_type (objfile);
|
||||
TYPE_CODE (type) = code;
|
||||
TYPE_LENGTH (type) = length;
|
||||
TYPE_FLAGS (type) |= flags;
|
||||
TYPE_NAME (type) = name;
|
||||
|
||||
/* C++ fancies. */
|
||||
|
||||
if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION)
|
||||
{
|
||||
INIT_CPLUS_SPECIFIC (type);
|
||||
}
|
||||
return (type);
|
||||
}
|
||||
|
||||
/* Look up a fundamental type for the specified objfile.
|
||||
May need to construct such a type if this is the first use.
|
||||
|
||||
Some object file formats (ELF, COFF, etc) do not define fundamental
|
||||
types such as "int" or "double". Others (stabs for example), do
|
||||
define fundamental types.
|
||||
|
||||
For the formats which don't provide fundamental types, gdb can create
|
||||
such types, using defaults reasonable for the current target machine. */
|
||||
|
||||
struct type *
|
||||
lookup_fundamental_type (objfile, typeid)
|
||||
struct objfile *objfile;
|
||||
int typeid;
|
||||
{
|
||||
register struct type *type = NULL;
|
||||
register struct type **typep;
|
||||
register int nbytes;
|
||||
|
||||
if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
|
||||
{
|
||||
error ("internal error - invalid fundamental type id %d", typeid);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* If this is the first time we */
|
||||
if (objfile -> fundamental_types == NULL)
|
||||
{
|
||||
nbytes = FT_NUM_MEMBERS * sizeof (struct type *);
|
||||
objfile -> fundamental_types = (struct type **)
|
||||
obstack_alloc (&objfile -> type_obstack, nbytes);
|
||||
(void) memset (objfile -> fundamental_types, 0, nbytes);
|
||||
}
|
||||
typep = objfile -> fundamental_types + typeid;
|
||||
if ((type = *typep) == NULL)
|
||||
{
|
||||
switch (typeid)
|
||||
{
|
||||
default:
|
||||
error ("internal error: unhandled type id %d", typeid);
|
||||
break;
|
||||
case FT_VOID:
|
||||
type = init_type (TYPE_CODE_VOID,
|
||||
TARGET_CHAR_BIT / TARGET_CHAR_BIT,
|
||||
0,
|
||||
"void", objfile);
|
||||
break;
|
||||
case FT_BOOLEAN:
|
||||
type = init_type (TYPE_CODE_INT,
|
||||
TARGET_INT_BIT / TARGET_CHAR_BIT,
|
||||
TYPE_FLAG_UNSIGNED,
|
||||
"boolean", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_STRING:
|
||||
type = init_type (TYPE_CODE_PASCAL_ARRAY,
|
||||
TARGET_CHAR_BIT / TARGET_CHAR_BIT,
|
||||
0,
|
||||
"string", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_CHAR:
|
||||
type = init_type (TYPE_CODE_INT,
|
||||
TARGET_CHAR_BIT / TARGET_CHAR_BIT,
|
||||
0,
|
||||
"char", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_SIGNED_CHAR:
|
||||
type = init_type (TYPE_CODE_INT,
|
||||
TARGET_CHAR_BIT / TARGET_CHAR_BIT,
|
||||
TYPE_FLAG_SIGNED,
|
||||
"signed char", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_UNSIGNED_CHAR:
|
||||
type = init_type (TYPE_CODE_INT,
|
||||
TARGET_CHAR_BIT / TARGET_CHAR_BIT,
|
||||
TYPE_FLAG_UNSIGNED,
|
||||
"unsigned char", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_SHORT:
|
||||
type = init_type (TYPE_CODE_INT,
|
||||
TARGET_SHORT_BIT / TARGET_CHAR_BIT,
|
||||
0,
|
||||
"short", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_SIGNED_SHORT:
|
||||
type = init_type (TYPE_CODE_INT,
|
||||
TARGET_SHORT_BIT / TARGET_CHAR_BIT,
|
||||
TYPE_FLAG_SIGNED,
|
||||
"signed short", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_UNSIGNED_SHORT:
|
||||
type = init_type (TYPE_CODE_INT,
|
||||
TARGET_SHORT_BIT / TARGET_CHAR_BIT,
|
||||
TYPE_FLAG_UNSIGNED,
|
||||
"unsigned short", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_INTEGER:
|
||||
type = init_type (TYPE_CODE_INT,
|
||||
TARGET_INT_BIT / TARGET_CHAR_BIT,
|
||||
0,
|
||||
"int", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_SIGNED_INTEGER:
|
||||
type = init_type (TYPE_CODE_INT,
|
||||
TARGET_INT_BIT / TARGET_CHAR_BIT,
|
||||
TYPE_FLAG_SIGNED,
|
||||
"signed int", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_UNSIGNED_INTEGER:
|
||||
type = init_type (TYPE_CODE_INT,
|
||||
TARGET_INT_BIT / TARGET_CHAR_BIT,
|
||||
TYPE_FLAG_UNSIGNED,
|
||||
"unsigned int", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_LONG:
|
||||
type = init_type (TYPE_CODE_INT,
|
||||
TARGET_LONG_BIT / TARGET_CHAR_BIT,
|
||||
0,
|
||||
"long", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_SIGNED_LONG:
|
||||
type = init_type (TYPE_CODE_INT,
|
||||
TARGET_LONG_BIT / TARGET_CHAR_BIT,
|
||||
TYPE_FLAG_SIGNED,
|
||||
"signed long", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_UNSIGNED_LONG:
|
||||
type = init_type (TYPE_CODE_INT,
|
||||
TARGET_LONG_BIT / TARGET_CHAR_BIT,
|
||||
TYPE_FLAG_UNSIGNED,
|
||||
"unsigned long", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_LONG_LONG:
|
||||
type = init_type (TYPE_CODE_INT,
|
||||
TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
|
||||
0,
|
||||
"long long", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_SIGNED_LONG_LONG:
|
||||
type = init_type (TYPE_CODE_INT,
|
||||
TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
|
||||
TYPE_FLAG_SIGNED,
|
||||
"signed long long", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_UNSIGNED_LONG_LONG:
|
||||
type = init_type (TYPE_CODE_INT,
|
||||
TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
|
||||
TYPE_FLAG_UNSIGNED,
|
||||
"unsigned long long",
|
||||
(struct objfile *) NULL);
|
||||
break;
|
||||
case FT_FLOAT:
|
||||
type = init_type (TYPE_CODE_FLT,
|
||||
TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
|
||||
0,
|
||||
"float", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_DBL_PREC_FLOAT:
|
||||
type = init_type (TYPE_CODE_FLT,
|
||||
TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
|
||||
0,
|
||||
"double", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_EXT_PREC_FLOAT:
|
||||
type = init_type (TYPE_CODE_FLT,
|
||||
TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
|
||||
0,
|
||||
"long double", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_COMPLEX:
|
||||
type = init_type (TYPE_CODE_FLT,
|
||||
TARGET_COMPLEX_BIT / TARGET_CHAR_BIT,
|
||||
0,
|
||||
"complex", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_DBL_PREC_COMPLEX:
|
||||
type = init_type (TYPE_CODE_FLT,
|
||||
TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
|
||||
0,
|
||||
"double complex", (struct objfile *) NULL);
|
||||
break;
|
||||
case FT_EXT_PREC_COMPLEX:
|
||||
type = init_type (TYPE_CODE_FLT,
|
||||
TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
|
||||
0,
|
||||
"long double complex",
|
||||
(struct objfile *) NULL);
|
||||
break;
|
||||
}
|
||||
/* Install the newly created type in the objfile's fundamental_types
|
||||
vector. */
|
||||
*typep = type;
|
||||
}
|
||||
}
|
||||
return (type);
|
||||
}
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue