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 /* The enums may not be sorted by value, so search all
363 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
364 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
366 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
367 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
368 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
369 *highp
= TYPE_FIELD_BITPOS (type
, i
);
383 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
385 if (!TYPE_UNSIGNED (type
))
387 *lowp
= - (1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
391 /* ... fall through for unsigned ints ... */
394 /* This round-about calculation is to avoid shifting by
395 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
396 if TYPE_LENGTH (type) == sizeof (LONGEST). */
397 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
398 *highp
= (*highp
- 1) | *highp
;
405 /* Create an array type using either a blank type supplied in RESULT_TYPE,
406 or creating a new type, inheriting the objfile from RANGE_TYPE.
408 Elements will be of type ELEMENT_TYPE, the indices will be of type
411 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
412 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
415 create_array_type (result_type
, element_type
, range_type
)
416 struct type
*result_type
;
417 struct type
*element_type
;
418 struct type
*range_type
;
420 LONGEST low_bound
, high_bound
;
422 if (result_type
== NULL
)
424 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
426 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
427 TYPE_TARGET_TYPE (result_type
) = element_type
;
428 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
429 low_bound
= high_bound
= 0;
430 CHECK_TYPEDEF (element_type
);
431 TYPE_LENGTH (result_type
) =
432 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
433 TYPE_NFIELDS (result_type
) = 1;
434 TYPE_FIELDS (result_type
) =
435 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
436 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
437 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
438 TYPE_VPTR_FIELDNO (result_type
) = -1;
440 return (result_type
);
443 /* Create a string type using either a blank type supplied in RESULT_TYPE,
444 or creating a new type. String types are similar enough to array of
445 char types that we can use create_array_type to build the basic type
446 and then bash it into a string type.
448 For fixed length strings, the range type contains 0 as the lower
449 bound and the length of the string minus one as the upper bound.
451 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
452 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
455 create_string_type (result_type
, range_type
)
456 struct type
*result_type
;
457 struct type
*range_type
;
459 result_type
= create_array_type (result_type
,
460 *current_language
->string_char_type
,
462 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
463 return (result_type
);
467 create_set_type (result_type
, domain_type
)
468 struct type
*result_type
;
469 struct type
*domain_type
;
471 LONGEST low_bound
, high_bound
, bit_length
;
472 if (result_type
== NULL
)
474 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
476 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
477 TYPE_NFIELDS (result_type
) = 1;
478 TYPE_FIELDS (result_type
) = (struct field
*)
479 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
480 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
482 if (! (TYPE_FLAGS (domain_type
) & TYPE_FLAG_STUB
))
484 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
485 low_bound
= high_bound
= 0;
486 bit_length
= high_bound
- low_bound
+ 1;
487 TYPE_LENGTH (result_type
)
488 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
490 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
491 return (result_type
);
494 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
495 A MEMBER is a wierd thing -- it amounts to a typed offset into
496 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
497 include the offset (that's the value of the MEMBER itself), but does
498 include the structure type into which it points (for some reason).
500 When "smashing" the type, we preserve the objfile that the
501 old type pointed to, since we aren't changing where the type is actually
505 smash_to_member_type (type
, domain
, to_type
)
508 struct type
*to_type
;
510 struct objfile
*objfile
;
512 objfile
= TYPE_OBJFILE (type
);
514 memset ((char *) type
, 0, sizeof (struct type
));
515 TYPE_OBJFILE (type
) = objfile
;
516 TYPE_TARGET_TYPE (type
) = to_type
;
517 TYPE_DOMAIN_TYPE (type
) = domain
;
518 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
519 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
522 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
523 METHOD just means `function that gets an extra "this" argument'.
525 When "smashing" the type, we preserve the objfile that the
526 old type pointed to, since we aren't changing where the type is actually
530 smash_to_method_type (type
, domain
, to_type
, args
)
533 struct type
*to_type
;
536 struct objfile
*objfile
;
538 objfile
= TYPE_OBJFILE (type
);
540 memset ((char *) type
, 0, sizeof (struct type
));
541 TYPE_OBJFILE (type
) = objfile
;
542 TYPE_TARGET_TYPE (type
) = to_type
;
543 TYPE_DOMAIN_TYPE (type
) = domain
;
544 TYPE_ARG_TYPES (type
) = args
;
545 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
546 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
549 /* Return a typename for a struct/union/enum type without "struct ",
550 "union ", or "enum ". If the type has a NULL name, return NULL. */
553 type_name_no_tag (type
)
554 register const struct type
*type
;
556 if (TYPE_TAG_NAME (type
) != NULL
)
557 return TYPE_TAG_NAME (type
);
559 /* Is there code which expects this to return the name if there is no
560 tag name? My guess is that this is mainly used for C++ in cases where
561 the two will always be the same. */
562 return TYPE_NAME (type
);
565 /* Lookup a primitive type named NAME.
566 Return zero if NAME is not a primitive type.*/
569 lookup_primitive_typename (name
)
572 struct type
** const *p
;
574 for (p
= current_language
-> la_builtin_type_vector
; *p
!= NULL
; p
++)
576 if (STREQ ((**p
) -> name
, name
))
584 /* Lookup a typedef or primitive type named NAME,
585 visible in lexical block BLOCK.
586 If NOERR is nonzero, return zero if NAME is not suitably defined. */
589 lookup_typename (name
, block
, noerr
)
594 register struct symbol
*sym
;
595 register struct type
*tmp
;
597 sym
= lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
598 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
600 tmp
= lookup_primitive_typename (name
);
605 else if (!tmp
&& noerr
)
611 error ("No type named %s.", name
);
614 return (SYMBOL_TYPE (sym
));
618 lookup_unsigned_typename (name
)
621 char *uns
= alloca (strlen (name
) + 10);
623 strcpy (uns
, "unsigned ");
624 strcpy (uns
+ 9, name
);
625 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
629 lookup_signed_typename (name
)
633 char *uns
= alloca (strlen (name
) + 8);
635 strcpy (uns
, "signed ");
636 strcpy (uns
+ 7, name
);
637 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
638 /* If we don't find "signed FOO" just try again with plain "FOO". */
641 return lookup_typename (name
, (struct block
*) NULL
, 0);
644 /* Lookup a structure type named "struct NAME",
645 visible in lexical block BLOCK. */
648 lookup_struct (name
, block
)
652 register struct symbol
*sym
;
654 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
655 (struct symtab
**) NULL
);
659 error ("No struct type named %s.", name
);
661 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
663 error ("This context has class, union or enum %s, not a struct.", name
);
665 return (SYMBOL_TYPE (sym
));
668 /* Lookup a union type named "union NAME",
669 visible in lexical block BLOCK. */
672 lookup_union (name
, block
)
676 register struct symbol
*sym
;
678 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
679 (struct symtab
**) NULL
);
683 error ("No union type named %s.", name
);
685 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_UNION
)
687 error ("This context has class, struct or enum %s, not a union.", name
);
689 return (SYMBOL_TYPE (sym
));
692 /* Lookup an enum type named "enum NAME",
693 visible in lexical block BLOCK. */
696 lookup_enum (name
, block
)
700 register struct symbol
*sym
;
702 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
703 (struct symtab
**) NULL
);
706 error ("No enum type named %s.", name
);
708 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
710 error ("This context has class, struct or union %s, not an enum.", name
);
712 return (SYMBOL_TYPE (sym
));
715 /* Lookup a template type named "template NAME<TYPE>",
716 visible in lexical block BLOCK. */
719 lookup_template_type (name
, type
, block
)
725 char *nam
= (char*) alloca(strlen(name
) + strlen(type
->name
) + 4);
728 strcat (nam
, type
->name
);
729 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
731 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
735 error ("No template type named %s.", name
);
737 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
739 error ("This context has class, union or enum %s, not a struct.", name
);
741 return (SYMBOL_TYPE (sym
));
744 /* Given a type TYPE, lookup the type of the component of type named NAME.
746 TYPE can be either a struct or union, or a pointer or reference to a struct or
747 union. If it is a pointer or reference, its target type is automatically used.
748 Thus '.' and '->' are interchangable, as specified for the definitions of the
749 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
751 If NOERR is nonzero, return zero if NAME is not suitably defined.
752 If NAME is the name of a baseclass type, return that type. */
755 lookup_struct_elt_type (type
, name
, noerr
)
764 CHECK_TYPEDEF (type
);
765 if (TYPE_CODE (type
) != TYPE_CODE_PTR
766 && TYPE_CODE (type
) != TYPE_CODE_REF
)
768 type
= TYPE_TARGET_TYPE (type
);
771 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
772 TYPE_CODE (type
) != TYPE_CODE_UNION
)
774 target_terminal_ours ();
775 gdb_flush (gdb_stdout
);
776 fprintf_unfiltered (gdb_stderr
, "Type ");
777 type_print (type
, "", gdb_stderr
, -1);
778 error (" is not a structure or union type.");
782 /* FIXME: This change put in by Michael seems incorrect for the case where
783 the structure tag name is the same as the member name. I.E. when doing
784 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
789 typename
= type_name_no_tag (type
);
790 if (typename
!= NULL
&& STREQ (typename
, name
))
795 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
797 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
799 if (t_field_name
&& STREQ (t_field_name
, name
))
801 return TYPE_FIELD_TYPE (type
, i
);
805 /* OK, it's not in this class. Recursively check the baseclasses. */
806 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
810 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, noerr
);
822 target_terminal_ours ();
823 gdb_flush (gdb_stdout
);
824 fprintf_unfiltered (gdb_stderr
, "Type ");
825 type_print (type
, "", gdb_stderr
, -1);
826 fprintf_unfiltered (gdb_stderr
, " has no component named ");
827 fputs_filtered (name
, gdb_stderr
);
829 return (struct type
*)-1; /* For lint */
832 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
833 valid. Callers should be aware that in some cases (for example,
834 the type or one of its baseclasses is a stub type and we are
835 debugging a .o file), this function will not be able to find the virtual
836 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
840 fill_in_vptr_fieldno (type
)
843 CHECK_TYPEDEF (type
);
845 if (TYPE_VPTR_FIELDNO (type
) < 0)
849 /* We must start at zero in case the first (and only) baseclass is
850 virtual (and hence we cannot share the table pointer). */
851 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
853 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, i
));
854 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
)) >= 0)
856 TYPE_VPTR_FIELDNO (type
)
857 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
));
858 TYPE_VPTR_BASETYPE (type
)
859 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type
, i
));
866 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
868 If this is a stubbed struct (i.e. declared as struct foo *), see if
869 we can find a full definition in some other file. If so, copy this
870 definition, so we can use it in future. There used to be a comment (but
871 not any code) that if we don't find a full definition, we'd set a flag
872 so we don't spend time in the future checking the same type. That would
873 be a mistake, though--we might load in more symbols which contain a
874 full definition for the type.
876 This used to be coded as a macro, but I don't think it is called
877 often enough to merit such treatment. */
879 struct complaint stub_noname_complaint
=
880 {"stub type has NULL name", 0, 0};
884 register struct type
*type
;
886 struct type
*orig_type
= type
;
887 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
889 if (!TYPE_TARGET_TYPE (type
))
894 /* It is dangerous to call lookup_symbol if we are currently
895 reading a symtab. Infinite recursion is one danger. */
896 if (currently_reading_symtab
)
899 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). */
906 complain (&stub_noname_complaint
);
909 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
910 (struct symtab
**) NULL
);
912 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
914 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
); /* TYPE_CODE_UNDEF */
916 type
= TYPE_TARGET_TYPE (type
);
919 if ((TYPE_FLAGS(type
) & TYPE_FLAG_STUB
) && ! currently_reading_symtab
)
921 char* name
= type_name_no_tag (type
);
922 /* FIXME: shouldn't we separately check the TYPE_NAME and the
923 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
924 as appropriate? (this code was written before TYPE_NAME and
925 TYPE_TAG_NAME were separate). */
929 complain (&stub_noname_complaint
);
932 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
933 (struct symtab
**) NULL
);
936 memcpy ((char *)type
,
937 (char *)SYMBOL_TYPE(sym
),
938 sizeof (struct type
));
942 if (TYPE_FLAGS (type
) & TYPE_FLAG_TARGET_STUB
)
944 struct type
*range_type
;
945 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
947 if (TYPE_FLAGS (target_type
) & TYPE_FLAG_STUB
)
949 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
950 && TYPE_NFIELDS (type
) == 1
951 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
954 /* Now recompute the length of the array type, based on its
955 number of elements and the target type's length. */
957 ((TYPE_FIELD_BITPOS (range_type
, 1)
958 - TYPE_FIELD_BITPOS (range_type
, 0)
960 * TYPE_LENGTH (target_type
));
961 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
963 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
965 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
966 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
969 /* Cache TYPE_LENGTH for future use. */
970 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
974 /* Ugly hack to convert method stubs into method types.
976 He ain't kiddin'. This demangles the name of the method into a string
977 including argument types, parses out each argument type, generates
978 a string casting a zero to that type, evaluates the string, and stuffs
979 the resulting type into an argtype vector!!! Then it knows the type
980 of the whole function (including argument types for overloading),
981 which info used to be in the stab's but was removed to hack back
982 the space required for them. */
985 check_stub_method (type
, i
, j
)
991 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
992 char *demangled_name
= cplus_demangle (mangled_name
,
993 DMGL_PARAMS
| DMGL_ANSI
);
994 char *argtypetext
, *p
;
995 int depth
= 0, argcount
= 1;
996 struct type
**argtypes
;
999 /* Make sure we got back a function string that we can use. */
1001 p
= strchr (demangled_name
, '(');
1003 if (demangled_name
== NULL
|| p
== NULL
)
1004 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
1006 /* Now, read in the parameters that define this type. */
1019 else if (*p
== ',' && depth
== 0)
1027 /* We need two more slots: one for the THIS pointer, and one for the
1028 NULL [...] or void [end of arglist]. */
1030 argtypes
= (struct type
**)
1031 TYPE_ALLOC (type
, (argcount
+ 2) * sizeof (struct type
*));
1033 /* FIXME: This is wrong for static member functions. */
1034 argtypes
[0] = lookup_pointer_type (type
);
1037 if (*p
!= ')') /* () means no args, skip while */
1042 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1044 /* Avoid parsing of ellipsis, they will be handled below. */
1045 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0)
1047 argtypes
[argcount
] =
1048 parse_and_eval_type (argtypetext
, p
- argtypetext
);
1051 argtypetext
= p
+ 1;
1067 if (p
[-2] != '.') /* Not '...' */
1069 argtypes
[argcount
] = builtin_type_void
; /* List terminator */
1073 argtypes
[argcount
] = NULL
; /* Ellist terminator */
1076 free (demangled_name
);
1078 f
= TYPE_FN_FIELDLIST1 (type
, i
);
1079 TYPE_FN_FIELD_PHYSNAME (f
, j
) = mangled_name
;
1081 /* Now update the old "stub" type into a real type. */
1082 mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1083 TYPE_DOMAIN_TYPE (mtype
) = type
;
1084 TYPE_ARG_TYPES (mtype
) = argtypes
;
1085 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1086 TYPE_FN_FIELD_STUB (f
, j
) = 0;
1089 const struct cplus_struct_type cplus_struct_default
;
1092 allocate_cplus_struct_type (type
)
1095 if (!HAVE_CPLUS_STRUCT (type
))
1097 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1098 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1099 *(TYPE_CPLUS_SPECIFIC(type
)) = cplus_struct_default
;
1103 /* Helper function to initialize the standard scalar types.
1105 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1106 of the string pointed to by name in the type_obstack for that objfile,
1107 and initialize the type name to that copy. There are places (mipsread.c
1108 in particular, where init_type is called with a NULL value for NAME). */
1111 init_type (code
, length
, flags
, name
, objfile
)
1112 enum type_code code
;
1116 struct objfile
*objfile
;
1118 register struct type
*type
;
1120 type
= alloc_type (objfile
);
1121 TYPE_CODE (type
) = code
;
1122 TYPE_LENGTH (type
) = length
;
1123 TYPE_FLAGS (type
) |= flags
;
1124 if ((name
!= NULL
) && (objfile
!= NULL
))
1127 obsavestring (name
, strlen (name
), &objfile
-> type_obstack
);
1131 TYPE_NAME (type
) = name
;
1136 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
1138 INIT_CPLUS_SPECIFIC (type
);
1143 /* Look up a fundamental type for the specified objfile.
1144 May need to construct such a type if this is the first use.
1146 Some object file formats (ELF, COFF, etc) do not define fundamental
1147 types such as "int" or "double". Others (stabs for example), do
1148 define fundamental types.
1150 For the formats which don't provide fundamental types, gdb can create
1151 such types, using defaults reasonable for the current language and
1152 the current target machine.
1154 NOTE: This routine is obsolescent. Each debugging format reader
1155 should manage it's own fundamental types, either creating them from
1156 suitable defaults or reading them from the debugging information,
1157 whichever is appropriate. The DWARF reader has already been
1158 fixed to do this. Once the other readers are fixed, this routine
1159 will go away. Also note that fundamental types should be managed
1160 on a compilation unit basis in a multi-language environment, not
1161 on a linkage unit basis as is done here. */
1165 lookup_fundamental_type (objfile
, typeid)
1166 struct objfile
*objfile
;
1169 register struct type
**typep
;
1170 register int nbytes
;
1172 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1174 error ("internal error - invalid fundamental type id %d", typeid);
1177 /* If this is the first time we need a fundamental type for this objfile
1178 then we need to initialize the vector of type pointers. */
1180 if (objfile
-> fundamental_types
== NULL
)
1182 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1183 objfile
-> fundamental_types
= (struct type
**)
1184 obstack_alloc (&objfile
-> type_obstack
, nbytes
);
1185 memset ((char *) objfile
-> fundamental_types
, 0, nbytes
);
1186 OBJSTAT (objfile
, n_types
+= FT_NUM_MEMBERS
);
1189 /* Look for this particular type in the fundamental type vector. If one is
1190 not found, create and install one appropriate for the current language. */
1192 typep
= objfile
-> fundamental_types
+ typeid;
1195 *typep
= create_fundamental_type (objfile
, typeid);
1205 /* FIXME: Should we return true for references as well as pointers? */
1209 && TYPE_CODE (t
) == TYPE_CODE_PTR
1210 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1213 /* Chill varying string and arrays are represented as follows:
1215 struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
1217 Return true if TYPE is such a Chill varying type. */
1220 chill_varying_type (type
)
1223 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1224 || TYPE_NFIELDS (type
) != 2
1225 || strcmp (TYPE_FIELD_NAME (type
, 0), "__var_length") != 0)
1230 #if MAINTENANCE_CMDS
1233 print_bit_vector (bits
, nbits
)
1239 for (bitno
= 0; bitno
< nbits
; bitno
++)
1241 if ((bitno
% 8) == 0)
1243 puts_filtered (" ");
1245 if (B_TST (bits
, bitno
))
1247 printf_filtered ("1");
1251 printf_filtered ("0");
1256 /* The args list is a strange beast. It is either terminated by a NULL
1257 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
1258 type for normal fixed argcount functions. (FIXME someday)
1259 Also note the first arg should be the "this" pointer, we may not want to
1260 include it since we may get into a infinitely recursive situation. */
1263 print_arg_types (args
, spaces
)
1269 while (*args
!= NULL
)
1271 recursive_dump_type (*args
, spaces
+ 2);
1272 if ((*args
++) -> code
== TYPE_CODE_VOID
)
1281 dump_fn_fieldlists (type
, spaces
)
1289 printfi_filtered (spaces
, "fn_fieldlists ");
1290 gdb_print_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
1291 printf_filtered ("\n");
1292 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
1294 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
1295 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
1297 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
1298 gdb_print_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
1300 printf_filtered (") length %d\n",
1301 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
1302 for (overload_idx
= 0;
1303 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
1306 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
1308 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
1309 gdb_print_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
1311 printf_filtered (")\n");
1312 printfi_filtered (spaces
+ 8, "type ");
1313 gdb_print_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
1314 printf_filtered ("\n");
1316 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
1319 printfi_filtered (spaces
+ 8, "args ");
1320 gdb_print_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
1321 printf_filtered ("\n");
1323 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
), spaces
);
1324 printfi_filtered (spaces
+ 8, "fcontext ");
1325 gdb_print_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
1327 printf_filtered ("\n");
1329 printfi_filtered (spaces
+ 8, "is_const %d\n",
1330 TYPE_FN_FIELD_CONST (f
, overload_idx
));
1331 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
1332 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
1333 printfi_filtered (spaces
+ 8, "is_private %d\n",
1334 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
1335 printfi_filtered (spaces
+ 8, "is_protected %d\n",
1336 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
1337 printfi_filtered (spaces
+ 8, "is_stub %d\n",
1338 TYPE_FN_FIELD_STUB (f
, overload_idx
));
1339 printfi_filtered (spaces
+ 8, "voffset %u\n",
1340 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
1346 print_cplus_stuff (type
, spaces
)
1350 printfi_filtered (spaces
, "n_baseclasses %d\n",
1351 TYPE_N_BASECLASSES (type
));
1352 printfi_filtered (spaces
, "nfn_fields %d\n",
1353 TYPE_NFN_FIELDS (type
));
1354 printfi_filtered (spaces
, "nfn_fields_total %d\n",
1355 TYPE_NFN_FIELDS_TOTAL (type
));
1356 if (TYPE_N_BASECLASSES (type
) > 0)
1358 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
1359 TYPE_N_BASECLASSES (type
));
1360 gdb_print_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
1361 printf_filtered (")");
1363 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
1364 TYPE_N_BASECLASSES (type
));
1365 puts_filtered ("\n");
1367 if (TYPE_NFIELDS (type
) > 0)
1369 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
1371 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
1372 TYPE_NFIELDS (type
));
1373 gdb_print_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
1374 printf_filtered (")");
1375 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
1376 TYPE_NFIELDS (type
));
1377 puts_filtered ("\n");
1379 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
1381 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
1382 TYPE_NFIELDS (type
));
1383 gdb_print_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
1384 printf_filtered (")");
1385 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
1386 TYPE_NFIELDS (type
));
1387 puts_filtered ("\n");
1390 if (TYPE_NFN_FIELDS (type
) > 0)
1392 dump_fn_fieldlists (type
, spaces
);
1396 static struct obstack dont_print_type_obstack
;
1399 recursive_dump_type (type
, spaces
)
1406 obstack_begin (&dont_print_type_obstack
, 0);
1408 if (TYPE_NFIELDS (type
) > 0
1409 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
1411 struct type
**first_dont_print
1412 = (struct type
**)obstack_base (&dont_print_type_obstack
);
1414 int i
= (struct type
**)obstack_next_free (&dont_print_type_obstack
)
1419 if (type
== first_dont_print
[i
])
1421 printfi_filtered (spaces
, "type node ");
1422 gdb_print_address (type
, gdb_stdout
);
1423 printf_filtered (" <same as already seen type>\n");
1428 obstack_ptr_grow (&dont_print_type_obstack
, type
);
1431 printfi_filtered (spaces
, "type node ");
1432 gdb_print_address (type
, gdb_stdout
);
1433 printf_filtered ("\n");
1434 printfi_filtered (spaces
, "name '%s' (",
1435 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
1436 gdb_print_address (TYPE_NAME (type
), gdb_stdout
);
1437 printf_filtered (")\n");
1438 if (TYPE_TAG_NAME (type
) != NULL
)
1440 printfi_filtered (spaces
, "tagname '%s' (",
1441 TYPE_TAG_NAME (type
));
1442 gdb_print_address (TYPE_TAG_NAME (type
), gdb_stdout
);
1443 printf_filtered (")\n");
1445 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
1446 switch (TYPE_CODE (type
))
1448 case TYPE_CODE_UNDEF
:
1449 printf_filtered ("(TYPE_CODE_UNDEF)");
1452 printf_filtered ("(TYPE_CODE_PTR)");
1454 case TYPE_CODE_ARRAY
:
1455 printf_filtered ("(TYPE_CODE_ARRAY)");
1457 case TYPE_CODE_STRUCT
:
1458 printf_filtered ("(TYPE_CODE_STRUCT)");
1460 case TYPE_CODE_UNION
:
1461 printf_filtered ("(TYPE_CODE_UNION)");
1463 case TYPE_CODE_ENUM
:
1464 printf_filtered ("(TYPE_CODE_ENUM)");
1466 case TYPE_CODE_FUNC
:
1467 printf_filtered ("(TYPE_CODE_FUNC)");
1470 printf_filtered ("(TYPE_CODE_INT)");
1473 printf_filtered ("(TYPE_CODE_FLT)");
1475 case TYPE_CODE_VOID
:
1476 printf_filtered ("(TYPE_CODE_VOID)");
1479 printf_filtered ("(TYPE_CODE_SET)");
1481 case TYPE_CODE_RANGE
:
1482 printf_filtered ("(TYPE_CODE_RANGE)");
1484 case TYPE_CODE_STRING
:
1485 printf_filtered ("(TYPE_CODE_STRING)");
1487 case TYPE_CODE_ERROR
:
1488 printf_filtered ("(TYPE_CODE_ERROR)");
1490 case TYPE_CODE_MEMBER
:
1491 printf_filtered ("(TYPE_CODE_MEMBER)");
1493 case TYPE_CODE_METHOD
:
1494 printf_filtered ("(TYPE_CODE_METHOD)");
1497 printf_filtered ("(TYPE_CODE_REF)");
1499 case TYPE_CODE_CHAR
:
1500 printf_filtered ("(TYPE_CODE_CHAR)");
1502 case TYPE_CODE_BOOL
:
1503 printf_filtered ("(TYPE_CODE_BOOL)");
1505 case TYPE_CODE_TYPEDEF
:
1506 printf_filtered ("(TYPE_CODE_TYPEDEF)");
1509 printf_filtered ("(UNKNOWN TYPE CODE)");
1512 puts_filtered ("\n");
1513 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
1514 printfi_filtered (spaces
, "objfile ");
1515 gdb_print_address (TYPE_OBJFILE (type
), gdb_stdout
);
1516 printf_filtered ("\n");
1517 printfi_filtered (spaces
, "target_type ");
1518 gdb_print_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
1519 printf_filtered ("\n");
1520 if (TYPE_TARGET_TYPE (type
) != NULL
)
1522 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
1524 printfi_filtered (spaces
, "pointer_type ");
1525 gdb_print_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
1526 printf_filtered ("\n");
1527 printfi_filtered (spaces
, "reference_type ");
1528 gdb_print_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
1529 printf_filtered ("\n");
1530 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
1531 if (TYPE_FLAGS (type
) & TYPE_FLAG_UNSIGNED
)
1533 puts_filtered (" TYPE_FLAG_UNSIGNED");
1535 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
1537 puts_filtered (" TYPE_FLAG_STUB");
1539 puts_filtered ("\n");
1540 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
1541 gdb_print_address (TYPE_FIELDS (type
), gdb_stdout
);
1542 puts_filtered ("\n");
1543 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
1545 printfi_filtered (spaces
+ 2,
1546 "[%d] bitpos %d bitsize %d type ",
1547 idx
, TYPE_FIELD_BITPOS (type
, idx
),
1548 TYPE_FIELD_BITSIZE (type
, idx
));
1549 gdb_print_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
1550 printf_filtered (" name '%s' (",
1551 TYPE_FIELD_NAME (type
, idx
) != NULL
1552 ? TYPE_FIELD_NAME (type
, idx
)
1554 gdb_print_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
1555 printf_filtered (")\n");
1556 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
1558 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
1561 printfi_filtered (spaces
, "vptr_basetype ");
1562 gdb_print_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
1563 puts_filtered ("\n");
1564 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
1566 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
1568 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
1569 switch (TYPE_CODE (type
))
1571 case TYPE_CODE_METHOD
:
1572 case TYPE_CODE_FUNC
:
1573 printfi_filtered (spaces
, "arg_types ");
1574 gdb_print_address (TYPE_ARG_TYPES (type
), gdb_stdout
);
1575 puts_filtered ("\n");
1576 print_arg_types (TYPE_ARG_TYPES (type
), spaces
);
1579 case TYPE_CODE_STRUCT
:
1580 printfi_filtered (spaces
, "cplus_stuff ");
1581 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1582 puts_filtered ("\n");
1583 print_cplus_stuff (type
, spaces
);
1587 /* We have to pick one of the union types to be able print and test
1588 the value. Pick cplus_struct_type, even though we know it isn't
1589 any particular one. */
1590 printfi_filtered (spaces
, "type_specific ");
1591 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1592 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
1594 printf_filtered (" (unknown data form)");
1596 printf_filtered ("\n");
1601 obstack_free (&dont_print_type_obstack
, NULL
);
1604 #endif /* MAINTENANCE_CMDS */
1607 _initialize_gdbtypes ()
1610 init_type (TYPE_CODE_VOID
, 1,
1612 "void", (struct objfile
*) NULL
);
1614 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1616 "char", (struct objfile
*) NULL
);
1617 builtin_type_signed_char
=
1618 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1620 "signed char", (struct objfile
*) NULL
);
1621 builtin_type_unsigned_char
=
1622 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1624 "unsigned char", (struct objfile
*) NULL
);
1625 builtin_type_short
=
1626 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1628 "short", (struct objfile
*) NULL
);
1629 builtin_type_unsigned_short
=
1630 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1632 "unsigned short", (struct objfile
*) NULL
);
1634 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1636 "int", (struct objfile
*) NULL
);
1637 builtin_type_unsigned_int
=
1638 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1640 "unsigned int", (struct objfile
*) NULL
);
1642 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1644 "long", (struct objfile
*) NULL
);
1645 builtin_type_unsigned_long
=
1646 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1648 "unsigned long", (struct objfile
*) NULL
);
1649 builtin_type_long_long
=
1650 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1652 "long long", (struct objfile
*) NULL
);
1653 builtin_type_unsigned_long_long
=
1654 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1656 "unsigned long long", (struct objfile
*) NULL
);
1657 builtin_type_float
=
1658 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1660 "float", (struct objfile
*) NULL
);
1661 builtin_type_double
=
1662 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1664 "double", (struct objfile
*) NULL
);
1665 builtin_type_long_double
=
1666 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1668 "long double", (struct objfile
*) NULL
);
1669 builtin_type_complex
=
1670 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1672 "complex", (struct objfile
*) NULL
);
1673 TYPE_TARGET_TYPE (builtin_type_complex
) = builtin_type_float
;
1674 builtin_type_double_complex
=
1675 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1677 "double complex", (struct objfile
*) NULL
);
1678 TYPE_TARGET_TYPE (builtin_type_double_complex
) = builtin_type_double
;
1679 builtin_type_string
=
1680 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1682 "string", (struct objfile
*) NULL
);