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
));
78 memset ((char *) type
, 0, sizeof (struct type
));
80 /* Initialize the fields that might not be zero. */
82 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
83 TYPE_OBJFILE (type
) = objfile
;
84 TYPE_VPTR_FIELDNO (type
) = -1;
89 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
90 to a pointer to memory where the pointer type should be stored.
91 If *TYPEPTR is zero, update it to point to the pointer type we return.
92 We allocate new memory if needed. */
95 make_pointer_type (type
, typeptr
)
97 struct type
**typeptr
;
99 register struct type
*ntype
; /* New type */
100 struct objfile
*objfile
;
102 ntype
= TYPE_POINTER_TYPE (type
);
106 return ntype
; /* Don't care about alloc, and have new type. */
107 else if (*typeptr
== 0)
109 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
113 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
115 ntype
= alloc_type (TYPE_OBJFILE (type
));
119 else /* We have storage, but need to reset it. */
122 objfile
= TYPE_OBJFILE (ntype
);
123 memset ((char *) ntype
, 0, sizeof (struct type
));
124 TYPE_OBJFILE (ntype
) = objfile
;
127 TYPE_TARGET_TYPE (ntype
) = type
;
128 TYPE_POINTER_TYPE (type
) = ntype
;
130 /* FIXME! Assume the machine has only one representation for pointers! */
132 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
133 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
135 /* pointers are unsigned */
136 TYPE_FLAGS (ntype
) |= TYPE_FLAG_UNSIGNED
;
138 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
139 TYPE_POINTER_TYPE (type
) = ntype
;
144 /* Given a type TYPE, return a type of pointers to that type.
145 May need to construct such a type if this is the first use. */
148 lookup_pointer_type (type
)
151 return make_pointer_type (type
, (struct type
**)0);
154 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero, points
155 to a pointer to memory where the reference type should be stored.
156 If *TYPEPTR is zero, update it to point to the reference type we return.
157 We allocate new memory if needed. */
160 make_reference_type (type
, typeptr
)
162 struct type
**typeptr
;
164 register struct type
*ntype
; /* New type */
165 struct objfile
*objfile
;
167 ntype
= TYPE_REFERENCE_TYPE (type
);
171 return ntype
; /* Don't care about alloc, and have new type. */
172 else if (*typeptr
== 0)
174 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
178 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
180 ntype
= alloc_type (TYPE_OBJFILE (type
));
184 else /* We have storage, but need to reset it. */
187 objfile
= TYPE_OBJFILE (ntype
);
188 memset ((char *) ntype
, 0, sizeof (struct type
));
189 TYPE_OBJFILE (ntype
) = objfile
;
192 TYPE_TARGET_TYPE (ntype
) = type
;
193 TYPE_REFERENCE_TYPE (type
) = ntype
;
195 /* FIXME! Assume the machine has only one representation for references,
196 and that it matches the (only) representation for pointers! */
198 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
199 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
201 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
202 TYPE_REFERENCE_TYPE (type
) = ntype
;
207 /* Same as above, but caller doesn't care about memory allocation details. */
210 lookup_reference_type (type
)
213 return make_reference_type (type
, (struct type
**)0);
216 /* Lookup a function type that returns type TYPE. TYPEPTR, if nonzero, points
217 to a pointer to memory where the function type should be stored.
218 If *TYPEPTR is zero, update it to point to the function type we return.
219 We allocate new memory if needed. */
222 make_function_type (type
, typeptr
)
224 struct type
**typeptr
;
226 register struct type
*ntype
; /* New type */
227 struct objfile
*objfile
;
229 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
231 ntype
= alloc_type (TYPE_OBJFILE (type
));
235 else /* We have storage, but need to reset it. */
238 objfile
= TYPE_OBJFILE (ntype
);
239 memset ((char *) ntype
, 0, sizeof (struct type
));
240 TYPE_OBJFILE (ntype
) = objfile
;
243 TYPE_TARGET_TYPE (ntype
) = type
;
245 TYPE_LENGTH (ntype
) = 1;
246 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
252 /* Given a type TYPE, return a type of functions that return that type.
253 May need to construct such a type if this is the first use. */
256 lookup_function_type (type
)
259 return make_function_type (type
, (struct type
**)0);
262 /* Implement direct support for MEMBER_TYPE in GNU C++.
263 May need to construct such a type if this is the first use.
264 The TYPE is the type of the member. The DOMAIN is the type
265 of the aggregate that the member belongs to. */
268 lookup_member_type (type
, domain
)
272 register struct type
*mtype
;
274 mtype
= alloc_type (TYPE_OBJFILE (type
));
275 smash_to_member_type (mtype
, domain
, type
);
279 /* Allocate a stub method whose return type is TYPE.
280 This apparently happens for speed of symbol reading, since parsing
281 out the arguments to the method is cpu-intensive, the way we are doing
282 it. So, we will fill in arguments later.
283 This always returns a fresh type. */
286 allocate_stub_method (type
)
291 mtype
= alloc_type (TYPE_OBJFILE (type
));
292 TYPE_TARGET_TYPE (mtype
) = type
;
293 /* _DOMAIN_TYPE (mtype) = unknown yet */
294 /* _ARG_TYPES (mtype) = unknown yet */
295 TYPE_FLAGS (mtype
) = TYPE_FLAG_STUB
;
296 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
297 TYPE_LENGTH (mtype
) = 1;
301 /* Create a range type using either a blank type supplied in RESULT_TYPE,
302 or creating a new type, inheriting the objfile from INDEX_TYPE.
304 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
305 HIGH_BOUND, inclusive.
307 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
308 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
311 create_range_type (result_type
, index_type
, low_bound
, high_bound
)
312 struct type
*result_type
;
313 struct type
*index_type
;
317 if (result_type
== NULL
)
319 result_type
= alloc_type (TYPE_OBJFILE (index_type
));
321 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
322 TYPE_TARGET_TYPE (result_type
) = index_type
;
323 if (TYPE_FLAGS (index_type
) & TYPE_FLAG_STUB
)
324 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
326 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
327 TYPE_NFIELDS (result_type
) = 2;
328 TYPE_FIELDS (result_type
) = (struct field
*)
329 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
330 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
331 TYPE_FIELD_BITPOS (result_type
, 0) = low_bound
;
332 TYPE_FIELD_BITPOS (result_type
, 1) = high_bound
;
333 TYPE_FIELD_TYPE (result_type
, 0) = builtin_type_int
; /* FIXME */
334 TYPE_FIELD_TYPE (result_type
, 1) = builtin_type_int
; /* FIXME */
336 return (result_type
);
339 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE.
340 Return 1 of type is a range type, 0 if it is discrete (and bounds
341 will fit in LONGEST), or -1 otherwise. */
344 get_discrete_bounds (type
, lowp
, highp
)
346 LONGEST
*lowp
, *highp
;
348 CHECK_TYPEDEF (type
);
349 switch (TYPE_CODE (type
))
351 case TYPE_CODE_RANGE
:
352 *lowp
= TYPE_LOW_BOUND (type
);
353 *highp
= TYPE_HIGH_BOUND (type
);
356 if (TYPE_NFIELDS (type
) > 0)
358 *lowp
= TYPE_FIELD_BITPOS (type
, 0);
359 *highp
= TYPE_FIELD_BITPOS (type
, TYPE_NFIELDS (type
) - 1);
372 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
374 if (!TYPE_UNSIGNED (type
))
376 *lowp
= - (1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
380 /* ... fall through for unsigned ints ... */
383 /* This round-about calculation is to avoid shifting by
384 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
385 if TYPE_LENGTH (type) == sizeof (LONGEST). */
386 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
387 *highp
= (*highp
- 1) | *highp
;
394 /* Create an array type using either a blank type supplied in RESULT_TYPE,
395 or creating a new type, inheriting the objfile from RANGE_TYPE.
397 Elements will be of type ELEMENT_TYPE, the indices will be of type
400 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
401 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
404 create_array_type (result_type
, element_type
, range_type
)
405 struct type
*result_type
;
406 struct type
*element_type
;
407 struct type
*range_type
;
409 LONGEST low_bound
, high_bound
;
411 if (result_type
== NULL
)
413 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
415 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
416 TYPE_TARGET_TYPE (result_type
) = element_type
;
417 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
418 low_bound
= high_bound
= 0;
419 CHECK_TYPEDEF (element_type
);
420 TYPE_LENGTH (result_type
) =
421 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
422 TYPE_NFIELDS (result_type
) = 1;
423 TYPE_FIELDS (result_type
) =
424 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
425 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
426 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
427 TYPE_VPTR_FIELDNO (result_type
) = -1;
429 return (result_type
);
432 /* Create a string type using either a blank type supplied in RESULT_TYPE,
433 or creating a new type. String types are similar enough to array of
434 char types that we can use create_array_type to build the basic type
435 and then bash it into a string type.
437 For fixed length strings, the range type contains 0 as the lower
438 bound and the length of the string minus one as the upper bound.
440 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
441 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
444 create_string_type (result_type
, range_type
)
445 struct type
*result_type
;
446 struct type
*range_type
;
448 result_type
= create_array_type (result_type
,
449 *current_language
->string_char_type
,
451 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
452 return (result_type
);
456 create_set_type (result_type
, domain_type
)
457 struct type
*result_type
;
458 struct type
*domain_type
;
460 LONGEST low_bound
, high_bound
, bit_length
;
461 if (result_type
== NULL
)
463 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
465 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
466 TYPE_NFIELDS (result_type
) = 1;
467 TYPE_FIELDS (result_type
) = (struct field
*)
468 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
469 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
471 if (! (TYPE_FLAGS (domain_type
) & TYPE_FLAG_STUB
))
473 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
474 low_bound
= high_bound
= 0;
475 bit_length
= high_bound
- low_bound
+ 1;
476 TYPE_LENGTH (result_type
)
477 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
479 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
480 return (result_type
);
483 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
484 A MEMBER is a wierd thing -- it amounts to a typed offset into
485 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
486 include the offset (that's the value of the MEMBER itself), but does
487 include the structure type into which it points (for some reason).
489 When "smashing" the type, we preserve the objfile that the
490 old type pointed to, since we aren't changing where the type is actually
494 smash_to_member_type (type
, domain
, to_type
)
497 struct type
*to_type
;
499 struct objfile
*objfile
;
501 objfile
= TYPE_OBJFILE (type
);
503 memset ((char *) type
, 0, sizeof (struct type
));
504 TYPE_OBJFILE (type
) = objfile
;
505 TYPE_TARGET_TYPE (type
) = to_type
;
506 TYPE_DOMAIN_TYPE (type
) = domain
;
507 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
508 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
511 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
512 METHOD just means `function that gets an extra "this" argument'.
514 When "smashing" the type, we preserve the objfile that the
515 old type pointed to, since we aren't changing where the type is actually
519 smash_to_method_type (type
, domain
, to_type
, args
)
522 struct type
*to_type
;
525 struct objfile
*objfile
;
527 objfile
= TYPE_OBJFILE (type
);
529 memset ((char *) type
, 0, sizeof (struct type
));
530 TYPE_OBJFILE (type
) = objfile
;
531 TYPE_TARGET_TYPE (type
) = to_type
;
532 TYPE_DOMAIN_TYPE (type
) = domain
;
533 TYPE_ARG_TYPES (type
) = args
;
534 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
535 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
538 /* Return a typename for a struct/union/enum type without "struct ",
539 "union ", or "enum ". If the type has a NULL name, return NULL. */
542 type_name_no_tag (type
)
543 register const struct type
*type
;
545 if (TYPE_TAG_NAME (type
) != NULL
)
546 return TYPE_TAG_NAME (type
);
548 /* Is there code which expects this to return the name if there is no
549 tag name? My guess is that this is mainly used for C++ in cases where
550 the two will always be the same. */
551 return TYPE_NAME (type
);
554 /* Lookup a primitive type named NAME.
555 Return zero if NAME is not a primitive type.*/
558 lookup_primitive_typename (name
)
561 struct type
** const *p
;
563 for (p
= current_language
-> la_builtin_type_vector
; *p
!= NULL
; p
++)
565 if (STREQ ((**p
) -> name
, name
))
573 /* Lookup a typedef or primitive type named NAME,
574 visible in lexical block BLOCK.
575 If NOERR is nonzero, return zero if NAME is not suitably defined. */
578 lookup_typename (name
, block
, noerr
)
583 register struct symbol
*sym
;
584 register struct type
*tmp
;
586 sym
= lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
587 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
589 tmp
= lookup_primitive_typename (name
);
594 else if (!tmp
&& noerr
)
600 error ("No type named %s.", name
);
603 return (SYMBOL_TYPE (sym
));
607 lookup_unsigned_typename (name
)
610 char *uns
= alloca (strlen (name
) + 10);
612 strcpy (uns
, "unsigned ");
613 strcpy (uns
+ 9, name
);
614 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
618 lookup_signed_typename (name
)
622 char *uns
= alloca (strlen (name
) + 8);
624 strcpy (uns
, "signed ");
625 strcpy (uns
+ 7, name
);
626 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
627 /* If we don't find "signed FOO" just try again with plain "FOO". */
630 return lookup_typename (name
, (struct block
*) NULL
, 0);
633 /* Lookup a structure type named "struct NAME",
634 visible in lexical block BLOCK. */
637 lookup_struct (name
, block
)
641 register struct symbol
*sym
;
643 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
644 (struct symtab
**) NULL
);
648 error ("No struct type named %s.", name
);
650 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
652 error ("This context has class, union or enum %s, not a struct.", name
);
654 return (SYMBOL_TYPE (sym
));
657 /* Lookup a union type named "union NAME",
658 visible in lexical block BLOCK. */
661 lookup_union (name
, block
)
665 register struct symbol
*sym
;
667 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
668 (struct symtab
**) NULL
);
672 error ("No union type named %s.", name
);
674 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_UNION
)
676 error ("This context has class, struct or enum %s, not a union.", name
);
678 return (SYMBOL_TYPE (sym
));
681 /* Lookup an enum type named "enum NAME",
682 visible in lexical block BLOCK. */
685 lookup_enum (name
, block
)
689 register struct symbol
*sym
;
691 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
692 (struct symtab
**) NULL
);
695 error ("No enum type named %s.", name
);
697 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
699 error ("This context has class, struct or union %s, not an enum.", name
);
701 return (SYMBOL_TYPE (sym
));
704 /* Lookup a template type named "template NAME<TYPE>",
705 visible in lexical block BLOCK. */
708 lookup_template_type (name
, type
, block
)
714 char *nam
= (char*) alloca(strlen(name
) + strlen(type
->name
) + 4);
717 strcat (nam
, type
->name
);
718 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
720 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
724 error ("No template type named %s.", name
);
726 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
728 error ("This context has class, union or enum %s, not a struct.", name
);
730 return (SYMBOL_TYPE (sym
));
733 /* Given a type TYPE, lookup the type of the component of type named NAME.
735 TYPE can be either a struct or union, or a pointer or reference to a struct or
736 union. If it is a pointer or reference, its target type is automatically used.
737 Thus '.' and '->' are interchangable, as specified for the definitions of the
738 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
740 If NOERR is nonzero, return zero if NAME is not suitably defined.
741 If NAME is the name of a baseclass type, return that type. */
744 lookup_struct_elt_type (type
, name
, noerr
)
753 CHECK_TYPEDEF (type
);
754 if (TYPE_CODE (type
) != TYPE_CODE_PTR
755 && TYPE_CODE (type
) != TYPE_CODE_REF
)
757 type
= TYPE_TARGET_TYPE (type
);
760 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
761 TYPE_CODE (type
) != TYPE_CODE_UNION
)
763 target_terminal_ours ();
764 gdb_flush (gdb_stdout
);
765 fprintf_unfiltered (gdb_stderr
, "Type ");
766 type_print (type
, "", gdb_stderr
, -1);
767 error (" is not a structure or union type.");
771 /* FIXME: This change put in by Michael seems incorrect for the case where
772 the structure tag name is the same as the member name. I.E. when doing
773 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
778 typename
= type_name_no_tag (type
);
779 if (typename
!= NULL
&& STREQ (typename
, name
))
784 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
786 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
788 if (t_field_name
&& STREQ (t_field_name
, name
))
790 return TYPE_FIELD_TYPE (type
, i
);
794 /* OK, it's not in this class. Recursively check the baseclasses. */
795 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
799 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, noerr
);
811 target_terminal_ours ();
812 gdb_flush (gdb_stdout
);
813 fprintf_unfiltered (gdb_stderr
, "Type ");
814 type_print (type
, "", gdb_stderr
, -1);
815 fprintf_unfiltered (gdb_stderr
, " has no component named ");
816 fputs_filtered (name
, gdb_stderr
);
818 return (struct type
*)-1; /* For lint */
821 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
822 valid. Callers should be aware that in some cases (for example,
823 the type or one of its baseclasses is a stub type and we are
824 debugging a .o file), this function will not be able to find the virtual
825 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
829 fill_in_vptr_fieldno (type
)
832 CHECK_TYPEDEF (type
);
834 if (TYPE_VPTR_FIELDNO (type
) < 0)
838 /* We must start at zero in case the first (and only) baseclass is
839 virtual (and hence we cannot share the table pointer). */
840 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
842 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, i
));
843 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
)) >= 0)
845 TYPE_VPTR_FIELDNO (type
)
846 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
));
847 TYPE_VPTR_BASETYPE (type
)
848 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type
, i
));
855 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
857 If this is a stubbed struct (i.e. declared as struct foo *), see if
858 we can find a full definition in some other file. If so, copy this
859 definition, so we can use it in future. There used to be a comment (but
860 not any code) that if we don't find a full definition, we'd set a flag
861 so we don't spend time in the future checking the same type. That would
862 be a mistake, though--we might load in more symbols which contain a
863 full definition for the type.
865 This used to be coded as a macro, but I don't think it is called
866 often enough to merit such treatment. */
868 struct complaint stub_noname_complaint
=
869 {"stub type has NULL name", 0, 0};
873 register struct type
*type
;
875 struct type
*orig_type
= type
;
876 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
878 if (!TYPE_TARGET_TYPE (type
))
880 char* name
= type_name_no_tag (type
);
881 /* FIXME: shouldn't we separately check the TYPE_NAME and the
882 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
883 as appropriate? (this code was written before TYPE_NAME and
884 TYPE_TAG_NAME were separate). */
888 complain (&stub_noname_complaint
);
891 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
892 (struct symtab
**) NULL
);
894 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
896 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
); /* TYPE_CODE_UNDEF */
898 type
= TYPE_TARGET_TYPE (type
);
901 if (TYPE_FLAGS(type
) & TYPE_FLAG_STUB
)
903 char* name
= type_name_no_tag (type
);
904 /* FIXME: shouldn't we separately check the TYPE_NAME and the
905 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
906 as appropriate? (this code was written before TYPE_NAME and
907 TYPE_TAG_NAME were separate). */
911 complain (&stub_noname_complaint
);
914 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
915 (struct symtab
**) NULL
);
918 memcpy ((char *)type
,
919 (char *)SYMBOL_TYPE(sym
),
920 sizeof (struct type
));
924 if (TYPE_FLAGS (type
) & TYPE_FLAG_TARGET_STUB
)
926 struct type
*range_type
;
927 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
929 if (TYPE_FLAGS (target_type
) & TYPE_FLAG_STUB
)
931 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
932 && TYPE_NFIELDS (type
) == 1
933 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
936 /* Now recompute the length of the array type, based on its
937 number of elements and the target type's length. */
939 ((TYPE_FIELD_BITPOS (range_type
, 1)
940 - TYPE_FIELD_BITPOS (range_type
, 0)
942 * TYPE_LENGTH (target_type
));
943 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
945 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
947 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
948 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
951 /* Cache TYPE_LENGTH for future use. */
952 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
956 /* Ugly hack to convert method stubs into method types.
958 He ain't kiddin'. This demangles the name of the method into a string
959 including argument types, parses out each argument type, generates
960 a string casting a zero to that type, evaluates the string, and stuffs
961 the resulting type into an argtype vector!!! Then it knows the type
962 of the whole function (including argument types for overloading),
963 which info used to be in the stab's but was removed to hack back
964 the space required for them. */
967 check_stub_method (type
, i
, j
)
973 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
974 char *demangled_name
= cplus_demangle (mangled_name
,
975 DMGL_PARAMS
| DMGL_ANSI
);
976 char *argtypetext
, *p
;
977 int depth
= 0, argcount
= 1;
978 struct type
**argtypes
;
981 /* Make sure we got back a function string that we can use. */
983 p
= strchr (demangled_name
, '(');
985 if (demangled_name
== NULL
|| p
== NULL
)
986 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
988 /* Now, read in the parameters that define this type. */
1001 else if (*p
== ',' && depth
== 0)
1009 /* We need two more slots: one for the THIS pointer, and one for the
1010 NULL [...] or void [end of arglist]. */
1012 argtypes
= (struct type
**)
1013 TYPE_ALLOC (type
, (argcount
+ 2) * sizeof (struct type
*));
1015 /* FIXME: This is wrong for static member functions. */
1016 argtypes
[0] = lookup_pointer_type (type
);
1019 if (*p
!= ')') /* () means no args, skip while */
1024 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1026 /* Avoid parsing of ellipsis, they will be handled below. */
1027 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0)
1029 argtypes
[argcount
] =
1030 parse_and_eval_type (argtypetext
, p
- argtypetext
);
1033 argtypetext
= p
+ 1;
1049 if (p
[-2] != '.') /* Not '...' */
1051 argtypes
[argcount
] = builtin_type_void
; /* List terminator */
1055 argtypes
[argcount
] = NULL
; /* Ellist terminator */
1058 free (demangled_name
);
1060 f
= TYPE_FN_FIELDLIST1 (type
, i
);
1061 TYPE_FN_FIELD_PHYSNAME (f
, j
) = mangled_name
;
1063 /* Now update the old "stub" type into a real type. */
1064 mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1065 TYPE_DOMAIN_TYPE (mtype
) = type
;
1066 TYPE_ARG_TYPES (mtype
) = argtypes
;
1067 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1068 TYPE_FN_FIELD_STUB (f
, j
) = 0;
1071 const struct cplus_struct_type cplus_struct_default
;
1074 allocate_cplus_struct_type (type
)
1077 if (!HAVE_CPLUS_STRUCT (type
))
1079 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1080 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1081 *(TYPE_CPLUS_SPECIFIC(type
)) = cplus_struct_default
;
1085 /* Helper function to initialize the standard scalar types.
1087 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1088 of the string pointed to by name in the type_obstack for that objfile,
1089 and initialize the type name to that copy. There are places (mipsread.c
1090 in particular, where init_type is called with a NULL value for NAME). */
1093 init_type (code
, length
, flags
, name
, objfile
)
1094 enum type_code code
;
1098 struct objfile
*objfile
;
1100 register struct type
*type
;
1102 type
= alloc_type (objfile
);
1103 TYPE_CODE (type
) = code
;
1104 TYPE_LENGTH (type
) = length
;
1105 TYPE_FLAGS (type
) |= flags
;
1106 if ((name
!= NULL
) && (objfile
!= NULL
))
1109 obsavestring (name
, strlen (name
), &objfile
-> type_obstack
);
1113 TYPE_NAME (type
) = name
;
1118 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
1120 INIT_CPLUS_SPECIFIC (type
);
1125 /* Look up a fundamental type for the specified objfile.
1126 May need to construct such a type if this is the first use.
1128 Some object file formats (ELF, COFF, etc) do not define fundamental
1129 types such as "int" or "double". Others (stabs for example), do
1130 define fundamental types.
1132 For the formats which don't provide fundamental types, gdb can create
1133 such types, using defaults reasonable for the current language and
1134 the current target machine.
1136 NOTE: This routine is obsolescent. Each debugging format reader
1137 should manage it's own fundamental types, either creating them from
1138 suitable defaults or reading them from the debugging information,
1139 whichever is appropriate. The DWARF reader has already been
1140 fixed to do this. Once the other readers are fixed, this routine
1141 will go away. Also note that fundamental types should be managed
1142 on a compilation unit basis in a multi-language environment, not
1143 on a linkage unit basis as is done here. */
1147 lookup_fundamental_type (objfile
, typeid)
1148 struct objfile
*objfile
;
1151 register struct type
**typep
;
1152 register int nbytes
;
1154 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1156 error ("internal error - invalid fundamental type id %d", typeid);
1159 /* If this is the first time we need a fundamental type for this objfile
1160 then we need to initialize the vector of type pointers. */
1162 if (objfile
-> fundamental_types
== NULL
)
1164 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1165 objfile
-> fundamental_types
= (struct type
**)
1166 obstack_alloc (&objfile
-> type_obstack
, nbytes
);
1167 memset ((char *) objfile
-> fundamental_types
, 0, nbytes
);
1170 /* Look for this particular type in the fundamental type vector. If one is
1171 not found, create and install one appropriate for the current language. */
1173 typep
= objfile
-> fundamental_types
+ typeid;
1176 *typep
= create_fundamental_type (objfile
, typeid);
1186 /* FIXME: Should we return true for references as well as pointers? */
1190 && TYPE_CODE (t
) == TYPE_CODE_PTR
1191 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1194 /* Chill varying string and arrays are represented as follows:
1196 struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
1198 Return true if TYPE is such a Chill varying type. */
1201 chill_varying_type (type
)
1204 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1205 || TYPE_NFIELDS (type
) != 2
1206 || strcmp (TYPE_FIELD_NAME (type
, 0), "__var_length") != 0)
1211 #if MAINTENANCE_CMDS
1214 print_bit_vector (bits
, nbits
)
1220 for (bitno
= 0; bitno
< nbits
; bitno
++)
1222 if ((bitno
% 8) == 0)
1224 puts_filtered (" ");
1226 if (B_TST (bits
, bitno
))
1228 printf_filtered ("1");
1232 printf_filtered ("0");
1237 /* The args list is a strange beast. It is either terminated by a NULL
1238 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
1239 type for normal fixed argcount functions. (FIXME someday)
1240 Also note the first arg should be the "this" pointer, we may not want to
1241 include it since we may get into a infinitely recursive situation. */
1244 print_arg_types (args
, spaces
)
1250 while (*args
!= NULL
)
1252 recursive_dump_type (*args
, spaces
+ 2);
1253 if ((*args
++) -> code
== TYPE_CODE_VOID
)
1262 dump_fn_fieldlists (type
, spaces
)
1270 printfi_filtered (spaces
, "fn_fieldlists ");
1271 gdb_print_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
1272 printf_filtered ("\n");
1273 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
1275 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
1276 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
1278 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
1279 gdb_print_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
1281 printf_filtered (") length %d\n",
1282 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
1283 for (overload_idx
= 0;
1284 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
1287 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
1289 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
1290 gdb_print_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
1292 printf_filtered (")\n");
1293 printfi_filtered (spaces
+ 8, "type ");
1294 gdb_print_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
1295 printf_filtered ("\n");
1297 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
1300 printfi_filtered (spaces
+ 8, "args ");
1301 gdb_print_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
1302 printf_filtered ("\n");
1304 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
), spaces
);
1305 printfi_filtered (spaces
+ 8, "fcontext ");
1306 gdb_print_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
1308 printf_filtered ("\n");
1310 printfi_filtered (spaces
+ 8, "is_const %d\n",
1311 TYPE_FN_FIELD_CONST (f
, overload_idx
));
1312 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
1313 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
1314 printfi_filtered (spaces
+ 8, "is_private %d\n",
1315 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
1316 printfi_filtered (spaces
+ 8, "is_protected %d\n",
1317 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
1318 printfi_filtered (spaces
+ 8, "is_stub %d\n",
1319 TYPE_FN_FIELD_STUB (f
, overload_idx
));
1320 printfi_filtered (spaces
+ 8, "voffset %u\n",
1321 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
1327 print_cplus_stuff (type
, spaces
)
1331 printfi_filtered (spaces
, "n_baseclasses %d\n",
1332 TYPE_N_BASECLASSES (type
));
1333 printfi_filtered (spaces
, "nfn_fields %d\n",
1334 TYPE_NFN_FIELDS (type
));
1335 printfi_filtered (spaces
, "nfn_fields_total %d\n",
1336 TYPE_NFN_FIELDS_TOTAL (type
));
1337 if (TYPE_N_BASECLASSES (type
) > 0)
1339 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
1340 TYPE_N_BASECLASSES (type
));
1341 gdb_print_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
1342 printf_filtered (")");
1344 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
1345 TYPE_N_BASECLASSES (type
));
1346 puts_filtered ("\n");
1348 if (TYPE_NFIELDS (type
) > 0)
1350 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
1352 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
1353 TYPE_NFIELDS (type
));
1354 gdb_print_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
1355 printf_filtered (")");
1356 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
1357 TYPE_NFIELDS (type
));
1358 puts_filtered ("\n");
1360 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
1362 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
1363 TYPE_NFIELDS (type
));
1364 gdb_print_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
1365 printf_filtered (")");
1366 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
1367 TYPE_NFIELDS (type
));
1368 puts_filtered ("\n");
1371 if (TYPE_NFN_FIELDS (type
) > 0)
1373 dump_fn_fieldlists (type
, spaces
);
1377 static struct obstack dont_print_type_obstack
;
1380 recursive_dump_type (type
, spaces
)
1387 obstack_begin (&dont_print_type_obstack
, 0);
1389 if (TYPE_NFIELDS (type
) > 0
1390 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
1392 struct type
**first_dont_print
1393 = (struct type
**)obstack_base (&dont_print_type_obstack
);
1395 int i
= (struct type
**)obstack_next_free (&dont_print_type_obstack
)
1400 if (type
== first_dont_print
[i
])
1402 printfi_filtered (spaces
, "type node ");
1403 gdb_print_address (type
, gdb_stdout
);
1404 printf_filtered (" <same as already seen type>\n");
1409 obstack_ptr_grow (&dont_print_type_obstack
, type
);
1412 printfi_filtered (spaces
, "type node ");
1413 gdb_print_address (type
, gdb_stdout
);
1414 printf_filtered ("\n");
1415 printfi_filtered (spaces
, "name '%s' (",
1416 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
1417 gdb_print_address (TYPE_NAME (type
), gdb_stdout
);
1418 printf_filtered (")\n");
1419 if (TYPE_TAG_NAME (type
) != NULL
)
1421 printfi_filtered (spaces
, "tagname '%s' (",
1422 TYPE_TAG_NAME (type
));
1423 gdb_print_address (TYPE_TAG_NAME (type
), gdb_stdout
);
1424 printf_filtered (")\n");
1426 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
1427 switch (TYPE_CODE (type
))
1429 case TYPE_CODE_UNDEF
:
1430 printf_filtered ("(TYPE_CODE_UNDEF)");
1433 printf_filtered ("(TYPE_CODE_PTR)");
1435 case TYPE_CODE_ARRAY
:
1436 printf_filtered ("(TYPE_CODE_ARRAY)");
1438 case TYPE_CODE_STRUCT
:
1439 printf_filtered ("(TYPE_CODE_STRUCT)");
1441 case TYPE_CODE_UNION
:
1442 printf_filtered ("(TYPE_CODE_UNION)");
1444 case TYPE_CODE_ENUM
:
1445 printf_filtered ("(TYPE_CODE_ENUM)");
1447 case TYPE_CODE_FUNC
:
1448 printf_filtered ("(TYPE_CODE_FUNC)");
1451 printf_filtered ("(TYPE_CODE_INT)");
1454 printf_filtered ("(TYPE_CODE_FLT)");
1456 case TYPE_CODE_VOID
:
1457 printf_filtered ("(TYPE_CODE_VOID)");
1460 printf_filtered ("(TYPE_CODE_SET)");
1462 case TYPE_CODE_RANGE
:
1463 printf_filtered ("(TYPE_CODE_RANGE)");
1465 case TYPE_CODE_STRING
:
1466 printf_filtered ("(TYPE_CODE_STRING)");
1468 case TYPE_CODE_ERROR
:
1469 printf_filtered ("(TYPE_CODE_ERROR)");
1471 case TYPE_CODE_MEMBER
:
1472 printf_filtered ("(TYPE_CODE_MEMBER)");
1474 case TYPE_CODE_METHOD
:
1475 printf_filtered ("(TYPE_CODE_METHOD)");
1478 printf_filtered ("(TYPE_CODE_REF)");
1480 case TYPE_CODE_CHAR
:
1481 printf_filtered ("(TYPE_CODE_CHAR)");
1483 case TYPE_CODE_BOOL
:
1484 printf_filtered ("(TYPE_CODE_BOOL)");
1486 case TYPE_CODE_TYPEDEF
:
1487 printf_filtered ("(TYPE_CODE_TYPEDEF)");
1490 printf_filtered ("(UNKNOWN TYPE CODE)");
1493 puts_filtered ("\n");
1494 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
1495 printfi_filtered (spaces
, "objfile ");
1496 gdb_print_address (TYPE_OBJFILE (type
), gdb_stdout
);
1497 printf_filtered ("\n");
1498 printfi_filtered (spaces
, "target_type ");
1499 gdb_print_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
1500 printf_filtered ("\n");
1501 if (TYPE_TARGET_TYPE (type
) != NULL
)
1503 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
1505 printfi_filtered (spaces
, "pointer_type ");
1506 gdb_print_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
1507 printf_filtered ("\n");
1508 printfi_filtered (spaces
, "reference_type ");
1509 gdb_print_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
1510 printf_filtered ("\n");
1511 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
1512 if (TYPE_FLAGS (type
) & TYPE_FLAG_UNSIGNED
)
1514 puts_filtered (" TYPE_FLAG_UNSIGNED");
1516 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
1518 puts_filtered (" TYPE_FLAG_STUB");
1520 puts_filtered ("\n");
1521 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
1522 gdb_print_address (TYPE_FIELDS (type
), gdb_stdout
);
1523 puts_filtered ("\n");
1524 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
1526 printfi_filtered (spaces
+ 2,
1527 "[%d] bitpos %d bitsize %d type ",
1528 idx
, TYPE_FIELD_BITPOS (type
, idx
),
1529 TYPE_FIELD_BITSIZE (type
, idx
));
1530 gdb_print_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
1531 printf_filtered (" name '%s' (",
1532 TYPE_FIELD_NAME (type
, idx
) != NULL
1533 ? TYPE_FIELD_NAME (type
, idx
)
1535 gdb_print_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
1536 printf_filtered (")\n");
1537 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
1539 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
1542 printfi_filtered (spaces
, "vptr_basetype ");
1543 gdb_print_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
1544 puts_filtered ("\n");
1545 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
1547 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
1549 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
1550 switch (TYPE_CODE (type
))
1552 case TYPE_CODE_METHOD
:
1553 case TYPE_CODE_FUNC
:
1554 printfi_filtered (spaces
, "arg_types ");
1555 gdb_print_address (TYPE_ARG_TYPES (type
), gdb_stdout
);
1556 puts_filtered ("\n");
1557 print_arg_types (TYPE_ARG_TYPES (type
), spaces
);
1560 case TYPE_CODE_STRUCT
:
1561 printfi_filtered (spaces
, "cplus_stuff ");
1562 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1563 puts_filtered ("\n");
1564 print_cplus_stuff (type
, spaces
);
1568 /* We have to pick one of the union types to be able print and test
1569 the value. Pick cplus_struct_type, even though we know it isn't
1570 any particular one. */
1571 printfi_filtered (spaces
, "type_specific ");
1572 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1573 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
1575 printf_filtered (" (unknown data form)");
1577 printf_filtered ("\n");
1582 obstack_free (&dont_print_type_obstack
, NULL
);
1585 #endif /* MAINTENANCE_CMDS */
1588 _initialize_gdbtypes ()
1591 init_type (TYPE_CODE_VOID
, 1,
1593 "void", (struct objfile
*) NULL
);
1595 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1597 "char", (struct objfile
*) NULL
);
1598 builtin_type_signed_char
=
1599 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1601 "signed char", (struct objfile
*) NULL
);
1602 builtin_type_unsigned_char
=
1603 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1605 "unsigned char", (struct objfile
*) NULL
);
1606 builtin_type_short
=
1607 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1609 "short", (struct objfile
*) NULL
);
1610 builtin_type_unsigned_short
=
1611 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1613 "unsigned short", (struct objfile
*) NULL
);
1615 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1617 "int", (struct objfile
*) NULL
);
1618 builtin_type_unsigned_int
=
1619 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1621 "unsigned int", (struct objfile
*) NULL
);
1623 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1625 "long", (struct objfile
*) NULL
);
1626 builtin_type_unsigned_long
=
1627 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1629 "unsigned long", (struct objfile
*) NULL
);
1630 builtin_type_long_long
=
1631 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1633 "long long", (struct objfile
*) NULL
);
1634 builtin_type_unsigned_long_long
=
1635 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1637 "unsigned long long", (struct objfile
*) NULL
);
1638 builtin_type_float
=
1639 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1641 "float", (struct objfile
*) NULL
);
1642 builtin_type_double
=
1643 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1645 "double", (struct objfile
*) NULL
);
1646 builtin_type_long_double
=
1647 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1649 "long double", (struct objfile
*) NULL
);
1650 builtin_type_complex
=
1651 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1653 "complex", (struct objfile
*) NULL
);
1654 TYPE_TARGET_TYPE (builtin_type_complex
) = builtin_type_float
;
1655 builtin_type_double_complex
=
1656 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1658 "double complex", (struct objfile
*) NULL
);
1659 TYPE_TARGET_TYPE (builtin_type_double_complex
) = builtin_type_double
;
1660 builtin_type_string
=
1661 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1663 "string", (struct objfile
*) NULL
);