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
))
884 /* It is dangerous to call lookup_symbol if we are currently
885 reading a symtab. Infinite recursion is one danger. */
886 if (currently_reading_symtab
)
889 name
= type_name_no_tag (type
);
890 /* FIXME: shouldn't we separately check the TYPE_NAME and the
891 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
892 as appropriate? (this code was written before TYPE_NAME and
893 TYPE_TAG_NAME were separate). */
896 complain (&stub_noname_complaint
);
899 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
900 (struct symtab
**) NULL
);
902 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
904 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
); /* TYPE_CODE_UNDEF */
906 type
= TYPE_TARGET_TYPE (type
);
909 if ((TYPE_FLAGS(type
) & TYPE_FLAG_STUB
) && ! currently_reading_symtab
)
911 char* name
= type_name_no_tag (type
);
912 /* FIXME: shouldn't we separately check the TYPE_NAME and the
913 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
914 as appropriate? (this code was written before TYPE_NAME and
915 TYPE_TAG_NAME were separate). */
919 complain (&stub_noname_complaint
);
922 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
923 (struct symtab
**) NULL
);
926 memcpy ((char *)type
,
927 (char *)SYMBOL_TYPE(sym
),
928 sizeof (struct type
));
932 if (TYPE_FLAGS (type
) & TYPE_FLAG_TARGET_STUB
)
934 struct type
*range_type
;
935 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
937 if (TYPE_FLAGS (target_type
) & TYPE_FLAG_STUB
)
939 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
940 && TYPE_NFIELDS (type
) == 1
941 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
944 /* Now recompute the length of the array type, based on its
945 number of elements and the target type's length. */
947 ((TYPE_FIELD_BITPOS (range_type
, 1)
948 - TYPE_FIELD_BITPOS (range_type
, 0)
950 * TYPE_LENGTH (target_type
));
951 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
953 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
955 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
956 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
959 /* Cache TYPE_LENGTH for future use. */
960 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
964 /* Ugly hack to convert method stubs into method types.
966 He ain't kiddin'. This demangles the name of the method into a string
967 including argument types, parses out each argument type, generates
968 a string casting a zero to that type, evaluates the string, and stuffs
969 the resulting type into an argtype vector!!! Then it knows the type
970 of the whole function (including argument types for overloading),
971 which info used to be in the stab's but was removed to hack back
972 the space required for them. */
975 check_stub_method (type
, i
, j
)
981 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
982 char *demangled_name
= cplus_demangle (mangled_name
,
983 DMGL_PARAMS
| DMGL_ANSI
);
984 char *argtypetext
, *p
;
985 int depth
= 0, argcount
= 1;
986 struct type
**argtypes
;
989 /* Make sure we got back a function string that we can use. */
991 p
= strchr (demangled_name
, '(');
993 if (demangled_name
== NULL
|| p
== NULL
)
994 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
996 /* Now, read in the parameters that define this type. */
1009 else if (*p
== ',' && depth
== 0)
1017 /* We need two more slots: one for the THIS pointer, and one for the
1018 NULL [...] or void [end of arglist]. */
1020 argtypes
= (struct type
**)
1021 TYPE_ALLOC (type
, (argcount
+ 2) * sizeof (struct type
*));
1023 /* FIXME: This is wrong for static member functions. */
1024 argtypes
[0] = lookup_pointer_type (type
);
1027 if (*p
!= ')') /* () means no args, skip while */
1032 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1034 /* Avoid parsing of ellipsis, they will be handled below. */
1035 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0)
1037 argtypes
[argcount
] =
1038 parse_and_eval_type (argtypetext
, p
- argtypetext
);
1041 argtypetext
= p
+ 1;
1057 if (p
[-2] != '.') /* Not '...' */
1059 argtypes
[argcount
] = builtin_type_void
; /* List terminator */
1063 argtypes
[argcount
] = NULL
; /* Ellist terminator */
1066 free (demangled_name
);
1068 f
= TYPE_FN_FIELDLIST1 (type
, i
);
1069 TYPE_FN_FIELD_PHYSNAME (f
, j
) = mangled_name
;
1071 /* Now update the old "stub" type into a real type. */
1072 mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1073 TYPE_DOMAIN_TYPE (mtype
) = type
;
1074 TYPE_ARG_TYPES (mtype
) = argtypes
;
1075 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1076 TYPE_FN_FIELD_STUB (f
, j
) = 0;
1079 const struct cplus_struct_type cplus_struct_default
;
1082 allocate_cplus_struct_type (type
)
1085 if (!HAVE_CPLUS_STRUCT (type
))
1087 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1088 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1089 *(TYPE_CPLUS_SPECIFIC(type
)) = cplus_struct_default
;
1093 /* Helper function to initialize the standard scalar types.
1095 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1096 of the string pointed to by name in the type_obstack for that objfile,
1097 and initialize the type name to that copy. There are places (mipsread.c
1098 in particular, where init_type is called with a NULL value for NAME). */
1101 init_type (code
, length
, flags
, name
, objfile
)
1102 enum type_code code
;
1106 struct objfile
*objfile
;
1108 register struct type
*type
;
1110 type
= alloc_type (objfile
);
1111 TYPE_CODE (type
) = code
;
1112 TYPE_LENGTH (type
) = length
;
1113 TYPE_FLAGS (type
) |= flags
;
1114 if ((name
!= NULL
) && (objfile
!= NULL
))
1117 obsavestring (name
, strlen (name
), &objfile
-> type_obstack
);
1121 TYPE_NAME (type
) = name
;
1126 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
1128 INIT_CPLUS_SPECIFIC (type
);
1133 /* Look up a fundamental type for the specified objfile.
1134 May need to construct such a type if this is the first use.
1136 Some object file formats (ELF, COFF, etc) do not define fundamental
1137 types such as "int" or "double". Others (stabs for example), do
1138 define fundamental types.
1140 For the formats which don't provide fundamental types, gdb can create
1141 such types, using defaults reasonable for the current language and
1142 the current target machine.
1144 NOTE: This routine is obsolescent. Each debugging format reader
1145 should manage it's own fundamental types, either creating them from
1146 suitable defaults or reading them from the debugging information,
1147 whichever is appropriate. The DWARF reader has already been
1148 fixed to do this. Once the other readers are fixed, this routine
1149 will go away. Also note that fundamental types should be managed
1150 on a compilation unit basis in a multi-language environment, not
1151 on a linkage unit basis as is done here. */
1155 lookup_fundamental_type (objfile
, typeid)
1156 struct objfile
*objfile
;
1159 register struct type
**typep
;
1160 register int nbytes
;
1162 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1164 error ("internal error - invalid fundamental type id %d", typeid);
1167 /* If this is the first time we need a fundamental type for this objfile
1168 then we need to initialize the vector of type pointers. */
1170 if (objfile
-> fundamental_types
== NULL
)
1172 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1173 objfile
-> fundamental_types
= (struct type
**)
1174 obstack_alloc (&objfile
-> type_obstack
, nbytes
);
1175 memset ((char *) objfile
-> fundamental_types
, 0, nbytes
);
1176 OBJSTAT (objfile
, n_types
+= FT_NUM_MEMBERS
);
1179 /* Look for this particular type in the fundamental type vector. If one is
1180 not found, create and install one appropriate for the current language. */
1182 typep
= objfile
-> fundamental_types
+ typeid;
1185 *typep
= create_fundamental_type (objfile
, typeid);
1195 /* FIXME: Should we return true for references as well as pointers? */
1199 && TYPE_CODE (t
) == TYPE_CODE_PTR
1200 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1203 /* Chill varying string and arrays are represented as follows:
1205 struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
1207 Return true if TYPE is such a Chill varying type. */
1210 chill_varying_type (type
)
1213 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1214 || TYPE_NFIELDS (type
) != 2
1215 || strcmp (TYPE_FIELD_NAME (type
, 0), "__var_length") != 0)
1220 #if MAINTENANCE_CMDS
1223 print_bit_vector (bits
, nbits
)
1229 for (bitno
= 0; bitno
< nbits
; bitno
++)
1231 if ((bitno
% 8) == 0)
1233 puts_filtered (" ");
1235 if (B_TST (bits
, bitno
))
1237 printf_filtered ("1");
1241 printf_filtered ("0");
1246 /* The args list is a strange beast. It is either terminated by a NULL
1247 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
1248 type for normal fixed argcount functions. (FIXME someday)
1249 Also note the first arg should be the "this" pointer, we may not want to
1250 include it since we may get into a infinitely recursive situation. */
1253 print_arg_types (args
, spaces
)
1259 while (*args
!= NULL
)
1261 recursive_dump_type (*args
, spaces
+ 2);
1262 if ((*args
++) -> code
== TYPE_CODE_VOID
)
1271 dump_fn_fieldlists (type
, spaces
)
1279 printfi_filtered (spaces
, "fn_fieldlists ");
1280 gdb_print_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
1281 printf_filtered ("\n");
1282 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
1284 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
1285 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
1287 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
1288 gdb_print_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
1290 printf_filtered (") length %d\n",
1291 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
1292 for (overload_idx
= 0;
1293 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
1296 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
1298 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
1299 gdb_print_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
1301 printf_filtered (")\n");
1302 printfi_filtered (spaces
+ 8, "type ");
1303 gdb_print_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
1304 printf_filtered ("\n");
1306 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
1309 printfi_filtered (spaces
+ 8, "args ");
1310 gdb_print_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
1311 printf_filtered ("\n");
1313 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
), spaces
);
1314 printfi_filtered (spaces
+ 8, "fcontext ");
1315 gdb_print_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
1317 printf_filtered ("\n");
1319 printfi_filtered (spaces
+ 8, "is_const %d\n",
1320 TYPE_FN_FIELD_CONST (f
, overload_idx
));
1321 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
1322 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
1323 printfi_filtered (spaces
+ 8, "is_private %d\n",
1324 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
1325 printfi_filtered (spaces
+ 8, "is_protected %d\n",
1326 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
1327 printfi_filtered (spaces
+ 8, "is_stub %d\n",
1328 TYPE_FN_FIELD_STUB (f
, overload_idx
));
1329 printfi_filtered (spaces
+ 8, "voffset %u\n",
1330 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
1336 print_cplus_stuff (type
, spaces
)
1340 printfi_filtered (spaces
, "n_baseclasses %d\n",
1341 TYPE_N_BASECLASSES (type
));
1342 printfi_filtered (spaces
, "nfn_fields %d\n",
1343 TYPE_NFN_FIELDS (type
));
1344 printfi_filtered (spaces
, "nfn_fields_total %d\n",
1345 TYPE_NFN_FIELDS_TOTAL (type
));
1346 if (TYPE_N_BASECLASSES (type
) > 0)
1348 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
1349 TYPE_N_BASECLASSES (type
));
1350 gdb_print_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
1351 printf_filtered (")");
1353 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
1354 TYPE_N_BASECLASSES (type
));
1355 puts_filtered ("\n");
1357 if (TYPE_NFIELDS (type
) > 0)
1359 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
1361 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
1362 TYPE_NFIELDS (type
));
1363 gdb_print_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
1364 printf_filtered (")");
1365 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
1366 TYPE_NFIELDS (type
));
1367 puts_filtered ("\n");
1369 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
1371 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
1372 TYPE_NFIELDS (type
));
1373 gdb_print_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
1374 printf_filtered (")");
1375 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
1376 TYPE_NFIELDS (type
));
1377 puts_filtered ("\n");
1380 if (TYPE_NFN_FIELDS (type
) > 0)
1382 dump_fn_fieldlists (type
, spaces
);
1386 static struct obstack dont_print_type_obstack
;
1389 recursive_dump_type (type
, spaces
)
1396 obstack_begin (&dont_print_type_obstack
, 0);
1398 if (TYPE_NFIELDS (type
) > 0
1399 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
1401 struct type
**first_dont_print
1402 = (struct type
**)obstack_base (&dont_print_type_obstack
);
1404 int i
= (struct type
**)obstack_next_free (&dont_print_type_obstack
)
1409 if (type
== first_dont_print
[i
])
1411 printfi_filtered (spaces
, "type node ");
1412 gdb_print_address (type
, gdb_stdout
);
1413 printf_filtered (" <same as already seen type>\n");
1418 obstack_ptr_grow (&dont_print_type_obstack
, type
);
1421 printfi_filtered (spaces
, "type node ");
1422 gdb_print_address (type
, gdb_stdout
);
1423 printf_filtered ("\n");
1424 printfi_filtered (spaces
, "name '%s' (",
1425 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
1426 gdb_print_address (TYPE_NAME (type
), gdb_stdout
);
1427 printf_filtered (")\n");
1428 if (TYPE_TAG_NAME (type
) != NULL
)
1430 printfi_filtered (spaces
, "tagname '%s' (",
1431 TYPE_TAG_NAME (type
));
1432 gdb_print_address (TYPE_TAG_NAME (type
), gdb_stdout
);
1433 printf_filtered (")\n");
1435 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
1436 switch (TYPE_CODE (type
))
1438 case TYPE_CODE_UNDEF
:
1439 printf_filtered ("(TYPE_CODE_UNDEF)");
1442 printf_filtered ("(TYPE_CODE_PTR)");
1444 case TYPE_CODE_ARRAY
:
1445 printf_filtered ("(TYPE_CODE_ARRAY)");
1447 case TYPE_CODE_STRUCT
:
1448 printf_filtered ("(TYPE_CODE_STRUCT)");
1450 case TYPE_CODE_UNION
:
1451 printf_filtered ("(TYPE_CODE_UNION)");
1453 case TYPE_CODE_ENUM
:
1454 printf_filtered ("(TYPE_CODE_ENUM)");
1456 case TYPE_CODE_FUNC
:
1457 printf_filtered ("(TYPE_CODE_FUNC)");
1460 printf_filtered ("(TYPE_CODE_INT)");
1463 printf_filtered ("(TYPE_CODE_FLT)");
1465 case TYPE_CODE_VOID
:
1466 printf_filtered ("(TYPE_CODE_VOID)");
1469 printf_filtered ("(TYPE_CODE_SET)");
1471 case TYPE_CODE_RANGE
:
1472 printf_filtered ("(TYPE_CODE_RANGE)");
1474 case TYPE_CODE_STRING
:
1475 printf_filtered ("(TYPE_CODE_STRING)");
1477 case TYPE_CODE_ERROR
:
1478 printf_filtered ("(TYPE_CODE_ERROR)");
1480 case TYPE_CODE_MEMBER
:
1481 printf_filtered ("(TYPE_CODE_MEMBER)");
1483 case TYPE_CODE_METHOD
:
1484 printf_filtered ("(TYPE_CODE_METHOD)");
1487 printf_filtered ("(TYPE_CODE_REF)");
1489 case TYPE_CODE_CHAR
:
1490 printf_filtered ("(TYPE_CODE_CHAR)");
1492 case TYPE_CODE_BOOL
:
1493 printf_filtered ("(TYPE_CODE_BOOL)");
1495 case TYPE_CODE_TYPEDEF
:
1496 printf_filtered ("(TYPE_CODE_TYPEDEF)");
1499 printf_filtered ("(UNKNOWN TYPE CODE)");
1502 puts_filtered ("\n");
1503 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
1504 printfi_filtered (spaces
, "objfile ");
1505 gdb_print_address (TYPE_OBJFILE (type
), gdb_stdout
);
1506 printf_filtered ("\n");
1507 printfi_filtered (spaces
, "target_type ");
1508 gdb_print_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
1509 printf_filtered ("\n");
1510 if (TYPE_TARGET_TYPE (type
) != NULL
)
1512 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
1514 printfi_filtered (spaces
, "pointer_type ");
1515 gdb_print_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
1516 printf_filtered ("\n");
1517 printfi_filtered (spaces
, "reference_type ");
1518 gdb_print_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
1519 printf_filtered ("\n");
1520 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
1521 if (TYPE_FLAGS (type
) & TYPE_FLAG_UNSIGNED
)
1523 puts_filtered (" TYPE_FLAG_UNSIGNED");
1525 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
1527 puts_filtered (" TYPE_FLAG_STUB");
1529 puts_filtered ("\n");
1530 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
1531 gdb_print_address (TYPE_FIELDS (type
), gdb_stdout
);
1532 puts_filtered ("\n");
1533 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
1535 printfi_filtered (spaces
+ 2,
1536 "[%d] bitpos %d bitsize %d type ",
1537 idx
, TYPE_FIELD_BITPOS (type
, idx
),
1538 TYPE_FIELD_BITSIZE (type
, idx
));
1539 gdb_print_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
1540 printf_filtered (" name '%s' (",
1541 TYPE_FIELD_NAME (type
, idx
) != NULL
1542 ? TYPE_FIELD_NAME (type
, idx
)
1544 gdb_print_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
1545 printf_filtered (")\n");
1546 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
1548 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
1551 printfi_filtered (spaces
, "vptr_basetype ");
1552 gdb_print_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
1553 puts_filtered ("\n");
1554 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
1556 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
1558 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
1559 switch (TYPE_CODE (type
))
1561 case TYPE_CODE_METHOD
:
1562 case TYPE_CODE_FUNC
:
1563 printfi_filtered (spaces
, "arg_types ");
1564 gdb_print_address (TYPE_ARG_TYPES (type
), gdb_stdout
);
1565 puts_filtered ("\n");
1566 print_arg_types (TYPE_ARG_TYPES (type
), spaces
);
1569 case TYPE_CODE_STRUCT
:
1570 printfi_filtered (spaces
, "cplus_stuff ");
1571 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1572 puts_filtered ("\n");
1573 print_cplus_stuff (type
, spaces
);
1577 /* We have to pick one of the union types to be able print and test
1578 the value. Pick cplus_struct_type, even though we know it isn't
1579 any particular one. */
1580 printfi_filtered (spaces
, "type_specific ");
1581 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1582 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
1584 printf_filtered (" (unknown data form)");
1586 printf_filtered ("\n");
1591 obstack_free (&dont_print_type_obstack
, NULL
);
1594 #endif /* MAINTENANCE_CMDS */
1597 _initialize_gdbtypes ()
1600 init_type (TYPE_CODE_VOID
, 1,
1602 "void", (struct objfile
*) NULL
);
1604 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1606 "char", (struct objfile
*) NULL
);
1607 builtin_type_signed_char
=
1608 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1610 "signed char", (struct objfile
*) NULL
);
1611 builtin_type_unsigned_char
=
1612 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1614 "unsigned char", (struct objfile
*) NULL
);
1615 builtin_type_short
=
1616 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1618 "short", (struct objfile
*) NULL
);
1619 builtin_type_unsigned_short
=
1620 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1622 "unsigned short", (struct objfile
*) NULL
);
1624 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1626 "int", (struct objfile
*) NULL
);
1627 builtin_type_unsigned_int
=
1628 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1630 "unsigned int", (struct objfile
*) NULL
);
1632 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1634 "long", (struct objfile
*) NULL
);
1635 builtin_type_unsigned_long
=
1636 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1638 "unsigned long", (struct objfile
*) NULL
);
1639 builtin_type_long_long
=
1640 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1642 "long long", (struct objfile
*) NULL
);
1643 builtin_type_unsigned_long_long
=
1644 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1646 "unsigned long long", (struct objfile
*) NULL
);
1647 builtin_type_float
=
1648 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1650 "float", (struct objfile
*) NULL
);
1651 builtin_type_double
=
1652 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1654 "double", (struct objfile
*) NULL
);
1655 builtin_type_long_double
=
1656 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1658 "long double", (struct objfile
*) NULL
);
1659 builtin_type_complex
=
1660 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1662 "complex", (struct objfile
*) NULL
);
1663 TYPE_TARGET_TYPE (builtin_type_complex
) = builtin_type_float
;
1664 builtin_type_double_complex
=
1665 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1667 "double complex", (struct objfile
*) NULL
);
1668 TYPE_TARGET_TYPE (builtin_type_double_complex
) = builtin_type_double
;
1669 builtin_type_string
=
1670 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1672 "string", (struct objfile
*) NULL
);