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 /* New code added to support parsing of Cfront stabs strings */
976 #define INIT_EXTRA { pextras->len=0; pextras->str[0]='\0'; }
977 #define ADD_EXTRA(c) { pextras->str[pextras->len++]=c; }
978 struct extra
{ char str
[128]; int len
; }; /* maximum extention is 128! FIXME */
981 struct extra
* pextras
;
984 char lenstr
[512]; /* FIXME! hardcoded :-( */
986 if ((nlen
= (n
? strlen(n
) : 0))==0)
988 sprintf(pextras
->str
+pextras
->len
,"%d%s",nlen
,n
);
989 pextras
->len
=strlen(pextras
->str
);
993 add_mangled_type(pextras
,t
)
994 struct extra
* pextras
;
997 enum type_code tcode
;
1001 tcode
= TYPE_CODE(t
);
1002 tlen
= TYPE_LENGTH(t
);
1003 tflags
= TYPE_FLAGS(t
);
1004 tname
= TYPE_NAME(t
);
1005 /* args of "..." seem to get mangled as "e" */
1023 if ((pname
=strrchr(tname
,'l'),pname
) && !strcmp(pname
,"long"))
1032 static struct complaint msg
= {"Bad int type code length x%x\n",0,0};
1034 complain (&msg
, tlen
);
1053 static struct complaint msg
= {"Bad float type code length x%x\n",0,0};
1054 complain (&msg
, tlen
);
1060 /* followed by what it's a ref to */
1064 /* followed by what it's a ptr to */
1066 case TYPE_CODE_TYPEDEF
:
1068 static struct complaint msg
= {"Typedefs in overloaded functions not yet supported\n",0,0};
1071 /* followed by type bytes & name */
1073 case TYPE_CODE_FUNC
:
1075 /* followed by func's arg '_' & ret types */
1077 case TYPE_CODE_VOID
:
1080 case TYPE_CODE_METHOD
:
1082 /* followed by name of class and func's arg '_' & ret types */
1083 add_name(pextras
,tname
);
1084 ADD_EXTRA('F'); /* then mangle function */
1086 case TYPE_CODE_STRUCT
: /* C struct */
1087 case TYPE_CODE_UNION
: /* C union */
1088 case TYPE_CODE_ENUM
: /* Enumeration type */
1089 /* followed by name of type */
1090 add_name(pextras
,tname
);
1093 /* errors possible types/not supported */
1094 case TYPE_CODE_CHAR
:
1095 case TYPE_CODE_ARRAY
: /* Array type */
1096 case TYPE_CODE_MEMBER
: /* Member type */
1097 case TYPE_CODE_BOOL
:
1098 case TYPE_CODE_COMPLEX
: /* Complex float */
1099 case TYPE_CODE_UNDEF
:
1100 case TYPE_CODE_SET
: /* Pascal sets */
1101 case TYPE_CODE_RANGE
:
1102 case TYPE_CODE_STRING
:
1103 case TYPE_CODE_BITSTRING
:
1104 case TYPE_CODE_ERROR
:
1107 static struct complaint msg
= {"Unknown type code x%x\n",0,0};
1108 complain (&msg
, tcode
);
1112 add_mangled_type(pextras
,t
->target_type
);
1116 cfront_mangle_name(type
, i
, j
)
1122 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
1124 f
= TYPE_FN_FIELDLIST1 (type
, i
); /* moved from below */
1126 /* kludge to support cfront methods - gdb expects to find "F" for
1127 ARM_mangled names, so when we mangle, we have to add it here */
1131 char * arm_mangled_name
;
1132 struct fn_field
*method
= &f
[j
];
1133 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1134 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1135 char *newname
= type_name_no_tag (type
);
1137 struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
1138 int nargs
= TYPE_NFIELDS(ftype
); /* number of args */
1139 struct extra extras
, * pextras
= &extras
;
1142 if (TYPE_FN_FIELD_STATIC_P (f
, j
)) /* j for sublist within this list */
1145 /* add args here! */
1146 if (nargs
<= 1) /* no args besides this */
1149 for (k
=1; k
<nargs
; k
++)
1152 t
= TYPE_FIELD_TYPE(ftype
,k
);
1153 add_mangled_type(pextras
,t
);
1157 printf("add_mangled_type: %s\n",extras
.str
); /* FIXME */
1158 arm_mangled_name
= malloc(strlen(mangled_name
)+extras
.len
);
1159 sprintf(arm_mangled_name
,"%s%s",mangled_name
,extras
.str
);
1161 mangled_name
= arm_mangled_name
;
1165 /* End of new code added to support parsing of Cfront stabs strings */
1167 /* Ugly hack to convert method stubs into method types.
1169 He ain't kiddin'. This demangles the name of the method into a string
1170 including argument types, parses out each argument type, generates
1171 a string casting a zero to that type, evaluates the string, and stuffs
1172 the resulting type into an argtype vector!!! Then it knows the type
1173 of the whole function (including argument types for overloading),
1174 which info used to be in the stab's but was removed to hack back
1175 the space required for them. */
1178 check_stub_method (type
, i
, j
)
1184 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
1185 char *demangled_name
= cplus_demangle (mangled_name
,
1186 DMGL_PARAMS
| DMGL_ANSI
);
1187 char *argtypetext
, *p
;
1188 int depth
= 0, argcount
= 1;
1189 struct type
**argtypes
;
1192 /* Make sure we got back a function string that we can use. */
1194 p
= strchr (demangled_name
, '(');
1196 if (demangled_name
== NULL
|| p
== NULL
)
1197 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
1199 /* Now, read in the parameters that define this type. */
1212 else if (*p
== ',' && depth
== 0)
1220 /* We need two more slots: one for the THIS pointer, and one for the
1221 NULL [...] or void [end of arglist]. */
1223 argtypes
= (struct type
**)
1224 TYPE_ALLOC (type
, (argcount
+ 2) * sizeof (struct type
*));
1226 /* FIXME: This is wrong for static member functions. */
1227 argtypes
[0] = lookup_pointer_type (type
);
1230 if (*p
!= ')') /* () means no args, skip while */
1235 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1237 /* Avoid parsing of ellipsis, they will be handled below. */
1238 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0)
1240 argtypes
[argcount
] =
1241 parse_and_eval_type (argtypetext
, p
- argtypetext
);
1244 argtypetext
= p
+ 1;
1260 if (p
[-2] != '.') /* Not '...' */
1262 argtypes
[argcount
] = builtin_type_void
; /* List terminator */
1266 argtypes
[argcount
] = NULL
; /* Ellist terminator */
1269 free (demangled_name
);
1271 f
= TYPE_FN_FIELDLIST1 (type
, i
);
1273 TYPE_FN_FIELD_PHYSNAME (f
, j
) = mangled_name
;
1275 /* Now update the old "stub" type into a real type. */
1276 mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1277 TYPE_DOMAIN_TYPE (mtype
) = type
;
1278 TYPE_ARG_TYPES (mtype
) = argtypes
;
1279 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1280 TYPE_FN_FIELD_STUB (f
, j
) = 0;
1283 const struct cplus_struct_type cplus_struct_default
;
1286 allocate_cplus_struct_type (type
)
1289 if (!HAVE_CPLUS_STRUCT (type
))
1291 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1292 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1293 *(TYPE_CPLUS_SPECIFIC(type
)) = cplus_struct_default
;
1297 /* Helper function to initialize the standard scalar types.
1299 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1300 of the string pointed to by name in the type_obstack for that objfile,
1301 and initialize the type name to that copy. There are places (mipsread.c
1302 in particular, where init_type is called with a NULL value for NAME). */
1305 init_type (code
, length
, flags
, name
, objfile
)
1306 enum type_code code
;
1310 struct objfile
*objfile
;
1312 register struct type
*type
;
1314 type
= alloc_type (objfile
);
1315 TYPE_CODE (type
) = code
;
1316 TYPE_LENGTH (type
) = length
;
1317 TYPE_FLAGS (type
) |= flags
;
1318 if ((name
!= NULL
) && (objfile
!= NULL
))
1321 obsavestring (name
, strlen (name
), &objfile
-> type_obstack
);
1325 TYPE_NAME (type
) = name
;
1330 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
1332 INIT_CPLUS_SPECIFIC (type
);
1337 /* Look up a fundamental type for the specified objfile.
1338 May need to construct such a type if this is the first use.
1340 Some object file formats (ELF, COFF, etc) do not define fundamental
1341 types such as "int" or "double". Others (stabs for example), do
1342 define fundamental types.
1344 For the formats which don't provide fundamental types, gdb can create
1345 such types, using defaults reasonable for the current language and
1346 the current target machine.
1348 NOTE: This routine is obsolescent. Each debugging format reader
1349 should manage it's own fundamental types, either creating them from
1350 suitable defaults or reading them from the debugging information,
1351 whichever is appropriate. The DWARF reader has already been
1352 fixed to do this. Once the other readers are fixed, this routine
1353 will go away. Also note that fundamental types should be managed
1354 on a compilation unit basis in a multi-language environment, not
1355 on a linkage unit basis as is done here. */
1359 lookup_fundamental_type (objfile
, typeid)
1360 struct objfile
*objfile
;
1363 register struct type
**typep
;
1364 register int nbytes
;
1366 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1368 error ("internal error - invalid fundamental type id %d", typeid);
1371 /* If this is the first time we need a fundamental type for this objfile
1372 then we need to initialize the vector of type pointers. */
1374 if (objfile
-> fundamental_types
== NULL
)
1376 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1377 objfile
-> fundamental_types
= (struct type
**)
1378 obstack_alloc (&objfile
-> type_obstack
, nbytes
);
1379 memset ((char *) objfile
-> fundamental_types
, 0, nbytes
);
1380 OBJSTAT (objfile
, n_types
+= FT_NUM_MEMBERS
);
1383 /* Look for this particular type in the fundamental type vector. If one is
1384 not found, create and install one appropriate for the current language. */
1386 typep
= objfile
-> fundamental_types
+ typeid;
1389 *typep
= create_fundamental_type (objfile
, typeid);
1399 /* FIXME: Should we return true for references as well as pointers? */
1403 && TYPE_CODE (t
) == TYPE_CODE_PTR
1404 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1407 /* Chill varying string and arrays are represented as follows:
1409 struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
1411 Return true if TYPE is such a Chill varying type. */
1414 chill_varying_type (type
)
1417 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1418 || TYPE_NFIELDS (type
) != 2
1419 || strcmp (TYPE_FIELD_NAME (type
, 0), "__var_length") != 0)
1424 #if MAINTENANCE_CMDS
1427 print_bit_vector (bits
, nbits
)
1433 for (bitno
= 0; bitno
< nbits
; bitno
++)
1435 if ((bitno
% 8) == 0)
1437 puts_filtered (" ");
1439 if (B_TST (bits
, bitno
))
1441 printf_filtered ("1");
1445 printf_filtered ("0");
1450 /* The args list is a strange beast. It is either terminated by a NULL
1451 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
1452 type for normal fixed argcount functions. (FIXME someday)
1453 Also note the first arg should be the "this" pointer, we may not want to
1454 include it since we may get into a infinitely recursive situation. */
1457 print_arg_types (args
, spaces
)
1463 while (*args
!= NULL
)
1465 recursive_dump_type (*args
, spaces
+ 2);
1466 if ((*args
++) -> code
== TYPE_CODE_VOID
)
1475 dump_fn_fieldlists (type
, spaces
)
1483 printfi_filtered (spaces
, "fn_fieldlists ");
1484 gdb_print_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
1485 printf_filtered ("\n");
1486 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
1488 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
1489 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
1491 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
1492 gdb_print_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
1494 printf_filtered (") length %d\n",
1495 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
1496 for (overload_idx
= 0;
1497 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
1500 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
1502 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
1503 gdb_print_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
1505 printf_filtered (")\n");
1506 printfi_filtered (spaces
+ 8, "type ");
1507 gdb_print_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
1508 printf_filtered ("\n");
1510 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
1513 printfi_filtered (spaces
+ 8, "args ");
1514 gdb_print_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
1515 printf_filtered ("\n");
1517 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
), spaces
);
1518 printfi_filtered (spaces
+ 8, "fcontext ");
1519 gdb_print_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
1521 printf_filtered ("\n");
1523 printfi_filtered (spaces
+ 8, "is_const %d\n",
1524 TYPE_FN_FIELD_CONST (f
, overload_idx
));
1525 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
1526 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
1527 printfi_filtered (spaces
+ 8, "is_private %d\n",
1528 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
1529 printfi_filtered (spaces
+ 8, "is_protected %d\n",
1530 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
1531 printfi_filtered (spaces
+ 8, "is_stub %d\n",
1532 TYPE_FN_FIELD_STUB (f
, overload_idx
));
1533 printfi_filtered (spaces
+ 8, "voffset %u\n",
1534 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
1540 print_cplus_stuff (type
, spaces
)
1544 printfi_filtered (spaces
, "n_baseclasses %d\n",
1545 TYPE_N_BASECLASSES (type
));
1546 printfi_filtered (spaces
, "nfn_fields %d\n",
1547 TYPE_NFN_FIELDS (type
));
1548 printfi_filtered (spaces
, "nfn_fields_total %d\n",
1549 TYPE_NFN_FIELDS_TOTAL (type
));
1550 if (TYPE_N_BASECLASSES (type
) > 0)
1552 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
1553 TYPE_N_BASECLASSES (type
));
1554 gdb_print_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
1555 printf_filtered (")");
1557 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
1558 TYPE_N_BASECLASSES (type
));
1559 puts_filtered ("\n");
1561 if (TYPE_NFIELDS (type
) > 0)
1563 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
1565 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
1566 TYPE_NFIELDS (type
));
1567 gdb_print_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
1568 printf_filtered (")");
1569 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
1570 TYPE_NFIELDS (type
));
1571 puts_filtered ("\n");
1573 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
1575 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
1576 TYPE_NFIELDS (type
));
1577 gdb_print_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
1578 printf_filtered (")");
1579 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
1580 TYPE_NFIELDS (type
));
1581 puts_filtered ("\n");
1584 if (TYPE_NFN_FIELDS (type
) > 0)
1586 dump_fn_fieldlists (type
, spaces
);
1590 static struct obstack dont_print_type_obstack
;
1593 recursive_dump_type (type
, spaces
)
1600 obstack_begin (&dont_print_type_obstack
, 0);
1602 if (TYPE_NFIELDS (type
) > 0
1603 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
1605 struct type
**first_dont_print
1606 = (struct type
**)obstack_base (&dont_print_type_obstack
);
1608 int i
= (struct type
**)obstack_next_free (&dont_print_type_obstack
)
1613 if (type
== first_dont_print
[i
])
1615 printfi_filtered (spaces
, "type node ");
1616 gdb_print_address (type
, gdb_stdout
);
1617 printf_filtered (" <same as already seen type>\n");
1622 obstack_ptr_grow (&dont_print_type_obstack
, type
);
1625 printfi_filtered (spaces
, "type node ");
1626 gdb_print_address (type
, gdb_stdout
);
1627 printf_filtered ("\n");
1628 printfi_filtered (spaces
, "name '%s' (",
1629 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
1630 gdb_print_address (TYPE_NAME (type
), gdb_stdout
);
1631 printf_filtered (")\n");
1632 if (TYPE_TAG_NAME (type
) != NULL
)
1634 printfi_filtered (spaces
, "tagname '%s' (",
1635 TYPE_TAG_NAME (type
));
1636 gdb_print_address (TYPE_TAG_NAME (type
), gdb_stdout
);
1637 printf_filtered (")\n");
1639 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
1640 switch (TYPE_CODE (type
))
1642 case TYPE_CODE_UNDEF
:
1643 printf_filtered ("(TYPE_CODE_UNDEF)");
1646 printf_filtered ("(TYPE_CODE_PTR)");
1648 case TYPE_CODE_ARRAY
:
1649 printf_filtered ("(TYPE_CODE_ARRAY)");
1651 case TYPE_CODE_STRUCT
:
1652 printf_filtered ("(TYPE_CODE_STRUCT)");
1654 case TYPE_CODE_UNION
:
1655 printf_filtered ("(TYPE_CODE_UNION)");
1657 case TYPE_CODE_ENUM
:
1658 printf_filtered ("(TYPE_CODE_ENUM)");
1660 case TYPE_CODE_FUNC
:
1661 printf_filtered ("(TYPE_CODE_FUNC)");
1664 printf_filtered ("(TYPE_CODE_INT)");
1667 printf_filtered ("(TYPE_CODE_FLT)");
1669 case TYPE_CODE_VOID
:
1670 printf_filtered ("(TYPE_CODE_VOID)");
1673 printf_filtered ("(TYPE_CODE_SET)");
1675 case TYPE_CODE_RANGE
:
1676 printf_filtered ("(TYPE_CODE_RANGE)");
1678 case TYPE_CODE_STRING
:
1679 printf_filtered ("(TYPE_CODE_STRING)");
1681 case TYPE_CODE_ERROR
:
1682 printf_filtered ("(TYPE_CODE_ERROR)");
1684 case TYPE_CODE_MEMBER
:
1685 printf_filtered ("(TYPE_CODE_MEMBER)");
1687 case TYPE_CODE_METHOD
:
1688 printf_filtered ("(TYPE_CODE_METHOD)");
1691 printf_filtered ("(TYPE_CODE_REF)");
1693 case TYPE_CODE_CHAR
:
1694 printf_filtered ("(TYPE_CODE_CHAR)");
1696 case TYPE_CODE_BOOL
:
1697 printf_filtered ("(TYPE_CODE_BOOL)");
1699 case TYPE_CODE_TYPEDEF
:
1700 printf_filtered ("(TYPE_CODE_TYPEDEF)");
1703 printf_filtered ("(UNKNOWN TYPE CODE)");
1706 puts_filtered ("\n");
1707 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
1708 printfi_filtered (spaces
, "objfile ");
1709 gdb_print_address (TYPE_OBJFILE (type
), gdb_stdout
);
1710 printf_filtered ("\n");
1711 printfi_filtered (spaces
, "target_type ");
1712 gdb_print_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
1713 printf_filtered ("\n");
1714 if (TYPE_TARGET_TYPE (type
) != NULL
)
1716 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
1718 printfi_filtered (spaces
, "pointer_type ");
1719 gdb_print_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
1720 printf_filtered ("\n");
1721 printfi_filtered (spaces
, "reference_type ");
1722 gdb_print_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
1723 printf_filtered ("\n");
1724 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
1725 if (TYPE_FLAGS (type
) & TYPE_FLAG_UNSIGNED
)
1727 puts_filtered (" TYPE_FLAG_UNSIGNED");
1729 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
1731 puts_filtered (" TYPE_FLAG_STUB");
1733 puts_filtered ("\n");
1734 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
1735 gdb_print_address (TYPE_FIELDS (type
), gdb_stdout
);
1736 puts_filtered ("\n");
1737 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
1739 printfi_filtered (spaces
+ 2,
1740 "[%d] bitpos %d bitsize %d type ",
1741 idx
, TYPE_FIELD_BITPOS (type
, idx
),
1742 TYPE_FIELD_BITSIZE (type
, idx
));
1743 gdb_print_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
1744 printf_filtered (" name '%s' (",
1745 TYPE_FIELD_NAME (type
, idx
) != NULL
1746 ? TYPE_FIELD_NAME (type
, idx
)
1748 gdb_print_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
1749 printf_filtered (")\n");
1750 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
1752 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
1755 printfi_filtered (spaces
, "vptr_basetype ");
1756 gdb_print_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
1757 puts_filtered ("\n");
1758 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
1760 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
1762 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
1763 switch (TYPE_CODE (type
))
1765 case TYPE_CODE_METHOD
:
1766 case TYPE_CODE_FUNC
:
1767 printfi_filtered (spaces
, "arg_types ");
1768 gdb_print_address (TYPE_ARG_TYPES (type
), gdb_stdout
);
1769 puts_filtered ("\n");
1770 print_arg_types (TYPE_ARG_TYPES (type
), spaces
);
1773 case TYPE_CODE_STRUCT
:
1774 printfi_filtered (spaces
, "cplus_stuff ");
1775 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1776 puts_filtered ("\n");
1777 print_cplus_stuff (type
, spaces
);
1781 /* We have to pick one of the union types to be able print and test
1782 the value. Pick cplus_struct_type, even though we know it isn't
1783 any particular one. */
1784 printfi_filtered (spaces
, "type_specific ");
1785 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1786 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
1788 printf_filtered (" (unknown data form)");
1790 printf_filtered ("\n");
1795 obstack_free (&dont_print_type_obstack
, NULL
);
1798 #endif /* MAINTENANCE_CMDS */
1801 _initialize_gdbtypes ()
1804 init_type (TYPE_CODE_VOID
, 1,
1806 "void", (struct objfile
*) NULL
);
1808 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1810 "char", (struct objfile
*) NULL
);
1811 builtin_type_signed_char
=
1812 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1814 "signed char", (struct objfile
*) NULL
);
1815 builtin_type_unsigned_char
=
1816 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1818 "unsigned char", (struct objfile
*) NULL
);
1819 builtin_type_short
=
1820 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1822 "short", (struct objfile
*) NULL
);
1823 builtin_type_unsigned_short
=
1824 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1826 "unsigned short", (struct objfile
*) NULL
);
1828 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1830 "int", (struct objfile
*) NULL
);
1831 builtin_type_unsigned_int
=
1832 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1834 "unsigned int", (struct objfile
*) NULL
);
1836 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1838 "long", (struct objfile
*) NULL
);
1839 builtin_type_unsigned_long
=
1840 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1842 "unsigned long", (struct objfile
*) NULL
);
1843 builtin_type_long_long
=
1844 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1846 "long long", (struct objfile
*) NULL
);
1847 builtin_type_unsigned_long_long
=
1848 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1850 "unsigned long long", (struct objfile
*) NULL
);
1851 builtin_type_float
=
1852 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1854 "float", (struct objfile
*) NULL
);
1855 builtin_type_double
=
1856 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1858 "double", (struct objfile
*) NULL
);
1859 builtin_type_long_double
=
1860 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1862 "long double", (struct objfile
*) NULL
);
1863 builtin_type_complex
=
1864 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1866 "complex", (struct objfile
*) NULL
);
1867 TYPE_TARGET_TYPE (builtin_type_complex
) = builtin_type_float
;
1868 builtin_type_double_complex
=
1869 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1871 "double complex", (struct objfile
*) NULL
);
1872 TYPE_TARGET_TYPE (builtin_type_double_complex
) = builtin_type_double
;
1873 builtin_type_string
=
1874 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1876 "string", (struct objfile
*) NULL
);