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 *highp
= (1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
)) - 1;
390 /* Create an array type using either a blank type supplied in RESULT_TYPE,
391 or creating a new type, inheriting the objfile from RANGE_TYPE.
393 Elements will be of type ELEMENT_TYPE, the indices will be of type
396 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
397 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
400 create_array_type (result_type
, element_type
, range_type
)
401 struct type
*result_type
;
402 struct type
*element_type
;
403 struct type
*range_type
;
405 LONGEST low_bound
, high_bound
;
407 if (result_type
== NULL
)
409 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
411 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
412 TYPE_TARGET_TYPE (result_type
) = element_type
;
413 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
414 low_bound
= high_bound
= 0;
415 CHECK_TYPEDEF (element_type
);
416 TYPE_LENGTH (result_type
) =
417 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
418 TYPE_NFIELDS (result_type
) = 1;
419 TYPE_FIELDS (result_type
) =
420 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
421 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
422 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
423 TYPE_VPTR_FIELDNO (result_type
) = -1;
425 return (result_type
);
428 /* Create a string type using either a blank type supplied in RESULT_TYPE,
429 or creating a new type. String types are similar enough to array of
430 char types that we can use create_array_type to build the basic type
431 and then bash it into a string type.
433 For fixed length strings, the range type contains 0 as the lower
434 bound and the length of the string minus one as the upper bound.
436 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
437 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
440 create_string_type (result_type
, range_type
)
441 struct type
*result_type
;
442 struct type
*range_type
;
444 result_type
= create_array_type (result_type
,
445 *current_language
->string_char_type
,
447 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
448 return (result_type
);
452 create_set_type (result_type
, domain_type
)
453 struct type
*result_type
;
454 struct type
*domain_type
;
456 LONGEST low_bound
, high_bound
, bit_length
;
457 if (result_type
== NULL
)
459 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
461 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
462 TYPE_NFIELDS (result_type
) = 1;
463 TYPE_FIELDS (result_type
) = (struct field
*)
464 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
465 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
467 if (! (TYPE_FLAGS (domain_type
) & TYPE_FLAG_STUB
))
469 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
470 low_bound
= high_bound
= 0;
471 bit_length
= high_bound
- low_bound
+ 1;
472 TYPE_LENGTH (result_type
)
473 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
475 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
476 return (result_type
);
479 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
480 A MEMBER is a wierd thing -- it amounts to a typed offset into
481 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
482 include the offset (that's the value of the MEMBER itself), but does
483 include the structure type into which it points (for some reason).
485 When "smashing" the type, we preserve the objfile that the
486 old type pointed to, since we aren't changing where the type is actually
490 smash_to_member_type (type
, domain
, to_type
)
493 struct type
*to_type
;
495 struct objfile
*objfile
;
497 objfile
= TYPE_OBJFILE (type
);
499 memset ((char *) type
, 0, sizeof (struct type
));
500 TYPE_OBJFILE (type
) = objfile
;
501 TYPE_TARGET_TYPE (type
) = to_type
;
502 TYPE_DOMAIN_TYPE (type
) = domain
;
503 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
504 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
507 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
508 METHOD just means `function that gets an extra "this" argument'.
510 When "smashing" the type, we preserve the objfile that the
511 old type pointed to, since we aren't changing where the type is actually
515 smash_to_method_type (type
, domain
, to_type
, args
)
518 struct type
*to_type
;
521 struct objfile
*objfile
;
523 objfile
= TYPE_OBJFILE (type
);
525 memset ((char *) type
, 0, sizeof (struct type
));
526 TYPE_OBJFILE (type
) = objfile
;
527 TYPE_TARGET_TYPE (type
) = to_type
;
528 TYPE_DOMAIN_TYPE (type
) = domain
;
529 TYPE_ARG_TYPES (type
) = args
;
530 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
531 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
534 /* Return a typename for a struct/union/enum type without "struct ",
535 "union ", or "enum ". If the type has a NULL name, return NULL. */
538 type_name_no_tag (type
)
539 register const struct type
*type
;
541 if (TYPE_TAG_NAME (type
) != NULL
)
542 return TYPE_TAG_NAME (type
);
544 /* Is there code which expects this to return the name if there is no
545 tag name? My guess is that this is mainly used for C++ in cases where
546 the two will always be the same. */
547 return TYPE_NAME (type
);
550 /* Lookup a primitive type named NAME.
551 Return zero if NAME is not a primitive type.*/
554 lookup_primitive_typename (name
)
557 struct type
** const *p
;
559 for (p
= current_language
-> la_builtin_type_vector
; *p
!= NULL
; p
++)
561 if (STREQ ((**p
) -> name
, name
))
569 /* Lookup a typedef or primitive type named NAME,
570 visible in lexical block BLOCK.
571 If NOERR is nonzero, return zero if NAME is not suitably defined. */
574 lookup_typename (name
, block
, noerr
)
579 register struct symbol
*sym
;
580 register struct type
*tmp
;
582 sym
= lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
583 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
585 tmp
= lookup_primitive_typename (name
);
590 else if (!tmp
&& noerr
)
596 error ("No type named %s.", name
);
599 return (SYMBOL_TYPE (sym
));
603 lookup_unsigned_typename (name
)
606 char *uns
= alloca (strlen (name
) + 10);
608 strcpy (uns
, "unsigned ");
609 strcpy (uns
+ 9, name
);
610 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
614 lookup_signed_typename (name
)
618 char *uns
= alloca (strlen (name
) + 8);
620 strcpy (uns
, "signed ");
621 strcpy (uns
+ 7, name
);
622 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
623 /* If we don't find "signed FOO" just try again with plain "FOO". */
626 return lookup_typename (name
, (struct block
*) NULL
, 0);
629 /* Lookup a structure type named "struct NAME",
630 visible in lexical block BLOCK. */
633 lookup_struct (name
, block
)
637 register struct symbol
*sym
;
639 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
640 (struct symtab
**) NULL
);
644 error ("No struct type named %s.", name
);
646 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
648 error ("This context has class, union or enum %s, not a struct.", name
);
650 return (SYMBOL_TYPE (sym
));
653 /* Lookup a union type named "union NAME",
654 visible in lexical block BLOCK. */
657 lookup_union (name
, block
)
661 register struct symbol
*sym
;
663 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
664 (struct symtab
**) NULL
);
668 error ("No union type named %s.", name
);
670 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_UNION
)
672 error ("This context has class, struct or enum %s, not a union.", name
);
674 return (SYMBOL_TYPE (sym
));
677 /* Lookup an enum type named "enum NAME",
678 visible in lexical block BLOCK. */
681 lookup_enum (name
, block
)
685 register struct symbol
*sym
;
687 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
688 (struct symtab
**) NULL
);
691 error ("No enum type named %s.", name
);
693 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
695 error ("This context has class, struct or union %s, not an enum.", name
);
697 return (SYMBOL_TYPE (sym
));
700 /* Lookup a template type named "template NAME<TYPE>",
701 visible in lexical block BLOCK. */
704 lookup_template_type (name
, type
, block
)
710 char *nam
= (char*) alloca(strlen(name
) + strlen(type
->name
) + 4);
713 strcat (nam
, type
->name
);
714 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
716 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
720 error ("No template type named %s.", name
);
722 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
724 error ("This context has class, union or enum %s, not a struct.", name
);
726 return (SYMBOL_TYPE (sym
));
729 /* Given a type TYPE, lookup the type of the component of type named NAME.
731 TYPE can be either a struct or union, or a pointer or reference to a struct or
732 union. If it is a pointer or reference, its target type is automatically used.
733 Thus '.' and '->' are interchangable, as specified for the definitions of the
734 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
736 If NOERR is nonzero, return zero if NAME is not suitably defined.
737 If NAME is the name of a baseclass type, return that type. */
740 lookup_struct_elt_type (type
, name
, noerr
)
749 CHECK_TYPEDEF (type
);
750 if (TYPE_CODE (type
) != TYPE_CODE_PTR
751 && TYPE_CODE (type
) != TYPE_CODE_REF
)
753 type
= TYPE_TARGET_TYPE (type
);
756 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
757 TYPE_CODE (type
) != TYPE_CODE_UNION
)
759 target_terminal_ours ();
760 gdb_flush (gdb_stdout
);
761 fprintf_unfiltered (gdb_stderr
, "Type ");
762 type_print (type
, "", gdb_stderr
, -1);
763 error (" is not a structure or union type.");
767 /* FIXME: This change put in by Michael seems incorrect for the case where
768 the structure tag name is the same as the member name. I.E. when doing
769 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
774 typename
= type_name_no_tag (type
);
775 if (typename
!= NULL
&& STREQ (typename
, name
))
780 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
782 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
784 if (t_field_name
&& STREQ (t_field_name
, name
))
786 return TYPE_FIELD_TYPE (type
, i
);
790 /* OK, it's not in this class. Recursively check the baseclasses. */
791 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
795 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, noerr
);
807 target_terminal_ours ();
808 gdb_flush (gdb_stdout
);
809 fprintf_unfiltered (gdb_stderr
, "Type ");
810 type_print (type
, "", gdb_stderr
, -1);
811 fprintf_unfiltered (gdb_stderr
, " has no component named ");
812 fputs_filtered (name
, gdb_stderr
);
814 return (struct type
*)-1; /* For lint */
817 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
818 valid. Callers should be aware that in some cases (for example,
819 the type or one of its baseclasses is a stub type and we are
820 debugging a .o file), this function will not be able to find the virtual
821 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
825 fill_in_vptr_fieldno (type
)
828 CHECK_TYPEDEF (type
);
830 if (TYPE_VPTR_FIELDNO (type
) < 0)
834 /* We must start at zero in case the first (and only) baseclass is
835 virtual (and hence we cannot share the table pointer). */
836 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
838 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, i
));
839 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
)) >= 0)
841 TYPE_VPTR_FIELDNO (type
)
842 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
));
843 TYPE_VPTR_BASETYPE (type
)
844 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type
, i
));
851 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
853 If this is a stubbed struct (i.e. declared as struct foo *), see if
854 we can find a full definition in some other file. If so, copy this
855 definition, so we can use it in future. There used to be a comment (but
856 not any code) that if we don't find a full definition, we'd set a flag
857 so we don't spend time in the future checking the same type. That would
858 be a mistake, though--we might load in more symbols which contain a
859 full definition for the type.
861 This used to be coded as a macro, but I don't think it is called
862 often enough to merit such treatment. */
864 struct complaint stub_noname_complaint
=
865 {"stub type has NULL name", 0, 0};
869 register struct type
*type
;
871 struct type
*orig_type
= type
;
872 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
874 if (!TYPE_TARGET_TYPE (type
))
876 char* name
= type_name_no_tag (type
);
877 /* FIXME: shouldn't we separately check the TYPE_NAME and the
878 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
879 as appropriate? (this code was written before TYPE_NAME and
880 TYPE_TAG_NAME were separate). */
884 complain (&stub_noname_complaint
);
887 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
888 (struct symtab
**) NULL
);
890 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
892 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
); /* TYPE_CODE_UNDEF */
894 type
= TYPE_TARGET_TYPE (type
);
897 if (TYPE_FLAGS(type
) & TYPE_FLAG_STUB
)
899 char* name
= type_name_no_tag (type
);
900 /* FIXME: shouldn't we separately check the TYPE_NAME and the
901 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
902 as appropriate? (this code was written before TYPE_NAME and
903 TYPE_TAG_NAME were separate). */
907 complain (&stub_noname_complaint
);
910 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
911 (struct symtab
**) NULL
);
914 memcpy ((char *)type
,
915 (char *)SYMBOL_TYPE(sym
),
916 sizeof (struct type
));
920 if (TYPE_FLAGS (type
) & TYPE_FLAG_TARGET_STUB
)
922 struct type
*range_type
;
923 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
925 if (TYPE_FLAGS (target_type
) & TYPE_FLAG_STUB
)
927 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
928 && TYPE_NFIELDS (type
) == 1
929 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
932 /* Now recompute the length of the array type, based on its
933 number of elements and the target type's length. */
935 ((TYPE_FIELD_BITPOS (range_type
, 1)
936 - TYPE_FIELD_BITPOS (range_type
, 0)
938 * TYPE_LENGTH (target_type
));
939 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
941 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
943 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
944 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
947 /* Cache TYPE_LENGTH for future use. */
948 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
952 /* Ugly hack to convert method stubs into method types.
954 He ain't kiddin'. This demangles the name of the method into a string
955 including argument types, parses out each argument type, generates
956 a string casting a zero to that type, evaluates the string, and stuffs
957 the resulting type into an argtype vector!!! Then it knows the type
958 of the whole function (including argument types for overloading),
959 which info used to be in the stab's but was removed to hack back
960 the space required for them. */
963 check_stub_method (type
, i
, j
)
969 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
970 char *demangled_name
= cplus_demangle (mangled_name
,
971 DMGL_PARAMS
| DMGL_ANSI
);
972 char *argtypetext
, *p
;
973 int depth
= 0, argcount
= 1;
974 struct type
**argtypes
;
977 if (demangled_name
== NULL
)
979 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
982 /* Now, read in the parameters that define this type. */
983 argtypetext
= strchr (demangled_name
, '(') + 1;
995 else if (*p
== ',' && depth
== 0)
1003 /* We need two more slots: one for the THIS pointer, and one for the
1004 NULL [...] or void [end of arglist]. */
1006 argtypes
= (struct type
**)
1007 TYPE_ALLOC (type
, (argcount
+ 2) * sizeof (struct type
*));
1009 /* FIXME: This is wrong for static member functions. */
1010 argtypes
[0] = lookup_pointer_type (type
);
1013 if (*p
!= ')') /* () means no args, skip while */
1018 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1020 /* Avoid parsing of ellipsis, they will be handled below. */
1021 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0)
1023 argtypes
[argcount
] =
1024 parse_and_eval_type (argtypetext
, p
- argtypetext
);
1027 argtypetext
= p
+ 1;
1043 if (p
[-2] != '.') /* Not '...' */
1045 argtypes
[argcount
] = builtin_type_void
; /* List terminator */
1049 argtypes
[argcount
] = NULL
; /* Ellist terminator */
1052 free (demangled_name
);
1054 f
= TYPE_FN_FIELDLIST1 (type
, i
);
1055 TYPE_FN_FIELD_PHYSNAME (f
, j
) = mangled_name
;
1057 /* Now update the old "stub" type into a real type. */
1058 mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1059 TYPE_DOMAIN_TYPE (mtype
) = type
;
1060 TYPE_ARG_TYPES (mtype
) = argtypes
;
1061 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1062 TYPE_FN_FIELD_STUB (f
, j
) = 0;
1065 const struct cplus_struct_type cplus_struct_default
;
1068 allocate_cplus_struct_type (type
)
1071 if (!HAVE_CPLUS_STRUCT (type
))
1073 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1074 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1075 *(TYPE_CPLUS_SPECIFIC(type
)) = cplus_struct_default
;
1079 /* Helper function to initialize the standard scalar types.
1081 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1082 of the string pointed to by name in the type_obstack for that objfile,
1083 and initialize the type name to that copy. There are places (mipsread.c
1084 in particular, where init_type is called with a NULL value for NAME). */
1087 init_type (code
, length
, flags
, name
, objfile
)
1088 enum type_code code
;
1092 struct objfile
*objfile
;
1094 register struct type
*type
;
1096 type
= alloc_type (objfile
);
1097 TYPE_CODE (type
) = code
;
1098 TYPE_LENGTH (type
) = length
;
1099 TYPE_FLAGS (type
) |= flags
;
1100 if ((name
!= NULL
) && (objfile
!= NULL
))
1103 obsavestring (name
, strlen (name
), &objfile
-> type_obstack
);
1107 TYPE_NAME (type
) = name
;
1112 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
1114 INIT_CPLUS_SPECIFIC (type
);
1119 /* Look up a fundamental type for the specified objfile.
1120 May need to construct such a type if this is the first use.
1122 Some object file formats (ELF, COFF, etc) do not define fundamental
1123 types such as "int" or "double". Others (stabs for example), do
1124 define fundamental types.
1126 For the formats which don't provide fundamental types, gdb can create
1127 such types, using defaults reasonable for the current language and
1128 the current target machine.
1130 NOTE: This routine is obsolescent. Each debugging format reader
1131 should manage it's own fundamental types, either creating them from
1132 suitable defaults or reading them from the debugging information,
1133 whichever is appropriate. The DWARF reader has already been
1134 fixed to do this. Once the other readers are fixed, this routine
1135 will go away. Also note that fundamental types should be managed
1136 on a compilation unit basis in a multi-language environment, not
1137 on a linkage unit basis as is done here. */
1141 lookup_fundamental_type (objfile
, typeid)
1142 struct objfile
*objfile
;
1145 register struct type
**typep
;
1146 register int nbytes
;
1148 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1150 error ("internal error - invalid fundamental type id %d", typeid);
1153 /* If this is the first time we need a fundamental type for this objfile
1154 then we need to initialize the vector of type pointers. */
1156 if (objfile
-> fundamental_types
== NULL
)
1158 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1159 objfile
-> fundamental_types
= (struct type
**)
1160 obstack_alloc (&objfile
-> type_obstack
, nbytes
);
1161 memset ((char *) objfile
-> fundamental_types
, 0, nbytes
);
1164 /* Look for this particular type in the fundamental type vector. If one is
1165 not found, create and install one appropriate for the current language. */
1167 typep
= objfile
-> fundamental_types
+ typeid;
1170 *typep
= create_fundamental_type (objfile
, typeid);
1180 /* FIXME: Should we return true for references as well as pointers? */
1184 && TYPE_CODE (t
) == TYPE_CODE_PTR
1185 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1188 /* Chill varying string and arrays are represented as follows:
1190 struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
1192 Return true if TYPE is such a Chill varying type. */
1195 chill_varying_type (type
)
1198 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1199 || TYPE_NFIELDS (type
) != 2
1200 || strcmp (TYPE_FIELD_NAME (type
, 0), "__var_length") != 0)
1205 #if MAINTENANCE_CMDS
1208 print_bit_vector (bits
, nbits
)
1214 for (bitno
= 0; bitno
< nbits
; bitno
++)
1216 if ((bitno
% 8) == 0)
1218 puts_filtered (" ");
1220 if (B_TST (bits
, bitno
))
1222 printf_filtered ("1");
1226 printf_filtered ("0");
1231 /* The args list is a strange beast. It is either terminated by a NULL
1232 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
1233 type for normal fixed argcount functions. (FIXME someday)
1234 Also note the first arg should be the "this" pointer, we may not want to
1235 include it since we may get into a infinitely recursive situation. */
1238 print_arg_types (args
, spaces
)
1244 while (*args
!= NULL
)
1246 recursive_dump_type (*args
, spaces
+ 2);
1247 if ((*args
++) -> code
== TYPE_CODE_VOID
)
1256 dump_fn_fieldlists (type
, spaces
)
1264 printfi_filtered (spaces
, "fn_fieldlists ");
1265 gdb_print_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
1266 printf_filtered ("\n");
1267 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
1269 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
1270 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
1272 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
1273 gdb_print_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
1275 printf_filtered (") length %d\n",
1276 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
1277 for (overload_idx
= 0;
1278 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
1281 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
1283 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
1284 gdb_print_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
1286 printf_filtered (")\n");
1287 printfi_filtered (spaces
+ 8, "type ");
1288 gdb_print_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
1289 printf_filtered ("\n");
1291 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
1294 printfi_filtered (spaces
+ 8, "args ");
1295 gdb_print_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
1296 printf_filtered ("\n");
1298 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
), spaces
);
1299 printfi_filtered (spaces
+ 8, "fcontext ");
1300 gdb_print_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
1302 printf_filtered ("\n");
1304 printfi_filtered (spaces
+ 8, "is_const %d\n",
1305 TYPE_FN_FIELD_CONST (f
, overload_idx
));
1306 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
1307 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
1308 printfi_filtered (spaces
+ 8, "is_private %d\n",
1309 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
1310 printfi_filtered (spaces
+ 8, "is_protected %d\n",
1311 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
1312 printfi_filtered (spaces
+ 8, "is_stub %d\n",
1313 TYPE_FN_FIELD_STUB (f
, overload_idx
));
1314 printfi_filtered (spaces
+ 8, "voffset %u\n",
1315 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
1321 print_cplus_stuff (type
, spaces
)
1325 printfi_filtered (spaces
, "n_baseclasses %d\n",
1326 TYPE_N_BASECLASSES (type
));
1327 printfi_filtered (spaces
, "nfn_fields %d\n",
1328 TYPE_NFN_FIELDS (type
));
1329 printfi_filtered (spaces
, "nfn_fields_total %d\n",
1330 TYPE_NFN_FIELDS_TOTAL (type
));
1331 if (TYPE_N_BASECLASSES (type
) > 0)
1333 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
1334 TYPE_N_BASECLASSES (type
));
1335 gdb_print_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
1336 printf_filtered (")");
1338 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
1339 TYPE_N_BASECLASSES (type
));
1340 puts_filtered ("\n");
1342 if (TYPE_NFIELDS (type
) > 0)
1344 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
1346 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
1347 TYPE_NFIELDS (type
));
1348 gdb_print_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
1349 printf_filtered (")");
1350 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
1351 TYPE_NFIELDS (type
));
1352 puts_filtered ("\n");
1354 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
1356 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
1357 TYPE_NFIELDS (type
));
1358 gdb_print_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
1359 printf_filtered (")");
1360 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
1361 TYPE_NFIELDS (type
));
1362 puts_filtered ("\n");
1365 if (TYPE_NFN_FIELDS (type
) > 0)
1367 dump_fn_fieldlists (type
, spaces
);
1371 static struct obstack dont_print_type_obstack
;
1374 recursive_dump_type (type
, spaces
)
1381 obstack_begin (&dont_print_type_obstack
, 0);
1383 if (TYPE_NFIELDS (type
) > 0
1384 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
1386 struct type
**first_dont_print
1387 = (struct type
**)obstack_base (&dont_print_type_obstack
);
1389 int i
= (struct type
**)obstack_next_free (&dont_print_type_obstack
)
1394 if (type
== first_dont_print
[i
])
1396 printfi_filtered (spaces
, "type node ");
1397 gdb_print_address (type
, gdb_stdout
);
1398 printf_filtered (" <same as already seen type>\n");
1403 obstack_ptr_grow (&dont_print_type_obstack
, type
);
1406 printfi_filtered (spaces
, "type node ");
1407 gdb_print_address (type
, gdb_stdout
);
1408 printf_filtered ("\n");
1409 printfi_filtered (spaces
, "name '%s' (",
1410 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
1411 gdb_print_address (TYPE_NAME (type
), gdb_stdout
);
1412 printf_filtered (")\n");
1413 if (TYPE_TAG_NAME (type
) != NULL
)
1415 printfi_filtered (spaces
, "tagname '%s' (",
1416 TYPE_TAG_NAME (type
));
1417 gdb_print_address (TYPE_TAG_NAME (type
), gdb_stdout
);
1418 printf_filtered (")\n");
1420 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
1421 switch (TYPE_CODE (type
))
1423 case TYPE_CODE_UNDEF
:
1424 printf_filtered ("(TYPE_CODE_UNDEF)");
1427 printf_filtered ("(TYPE_CODE_PTR)");
1429 case TYPE_CODE_ARRAY
:
1430 printf_filtered ("(TYPE_CODE_ARRAY)");
1432 case TYPE_CODE_STRUCT
:
1433 printf_filtered ("(TYPE_CODE_STRUCT)");
1435 case TYPE_CODE_UNION
:
1436 printf_filtered ("(TYPE_CODE_UNION)");
1438 case TYPE_CODE_ENUM
:
1439 printf_filtered ("(TYPE_CODE_ENUM)");
1441 case TYPE_CODE_FUNC
:
1442 printf_filtered ("(TYPE_CODE_FUNC)");
1445 printf_filtered ("(TYPE_CODE_INT)");
1448 printf_filtered ("(TYPE_CODE_FLT)");
1450 case TYPE_CODE_VOID
:
1451 printf_filtered ("(TYPE_CODE_VOID)");
1454 printf_filtered ("(TYPE_CODE_SET)");
1456 case TYPE_CODE_RANGE
:
1457 printf_filtered ("(TYPE_CODE_RANGE)");
1459 case TYPE_CODE_STRING
:
1460 printf_filtered ("(TYPE_CODE_STRING)");
1462 case TYPE_CODE_ERROR
:
1463 printf_filtered ("(TYPE_CODE_ERROR)");
1465 case TYPE_CODE_MEMBER
:
1466 printf_filtered ("(TYPE_CODE_MEMBER)");
1468 case TYPE_CODE_METHOD
:
1469 printf_filtered ("(TYPE_CODE_METHOD)");
1472 printf_filtered ("(TYPE_CODE_REF)");
1474 case TYPE_CODE_CHAR
:
1475 printf_filtered ("(TYPE_CODE_CHAR)");
1477 case TYPE_CODE_BOOL
:
1478 printf_filtered ("(TYPE_CODE_BOOL)");
1480 case TYPE_CODE_TYPEDEF
:
1481 printf_filtered ("(TYPE_CODE_TYPEDEF)");
1484 printf_filtered ("(UNKNOWN TYPE CODE)");
1487 puts_filtered ("\n");
1488 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
1489 printfi_filtered (spaces
, "objfile ");
1490 gdb_print_address (TYPE_OBJFILE (type
), gdb_stdout
);
1491 printf_filtered ("\n");
1492 printfi_filtered (spaces
, "target_type ");
1493 gdb_print_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
1494 printf_filtered ("\n");
1495 if (TYPE_TARGET_TYPE (type
) != NULL
)
1497 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
1499 printfi_filtered (spaces
, "pointer_type ");
1500 gdb_print_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
1501 printf_filtered ("\n");
1502 printfi_filtered (spaces
, "reference_type ");
1503 gdb_print_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
1504 printf_filtered ("\n");
1505 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
1506 if (TYPE_FLAGS (type
) & TYPE_FLAG_UNSIGNED
)
1508 puts_filtered (" TYPE_FLAG_UNSIGNED");
1510 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
1512 puts_filtered (" TYPE_FLAG_STUB");
1514 puts_filtered ("\n");
1515 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
1516 gdb_print_address (TYPE_FIELDS (type
), gdb_stdout
);
1517 puts_filtered ("\n");
1518 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
1520 printfi_filtered (spaces
+ 2,
1521 "[%d] bitpos %d bitsize %d type ",
1522 idx
, TYPE_FIELD_BITPOS (type
, idx
),
1523 TYPE_FIELD_BITSIZE (type
, idx
));
1524 gdb_print_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
1525 printf_filtered (" name '%s' (",
1526 TYPE_FIELD_NAME (type
, idx
) != NULL
1527 ? TYPE_FIELD_NAME (type
, idx
)
1529 gdb_print_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
1530 printf_filtered (")\n");
1531 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
1533 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
1536 printfi_filtered (spaces
, "vptr_basetype ");
1537 gdb_print_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
1538 puts_filtered ("\n");
1539 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
1541 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
1543 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
1544 switch (TYPE_CODE (type
))
1546 case TYPE_CODE_METHOD
:
1547 case TYPE_CODE_FUNC
:
1548 printfi_filtered (spaces
, "arg_types ");
1549 gdb_print_address (TYPE_ARG_TYPES (type
), gdb_stdout
);
1550 puts_filtered ("\n");
1551 print_arg_types (TYPE_ARG_TYPES (type
), spaces
);
1554 case TYPE_CODE_STRUCT
:
1555 printfi_filtered (spaces
, "cplus_stuff ");
1556 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1557 puts_filtered ("\n");
1558 print_cplus_stuff (type
, spaces
);
1562 /* We have to pick one of the union types to be able print and test
1563 the value. Pick cplus_struct_type, even though we know it isn't
1564 any particular one. */
1565 printfi_filtered (spaces
, "type_specific ");
1566 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1567 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
1569 printf_filtered (" (unknown data form)");
1571 printf_filtered ("\n");
1576 obstack_free (&dont_print_type_obstack
, NULL
);
1579 #endif /* MAINTENANCE_CMDS */
1582 _initialize_gdbtypes ()
1585 init_type (TYPE_CODE_VOID
, 1,
1587 "void", (struct objfile
*) NULL
);
1589 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1591 "char", (struct objfile
*) NULL
);
1592 builtin_type_signed_char
=
1593 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1595 "signed char", (struct objfile
*) NULL
);
1596 builtin_type_unsigned_char
=
1597 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1599 "unsigned char", (struct objfile
*) NULL
);
1600 builtin_type_short
=
1601 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1603 "short", (struct objfile
*) NULL
);
1604 builtin_type_unsigned_short
=
1605 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1607 "unsigned short", (struct objfile
*) NULL
);
1609 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1611 "int", (struct objfile
*) NULL
);
1612 builtin_type_unsigned_int
=
1613 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1615 "unsigned int", (struct objfile
*) NULL
);
1617 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1619 "long", (struct objfile
*) NULL
);
1620 builtin_type_unsigned_long
=
1621 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1623 "unsigned long", (struct objfile
*) NULL
);
1624 builtin_type_long_long
=
1625 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1627 "long long", (struct objfile
*) NULL
);
1628 builtin_type_unsigned_long_long
=
1629 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1631 "unsigned long long", (struct objfile
*) NULL
);
1632 builtin_type_float
=
1633 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1635 "float", (struct objfile
*) NULL
);
1636 builtin_type_double
=
1637 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1639 "double", (struct objfile
*) NULL
);
1640 builtin_type_long_double
=
1641 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1643 "long double", (struct objfile
*) NULL
);
1644 builtin_type_complex
=
1645 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1647 "complex", (struct objfile
*) NULL
);
1648 TYPE_TARGET_TYPE (builtin_type_complex
) = builtin_type_float
;
1649 builtin_type_double_complex
=
1650 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1652 "double complex", (struct objfile
*) NULL
);
1653 TYPE_TARGET_TYPE (builtin_type_double_complex
) = builtin_type_double
;
1654 builtin_type_string
=
1655 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1657 "string", (struct objfile
*) NULL
);