1 /* Support routines for manipulating internal types for GDB.
2 Copyright (C) 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
3 Contributed by Cygnus Support, using pieces from other GDB modules.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #include "gdb_string.h"
28 #include "expression.h"
33 #include "complaints.h"
35 /* These variables point to the objects
36 representing the predefined C data types. */
38 struct type
*builtin_type_void
;
39 struct type
*builtin_type_char
;
40 struct type
*builtin_type_short
;
41 struct type
*builtin_type_int
;
42 struct type
*builtin_type_long
;
43 struct type
*builtin_type_long_long
;
44 struct type
*builtin_type_signed_char
;
45 struct type
*builtin_type_unsigned_char
;
46 struct type
*builtin_type_unsigned_short
;
47 struct type
*builtin_type_unsigned_int
;
48 struct type
*builtin_type_unsigned_long
;
49 struct type
*builtin_type_unsigned_long_long
;
50 struct type
*builtin_type_float
;
51 struct type
*builtin_type_double
;
52 struct type
*builtin_type_long_double
;
53 struct type
*builtin_type_complex
;
54 struct type
*builtin_type_double_complex
;
55 struct type
*builtin_type_string
;
57 /* Alloc a new type structure and fill it with some defaults. If
58 OBJFILE is non-NULL, then allocate the space for the type structure
59 in that objfile's type_obstack. */
63 struct objfile
*objfile
;
65 register struct type
*type
;
67 /* Alloc the structure and start off with all fields zeroed. */
71 type
= (struct type
*) xmalloc (sizeof (struct type
));
75 type
= (struct type
*) obstack_alloc (&objfile
-> type_obstack
,
76 sizeof (struct type
));
77 OBJSTAT (objfile
, n_types
++);
79 memset ((char *) type
, 0, sizeof (struct type
));
81 /* Initialize the fields that might not be zero. */
83 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
84 TYPE_OBJFILE (type
) = objfile
;
85 TYPE_VPTR_FIELDNO (type
) = -1;
90 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
91 to a pointer to memory where the pointer type should be stored.
92 If *TYPEPTR is zero, update it to point to the pointer type we return.
93 We allocate new memory if needed. */
96 make_pointer_type (type
, typeptr
)
98 struct type
**typeptr
;
100 register struct type
*ntype
; /* New type */
101 struct objfile
*objfile
;
103 ntype
= TYPE_POINTER_TYPE (type
);
107 return ntype
; /* Don't care about alloc, and have new type. */
108 else if (*typeptr
== 0)
110 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
114 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
116 ntype
= alloc_type (TYPE_OBJFILE (type
));
120 else /* We have storage, but need to reset it. */
123 objfile
= TYPE_OBJFILE (ntype
);
124 memset ((char *) ntype
, 0, sizeof (struct type
));
125 TYPE_OBJFILE (ntype
) = objfile
;
128 TYPE_TARGET_TYPE (ntype
) = type
;
129 TYPE_POINTER_TYPE (type
) = ntype
;
131 /* FIXME! Assume the machine has only one representation for pointers! */
133 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
134 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
136 /* pointers are unsigned */
137 TYPE_FLAGS (ntype
) |= TYPE_FLAG_UNSIGNED
;
139 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
140 TYPE_POINTER_TYPE (type
) = ntype
;
145 /* Given a type TYPE, return a type of pointers to that type.
146 May need to construct such a type if this is the first use. */
149 lookup_pointer_type (type
)
152 return make_pointer_type (type
, (struct type
**)0);
155 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero, points
156 to a pointer to memory where the reference type should be stored.
157 If *TYPEPTR is zero, update it to point to the reference type we return.
158 We allocate new memory if needed. */
161 make_reference_type (type
, typeptr
)
163 struct type
**typeptr
;
165 register struct type
*ntype
; /* New type */
166 struct objfile
*objfile
;
168 ntype
= TYPE_REFERENCE_TYPE (type
);
172 return ntype
; /* Don't care about alloc, and have new type. */
173 else if (*typeptr
== 0)
175 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
179 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
181 ntype
= alloc_type (TYPE_OBJFILE (type
));
185 else /* We have storage, but need to reset it. */
188 objfile
= TYPE_OBJFILE (ntype
);
189 memset ((char *) ntype
, 0, sizeof (struct type
));
190 TYPE_OBJFILE (ntype
) = objfile
;
193 TYPE_TARGET_TYPE (ntype
) = type
;
194 TYPE_REFERENCE_TYPE (type
) = ntype
;
196 /* FIXME! Assume the machine has only one representation for references,
197 and that it matches the (only) representation for pointers! */
199 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
200 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
202 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
203 TYPE_REFERENCE_TYPE (type
) = ntype
;
208 /* Same as above, but caller doesn't care about memory allocation details. */
211 lookup_reference_type (type
)
214 return make_reference_type (type
, (struct type
**)0);
217 /* Lookup a function type that returns type TYPE. TYPEPTR, if nonzero, points
218 to a pointer to memory where the function type should be stored.
219 If *TYPEPTR is zero, update it to point to the function type we return.
220 We allocate new memory if needed. */
223 make_function_type (type
, typeptr
)
225 struct type
**typeptr
;
227 register struct type
*ntype
; /* New type */
228 struct objfile
*objfile
;
230 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
232 ntype
= alloc_type (TYPE_OBJFILE (type
));
236 else /* We have storage, but need to reset it. */
239 objfile
= TYPE_OBJFILE (ntype
);
240 memset ((char *) ntype
, 0, sizeof (struct type
));
241 TYPE_OBJFILE (ntype
) = objfile
;
244 TYPE_TARGET_TYPE (ntype
) = type
;
246 TYPE_LENGTH (ntype
) = 1;
247 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
253 /* Given a type TYPE, return a type of functions that return that type.
254 May need to construct such a type if this is the first use. */
257 lookup_function_type (type
)
260 return make_function_type (type
, (struct type
**)0);
263 /* Implement direct support for MEMBER_TYPE in GNU C++.
264 May need to construct such a type if this is the first use.
265 The TYPE is the type of the member. The DOMAIN is the type
266 of the aggregate that the member belongs to. */
269 lookup_member_type (type
, domain
)
273 register struct type
*mtype
;
275 mtype
= alloc_type (TYPE_OBJFILE (type
));
276 smash_to_member_type (mtype
, domain
, type
);
280 /* Allocate a stub method whose return type is TYPE.
281 This apparently happens for speed of symbol reading, since parsing
282 out the arguments to the method is cpu-intensive, the way we are doing
283 it. So, we will fill in arguments later.
284 This always returns a fresh type. */
287 allocate_stub_method (type
)
292 mtype
= alloc_type (TYPE_OBJFILE (type
));
293 TYPE_TARGET_TYPE (mtype
) = type
;
294 /* _DOMAIN_TYPE (mtype) = unknown yet */
295 /* _ARG_TYPES (mtype) = unknown yet */
296 TYPE_FLAGS (mtype
) = TYPE_FLAG_STUB
;
297 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
298 TYPE_LENGTH (mtype
) = 1;
302 /* Create a range type using either a blank type supplied in RESULT_TYPE,
303 or creating a new type, inheriting the objfile from INDEX_TYPE.
305 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
306 HIGH_BOUND, inclusive.
308 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
309 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
312 create_range_type (result_type
, index_type
, low_bound
, high_bound
)
313 struct type
*result_type
;
314 struct type
*index_type
;
318 if (result_type
== NULL
)
320 result_type
= alloc_type (TYPE_OBJFILE (index_type
));
322 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
323 TYPE_TARGET_TYPE (result_type
) = index_type
;
324 if (TYPE_FLAGS (index_type
) & TYPE_FLAG_STUB
)
325 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
327 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
328 TYPE_NFIELDS (result_type
) = 2;
329 TYPE_FIELDS (result_type
) = (struct field
*)
330 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
331 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
332 TYPE_FIELD_BITPOS (result_type
, 0) = low_bound
;
333 TYPE_FIELD_BITPOS (result_type
, 1) = high_bound
;
334 TYPE_FIELD_TYPE (result_type
, 0) = builtin_type_int
; /* FIXME */
335 TYPE_FIELD_TYPE (result_type
, 1) = builtin_type_int
; /* FIXME */
337 return (result_type
);
340 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE.
341 Return 1 of type is a range type, 0 if it is discrete (and bounds
342 will fit in LONGEST), or -1 otherwise. */
345 get_discrete_bounds (type
, lowp
, highp
)
347 LONGEST
*lowp
, *highp
;
349 CHECK_TYPEDEF (type
);
350 switch (TYPE_CODE (type
))
352 case TYPE_CODE_RANGE
:
353 *lowp
= TYPE_LOW_BOUND (type
);
354 *highp
= TYPE_HIGH_BOUND (type
);
357 if (TYPE_NFIELDS (type
) > 0)
359 *lowp
= TYPE_FIELD_BITPOS (type
, 0);
360 *highp
= TYPE_FIELD_BITPOS (type
, TYPE_NFIELDS (type
) - 1);
373 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
375 if (!TYPE_UNSIGNED (type
))
377 *lowp
= - (1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
381 /* ... fall through for unsigned ints ... */
384 /* This round-about calculation is to avoid shifting by
385 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
386 if TYPE_LENGTH (type) == sizeof (LONGEST). */
387 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
388 *highp
= (*highp
- 1) | *highp
;
395 /* Create an array type using either a blank type supplied in RESULT_TYPE,
396 or creating a new type, inheriting the objfile from RANGE_TYPE.
398 Elements will be of type ELEMENT_TYPE, the indices will be of type
401 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
402 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
405 create_array_type (result_type
, element_type
, range_type
)
406 struct type
*result_type
;
407 struct type
*element_type
;
408 struct type
*range_type
;
410 LONGEST low_bound
, high_bound
;
412 if (result_type
== NULL
)
414 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
416 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
417 TYPE_TARGET_TYPE (result_type
) = element_type
;
418 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
419 low_bound
= high_bound
= 0;
420 CHECK_TYPEDEF (element_type
);
421 TYPE_LENGTH (result_type
) =
422 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
423 TYPE_NFIELDS (result_type
) = 1;
424 TYPE_FIELDS (result_type
) =
425 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
426 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
427 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
428 TYPE_VPTR_FIELDNO (result_type
) = -1;
430 return (result_type
);
433 /* Create a string type using either a blank type supplied in RESULT_TYPE,
434 or creating a new type. String types are similar enough to array of
435 char types that we can use create_array_type to build the basic type
436 and then bash it into a string type.
438 For fixed length strings, the range type contains 0 as the lower
439 bound and the length of the string minus one as the upper bound.
441 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
442 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
445 create_string_type (result_type
, range_type
)
446 struct type
*result_type
;
447 struct type
*range_type
;
449 result_type
= create_array_type (result_type
,
450 *current_language
->string_char_type
,
452 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
453 return (result_type
);
457 create_set_type (result_type
, domain_type
)
458 struct type
*result_type
;
459 struct type
*domain_type
;
461 LONGEST low_bound
, high_bound
, bit_length
;
462 if (result_type
== NULL
)
464 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
466 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
467 TYPE_NFIELDS (result_type
) = 1;
468 TYPE_FIELDS (result_type
) = (struct field
*)
469 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
470 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
472 if (! (TYPE_FLAGS (domain_type
) & TYPE_FLAG_STUB
))
474 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
475 low_bound
= high_bound
= 0;
476 bit_length
= high_bound
- low_bound
+ 1;
477 TYPE_LENGTH (result_type
)
478 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
480 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
481 return (result_type
);
484 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
485 A MEMBER is a wierd thing -- it amounts to a typed offset into
486 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
487 include the offset (that's the value of the MEMBER itself), but does
488 include the structure type into which it points (for some reason).
490 When "smashing" the type, we preserve the objfile that the
491 old type pointed to, since we aren't changing where the type is actually
495 smash_to_member_type (type
, domain
, to_type
)
498 struct type
*to_type
;
500 struct objfile
*objfile
;
502 objfile
= TYPE_OBJFILE (type
);
504 memset ((char *) type
, 0, sizeof (struct type
));
505 TYPE_OBJFILE (type
) = objfile
;
506 TYPE_TARGET_TYPE (type
) = to_type
;
507 TYPE_DOMAIN_TYPE (type
) = domain
;
508 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
509 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
512 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
513 METHOD just means `function that gets an extra "this" argument'.
515 When "smashing" the type, we preserve the objfile that the
516 old type pointed to, since we aren't changing where the type is actually
520 smash_to_method_type (type
, domain
, to_type
, args
)
523 struct type
*to_type
;
526 struct objfile
*objfile
;
528 objfile
= TYPE_OBJFILE (type
);
530 memset ((char *) type
, 0, sizeof (struct type
));
531 TYPE_OBJFILE (type
) = objfile
;
532 TYPE_TARGET_TYPE (type
) = to_type
;
533 TYPE_DOMAIN_TYPE (type
) = domain
;
534 TYPE_ARG_TYPES (type
) = args
;
535 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
536 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
539 /* Return a typename for a struct/union/enum type without "struct ",
540 "union ", or "enum ". If the type has a NULL name, return NULL. */
543 type_name_no_tag (type
)
544 register const struct type
*type
;
546 if (TYPE_TAG_NAME (type
) != NULL
)
547 return TYPE_TAG_NAME (type
);
549 /* Is there code which expects this to return the name if there is no
550 tag name? My guess is that this is mainly used for C++ in cases where
551 the two will always be the same. */
552 return TYPE_NAME (type
);
555 /* Lookup a primitive type named NAME.
556 Return zero if NAME is not a primitive type.*/
559 lookup_primitive_typename (name
)
562 struct type
** const *p
;
564 for (p
= current_language
-> la_builtin_type_vector
; *p
!= NULL
; p
++)
566 if (STREQ ((**p
) -> name
, name
))
574 /* Lookup a typedef or primitive type named NAME,
575 visible in lexical block BLOCK.
576 If NOERR is nonzero, return zero if NAME is not suitably defined. */
579 lookup_typename (name
, block
, noerr
)
584 register struct symbol
*sym
;
585 register struct type
*tmp
;
587 sym
= lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
588 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
590 tmp
= lookup_primitive_typename (name
);
595 else if (!tmp
&& noerr
)
601 error ("No type named %s.", name
);
604 return (SYMBOL_TYPE (sym
));
608 lookup_unsigned_typename (name
)
611 char *uns
= alloca (strlen (name
) + 10);
613 strcpy (uns
, "unsigned ");
614 strcpy (uns
+ 9, name
);
615 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
619 lookup_signed_typename (name
)
623 char *uns
= alloca (strlen (name
) + 8);
625 strcpy (uns
, "signed ");
626 strcpy (uns
+ 7, name
);
627 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
628 /* If we don't find "signed FOO" just try again with plain "FOO". */
631 return lookup_typename (name
, (struct block
*) NULL
, 0);
634 /* Lookup a structure type named "struct NAME",
635 visible in lexical block BLOCK. */
638 lookup_struct (name
, block
)
642 register struct symbol
*sym
;
644 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
645 (struct symtab
**) NULL
);
649 error ("No struct type named %s.", name
);
651 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
653 error ("This context has class, union or enum %s, not a struct.", name
);
655 return (SYMBOL_TYPE (sym
));
658 /* Lookup a union type named "union NAME",
659 visible in lexical block BLOCK. */
662 lookup_union (name
, block
)
666 register struct symbol
*sym
;
668 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
669 (struct symtab
**) NULL
);
673 error ("No union type named %s.", name
);
675 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_UNION
)
677 error ("This context has class, struct or enum %s, not a union.", name
);
679 return (SYMBOL_TYPE (sym
));
682 /* Lookup an enum type named "enum NAME",
683 visible in lexical block BLOCK. */
686 lookup_enum (name
, block
)
690 register struct symbol
*sym
;
692 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
693 (struct symtab
**) NULL
);
696 error ("No enum type named %s.", name
);
698 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
700 error ("This context has class, struct or union %s, not an enum.", name
);
702 return (SYMBOL_TYPE (sym
));
705 /* Lookup a template type named "template NAME<TYPE>",
706 visible in lexical block BLOCK. */
709 lookup_template_type (name
, type
, block
)
715 char *nam
= (char*) alloca(strlen(name
) + strlen(type
->name
) + 4);
718 strcat (nam
, type
->name
);
719 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
721 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
725 error ("No template type named %s.", name
);
727 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
729 error ("This context has class, union or enum %s, not a struct.", name
);
731 return (SYMBOL_TYPE (sym
));
734 /* Given a type TYPE, lookup the type of the component of type named NAME.
736 TYPE can be either a struct or union, or a pointer or reference to a struct or
737 union. If it is a pointer or reference, its target type is automatically used.
738 Thus '.' and '->' are interchangable, as specified for the definitions of the
739 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
741 If NOERR is nonzero, return zero if NAME is not suitably defined.
742 If NAME is the name of a baseclass type, return that type. */
745 lookup_struct_elt_type (type
, name
, noerr
)
754 CHECK_TYPEDEF (type
);
755 if (TYPE_CODE (type
) != TYPE_CODE_PTR
756 && TYPE_CODE (type
) != TYPE_CODE_REF
)
758 type
= TYPE_TARGET_TYPE (type
);
761 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
762 TYPE_CODE (type
) != TYPE_CODE_UNION
)
764 target_terminal_ours ();
765 gdb_flush (gdb_stdout
);
766 fprintf_unfiltered (gdb_stderr
, "Type ");
767 type_print (type
, "", gdb_stderr
, -1);
768 error (" is not a structure or union type.");
772 /* FIXME: This change put in by Michael seems incorrect for the case where
773 the structure tag name is the same as the member name. I.E. when doing
774 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
779 typename
= type_name_no_tag (type
);
780 if (typename
!= NULL
&& STREQ (typename
, name
))
785 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
787 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
789 if (t_field_name
&& STREQ (t_field_name
, name
))
791 return TYPE_FIELD_TYPE (type
, i
);
795 /* OK, it's not in this class. Recursively check the baseclasses. */
796 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
800 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, noerr
);
812 target_terminal_ours ();
813 gdb_flush (gdb_stdout
);
814 fprintf_unfiltered (gdb_stderr
, "Type ");
815 type_print (type
, "", gdb_stderr
, -1);
816 fprintf_unfiltered (gdb_stderr
, " has no component named ");
817 fputs_filtered (name
, gdb_stderr
);
819 return (struct type
*)-1; /* For lint */
822 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
823 valid. Callers should be aware that in some cases (for example,
824 the type or one of its baseclasses is a stub type and we are
825 debugging a .o file), this function will not be able to find the virtual
826 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
830 fill_in_vptr_fieldno (type
)
833 CHECK_TYPEDEF (type
);
835 if (TYPE_VPTR_FIELDNO (type
) < 0)
839 /* We must start at zero in case the first (and only) baseclass is
840 virtual (and hence we cannot share the table pointer). */
841 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
843 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, i
));
844 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
)) >= 0)
846 TYPE_VPTR_FIELDNO (type
)
847 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
));
848 TYPE_VPTR_BASETYPE (type
)
849 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type
, i
));
856 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
858 If this is a stubbed struct (i.e. declared as struct foo *), see if
859 we can find a full definition in some other file. If so, copy this
860 definition, so we can use it in future. There used to be a comment (but
861 not any code) that if we don't find a full definition, we'd set a flag
862 so we don't spend time in the future checking the same type. That would
863 be a mistake, though--we might load in more symbols which contain a
864 full definition for the type.
866 This used to be coded as a macro, but I don't think it is called
867 often enough to merit such treatment. */
869 struct complaint stub_noname_complaint
=
870 {"stub type has NULL name", 0, 0};
874 register struct type
*type
;
876 struct type
*orig_type
= type
;
877 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
879 if (!TYPE_TARGET_TYPE (type
))
881 char* name
= type_name_no_tag (type
);
882 /* FIXME: shouldn't we separately check the TYPE_NAME and the
883 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
884 as appropriate? (this code was written before TYPE_NAME and
885 TYPE_TAG_NAME were separate). */
889 complain (&stub_noname_complaint
);
892 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
893 (struct symtab
**) NULL
);
895 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
897 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
); /* TYPE_CODE_UNDEF */
899 type
= TYPE_TARGET_TYPE (type
);
902 if (TYPE_FLAGS(type
) & TYPE_FLAG_STUB
)
904 char* name
= type_name_no_tag (type
);
905 /* FIXME: shouldn't we separately check the TYPE_NAME and the
906 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
907 as appropriate? (this code was written before TYPE_NAME and
908 TYPE_TAG_NAME were separate). */
912 complain (&stub_noname_complaint
);
915 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
916 (struct symtab
**) NULL
);
919 memcpy ((char *)type
,
920 (char *)SYMBOL_TYPE(sym
),
921 sizeof (struct type
));
925 if (TYPE_FLAGS (type
) & TYPE_FLAG_TARGET_STUB
)
927 struct type
*range_type
;
928 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
930 if (TYPE_FLAGS (target_type
) & TYPE_FLAG_STUB
)
932 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
933 && TYPE_NFIELDS (type
) == 1
934 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
937 /* Now recompute the length of the array type, based on its
938 number of elements and the target type's length. */
940 ((TYPE_FIELD_BITPOS (range_type
, 1)
941 - TYPE_FIELD_BITPOS (range_type
, 0)
943 * TYPE_LENGTH (target_type
));
944 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
946 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
948 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
949 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
952 /* Cache TYPE_LENGTH for future use. */
953 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
957 /* Ugly hack to convert method stubs into method types.
959 He ain't kiddin'. This demangles the name of the method into a string
960 including argument types, parses out each argument type, generates
961 a string casting a zero to that type, evaluates the string, and stuffs
962 the resulting type into an argtype vector!!! Then it knows the type
963 of the whole function (including argument types for overloading),
964 which info used to be in the stab's but was removed to hack back
965 the space required for them. */
968 check_stub_method (type
, i
, j
)
974 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
975 char *demangled_name
= cplus_demangle (mangled_name
,
976 DMGL_PARAMS
| DMGL_ANSI
);
977 char *argtypetext
, *p
;
978 int depth
= 0, argcount
= 1;
979 struct type
**argtypes
;
982 /* Make sure we got back a function string that we can use. */
984 p
= strchr (demangled_name
, '(');
986 if (demangled_name
== NULL
|| p
== NULL
)
987 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
989 /* Now, read in the parameters that define this type. */
1002 else if (*p
== ',' && depth
== 0)
1010 /* We need two more slots: one for the THIS pointer, and one for the
1011 NULL [...] or void [end of arglist]. */
1013 argtypes
= (struct type
**)
1014 TYPE_ALLOC (type
, (argcount
+ 2) * sizeof (struct type
*));
1016 /* FIXME: This is wrong for static member functions. */
1017 argtypes
[0] = lookup_pointer_type (type
);
1020 if (*p
!= ')') /* () means no args, skip while */
1025 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1027 /* Avoid parsing of ellipsis, they will be handled below. */
1028 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0)
1030 argtypes
[argcount
] =
1031 parse_and_eval_type (argtypetext
, p
- argtypetext
);
1034 argtypetext
= p
+ 1;
1050 if (p
[-2] != '.') /* Not '...' */
1052 argtypes
[argcount
] = builtin_type_void
; /* List terminator */
1056 argtypes
[argcount
] = NULL
; /* Ellist terminator */
1059 free (demangled_name
);
1061 f
= TYPE_FN_FIELDLIST1 (type
, i
);
1062 TYPE_FN_FIELD_PHYSNAME (f
, j
) = mangled_name
;
1064 /* Now update the old "stub" type into a real type. */
1065 mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1066 TYPE_DOMAIN_TYPE (mtype
) = type
;
1067 TYPE_ARG_TYPES (mtype
) = argtypes
;
1068 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1069 TYPE_FN_FIELD_STUB (f
, j
) = 0;
1072 const struct cplus_struct_type cplus_struct_default
;
1075 allocate_cplus_struct_type (type
)
1078 if (!HAVE_CPLUS_STRUCT (type
))
1080 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1081 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1082 *(TYPE_CPLUS_SPECIFIC(type
)) = cplus_struct_default
;
1086 /* Helper function to initialize the standard scalar types.
1088 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1089 of the string pointed to by name in the type_obstack for that objfile,
1090 and initialize the type name to that copy. There are places (mipsread.c
1091 in particular, where init_type is called with a NULL value for NAME). */
1094 init_type (code
, length
, flags
, name
, objfile
)
1095 enum type_code code
;
1099 struct objfile
*objfile
;
1101 register struct type
*type
;
1103 type
= alloc_type (objfile
);
1104 TYPE_CODE (type
) = code
;
1105 TYPE_LENGTH (type
) = length
;
1106 TYPE_FLAGS (type
) |= flags
;
1107 if ((name
!= NULL
) && (objfile
!= NULL
))
1110 obsavestring (name
, strlen (name
), &objfile
-> type_obstack
);
1114 TYPE_NAME (type
) = name
;
1119 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
1121 INIT_CPLUS_SPECIFIC (type
);
1126 /* Look up a fundamental type for the specified objfile.
1127 May need to construct such a type if this is the first use.
1129 Some object file formats (ELF, COFF, etc) do not define fundamental
1130 types such as "int" or "double". Others (stabs for example), do
1131 define fundamental types.
1133 For the formats which don't provide fundamental types, gdb can create
1134 such types, using defaults reasonable for the current language and
1135 the current target machine.
1137 NOTE: This routine is obsolescent. Each debugging format reader
1138 should manage it's own fundamental types, either creating them from
1139 suitable defaults or reading them from the debugging information,
1140 whichever is appropriate. The DWARF reader has already been
1141 fixed to do this. Once the other readers are fixed, this routine
1142 will go away. Also note that fundamental types should be managed
1143 on a compilation unit basis in a multi-language environment, not
1144 on a linkage unit basis as is done here. */
1148 lookup_fundamental_type (objfile
, typeid)
1149 struct objfile
*objfile
;
1152 register struct type
**typep
;
1153 register int nbytes
;
1155 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1157 error ("internal error - invalid fundamental type id %d", typeid);
1160 /* If this is the first time we need a fundamental type for this objfile
1161 then we need to initialize the vector of type pointers. */
1163 if (objfile
-> fundamental_types
== NULL
)
1165 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1166 objfile
-> fundamental_types
= (struct type
**)
1167 obstack_alloc (&objfile
-> type_obstack
, nbytes
);
1168 memset ((char *) objfile
-> fundamental_types
, 0, nbytes
);
1169 OBJSTAT (objfile
, n_types
+= FT_NUM_MEMBERS
);
1172 /* Look for this particular type in the fundamental type vector. If one is
1173 not found, create and install one appropriate for the current language. */
1175 typep
= objfile
-> fundamental_types
+ typeid;
1178 *typep
= create_fundamental_type (objfile
, typeid);
1188 /* FIXME: Should we return true for references as well as pointers? */
1192 && TYPE_CODE (t
) == TYPE_CODE_PTR
1193 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1196 /* Chill varying string and arrays are represented as follows:
1198 struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
1200 Return true if TYPE is such a Chill varying type. */
1203 chill_varying_type (type
)
1206 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1207 || TYPE_NFIELDS (type
) != 2
1208 || strcmp (TYPE_FIELD_NAME (type
, 0), "__var_length") != 0)
1213 #if MAINTENANCE_CMDS
1216 print_bit_vector (bits
, nbits
)
1222 for (bitno
= 0; bitno
< nbits
; bitno
++)
1224 if ((bitno
% 8) == 0)
1226 puts_filtered (" ");
1228 if (B_TST (bits
, bitno
))
1230 printf_filtered ("1");
1234 printf_filtered ("0");
1239 /* The args list is a strange beast. It is either terminated by a NULL
1240 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
1241 type for normal fixed argcount functions. (FIXME someday)
1242 Also note the first arg should be the "this" pointer, we may not want to
1243 include it since we may get into a infinitely recursive situation. */
1246 print_arg_types (args
, spaces
)
1252 while (*args
!= NULL
)
1254 recursive_dump_type (*args
, spaces
+ 2);
1255 if ((*args
++) -> code
== TYPE_CODE_VOID
)
1264 dump_fn_fieldlists (type
, spaces
)
1272 printfi_filtered (spaces
, "fn_fieldlists ");
1273 gdb_print_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
1274 printf_filtered ("\n");
1275 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
1277 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
1278 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
1280 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
1281 gdb_print_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
1283 printf_filtered (") length %d\n",
1284 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
1285 for (overload_idx
= 0;
1286 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
1289 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
1291 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
1292 gdb_print_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
1294 printf_filtered (")\n");
1295 printfi_filtered (spaces
+ 8, "type ");
1296 gdb_print_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
1297 printf_filtered ("\n");
1299 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
1302 printfi_filtered (spaces
+ 8, "args ");
1303 gdb_print_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
1304 printf_filtered ("\n");
1306 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
), spaces
);
1307 printfi_filtered (spaces
+ 8, "fcontext ");
1308 gdb_print_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
1310 printf_filtered ("\n");
1312 printfi_filtered (spaces
+ 8, "is_const %d\n",
1313 TYPE_FN_FIELD_CONST (f
, overload_idx
));
1314 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
1315 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
1316 printfi_filtered (spaces
+ 8, "is_private %d\n",
1317 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
1318 printfi_filtered (spaces
+ 8, "is_protected %d\n",
1319 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
1320 printfi_filtered (spaces
+ 8, "is_stub %d\n",
1321 TYPE_FN_FIELD_STUB (f
, overload_idx
));
1322 printfi_filtered (spaces
+ 8, "voffset %u\n",
1323 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
1329 print_cplus_stuff (type
, spaces
)
1333 printfi_filtered (spaces
, "n_baseclasses %d\n",
1334 TYPE_N_BASECLASSES (type
));
1335 printfi_filtered (spaces
, "nfn_fields %d\n",
1336 TYPE_NFN_FIELDS (type
));
1337 printfi_filtered (spaces
, "nfn_fields_total %d\n",
1338 TYPE_NFN_FIELDS_TOTAL (type
));
1339 if (TYPE_N_BASECLASSES (type
) > 0)
1341 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
1342 TYPE_N_BASECLASSES (type
));
1343 gdb_print_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
1344 printf_filtered (")");
1346 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
1347 TYPE_N_BASECLASSES (type
));
1348 puts_filtered ("\n");
1350 if (TYPE_NFIELDS (type
) > 0)
1352 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
1354 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
1355 TYPE_NFIELDS (type
));
1356 gdb_print_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
1357 printf_filtered (")");
1358 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
1359 TYPE_NFIELDS (type
));
1360 puts_filtered ("\n");
1362 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
1364 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
1365 TYPE_NFIELDS (type
));
1366 gdb_print_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
1367 printf_filtered (")");
1368 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
1369 TYPE_NFIELDS (type
));
1370 puts_filtered ("\n");
1373 if (TYPE_NFN_FIELDS (type
) > 0)
1375 dump_fn_fieldlists (type
, spaces
);
1379 static struct obstack dont_print_type_obstack
;
1382 recursive_dump_type (type
, spaces
)
1389 obstack_begin (&dont_print_type_obstack
, 0);
1391 if (TYPE_NFIELDS (type
) > 0
1392 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
1394 struct type
**first_dont_print
1395 = (struct type
**)obstack_base (&dont_print_type_obstack
);
1397 int i
= (struct type
**)obstack_next_free (&dont_print_type_obstack
)
1402 if (type
== first_dont_print
[i
])
1404 printfi_filtered (spaces
, "type node ");
1405 gdb_print_address (type
, gdb_stdout
);
1406 printf_filtered (" <same as already seen type>\n");
1411 obstack_ptr_grow (&dont_print_type_obstack
, type
);
1414 printfi_filtered (spaces
, "type node ");
1415 gdb_print_address (type
, gdb_stdout
);
1416 printf_filtered ("\n");
1417 printfi_filtered (spaces
, "name '%s' (",
1418 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
1419 gdb_print_address (TYPE_NAME (type
), gdb_stdout
);
1420 printf_filtered (")\n");
1421 if (TYPE_TAG_NAME (type
) != NULL
)
1423 printfi_filtered (spaces
, "tagname '%s' (",
1424 TYPE_TAG_NAME (type
));
1425 gdb_print_address (TYPE_TAG_NAME (type
), gdb_stdout
);
1426 printf_filtered (")\n");
1428 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
1429 switch (TYPE_CODE (type
))
1431 case TYPE_CODE_UNDEF
:
1432 printf_filtered ("(TYPE_CODE_UNDEF)");
1435 printf_filtered ("(TYPE_CODE_PTR)");
1437 case TYPE_CODE_ARRAY
:
1438 printf_filtered ("(TYPE_CODE_ARRAY)");
1440 case TYPE_CODE_STRUCT
:
1441 printf_filtered ("(TYPE_CODE_STRUCT)");
1443 case TYPE_CODE_UNION
:
1444 printf_filtered ("(TYPE_CODE_UNION)");
1446 case TYPE_CODE_ENUM
:
1447 printf_filtered ("(TYPE_CODE_ENUM)");
1449 case TYPE_CODE_FUNC
:
1450 printf_filtered ("(TYPE_CODE_FUNC)");
1453 printf_filtered ("(TYPE_CODE_INT)");
1456 printf_filtered ("(TYPE_CODE_FLT)");
1458 case TYPE_CODE_VOID
:
1459 printf_filtered ("(TYPE_CODE_VOID)");
1462 printf_filtered ("(TYPE_CODE_SET)");
1464 case TYPE_CODE_RANGE
:
1465 printf_filtered ("(TYPE_CODE_RANGE)");
1467 case TYPE_CODE_STRING
:
1468 printf_filtered ("(TYPE_CODE_STRING)");
1470 case TYPE_CODE_ERROR
:
1471 printf_filtered ("(TYPE_CODE_ERROR)");
1473 case TYPE_CODE_MEMBER
:
1474 printf_filtered ("(TYPE_CODE_MEMBER)");
1476 case TYPE_CODE_METHOD
:
1477 printf_filtered ("(TYPE_CODE_METHOD)");
1480 printf_filtered ("(TYPE_CODE_REF)");
1482 case TYPE_CODE_CHAR
:
1483 printf_filtered ("(TYPE_CODE_CHAR)");
1485 case TYPE_CODE_BOOL
:
1486 printf_filtered ("(TYPE_CODE_BOOL)");
1488 case TYPE_CODE_TYPEDEF
:
1489 printf_filtered ("(TYPE_CODE_TYPEDEF)");
1492 printf_filtered ("(UNKNOWN TYPE CODE)");
1495 puts_filtered ("\n");
1496 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
1497 printfi_filtered (spaces
, "objfile ");
1498 gdb_print_address (TYPE_OBJFILE (type
), gdb_stdout
);
1499 printf_filtered ("\n");
1500 printfi_filtered (spaces
, "target_type ");
1501 gdb_print_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
1502 printf_filtered ("\n");
1503 if (TYPE_TARGET_TYPE (type
) != NULL
)
1505 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
1507 printfi_filtered (spaces
, "pointer_type ");
1508 gdb_print_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
1509 printf_filtered ("\n");
1510 printfi_filtered (spaces
, "reference_type ");
1511 gdb_print_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
1512 printf_filtered ("\n");
1513 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
1514 if (TYPE_FLAGS (type
) & TYPE_FLAG_UNSIGNED
)
1516 puts_filtered (" TYPE_FLAG_UNSIGNED");
1518 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
1520 puts_filtered (" TYPE_FLAG_STUB");
1522 puts_filtered ("\n");
1523 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
1524 gdb_print_address (TYPE_FIELDS (type
), gdb_stdout
);
1525 puts_filtered ("\n");
1526 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
1528 printfi_filtered (spaces
+ 2,
1529 "[%d] bitpos %d bitsize %d type ",
1530 idx
, TYPE_FIELD_BITPOS (type
, idx
),
1531 TYPE_FIELD_BITSIZE (type
, idx
));
1532 gdb_print_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
1533 printf_filtered (" name '%s' (",
1534 TYPE_FIELD_NAME (type
, idx
) != NULL
1535 ? TYPE_FIELD_NAME (type
, idx
)
1537 gdb_print_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
1538 printf_filtered (")\n");
1539 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
1541 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
1544 printfi_filtered (spaces
, "vptr_basetype ");
1545 gdb_print_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
1546 puts_filtered ("\n");
1547 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
1549 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
1551 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
1552 switch (TYPE_CODE (type
))
1554 case TYPE_CODE_METHOD
:
1555 case TYPE_CODE_FUNC
:
1556 printfi_filtered (spaces
, "arg_types ");
1557 gdb_print_address (TYPE_ARG_TYPES (type
), gdb_stdout
);
1558 puts_filtered ("\n");
1559 print_arg_types (TYPE_ARG_TYPES (type
), spaces
);
1562 case TYPE_CODE_STRUCT
:
1563 printfi_filtered (spaces
, "cplus_stuff ");
1564 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1565 puts_filtered ("\n");
1566 print_cplus_stuff (type
, spaces
);
1570 /* We have to pick one of the union types to be able print and test
1571 the value. Pick cplus_struct_type, even though we know it isn't
1572 any particular one. */
1573 printfi_filtered (spaces
, "type_specific ");
1574 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1575 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
1577 printf_filtered (" (unknown data form)");
1579 printf_filtered ("\n");
1584 obstack_free (&dont_print_type_obstack
, NULL
);
1587 #endif /* MAINTENANCE_CMDS */
1590 _initialize_gdbtypes ()
1593 init_type (TYPE_CODE_VOID
, 1,
1595 "void", (struct objfile
*) NULL
);
1597 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1599 "char", (struct objfile
*) NULL
);
1600 builtin_type_signed_char
=
1601 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1603 "signed char", (struct objfile
*) NULL
);
1604 builtin_type_unsigned_char
=
1605 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1607 "unsigned char", (struct objfile
*) NULL
);
1608 builtin_type_short
=
1609 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1611 "short", (struct objfile
*) NULL
);
1612 builtin_type_unsigned_short
=
1613 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1615 "unsigned short", (struct objfile
*) NULL
);
1617 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1619 "int", (struct objfile
*) NULL
);
1620 builtin_type_unsigned_int
=
1621 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1623 "unsigned int", (struct objfile
*) NULL
);
1625 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1627 "long", (struct objfile
*) NULL
);
1628 builtin_type_unsigned_long
=
1629 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1631 "unsigned long", (struct objfile
*) NULL
);
1632 builtin_type_long_long
=
1633 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1635 "long long", (struct objfile
*) NULL
);
1636 builtin_type_unsigned_long_long
=
1637 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1639 "unsigned long long", (struct objfile
*) NULL
);
1640 builtin_type_float
=
1641 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1643 "float", (struct objfile
*) NULL
);
1644 builtin_type_double
=
1645 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1647 "double", (struct objfile
*) NULL
);
1648 builtin_type_long_double
=
1649 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1651 "long double", (struct objfile
*) NULL
);
1652 builtin_type_complex
=
1653 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1655 "complex", (struct objfile
*) NULL
);
1656 TYPE_TARGET_TYPE (builtin_type_complex
) = builtin_type_float
;
1657 builtin_type_double_complex
=
1658 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1660 "double complex", (struct objfile
*) NULL
);
1661 TYPE_TARGET_TYPE (builtin_type_double_complex
) = builtin_type_double
;
1662 builtin_type_string
=
1663 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1665 "string", (struct objfile
*) NULL
);