}
}
- if (p[-2] != '.') /* ... */
+ if (p[-2] != '.') /* Not '...' */
{
- argtypes[argcount] = builtin_type_void; /* Ellist terminator */
+ argtypes[argcount] = builtin_type_void; /* List terminator */
}
else
{
- argtypes[argcount] = NULL; /* List terminator */
+ argtypes[argcount] = NULL; /* Ellist terminator */
}
free (demangled_name);
}
}
+/* The args list is a strange beast. It is either terminated by a NULL
+ pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
+ type for normal fixed argcount functions. (FIXME someday)
+ Also note the first arg should be the "this" pointer, we may not want to
+ include it since we may get into a infinitely recursive situation. */
+
+static void
+print_arg_types (args, spaces)
+ struct type **args;
+ int spaces;
+{
+ if (args != NULL)
+ {
+ while (*args != NULL)
+ {
+ recursive_dump_type (*args, spaces + 2);
+ if ((*args++) -> code == TYPE_CODE_VOID)
+ {
+ break;
+ }
+ }
+ }
+}
+
+static void
+dump_fn_fieldlists (type, spaces)
+ struct type *type;
+ int spaces;
+{
+ int method_idx;
+ int overload_idx;
+ struct fn_field *f;
+
+ printfi_filtered (spaces, "fn_fieldlists 0x%x\n",
+ TYPE_FN_FIELDLISTS (type));
+ for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
+ {
+ f = TYPE_FN_FIELDLIST1 (type, method_idx);
+ printfi_filtered (spaces + 2, "[%d] name '%s' (0x%x) length %d\n",
+ method_idx,
+ TYPE_FN_FIELDLIST_NAME (type, method_idx),
+ TYPE_FN_FIELDLIST_NAME (type, method_idx),
+ TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
+ for (overload_idx = 0;
+ overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
+ overload_idx++)
+ {
+ printfi_filtered (spaces + 4, "[%d] physname '%s' (0x%x)\n",
+ overload_idx,
+ TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
+ TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
+ printfi_filtered (spaces + 8, "type 0x%x\n",
+ TYPE_FN_FIELD_TYPE (f, overload_idx));
+ recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
+ spaces + 8 + 2);
+ printfi_filtered (spaces + 8, "args 0x%x\n",
+ TYPE_FN_FIELD_ARGS (f, overload_idx));
+ print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx), spaces);
+ printfi_filtered (spaces + 8, "fcontext 0x%x\n",
+ TYPE_FN_FIELD_FCONTEXT (f, overload_idx));
+ printfi_filtered (spaces + 8, "is_const %d\n",
+ TYPE_FN_FIELD_CONST (f, overload_idx));
+ printfi_filtered (spaces + 8, "is_volatile %d\n",
+ TYPE_FN_FIELD_VOLATILE (f, overload_idx));
+ printfi_filtered (spaces + 8, "is_private %d\n",
+ TYPE_FN_FIELD_PRIVATE (f, overload_idx));
+ printfi_filtered (spaces + 8, "is_protected %d\n",
+ TYPE_FN_FIELD_PROTECTED (f, overload_idx));
+ printfi_filtered (spaces + 8, "is_stub %d\n",
+ TYPE_FN_FIELD_STUB (f, overload_idx));
+ printfi_filtered (spaces + 8, "voffset %d\n",
+ TYPE_FN_FIELD_VOFFSET (f, overload_idx));
+ }
+ }
+}
+
static void
print_cplus_stuff (type, spaces)
struct type *type;
{
int bitno;
- printfi_filtered (spaces, "cplus_stuff: @ 0x%x\n",
+ printfi_filtered (spaces, "cplus_stuff 0x%x\n",
TYPE_CPLUS_SPECIFIC (type));
- printfi_filtered (spaces, "n_baseclasses: %d\n",
+ printfi_filtered (spaces, "n_baseclasses %d\n",
TYPE_N_BASECLASSES (type));
+ printfi_filtered (spaces, "nfn_fields %d\n",
+ TYPE_NFN_FIELDS (type));
+ printfi_filtered (spaces, "nfn_fields_total %d\n",
+ TYPE_NFN_FIELDS_TOTAL (type));
if (TYPE_N_BASECLASSES (type) > 0)
{
- printfi_filtered (spaces, "virtual_field_bits: %d @ 0x%x:",
+ printfi_filtered (spaces, "virtual_field_bits %d 0x%x",
TYPE_N_BASECLASSES (type),
TYPE_FIELD_VIRTUAL_BITS (type));
print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
{
if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
{
- printfi_filtered (spaces, "private_field_bits: %d @ 0x%x:",
+ printfi_filtered (spaces, "private_field_bits %d 0x%x",
TYPE_NFIELDS (type),
TYPE_FIELD_PRIVATE_BITS (type));
print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
}
if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
{
- printfi_filtered (spaces, "protected_field_bits: %d @ 0x%x:",
+ printfi_filtered (spaces, "protected_field_bits %d 0x%x",
TYPE_NFIELDS (type),
TYPE_FIELD_PROTECTED_BITS (type));
print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
puts_filtered ("\n");
}
}
+ if (TYPE_NFN_FIELDS (type) > 0)
+ {
+ dump_fn_fieldlists (type, spaces);
+ }
}
void
{
int idx;
- printfi_filtered (spaces, "type node @ 0x%x\n", type);
- printfi_filtered (spaces, "name: @ 0x%x '%s'\n", TYPE_NAME (type),
+ printfi_filtered (spaces, "type node 0x%x\n", type);
+ printfi_filtered (spaces, "name '%s' (0x%x)\n", TYPE_NAME (type),
TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
- printfi_filtered (spaces, "code: 0x%x ", TYPE_CODE (type));
+ printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
switch (TYPE_CODE (type))
{
case TYPE_CODE_UNDEF:
- printf_filtered ("TYPE_CODE_UNDEF");
+ printf_filtered ("(TYPE_CODE_UNDEF)");
break;
case TYPE_CODE_PTR:
- printf_filtered ("TYPE_CODE_PTR");
+ printf_filtered ("(TYPE_CODE_PTR)");
break;
case TYPE_CODE_ARRAY:
- printf_filtered ("TYPE_CODE_ARRAY");
+ printf_filtered ("(TYPE_CODE_ARRAY)");
break;
case TYPE_CODE_STRUCT:
- printf_filtered ("TYPE_CODE_STRUCT");
+ printf_filtered ("(TYPE_CODE_STRUCT)");
break;
case TYPE_CODE_UNION:
- printf_filtered ("TYPE_CODE_UNION");
+ printf_filtered ("(TYPE_CODE_UNION)");
break;
case TYPE_CODE_ENUM:
- printf_filtered ("TYPE_CODE_ENUM");
+ printf_filtered ("(TYPE_CODE_ENUM)");
break;
case TYPE_CODE_FUNC:
- printf_filtered ("TYPE_CODE_FUNC");
+ printf_filtered ("(TYPE_CODE_FUNC)");
break;
case TYPE_CODE_INT:
- printf_filtered ("TYPE_CODE_INT");
+ printf_filtered ("(TYPE_CODE_INT)");
break;
case TYPE_CODE_FLT:
- printf_filtered ("TYPE_CODE_FLT");
+ printf_filtered ("(TYPE_CODE_FLT)");
break;
case TYPE_CODE_VOID:
- printf_filtered ("TYPE_CODE_VOID");
+ printf_filtered ("(TYPE_CODE_VOID)");
break;
case TYPE_CODE_SET:
- printf_filtered ("TYPE_CODE_SET");
+ printf_filtered ("(TYPE_CODE_SET)");
break;
case TYPE_CODE_RANGE:
- printf_filtered ("TYPE_CODE_RANGE");
+ printf_filtered ("(TYPE_CODE_RANGE)");
break;
case TYPE_CODE_PASCAL_ARRAY:
- printf_filtered ("TYPE_CODE_PASCAL_ARRAY");
+ printf_filtered ("(TYPE_CODE_PASCAL_ARRAY)");
break;
case TYPE_CODE_ERROR:
- printf_filtered ("TYPE_CODE_ERROR");
+ printf_filtered ("(TYPE_CODE_ERROR)");
break;
case TYPE_CODE_MEMBER:
- printf_filtered ("TYPE_CODE_MEMBER");
+ printf_filtered ("(TYPE_CODE_MEMBER)");
break;
case TYPE_CODE_METHOD:
- printf_filtered ("TYPE_CODE_METHOD");
+ printf_filtered ("(TYPE_CODE_METHOD)");
break;
case TYPE_CODE_REF:
- printf_filtered ("TYPE_CODE_REF");
+ printf_filtered ("(TYPE_CODE_REF)");
break;
case TYPE_CODE_CHAR:
- printf_filtered ("TYPE_CODE_CHAR");
+ printf_filtered ("(TYPE_CODE_CHAR)");
break;
case TYPE_CODE_BOOL:
- printf_filtered ("TYPE_CODE_BOOL");
+ printf_filtered ("(TYPE_CODE_BOOL)");
break;
default:
- printf_filtered ("<UNKNOWN TYPE CODE>");
+ printf_filtered ("(UNKNOWN TYPE CODE)");
break;
}
puts_filtered ("\n");
- printfi_filtered (spaces, "length: %d\n", TYPE_LENGTH (type));
- printfi_filtered (spaces, "objfile: @ 0x%x\n", TYPE_OBJFILE (type));
- printfi_filtered (spaces, "target_type: @ 0x%x\n", TYPE_TARGET_TYPE (type));
+ printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
+ printfi_filtered (spaces, "objfile 0x%x\n", TYPE_OBJFILE (type));
+ printfi_filtered (spaces, "target_type 0x%x\n", TYPE_TARGET_TYPE (type));
if (TYPE_TARGET_TYPE (type) != NULL)
{
recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
}
- printfi_filtered (spaces, "pointer_type: @ 0x%x\n",
+ printfi_filtered (spaces, "pointer_type 0x%x\n",
TYPE_POINTER_TYPE (type));
- printfi_filtered (spaces, "reference_type: @ 0x%x\n",
+ printfi_filtered (spaces, "reference_type 0x%x\n",
TYPE_REFERENCE_TYPE (type));
- printfi_filtered (spaces, "function_type: @ 0x%x\n",
+ printfi_filtered (spaces, "function_type 0x%x\n",
TYPE_FUNCTION_TYPE (type));
- printfi_filtered (spaces, "flags: 0x%x", TYPE_FLAGS (type));
+ printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
if (TYPE_FLAGS (type) & TYPE_FLAG_UNSIGNED)
{
puts_filtered (" TYPE_FLAG_UNSIGNED");
puts_filtered (" TYPE_FLAG_STUB");
}
puts_filtered ("\n");
- printfi_filtered (spaces, "nfields: %d @ 0x%x\n", TYPE_NFIELDS (type),
+ printfi_filtered (spaces, "nfields %d 0x%x\n", TYPE_NFIELDS (type),
TYPE_FIELDS (type));
for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
{
printfi_filtered (spaces + 2,
- "[%d] bitpos %d bitsize %d type 0x%x name 0x%x '%s'\n",
+ "[%d] bitpos %d bitsize %d type 0x%x name '%s' (0x%x)\n",
idx, TYPE_FIELD_BITPOS (type, idx),
TYPE_FIELD_BITSIZE (type, idx),
TYPE_FIELD_TYPE (type, idx),
recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
}
}
- printfi_filtered (spaces, "vptr_basetype: @ 0x%x\n",
+ printfi_filtered (spaces, "vptr_basetype 0x%x\n",
TYPE_VPTR_BASETYPE (type));
if (TYPE_VPTR_BASETYPE (type) != NULL)
{
recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
}
- printfi_filtered (spaces, "vptr_fieldno: %d\n", TYPE_VPTR_FIELDNO (type));
+ printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type));
switch (TYPE_CODE (type))
{
case TYPE_CODE_METHOD:
case TYPE_CODE_FUNC:
- printfi_filtered (spaces, "arg_types: @ 0x%x\n",
- TYPE_ARG_TYPES (type));
+ printfi_filtered (spaces, "arg_types 0x%x\n", TYPE_ARG_TYPES (type));
+ print_arg_types (TYPE_ARG_TYPES (type), spaces);
break;
case TYPE_CODE_STRUCT:
struct cplus_struct_type
{
+ /* Number of base classes this type derives from. */
+
+ short n_baseclasses;
+
+ /* Number of methods with unique names. All overloaded methods with
+ the same name count only once. */
+
+ short nfn_fields;
+
+ /* Number of methods described for this type plus all the
+ methods that it derives from. */
+
+ int nfn_fields_total;
+
/* For derived classes, the number of base classes is given by
n_baseclasses and virtual_field_bits is a bit vector containing one bit
per base class.
B_TYPE *protected_field_bits;
- /* Number of methods described for this type */
-
- short nfn_fields;
-
- /* Number of base classes this type derives from. */
-
- short n_baseclasses;
-
- /* Number of methods described for this type plus all the
- methods that it derives from. */
-
- int nfn_fields_total;
-
/* For classes, structures, and unions, a description of each field,
which consists of an overloaded name, followed by the types of
arguments that the method expects, and then the name after it
- has been renamed to make it distinct. */
+ has been renamed to make it distinct.
+
+ fn_fieldlists points to an array of nfn_fields of these. */
struct fn_fieldlist
{
struct fn_field
{
+ /* The name after it has been processed */
+
+ char *physname;
+
/* The return value of the method */
struct type *type;
struct type **args;
- /* The name after it has been processed */
-
- char *physname;
-
- /* For virtual functions. */
- /* First baseclass that defines this virtual function. */
+ /* For virtual functions.
+ First baseclass that defines this virtual function. */
struct type *fcontext;
+ /* Attributes. */
+
unsigned int is_const : 1;
unsigned int is_volatile : 1;
unsigned int is_private : 1;
/* Index into that baseclass's virtual function table,
minus 2; else if static: VOFFSET_STATIC; else: 0. */
- unsigned voffset : 24;
+ unsigned int voffset : 24;
# define VOFFSET_STATIC 1
} *fn_fieldlists;
- unsigned char via_protected;
-
- unsigned char via_public;
};
/* The default value of TYPE_CPLUS_SPECIFIC(T) points to the
#define TYPE_FN_FIELDLIST_LENGTH(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].length
#define TYPE_FN_FIELD(thisfn, n) (thisfn)[n]
-#define TYPE_FN_FIELD_NAME(thisfn, n) (thisfn)[n].name
+#define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname
#define TYPE_FN_FIELD_TYPE(thisfn, n) (thisfn)[n].type
#define TYPE_FN_FIELD_ARGS(thisfn, n) TYPE_ARG_TYPES ((thisfn)[n].type)
-#define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname
-#define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1)
-#define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)
-#define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
-#define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext)
-#define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub)
+#define TYPE_FN_FIELD_CONST(thisfn, n) ((thisfn)[n].is_const)
+#define TYPE_FN_FIELD_VOLATILE(thisfn, n) ((thisfn)[n].is_volatile)
#define TYPE_FN_FIELD_PRIVATE(thisfn, n) ((thisfn)[n].is_private)
#define TYPE_FN_FIELD_PROTECTED(thisfn, n) ((thisfn)[n].is_protected)
+#define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub)
+#define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext)
+#define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
+#define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1)
+#define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)
extern struct type *builtin_type_void;
extern struct type *builtin_type_char;
objfile -> mmfd = fd;
objfile -> flags |= OBJF_MAPPED;
mmalloc_setkey (objfile -> md, 0, objfile);
- obstack_full_begin (&objfile -> psymbol_obstack, 0, 0,
- xmmalloc, mfree, objfile -> md,
- OBSTACK_MMALLOC_LIKE);
- obstack_full_begin (&objfile -> symbol_obstack, 0, 0,
- xmmalloc, mfree, objfile -> md,
- OBSTACK_MMALLOC_LIKE);
- obstack_full_begin (&objfile -> type_obstack, 0, 0,
- xmmalloc, mfree, objfile -> md,
- OBSTACK_MMALLOC_LIKE);
+ obstack_alloc_arg (&objfile -> psymbol_obstack, objfile -> md);
+ obstack_full_begin (&objfile -> psymbol_obstack, 0, 0, xmmalloc,
+ mfree);
+ obstack_alloc_arg (&objfile -> symbol_obstack, objfile -> md);
+ obstack_full_begin (&objfile -> symbol_obstack, 0, 0, xmmalloc,
+ mfree);
+ obstack_alloc_arg (&objfile -> type_obstack, objfile -> md);
+ obstack_full_begin (&objfile -> type_obstack, 0, 0, xmmalloc,
+ mfree);
}
}
objfile = (struct objfile *) xmalloc (sizeof (struct objfile));
memset (objfile, 0, sizeof (struct objfile));
objfile -> md = NULL;
- obstack_full_begin (&objfile -> psymbol_obstack, 0, 0, xmalloc, free,
- (void *) 0, 0);
- obstack_full_begin (&objfile -> symbol_obstack, 0, 0, xmalloc, free,
- (void *) 0, 0);
- obstack_full_begin (&objfile -> type_obstack, 0, 0, xmalloc, free,
- (void *) 0, 0);
-
+ obstack_full_begin (&objfile -> psymbol_obstack, 0, 0, xmalloc, free);
+ obstack_full_begin (&objfile -> symbol_obstack, 0, 0, xmalloc, free);
+ obstack_full_begin (&objfile -> type_obstack, 0, 0, xmalloc, free);
}
/* Update the per-objfile information that comes from the bfd, ensuring
projects / binutils-gdb.git / commitdiff