/* Support routines for manipulating internal types for GDB.
- Copyright (C) 1992 Free Software Foundation, Inc.
+ Copyright (C) 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
This file is part of GDB.
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. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include "defs.h"
-#include <string.h>
+#include "gdb_string.h"
#include "bfd.h"
#include "symtab.h"
#include "symfile.h"
{
type = (struct type *) obstack_alloc (&objfile -> type_obstack,
sizeof (struct type));
+ OBJSTAT (objfile, n_types++);
}
memset ((char *) type, 0, sizeof (struct type));
register struct type *ntype; /* New type */
struct objfile *objfile;
- ntype = TYPE_FUNCTION_TYPE (type);
-
- if (ntype)
- if (typeptr == 0)
- return ntype; /* Don't care about alloc, and have new type. */
- else if (*typeptr == 0)
- {
- *typeptr = ntype; /* Tracking alloc, and we have new type. */
- return ntype;
- }
-
if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
{
ntype = alloc_type (TYPE_OBJFILE (type));
}
TYPE_TARGET_TYPE (ntype) = type;
- TYPE_FUNCTION_TYPE (type) = ntype;
TYPE_LENGTH (ntype) = 1;
TYPE_CODE (ntype) = TYPE_CODE_FUNC;
- if (!TYPE_FUNCTION_TYPE (type)) /* Remember it, if don't have one. */
- TYPE_FUNCTION_TYPE (type) = ntype;
-
return ntype;
}
}
TYPE_CODE (result_type) = TYPE_CODE_RANGE;
TYPE_TARGET_TYPE (result_type) = index_type;
- TYPE_LENGTH (result_type) = TYPE_LENGTH (index_type);
+ if (TYPE_FLAGS (index_type) & TYPE_FLAG_STUB)
+ TYPE_FLAGS (result_type) |= TYPE_FLAG_TARGET_STUB;
+ else
+ TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
TYPE_NFIELDS (result_type) = 2;
TYPE_FIELDS (result_type) = (struct field *)
TYPE_ALLOC (result_type, 2 * sizeof (struct field));
return (result_type);
}
-/* A lot of code assumes that the "index type" of an array/string/
- set/bitstring is specifically a range type, though in some languages
- it can be any discrete type. */
+/* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE.
+ Return 1 of type is a range type, 0 if it is discrete (and bounds
+ will fit in LONGEST), or -1 otherwise. */
-struct type *
-force_to_range_type (type)
+int
+get_discrete_bounds (type, lowp, highp)
struct type *type;
+ LONGEST *lowp, *highp;
{
+ CHECK_TYPEDEF (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_RANGE:
- return type;
-
+ *lowp = TYPE_LOW_BOUND (type);
+ *highp = TYPE_HIGH_BOUND (type);
+ return 1;
case TYPE_CODE_ENUM:
- {
- int low_bound = TYPE_FIELD_BITPOS (type, 0);
- int high_bound = TYPE_FIELD_BITPOS (type, TYPE_NFIELDS (type) - 1);
- struct type *range_type =
- create_range_type (NULL, type, low_bound, high_bound);
- TYPE_NAME (range_type) = TYPE_NAME (range_type);
- TYPE_DUMMY_RANGE (range_type) = 1;
- return range_type;
- }
+ if (TYPE_NFIELDS (type) > 0)
+ {
+ /* The enums may not be sorted by value, so search all
+ entries */
+ int i;
+
+ *lowp = *highp = TYPE_FIELD_BITPOS (type, 0);
+ for (i = 0; i < TYPE_NFIELDS (type); i++)
+ {
+ if (TYPE_FIELD_BITPOS (type, i) < *lowp)
+ *lowp = TYPE_FIELD_BITPOS (type, i);
+ if (TYPE_FIELD_BITPOS (type, i) > *highp)
+ *highp = TYPE_FIELD_BITPOS (type, i);
+ }
+ }
+ else
+ {
+ *lowp = 0;
+ *highp = -1;
+ }
+ return 0;
case TYPE_CODE_BOOL:
- {
- struct type *range_type = create_range_type (NULL, type, 0, 1);
- TYPE_NAME (range_type) = TYPE_NAME (range_type);
- TYPE_DUMMY_RANGE (range_type) = 1;
- return range_type;
- }
+ *lowp = 0;
+ *highp = 1;
+ return 0;
+ case TYPE_CODE_INT:
+ if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */
+ return -1;
+ if (!TYPE_UNSIGNED (type))
+ {
+ *lowp = - (1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
+ *highp = -*lowp - 1;
+ return 0;
+ }
+ /* ... fall through for unsigned ints ... */
case TYPE_CODE_CHAR:
- {
- struct type *range_type = create_range_type (NULL, type, 0, 255);
- TYPE_NAME (range_type) = TYPE_NAME (range_type);
- TYPE_DUMMY_RANGE (range_type) = 1;
- return range_type;
- }
+ *lowp = 0;
+ /* This round-about calculation is to avoid shifting by
+ TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
+ if TYPE_LENGTH (type) == sizeof (LONGEST). */
+ *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
+ *highp = (*highp - 1) | *highp;
+ return 0;
default:
- {
- static struct complaint msg =
- { "array index type must be a discrete type", 0, 0};
- complain (&msg);
-
- return create_range_type (NULL, builtin_type_int, 0, 0);
- }
+ return -1;
}
}
struct type *element_type;
struct type *range_type;
{
- int low_bound;
- int high_bound;
+ LONGEST low_bound, high_bound;
- range_type = force_to_range_type (range_type);
if (result_type == NULL)
{
result_type = alloc_type (TYPE_OBJFILE (range_type));
}
TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
TYPE_TARGET_TYPE (result_type) = element_type;
- low_bound = TYPE_LOW_BOUND (range_type);
- high_bound = TYPE_HIGH_BOUND (range_type);
+ if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
+ low_bound = high_bound = 0;
+ CHECK_TYPEDEF (element_type);
TYPE_LENGTH (result_type) =
TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
TYPE_NFIELDS (result_type) = 1;
struct type *result_type;
struct type *range_type;
{
- result_type = create_array_type (result_type, builtin_type_char, range_type);
+ result_type = create_array_type (result_type,
+ *current_language->string_char_type,
+ range_type);
TYPE_CODE (result_type) = TYPE_CODE_STRING;
return (result_type);
}
struct type *result_type;
struct type *domain_type;
{
- int low_bound, high_bound, bit_length;
+ LONGEST low_bound, high_bound, bit_length;
if (result_type == NULL)
{
result_type = alloc_type (TYPE_OBJFILE (domain_type));
if (! (TYPE_FLAGS (domain_type) & TYPE_FLAG_STUB))
{
- domain_type = force_to_range_type (domain_type);
- low_bound = TYPE_LOW_BOUND (domain_type);
- high_bound = TYPE_HIGH_BOUND (domain_type);
+ if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
+ low_bound = high_bound = 0;
bit_length = high_bound - low_bound + 1;
TYPE_LENGTH (result_type)
- = ((bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT)
- * TARGET_CHAR_BIT;
+ = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
}
TYPE_FIELD_TYPE (result_type, 0) = domain_type;
return (result_type);
}
-/* Create an F77 literal complex type composed of the two types we are
- given as arguments. */
-
-struct type *
-f77_create_literal_complex_type (type_arg1, type_arg2)
- struct type *type_arg1;
- struct type *type_arg2;
-{
- struct type *result;
-
- /* First make sure that the 2 components of the complex
- number both have the same type */
-
- if (TYPE_CODE (type_arg1) != TYPE_CODE (type_arg2))
- error ("Both components of a F77 complex number must have the same type!");
-
- result = alloc_type (TYPE_OBJFILE (type_arg1));
-
- TYPE_CODE (result) = TYPE_CODE_LITERAL_COMPLEX;
- TYPE_LENGTH (result) = TYPE_LENGTH(type_arg1) * 2;
-
- return result;
-}
-
-/* Create a F77 LITERAL string type supplied by the user from the keyboard.
-
- Elements will be of type ELEMENT_TYPE, the indices will be of type
- RANGE_TYPE.
-
- FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
- sure it is TYPE_CODE_UNDEF before we bash it into an array type?
-
- This is a total clone of create_array_type() except that there are
- a few simplyfing assumptions (e.g all bound types are simple). */
-
-struct type *
-f77_create_literal_string_type (result_type, range_type)
- struct type *result_type;
- struct type *range_type;
-{
- int low_bound;
- int high_bound;
-
- if (TYPE_CODE (range_type) != TYPE_CODE_RANGE)
- {
- /* FIXME: We only handle range types at the moment. Complain and
- create a dummy range type to use. */
- warning ("internal error: array index type must be a range type");
- range_type = lookup_fundamental_type (TYPE_OBJFILE (range_type),
- FT_INTEGER);
- range_type = create_range_type ((struct type *) NULL, range_type, 0, 0);
- }
- if (result_type == NULL)
- result_type = alloc_type (TYPE_OBJFILE (range_type));
- TYPE_CODE (result_type) = TYPE_CODE_LITERAL_STRING;
- TYPE_TARGET_TYPE (result_type) = builtin_type_f_character;
- low_bound = TYPE_FIELD_BITPOS (range_type, 0);
- high_bound = TYPE_FIELD_BITPOS (range_type, 1);
-
- /* Safely can assume that all bound types are simple */
-
- TYPE_LENGTH (result_type) =
- TYPE_LENGTH (builtin_type_f_character) * (high_bound - low_bound + 1);
-
- TYPE_NFIELDS (result_type) = 1;
- TYPE_FIELDS (result_type) =
- (struct field *) TYPE_ALLOC (result_type, sizeof (struct field));
- memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
- TYPE_FIELD_TYPE (result_type, 0) = range_type;
- TYPE_VPTR_FIELDNO (result_type) = -1;
-
- /* Remember that all literal strings in F77 are of the
- character*N type. */
-
- TYPE_ARRAY_LOWER_BOUND_TYPE (result_type) = BOUND_SIMPLE;
- TYPE_ARRAY_UPPER_BOUND_TYPE (result_type) = BOUND_SIMPLE;
-
- 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
{
int i;
- while (TYPE_CODE (type) == TYPE_CODE_PTR ||
- TYPE_CODE (type) == TYPE_CODE_REF)
+ for (;;)
+ {
+ CHECK_TYPEDEF (type);
+ if (TYPE_CODE (type) != TYPE_CODE_PTR
+ && TYPE_CODE (type) != TYPE_CODE_REF)
+ break;
type = TYPE_TARGET_TYPE (type);
+ }
if (TYPE_CODE (type) != TYPE_CODE_STRUCT &&
TYPE_CODE (type) != TYPE_CODE_UNION)
error (" is not a structure or union type.");
}
- check_stub_type (type);
-
#if 0
/* FIXME: This change put in by Michael seems incorrect for the case where
the structure tag name is the same as the member name. I.E. when doing
fill_in_vptr_fieldno (type)
struct type *type;
{
- check_stub_type (type);
+ CHECK_TYPEDEF (type);
if (TYPE_VPTR_FIELDNO (type) < 0)
{
struct complaint stub_noname_complaint =
{"stub type has NULL name", 0, 0};
-void
-check_stub_type (type)
- struct type *type;
+struct type *
+check_typedef (type)
+ register struct type *type;
{
- if (TYPE_FLAGS(type) & TYPE_FLAG_STUB)
+ struct type *orig_type = type;
+ while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
+ {
+ if (!TYPE_TARGET_TYPE (type))
+ {
+ char* name;
+ struct symbol *sym;
+
+ /* It is dangerous to call lookup_symbol if we are currently
+ reading a symtab. Infinite recursion is one danger. */
+ if (currently_reading_symtab)
+ return type;
+
+ name = type_name_no_tag (type);
+ /* FIXME: shouldn't we separately check the TYPE_NAME and the
+ TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
+ as appropriate? (this code was written before TYPE_NAME and
+ TYPE_TAG_NAME were separate). */
+ if (name == NULL)
+ {
+ complain (&stub_noname_complaint);
+ return type;
+ }
+ sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0,
+ (struct symtab **) NULL);
+ if (sym)
+ TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
+ else
+ TYPE_TARGET_TYPE (type) = alloc_type (NULL); /* TYPE_CODE_UNDEF */
+ }
+ type = TYPE_TARGET_TYPE (type);
+ }
+
+ if ((TYPE_FLAGS(type) & TYPE_FLAG_STUB) && ! currently_reading_symtab)
{
char* name = type_name_no_tag (type);
/* FIXME: shouldn't we separately check the TYPE_NAME and the
if (name == NULL)
{
complain (&stub_noname_complaint);
- return;
+ return type;
}
sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0,
(struct symtab **) NULL);
if (TYPE_FLAGS (type) & TYPE_FLAG_TARGET_STUB)
{
struct type *range_type;
-
- check_stub_type (TYPE_TARGET_TYPE (type));
- if (!(TYPE_FLAGS (TYPE_TARGET_TYPE (type)) & TYPE_FLAG_STUB)
- && TYPE_CODE (type) == TYPE_CODE_ARRAY
- && TYPE_NFIELDS (type) == 1
- && (TYPE_CODE (range_type = TYPE_FIELD_TYPE (type, 0))
- == TYPE_CODE_RANGE))
+ struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
+
+ if (TYPE_FLAGS (target_type) & TYPE_FLAG_STUB)
+ { }
+ else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
+ && TYPE_NFIELDS (type) == 1
+ && (TYPE_CODE (range_type = TYPE_FIELD_TYPE (type, 0))
+ == TYPE_CODE_RANGE))
{
/* Now recompute the length of the array type, based on its
number of elements and the target type's length. */
((TYPE_FIELD_BITPOS (range_type, 1)
- TYPE_FIELD_BITPOS (range_type, 0)
+ 1)
- * TYPE_LENGTH (TYPE_TARGET_TYPE (type)));
+ * TYPE_LENGTH (target_type));
+ TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB;
+ }
+ else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
+ {
+ TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB;
}
}
+ /* Cache TYPE_LENGTH for future use. */
+ TYPE_LENGTH (orig_type) = TYPE_LENGTH (type);
+ return type;
}
/* Ugly hack to convert method stubs into method types.
struct type **argtypes;
struct type *mtype;
- if (demangled_name == NULL)
- {
- error ("Internal: Cannot demangle mangled name `%s'.", mangled_name);
- }
+ /* Make sure we got back a function string that we can use. */
+ if (demangled_name)
+ p = strchr (demangled_name, '(');
+
+ if (demangled_name == NULL || p == 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;
+ p += 1;
+ argtypetext = p;
while (*p)
{
if (*p == '(')
objfile -> fundamental_types = (struct type **)
obstack_alloc (&objfile -> type_obstack, nbytes);
memset ((char *) objfile -> fundamental_types, 0, nbytes);
+ OBJSTAT (objfile, n_types += FT_NUM_MEMBERS);
}
/* Look for this particular type in the fundamental type vector. If one is
struct type *t;
{
/* FIXME: Should we return true for references as well as pointers? */
+ CHECK_TYPEDEF (t);
return
(t != NULL
&& TYPE_CODE (t) == TYPE_CODE_PTR
}
}
+static struct obstack dont_print_type_obstack;
+
void
recursive_dump_type (type, spaces)
struct type *type;
{
int idx;
+ if (spaces == 0)
+ obstack_begin (&dont_print_type_obstack, 0);
+
+ if (TYPE_NFIELDS (type) > 0
+ || (TYPE_CPLUS_SPECIFIC (type) && TYPE_NFN_FIELDS (type) > 0))
+ {
+ struct type **first_dont_print
+ = (struct type **)obstack_base (&dont_print_type_obstack);
+
+ int i = (struct type **)obstack_next_free (&dont_print_type_obstack)
+ - first_dont_print;
+
+ while (--i >= 0)
+ {
+ if (type == first_dont_print[i])
+ {
+ printfi_filtered (spaces, "type node ");
+ gdb_print_address (type, gdb_stdout);
+ printf_filtered (" <same as already seen type>\n");
+ return;
+ }
+ }
+
+ obstack_ptr_grow (&dont_print_type_obstack, type);
+ }
+
printfi_filtered (spaces, "type node ");
gdb_print_address (type, gdb_stdout);
printf_filtered ("\n");
case TYPE_CODE_BOOL:
printf_filtered ("(TYPE_CODE_BOOL)");
break;
+ case TYPE_CODE_TYPEDEF:
+ printf_filtered ("(TYPE_CODE_TYPEDEF)");
+ break;
default:
printf_filtered ("(UNKNOWN TYPE CODE)");
break;
printfi_filtered (spaces, "reference_type ");
gdb_print_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
printf_filtered ("\n");
- printfi_filtered (spaces, "function_type ");
- gdb_print_address (TYPE_FUNCTION_TYPE (type), gdb_stdout);
- printf_filtered ("\n");
printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
if (TYPE_FLAGS (type) & TYPE_FLAG_UNSIGNED)
{
break;
}
+ if (spaces == 0)
+ obstack_free (&dont_print_type_obstack, NULL);
}
#endif /* MAINTENANCE_CMDS */
0,
"long double", (struct objfile *) NULL);
builtin_type_complex =
- init_type (TYPE_CODE_FLT, TARGET_COMPLEX_BIT / TARGET_CHAR_BIT,
+ init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
0,
"complex", (struct objfile *) NULL);
+ TYPE_TARGET_TYPE (builtin_type_complex) = builtin_type_float;
builtin_type_double_complex =
- init_type (TYPE_CODE_FLT, TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
+ init_type (TYPE_CODE_COMPLEX, 2 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
0,
"double complex", (struct objfile *) NULL);
+ TYPE_TARGET_TYPE (builtin_type_double_complex) = builtin_type_double;
builtin_type_string =
init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
0,
projects / binutils.git / blobdiff