1 /* Support routines for manipulating internal types for GDB.
2 Copyright (C) 1992, 93, 94, 95, 96, 1998 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,
20 Boston, MA 02111-1307, USA. */
23 #include "gdb_string.h"
29 #include "expression.h"
34 #include "complaints.h"
37 /* These variables point to the objects
38 representing the predefined C data types. */
40 struct type
*builtin_type_void
;
41 struct type
*builtin_type_char
;
42 struct type
*builtin_type_true_char
;
43 struct type
*builtin_type_short
;
44 struct type
*builtin_type_int
;
45 struct type
*builtin_type_long
;
46 struct type
*builtin_type_long_long
;
47 struct type
*builtin_type_signed_char
;
48 struct type
*builtin_type_unsigned_char
;
49 struct type
*builtin_type_unsigned_short
;
50 struct type
*builtin_type_unsigned_int
;
51 struct type
*builtin_type_unsigned_long
;
52 struct type
*builtin_type_unsigned_long_long
;
53 struct type
*builtin_type_float
;
54 struct type
*builtin_type_double
;
55 struct type
*builtin_type_long_double
;
56 struct type
*builtin_type_complex
;
57 struct type
*builtin_type_double_complex
;
58 struct type
*builtin_type_string
;
59 struct type
*builtin_type_int8
;
60 struct type
*builtin_type_uint8
;
61 struct type
*builtin_type_int16
;
62 struct type
*builtin_type_uint16
;
63 struct type
*builtin_type_int32
;
64 struct type
*builtin_type_uint32
;
65 struct type
*builtin_type_int64
;
66 struct type
*builtin_type_uint64
;
67 struct type
*builtin_type_bool
;
69 int opaque_type_resolution
= 1;
76 }; /* maximum extention is 128! FIXME */
78 static void add_name
PARAMS ((struct extra
*, char *));
79 static void add_mangled_type
PARAMS ((struct extra
*, struct type
*));
81 static void cfront_mangle_name
PARAMS ((struct type
*, int, int));
83 static void print_bit_vector
PARAMS ((B_TYPE
*, int));
84 static void print_arg_types
PARAMS ((struct type
**, int));
85 static void dump_fn_fieldlists
PARAMS ((struct type
*, int));
86 static void print_cplus_stuff
PARAMS ((struct type
*, int));
87 static void virtual_base_list_aux
PARAMS ((struct type
* dclass
));
90 /* Alloc a new type structure and fill it with some defaults. If
91 OBJFILE is non-NULL, then allocate the space for the type structure
92 in that objfile's type_obstack. */
96 struct objfile
*objfile
;
98 register struct type
*type
;
100 /* Alloc the structure and start off with all fields zeroed. */
104 type
= (struct type
*) xmalloc (sizeof (struct type
));
108 type
= (struct type
*) obstack_alloc (&objfile
->type_obstack
,
109 sizeof (struct type
));
110 OBJSTAT (objfile
, n_types
++);
112 memset ((char *) type
, 0, sizeof (struct type
));
114 /* Initialize the fields that might not be zero. */
116 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
117 TYPE_OBJFILE (type
) = objfile
;
118 TYPE_VPTR_FIELDNO (type
) = -1;
119 TYPE_CV_TYPE (type
) = type
; /* chain back to itself */
124 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
125 to a pointer to memory where the pointer type should be stored.
126 If *TYPEPTR is zero, update it to point to the pointer type we return.
127 We allocate new memory if needed. */
130 make_pointer_type (type
, typeptr
)
132 struct type
**typeptr
;
134 register struct type
*ntype
; /* New type */
135 struct objfile
*objfile
;
137 ntype
= TYPE_POINTER_TYPE (type
);
142 return ntype
; /* Don't care about alloc, and have new type. */
143 else if (*typeptr
== 0)
145 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
150 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
152 ntype
= alloc_type (TYPE_OBJFILE (type
));
157 /* We have storage, but need to reset it. */
160 objfile
= TYPE_OBJFILE (ntype
);
161 memset ((char *) ntype
, 0, sizeof (struct type
));
162 TYPE_OBJFILE (ntype
) = objfile
;
165 TYPE_TARGET_TYPE (ntype
) = type
;
166 TYPE_POINTER_TYPE (type
) = ntype
;
168 /* FIXME! Assume the machine has only one representation for pointers! */
170 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
171 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
173 /* pointers are unsigned */
174 TYPE_FLAGS (ntype
) |= TYPE_FLAG_UNSIGNED
;
176 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
177 TYPE_POINTER_TYPE (type
) = ntype
;
182 /* Given a type TYPE, return a type of pointers to that type.
183 May need to construct such a type if this is the first use. */
186 lookup_pointer_type (type
)
189 return make_pointer_type (type
, (struct type
**) 0);
192 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero, points
193 to a pointer to memory where the reference type should be stored.
194 If *TYPEPTR is zero, update it to point to the reference type we return.
195 We allocate new memory if needed. */
198 make_reference_type (type
, typeptr
)
200 struct type
**typeptr
;
202 register struct type
*ntype
; /* New type */
203 struct objfile
*objfile
;
205 ntype
= TYPE_REFERENCE_TYPE (type
);
210 return ntype
; /* Don't care about alloc, and have new type. */
211 else if (*typeptr
== 0)
213 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
218 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
220 ntype
= alloc_type (TYPE_OBJFILE (type
));
225 /* We have storage, but need to reset it. */
228 objfile
= TYPE_OBJFILE (ntype
);
229 memset ((char *) ntype
, 0, sizeof (struct type
));
230 TYPE_OBJFILE (ntype
) = objfile
;
233 TYPE_TARGET_TYPE (ntype
) = type
;
234 TYPE_REFERENCE_TYPE (type
) = ntype
;
236 /* FIXME! Assume the machine has only one representation for references,
237 and that it matches the (only) representation for pointers! */
239 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
240 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
242 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
243 TYPE_REFERENCE_TYPE (type
) = ntype
;
248 /* Same as above, but caller doesn't care about memory allocation details. */
251 lookup_reference_type (type
)
254 return make_reference_type (type
, (struct type
**) 0);
257 /* Lookup a function type that returns type TYPE. TYPEPTR, if nonzero, points
258 to a pointer to memory where the function type should be stored.
259 If *TYPEPTR is zero, update it to point to the function type we return.
260 We allocate new memory if needed. */
263 make_function_type (type
, typeptr
)
265 struct type
**typeptr
;
267 register struct type
*ntype
; /* New type */
268 struct objfile
*objfile
;
270 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
272 ntype
= alloc_type (TYPE_OBJFILE (type
));
277 /* We have storage, but need to reset it. */
280 objfile
= TYPE_OBJFILE (ntype
);
281 memset ((char *) ntype
, 0, sizeof (struct type
));
282 TYPE_OBJFILE (ntype
) = objfile
;
285 TYPE_TARGET_TYPE (ntype
) = type
;
287 TYPE_LENGTH (ntype
) = 1;
288 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
294 /* Given a type TYPE, return a type of functions that return that type.
295 May need to construct such a type if this is the first use. */
298 lookup_function_type (type
)
301 return make_function_type (type
, (struct type
**) 0);
305 /* Make a "c-v" variant of a type -- a type that is identical to the
306 one supplied except that it may have const or volatile attributes
307 CNST is a flag for setting the const attribute
308 VOLTL is a flag for setting the volatile attribute
309 TYPE is the base type whose variant we are creating.
310 TYPEPTR, if nonzero, points
311 to a pointer to memory where the reference type should be stored.
312 If *TYPEPTR is zero, update it to point to the reference type we return.
313 We allocate new memory if needed. */
316 make_cv_type (cnst
, voltl
, type
, typeptr
)
320 struct type
**typeptr
;
322 register struct type
*ntype
; /* New type */
323 register struct type
*tmp_type
= type
; /* tmp type */
324 struct objfile
*objfile
;
326 ntype
= TYPE_CV_TYPE (type
);
328 while (ntype
!= type
)
330 if ((TYPE_CONST (ntype
) == cnst
) &&
331 (TYPE_VOLATILE (ntype
) == voltl
))
335 else if (*typeptr
== 0)
337 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
342 ntype
= TYPE_CV_TYPE (ntype
);
345 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
347 ntype
= alloc_type (TYPE_OBJFILE (type
));
352 /* We have storage, but need to reset it. */
355 objfile
= TYPE_OBJFILE (ntype
);
356 /* memset ((char *) ntype, 0, sizeof (struct type)); */
357 TYPE_OBJFILE (ntype
) = objfile
;
360 /* Copy original type */
361 memcpy ((char *) ntype
, (char *) type
, sizeof (struct type
));
362 /* But zero out fields that shouldn't be copied */
363 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0; /* Need new pointer kind */
364 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0; /* Need new referene kind */
365 /* Note: TYPE_TARGET_TYPE can be left as is */
367 /* Set flags appropriately */
369 TYPE_FLAGS (ntype
) |= TYPE_FLAG_CONST
;
371 TYPE_FLAGS (ntype
) &= ~TYPE_FLAG_CONST
;
374 TYPE_FLAGS (ntype
) |= TYPE_FLAG_VOLATILE
;
376 TYPE_FLAGS (ntype
) &= ~TYPE_FLAG_VOLATILE
;
378 /* Fix the chain of cv variants */
379 TYPE_CV_TYPE (ntype
) = type
;
380 TYPE_CV_TYPE (tmp_type
) = ntype
;
388 /* Implement direct support for MEMBER_TYPE in GNU C++.
389 May need to construct such a type if this is the first use.
390 The TYPE is the type of the member. The DOMAIN is the type
391 of the aggregate that the member belongs to. */
394 lookup_member_type (type
, domain
)
398 register struct type
*mtype
;
400 mtype
= alloc_type (TYPE_OBJFILE (type
));
401 smash_to_member_type (mtype
, domain
, type
);
405 /* Allocate a stub method whose return type is TYPE.
406 This apparently happens for speed of symbol reading, since parsing
407 out the arguments to the method is cpu-intensive, the way we are doing
408 it. So, we will fill in arguments later.
409 This always returns a fresh type. */
412 allocate_stub_method (type
)
417 mtype
= alloc_type (TYPE_OBJFILE (type
));
418 TYPE_TARGET_TYPE (mtype
) = type
;
419 /* _DOMAIN_TYPE (mtype) = unknown yet */
420 /* _ARG_TYPES (mtype) = unknown yet */
421 TYPE_FLAGS (mtype
) = TYPE_FLAG_STUB
;
422 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
423 TYPE_LENGTH (mtype
) = 1;
427 /* Create a range type using either a blank type supplied in RESULT_TYPE,
428 or creating a new type, inheriting the objfile from INDEX_TYPE.
430 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
431 HIGH_BOUND, inclusive.
433 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
434 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
437 create_range_type (result_type
, index_type
, low_bound
, high_bound
)
438 struct type
*result_type
;
439 struct type
*index_type
;
443 if (result_type
== NULL
)
445 result_type
= alloc_type (TYPE_OBJFILE (index_type
));
447 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
448 TYPE_TARGET_TYPE (result_type
) = index_type
;
449 if (TYPE_FLAGS (index_type
) & TYPE_FLAG_STUB
)
450 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
452 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
453 TYPE_NFIELDS (result_type
) = 2;
454 TYPE_FIELDS (result_type
) = (struct field
*)
455 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
456 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
457 TYPE_FIELD_BITPOS (result_type
, 0) = low_bound
;
458 TYPE_FIELD_BITPOS (result_type
, 1) = high_bound
;
459 TYPE_FIELD_TYPE (result_type
, 0) = builtin_type_int
; /* FIXME */
460 TYPE_FIELD_TYPE (result_type
, 1) = builtin_type_int
; /* FIXME */
463 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
465 return (result_type
);
468 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE.
469 Return 1 of type is a range type, 0 if it is discrete (and bounds
470 will fit in LONGEST), or -1 otherwise. */
473 get_discrete_bounds (type
, lowp
, highp
)
475 LONGEST
*lowp
, *highp
;
477 CHECK_TYPEDEF (type
);
478 switch (TYPE_CODE (type
))
480 case TYPE_CODE_RANGE
:
481 *lowp
= TYPE_LOW_BOUND (type
);
482 *highp
= TYPE_HIGH_BOUND (type
);
485 if (TYPE_NFIELDS (type
) > 0)
487 /* The enums may not be sorted by value, so search all
491 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
492 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
494 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
495 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
496 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
497 *highp
= TYPE_FIELD_BITPOS (type
, i
);
500 /* Set unsigned indicator if warranted. */
503 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
517 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
519 if (!TYPE_UNSIGNED (type
))
521 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
525 /* ... fall through for unsigned ints ... */
528 /* This round-about calculation is to avoid shifting by
529 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
530 if TYPE_LENGTH (type) == sizeof (LONGEST). */
531 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
532 *highp
= (*highp
- 1) | *highp
;
539 /* Create an array type using either a blank type supplied in RESULT_TYPE,
540 or creating a new type, inheriting the objfile from RANGE_TYPE.
542 Elements will be of type ELEMENT_TYPE, the indices will be of type
545 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
546 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
549 create_array_type (result_type
, element_type
, range_type
)
550 struct type
*result_type
;
551 struct type
*element_type
;
552 struct type
*range_type
;
554 LONGEST low_bound
, high_bound
;
556 if (result_type
== NULL
)
558 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
560 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
561 TYPE_TARGET_TYPE (result_type
) = element_type
;
562 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
563 low_bound
= high_bound
= 0;
564 CHECK_TYPEDEF (element_type
);
565 TYPE_LENGTH (result_type
) =
566 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
567 TYPE_NFIELDS (result_type
) = 1;
568 TYPE_FIELDS (result_type
) =
569 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
570 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
571 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
572 TYPE_VPTR_FIELDNO (result_type
) = -1;
574 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
575 if (TYPE_LENGTH (result_type
) == 0)
576 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
578 return (result_type
);
581 /* Create a string type using either a blank type supplied in RESULT_TYPE,
582 or creating a new type. String types are similar enough to array of
583 char types that we can use create_array_type to build the basic type
584 and then bash it into a string type.
586 For fixed length strings, the range type contains 0 as the lower
587 bound and the length of the string minus one as the upper bound.
589 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
590 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
593 create_string_type (result_type
, range_type
)
594 struct type
*result_type
;
595 struct type
*range_type
;
597 result_type
= create_array_type (result_type
,
598 *current_language
->string_char_type
,
600 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
601 return (result_type
);
605 create_set_type (result_type
, domain_type
)
606 struct type
*result_type
;
607 struct type
*domain_type
;
609 LONGEST low_bound
, high_bound
, bit_length
;
610 if (result_type
== NULL
)
612 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
614 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
615 TYPE_NFIELDS (result_type
) = 1;
616 TYPE_FIELDS (result_type
) = (struct field
*)
617 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
618 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
620 if (!(TYPE_FLAGS (domain_type
) & TYPE_FLAG_STUB
))
622 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
623 low_bound
= high_bound
= 0;
624 bit_length
= high_bound
- low_bound
+ 1;
625 TYPE_LENGTH (result_type
)
626 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
628 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
631 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
633 return (result_type
);
636 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
637 A MEMBER is a wierd thing -- it amounts to a typed offset into
638 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
639 include the offset (that's the value of the MEMBER itself), but does
640 include the structure type into which it points (for some reason).
642 When "smashing" the type, we preserve the objfile that the
643 old type pointed to, since we aren't changing where the type is actually
647 smash_to_member_type (type
, domain
, to_type
)
650 struct type
*to_type
;
652 struct objfile
*objfile
;
654 objfile
= TYPE_OBJFILE (type
);
656 memset ((char *) type
, 0, sizeof (struct type
));
657 TYPE_OBJFILE (type
) = objfile
;
658 TYPE_TARGET_TYPE (type
) = to_type
;
659 TYPE_DOMAIN_TYPE (type
) = domain
;
660 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
661 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
664 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
665 METHOD just means `function that gets an extra "this" argument'.
667 When "smashing" the type, we preserve the objfile that the
668 old type pointed to, since we aren't changing where the type is actually
672 smash_to_method_type (type
, domain
, to_type
, args
)
675 struct type
*to_type
;
678 struct objfile
*objfile
;
680 objfile
= TYPE_OBJFILE (type
);
682 memset ((char *) type
, 0, sizeof (struct type
));
683 TYPE_OBJFILE (type
) = objfile
;
684 TYPE_TARGET_TYPE (type
) = to_type
;
685 TYPE_DOMAIN_TYPE (type
) = domain
;
686 TYPE_ARG_TYPES (type
) = args
;
687 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
688 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
691 /* Return a typename for a struct/union/enum type without "struct ",
692 "union ", or "enum ". If the type has a NULL name, return NULL. */
695 type_name_no_tag (type
)
696 register const struct type
*type
;
698 if (TYPE_TAG_NAME (type
) != NULL
)
699 return TYPE_TAG_NAME (type
);
701 /* Is there code which expects this to return the name if there is no
702 tag name? My guess is that this is mainly used for C++ in cases where
703 the two will always be the same. */
704 return TYPE_NAME (type
);
707 /* Lookup a primitive type named NAME.
708 Return zero if NAME is not a primitive type. */
711 lookup_primitive_typename (name
)
714 struct type
**const *p
;
716 for (p
= current_language
->la_builtin_type_vector
; *p
!= NULL
; p
++)
718 if (STREQ ((**p
)->name
, name
))
726 /* Lookup a typedef or primitive type named NAME,
727 visible in lexical block BLOCK.
728 If NOERR is nonzero, return zero if NAME is not suitably defined. */
731 lookup_typename (name
, block
, noerr
)
736 register struct symbol
*sym
;
737 register struct type
*tmp
;
739 sym
= lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
740 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
742 tmp
= lookup_primitive_typename (name
);
747 else if (!tmp
&& noerr
)
753 error ("No type named %s.", name
);
756 return (SYMBOL_TYPE (sym
));
760 lookup_unsigned_typename (name
)
763 char *uns
= alloca (strlen (name
) + 10);
765 strcpy (uns
, "unsigned ");
766 strcpy (uns
+ 9, name
);
767 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
771 lookup_signed_typename (name
)
775 char *uns
= alloca (strlen (name
) + 8);
777 strcpy (uns
, "signed ");
778 strcpy (uns
+ 7, name
);
779 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
780 /* If we don't find "signed FOO" just try again with plain "FOO". */
783 return lookup_typename (name
, (struct block
*) NULL
, 0);
786 /* Lookup a structure type named "struct NAME",
787 visible in lexical block BLOCK. */
790 lookup_struct (name
, block
)
794 register struct symbol
*sym
;
796 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
797 (struct symtab
**) NULL
);
801 error ("No struct type named %s.", name
);
803 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
805 error ("This context has class, union or enum %s, not a struct.", name
);
807 return (SYMBOL_TYPE (sym
));
810 /* Lookup a union type named "union NAME",
811 visible in lexical block BLOCK. */
814 lookup_union (name
, block
)
818 register struct symbol
*sym
;
821 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
822 (struct symtab
**) NULL
);
825 error ("No union type named %s.", name
);
827 t
= SYMBOL_TYPE (sym
);
829 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
832 /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
833 * a further "declared_type" field to discover it is really a union.
835 if (HAVE_CPLUS_STRUCT (t
))
836 if (TYPE_DECLARED_TYPE (t
) == DECLARED_TYPE_UNION
)
839 /* If we get here, it's not a union */
840 error ("This context has class, struct or enum %s, not a union.", name
);
844 /* Lookup an enum type named "enum NAME",
845 visible in lexical block BLOCK. */
848 lookup_enum (name
, block
)
852 register struct symbol
*sym
;
854 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
855 (struct symtab
**) NULL
);
858 error ("No enum type named %s.", name
);
860 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
862 error ("This context has class, struct or union %s, not an enum.", name
);
864 return (SYMBOL_TYPE (sym
));
867 /* Lookup a template type named "template NAME<TYPE>",
868 visible in lexical block BLOCK. */
871 lookup_template_type (name
, type
, block
)
877 char *nam
= (char *) alloca (strlen (name
) + strlen (type
->name
) + 4);
880 strcat (nam
, type
->name
);
881 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
883 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
887 error ("No template type named %s.", name
);
889 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
891 error ("This context has class, union or enum %s, not a struct.", name
);
893 return (SYMBOL_TYPE (sym
));
896 /* Given a type TYPE, lookup the type of the component of type named NAME.
898 TYPE can be either a struct or union, or a pointer or reference to a struct or
899 union. If it is a pointer or reference, its target type is automatically used.
900 Thus '.' and '->' are interchangable, as specified for the definitions of the
901 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
903 If NOERR is nonzero, return zero if NAME is not suitably defined.
904 If NAME is the name of a baseclass type, return that type. */
907 lookup_struct_elt_type (type
, name
, noerr
)
916 CHECK_TYPEDEF (type
);
917 if (TYPE_CODE (type
) != TYPE_CODE_PTR
918 && TYPE_CODE (type
) != TYPE_CODE_REF
)
920 type
= TYPE_TARGET_TYPE (type
);
923 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
924 TYPE_CODE (type
) != TYPE_CODE_UNION
)
926 target_terminal_ours ();
927 gdb_flush (gdb_stdout
);
928 fprintf_unfiltered (gdb_stderr
, "Type ");
929 type_print (type
, "", gdb_stderr
, -1);
930 error (" is not a structure or union type.");
934 /* FIXME: This change put in by Michael seems incorrect for the case where
935 the structure tag name is the same as the member name. I.E. when doing
936 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
941 typename
= type_name_no_tag (type
);
942 if (typename
!= NULL
&& STREQ (typename
, name
))
947 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
949 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
951 if (t_field_name
&& STREQ (t_field_name
, name
))
953 return TYPE_FIELD_TYPE (type
, i
);
957 /* OK, it's not in this class. Recursively check the baseclasses. */
958 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
962 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, noerr
);
974 target_terminal_ours ();
975 gdb_flush (gdb_stdout
);
976 fprintf_unfiltered (gdb_stderr
, "Type ");
977 type_print (type
, "", gdb_stderr
, -1);
978 fprintf_unfiltered (gdb_stderr
, " has no component named ");
979 fputs_filtered (name
, gdb_stderr
);
981 return (struct type
*) -1; /* For lint */
984 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
985 valid. Callers should be aware that in some cases (for example,
986 the type or one of its baseclasses is a stub type and we are
987 debugging a .o file), this function will not be able to find the virtual
988 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
992 fill_in_vptr_fieldno (type
)
995 CHECK_TYPEDEF (type
);
997 if (TYPE_VPTR_FIELDNO (type
) < 0)
1001 /* We must start at zero in case the first (and only) baseclass is
1002 virtual (and hence we cannot share the table pointer). */
1003 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1005 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, i
));
1006 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
)) >= 0)
1008 TYPE_VPTR_FIELDNO (type
)
1009 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
));
1010 TYPE_VPTR_BASETYPE (type
)
1011 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type
, i
));
1018 /* Find the method and field indices for the destructor in class type T.
1019 Return 1 if the destructor was found, otherwise, return 0. */
1022 get_destructor_fn_field (t
, method_indexp
, field_indexp
)
1029 for (i
= 0; i
< TYPE_NFN_FIELDS (t
); i
++)
1032 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1034 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (t
, i
); j
++)
1036 if (DESTRUCTOR_PREFIX_P (TYPE_FN_FIELD_PHYSNAME (f
, j
)))
1047 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1049 If this is a stubbed struct (i.e. declared as struct foo *), see if
1050 we can find a full definition in some other file. If so, copy this
1051 definition, so we can use it in future. There used to be a comment (but
1052 not any code) that if we don't find a full definition, we'd set a flag
1053 so we don't spend time in the future checking the same type. That would
1054 be a mistake, though--we might load in more symbols which contain a
1055 full definition for the type.
1057 This used to be coded as a macro, but I don't think it is called
1058 often enough to merit such treatment. */
1060 struct complaint stub_noname_complaint
=
1061 {"stub type has NULL name", 0, 0};
1064 check_typedef (type
)
1065 register struct type
*type
;
1067 struct type
*orig_type
= type
;
1068 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1070 if (!TYPE_TARGET_TYPE (type
))
1075 /* It is dangerous to call lookup_symbol if we are currently
1076 reading a symtab. Infinite recursion is one danger. */
1077 if (currently_reading_symtab
)
1080 name
= type_name_no_tag (type
);
1081 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1082 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
1083 as appropriate? (this code was written before TYPE_NAME and
1084 TYPE_TAG_NAME were separate). */
1087 complain (&stub_noname_complaint
);
1090 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
1091 (struct symtab
**) NULL
);
1093 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1095 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
); /* TYPE_CODE_UNDEF */
1097 type
= TYPE_TARGET_TYPE (type
);
1100 /* If this is a struct/class/union with no fields, then check whether a
1101 full definition exists somewhere else. This is for systems where a
1102 type definition with no fields is issued for such types, instead of
1103 identifying them as stub types in the first place */
1105 if (TYPE_IS_OPAQUE (type
) && opaque_type_resolution
&& !currently_reading_symtab
)
1107 char *name
= type_name_no_tag (type
);
1108 struct type
*newtype
;
1111 complain (&stub_noname_complaint
);
1114 newtype
= lookup_transparent_type (name
);
1117 memcpy ((char *) type
, (char *) newtype
, sizeof (struct type
));
1120 /* Otherwise, rely on the stub flag being set for opaque/stubbed types */
1121 else if ((TYPE_FLAGS (type
) & TYPE_FLAG_STUB
) && !currently_reading_symtab
)
1123 char *name
= type_name_no_tag (type
);
1124 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1125 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
1126 as appropriate? (this code was written before TYPE_NAME and
1127 TYPE_TAG_NAME were separate). */
1131 complain (&stub_noname_complaint
);
1134 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0, (struct symtab
**) NULL
);
1137 memcpy ((char *) type
, (char *) SYMBOL_TYPE (sym
), sizeof (struct type
));
1141 if (TYPE_FLAGS (type
) & TYPE_FLAG_TARGET_STUB
)
1143 struct type
*range_type
;
1144 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1146 if (TYPE_FLAGS (target_type
) & (TYPE_FLAG_STUB
| TYPE_FLAG_TARGET_STUB
))
1149 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1150 && TYPE_NFIELDS (type
) == 1
1151 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
1152 == TYPE_CODE_RANGE
))
1154 /* Now recompute the length of the array type, based on its
1155 number of elements and the target type's length. */
1156 TYPE_LENGTH (type
) =
1157 ((TYPE_FIELD_BITPOS (range_type
, 1)
1158 - TYPE_FIELD_BITPOS (range_type
, 0)
1160 * TYPE_LENGTH (target_type
));
1161 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1163 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1165 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1166 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1169 /* Cache TYPE_LENGTH for future use. */
1170 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1174 /* New code added to support parsing of Cfront stabs strings */
1176 #define INIT_EXTRA { pextras->len=0; pextras->str[0]='\0'; }
1177 #define ADD_EXTRA(c) { pextras->str[pextras->len++]=c; }
1180 add_name (pextras
, n
)
1181 struct extra
*pextras
;
1186 if ((nlen
= (n
? strlen (n
) : 0)) == 0)
1188 sprintf (pextras
->str
+ pextras
->len
, "%d%s", nlen
, n
);
1189 pextras
->len
= strlen (pextras
->str
);
1193 add_mangled_type (pextras
, t
)
1194 struct extra
*pextras
;
1197 enum type_code tcode
;
1201 tcode
= TYPE_CODE (t
);
1202 tlen
= TYPE_LENGTH (t
);
1203 tflags
= TYPE_FLAGS (t
);
1204 tname
= TYPE_NAME (t
);
1205 /* args of "..." seem to get mangled as "e" */
1223 if ((pname
= strrchr (tname
, 'l'), pname
) && !strcmp (pname
, "long"))
1236 static struct complaint msg
=
1237 {"Bad int type code length x%x\n", 0, 0};
1239 complain (&msg
, tlen
);
1258 static struct complaint msg
=
1259 {"Bad float type code length x%x\n", 0, 0};
1260 complain (&msg
, tlen
);
1266 /* followed by what it's a ref to */
1270 /* followed by what it's a ptr to */
1272 case TYPE_CODE_TYPEDEF
:
1274 static struct complaint msg
=
1275 {"Typedefs in overloaded functions not yet supported\n", 0, 0};
1278 /* followed by type bytes & name */
1280 case TYPE_CODE_FUNC
:
1282 /* followed by func's arg '_' & ret types */
1284 case TYPE_CODE_VOID
:
1287 case TYPE_CODE_METHOD
:
1289 /* followed by name of class and func's arg '_' & ret types */
1290 add_name (pextras
, tname
);
1291 ADD_EXTRA ('F'); /* then mangle function */
1293 case TYPE_CODE_STRUCT
: /* C struct */
1294 case TYPE_CODE_UNION
: /* C union */
1295 case TYPE_CODE_ENUM
: /* Enumeration type */
1296 /* followed by name of type */
1297 add_name (pextras
, tname
);
1300 /* errors possible types/not supported */
1301 case TYPE_CODE_CHAR
:
1302 case TYPE_CODE_ARRAY
: /* Array type */
1303 case TYPE_CODE_MEMBER
: /* Member type */
1304 case TYPE_CODE_BOOL
:
1305 case TYPE_CODE_COMPLEX
: /* Complex float */
1306 case TYPE_CODE_UNDEF
:
1307 case TYPE_CODE_SET
: /* Pascal sets */
1308 case TYPE_CODE_RANGE
:
1309 case TYPE_CODE_STRING
:
1310 case TYPE_CODE_BITSTRING
:
1311 case TYPE_CODE_ERROR
:
1314 static struct complaint msg
=
1315 {"Unknown type code x%x\n", 0, 0};
1316 complain (&msg
, tcode
);
1320 add_mangled_type (pextras
, t
->target_type
);
1325 cfront_mangle_name (type
, i
, j
)
1331 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
1333 f
= TYPE_FN_FIELDLIST1 (type
, i
); /* moved from below */
1335 /* kludge to support cfront methods - gdb expects to find "F" for
1336 ARM_mangled names, so when we mangle, we have to add it here */
1340 char *arm_mangled_name
;
1341 struct fn_field
*method
= &f
[j
];
1342 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1343 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1344 char *newname
= type_name_no_tag (type
);
1346 struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
1347 int nargs
= TYPE_NFIELDS (ftype
); /* number of args */
1348 struct extra extras
, *pextras
= &extras
;
1351 if (TYPE_FN_FIELD_STATIC_P (f
, j
)) /* j for sublist within this list */
1354 /* add args here! */
1355 if (nargs
<= 1) /* no args besides this */
1359 for (k
= 1; k
< nargs
; k
++)
1362 t
= TYPE_FIELD_TYPE (ftype
, k
);
1363 add_mangled_type (pextras
, t
);
1367 printf ("add_mangled_type: %s\n", extras
.str
); /* FIXME */
1368 arm_mangled_name
= malloc (strlen (mangled_name
) + extras
.len
);
1369 sprintf (arm_mangled_name
, "%s%s", mangled_name
, extras
.str
);
1370 free (mangled_name
);
1371 mangled_name
= arm_mangled_name
;
1377 /* End of new code added to support parsing of Cfront stabs strings */
1379 /* Ugly hack to convert method stubs into method types.
1381 He ain't kiddin'. This demangles the name of the method into a string
1382 including argument types, parses out each argument type, generates
1383 a string casting a zero to that type, evaluates the string, and stuffs
1384 the resulting type into an argtype vector!!! Then it knows the type
1385 of the whole function (including argument types for overloading),
1386 which info used to be in the stab's but was removed to hack back
1387 the space required for them. */
1390 check_stub_method (type
, method_id
, signature_id
)
1396 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1397 char *demangled_name
= cplus_demangle (mangled_name
,
1398 DMGL_PARAMS
| DMGL_ANSI
);
1399 char *argtypetext
, *p
;
1400 int depth
= 0, argcount
= 1;
1401 struct type
**argtypes
;
1404 /* Make sure we got back a function string that we can use. */
1406 p
= strchr (demangled_name
, '(');
1408 if (demangled_name
== NULL
|| p
== NULL
)
1409 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
1411 /* Now, read in the parameters that define this type. */
1424 else if (*p
== ',' && depth
== 0)
1432 /* We need two more slots: one for the THIS pointer, and one for the
1433 NULL [...] or void [end of arglist]. */
1435 argtypes
= (struct type
**)
1436 TYPE_ALLOC (type
, (argcount
+ 2) * sizeof (struct type
*));
1438 /* FIXME: This is wrong for static member functions. */
1439 argtypes
[0] = lookup_pointer_type (type
);
1442 if (*p
!= ')') /* () means no args, skip while */
1447 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1449 /* Avoid parsing of ellipsis, they will be handled below. */
1450 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0)
1452 argtypes
[argcount
] =
1453 parse_and_eval_type (argtypetext
, p
- argtypetext
);
1456 argtypetext
= p
+ 1;
1472 if (p
[-2] != '.') /* Not '...' */
1474 argtypes
[argcount
] = builtin_type_void
; /* List terminator */
1478 argtypes
[argcount
] = NULL
; /* Ellist terminator */
1481 free (demangled_name
);
1483 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1485 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1487 /* Now update the old "stub" type into a real type. */
1488 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1489 TYPE_DOMAIN_TYPE (mtype
) = type
;
1490 TYPE_ARG_TYPES (mtype
) = argtypes
;
1491 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1492 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1495 const struct cplus_struct_type cplus_struct_default
;
1498 allocate_cplus_struct_type (type
)
1501 if (!HAVE_CPLUS_STRUCT (type
))
1503 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1504 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1505 *(TYPE_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1509 /* Helper function to initialize the standard scalar types.
1511 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1512 of the string pointed to by name in the type_obstack for that objfile,
1513 and initialize the type name to that copy. There are places (mipsread.c
1514 in particular, where init_type is called with a NULL value for NAME). */
1517 init_type (code
, length
, flags
, name
, objfile
)
1518 enum type_code code
;
1522 struct objfile
*objfile
;
1524 register struct type
*type
;
1526 type
= alloc_type (objfile
);
1527 TYPE_CODE (type
) = code
;
1528 TYPE_LENGTH (type
) = length
;
1529 TYPE_FLAGS (type
) |= flags
;
1530 if ((name
!= NULL
) && (objfile
!= NULL
))
1533 obsavestring (name
, strlen (name
), &objfile
->type_obstack
);
1537 TYPE_NAME (type
) = name
;
1542 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
1544 INIT_CPLUS_SPECIFIC (type
);
1549 /* Look up a fundamental type for the specified objfile.
1550 May need to construct such a type if this is the first use.
1552 Some object file formats (ELF, COFF, etc) do not define fundamental
1553 types such as "int" or "double". Others (stabs for example), do
1554 define fundamental types.
1556 For the formats which don't provide fundamental types, gdb can create
1557 such types, using defaults reasonable for the current language and
1558 the current target machine.
1560 NOTE: This routine is obsolescent. Each debugging format reader
1561 should manage it's own fundamental types, either creating them from
1562 suitable defaults or reading them from the debugging information,
1563 whichever is appropriate. The DWARF reader has already been
1564 fixed to do this. Once the other readers are fixed, this routine
1565 will go away. Also note that fundamental types should be managed
1566 on a compilation unit basis in a multi-language environment, not
1567 on a linkage unit basis as is done here. */
1571 lookup_fundamental_type (objfile
, typeid)
1572 struct objfile
*objfile
;
1575 register struct type
**typep
;
1576 register int nbytes
;
1578 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1580 error ("internal error - invalid fundamental type id %d", typeid);
1583 /* If this is the first time we need a fundamental type for this objfile
1584 then we need to initialize the vector of type pointers. */
1586 if (objfile
->fundamental_types
== NULL
)
1588 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1589 objfile
->fundamental_types
= (struct type
**)
1590 obstack_alloc (&objfile
->type_obstack
, nbytes
);
1591 memset ((char *) objfile
->fundamental_types
, 0, nbytes
);
1592 OBJSTAT (objfile
, n_types
+= FT_NUM_MEMBERS
);
1595 /* Look for this particular type in the fundamental type vector. If one is
1596 not found, create and install one appropriate for the current language. */
1598 typep
= objfile
->fundamental_types
+ typeid;
1601 *typep
= create_fundamental_type (objfile
, typeid);
1611 /* FIXME: Should we return true for references as well as pointers? */
1615 && TYPE_CODE (t
) == TYPE_CODE_PTR
1616 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1620 is_integral_type (t
)
1626 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
1627 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
1628 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
1629 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
1630 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
1633 /* Chill varying string and arrays are represented as follows:
1635 struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
1637 Return true if TYPE is such a Chill varying type. */
1640 chill_varying_type (type
)
1643 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1644 || TYPE_NFIELDS (type
) != 2
1645 || strcmp (TYPE_FIELD_NAME (type
, 0), "__var_length") != 0)
1650 /* Check whether BASE is an ancestor or base class or DCLASS
1651 Return 1 if so, and 0 if not.
1652 Note: callers may want to check for identity of the types before
1653 calling this function -- identical types are considered to satisfy
1654 the ancestor relationship even if they're identical */
1657 is_ancestor (base
, dclass
)
1659 struct type
*dclass
;
1663 CHECK_TYPEDEF (base
);
1664 CHECK_TYPEDEF (dclass
);
1669 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1670 if (is_ancestor (base
, TYPE_BASECLASS (dclass
, i
)))
1678 /* See whether DCLASS has a virtual table. This routine is aimed at
1679 the HP/Taligent ANSI C++ runtime model, and may not work with other
1680 runtime models. Return 1 => Yes, 0 => No. */
1684 struct type
*dclass
;
1686 /* In the HP ANSI C++ runtime model, a class has a vtable only if it
1687 has virtual functions or virtual bases. */
1691 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1694 /* First check for the presence of virtual bases */
1695 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
1696 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1697 if (B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
))
1700 /* Next check for virtual functions */
1701 if (TYPE_FN_FIELDLISTS (dclass
))
1702 for (i
= 0; i
< TYPE_NFN_FIELDS (dclass
); i
++)
1703 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, i
), 0))
1706 /* Recurse on non-virtual bases to see if any of them needs a vtable */
1707 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
1708 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1709 if ((!B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
)) &&
1710 (has_vtable (TYPE_FIELD_TYPE (dclass
, i
))))
1713 /* Well, maybe we don't need a virtual table */
1717 /* Return a pointer to the "primary base class" of DCLASS.
1719 A NULL return indicates that DCLASS has no primary base, or that it
1720 couldn't be found (insufficient information).
1722 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
1723 and may not work with other runtime models. */
1726 primary_base_class (dclass
)
1727 struct type
*dclass
;
1729 /* In HP ANSI C++'s runtime model, a "primary base class" of a class
1730 is the first directly inherited, non-virtual base class that
1731 requires a virtual table */
1735 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1738 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1739 if (!TYPE_FIELD_VIRTUAL (dclass
, i
) &&
1740 has_vtable (TYPE_FIELD_TYPE (dclass
, i
)))
1741 return TYPE_FIELD_TYPE (dclass
, i
);
1746 /* Global manipulated by virtual_base_list[_aux]() */
1748 static struct vbase
*current_vbase_list
= NULL
;
1750 /* Return a pointer to a null-terminated list of struct vbase
1751 items. The vbasetype pointer of each item in the list points to the
1752 type information for a virtual base of the argument DCLASS.
1754 Helper function for virtual_base_list().
1755 Note: the list goes backward, right-to-left. virtual_base_list()
1756 copies the items out in reverse order. */
1759 virtual_base_list_aux (dclass
)
1760 struct type
*dclass
;
1762 struct vbase
*tmp_vbase
;
1765 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1768 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1770 /* Recurse on this ancestor, first */
1771 virtual_base_list_aux (TYPE_FIELD_TYPE (dclass
, i
));
1773 /* If this current base is itself virtual, add it to the list */
1774 if (BASETYPE_VIA_VIRTUAL (dclass
, i
))
1776 struct type
*basetype
= TYPE_FIELD_TYPE (dclass
, i
);
1778 /* Check if base already recorded */
1779 tmp_vbase
= current_vbase_list
;
1782 if (tmp_vbase
->vbasetype
== basetype
)
1783 break; /* found it */
1784 tmp_vbase
= tmp_vbase
->next
;
1787 if (!tmp_vbase
) /* normal exit from loop */
1789 /* Allocate new item for this virtual base */
1790 tmp_vbase
= (struct vbase
*) xmalloc (sizeof (struct vbase
));
1792 /* Stick it on at the end of the list */
1793 tmp_vbase
->vbasetype
= basetype
;
1794 tmp_vbase
->next
= current_vbase_list
;
1795 current_vbase_list
= tmp_vbase
;
1798 } /* for loop over bases */
1802 /* Compute the list of virtual bases in the right order. Virtual
1803 bases are laid out in the object's memory area in order of their
1804 occurrence in a depth-first, left-to-right search through the
1807 Argument DCLASS is the type whose virtual bases are required.
1808 Return value is the address of a null-terminated array of pointers
1809 to struct type items.
1811 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
1812 and may not work with other runtime models.
1814 This routine merely hands off the argument to virtual_base_list_aux()
1815 and then copies the result into an array to save space. */
1818 virtual_base_list (dclass
)
1819 struct type
*dclass
;
1821 register struct vbase
*tmp_vbase
;
1822 register struct vbase
*tmp_vbase_2
;
1825 struct type
**vbase_array
;
1827 current_vbase_list
= NULL
;
1828 virtual_base_list_aux (dclass
);
1830 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
1835 vbase_array
= (struct type
**) xmalloc ((count
+ 1) * sizeof (struct type
*));
1837 for (i
= count
- 1, tmp_vbase
= current_vbase_list
; i
>= 0; i
--, tmp_vbase
= tmp_vbase
->next
)
1838 vbase_array
[i
] = tmp_vbase
->vbasetype
;
1840 /* Get rid of constructed chain */
1841 tmp_vbase_2
= tmp_vbase
= current_vbase_list
;
1844 tmp_vbase
= tmp_vbase
->next
;
1846 tmp_vbase_2
= tmp_vbase
;
1849 vbase_array
[count
] = NULL
;
1853 /* Return the length of the virtual base list of the type DCLASS. */
1856 virtual_base_list_length (dclass
)
1857 struct type
*dclass
;
1860 register struct vbase
*tmp_vbase
;
1862 current_vbase_list
= NULL
;
1863 virtual_base_list_aux (dclass
);
1865 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
1870 /* Return the number of elements of the virtual base list of the type
1871 DCLASS, ignoring those appearing in the primary base (and its
1872 primary base, recursively). */
1875 virtual_base_list_length_skip_primaries (dclass
)
1876 struct type
*dclass
;
1879 register struct vbase
*tmp_vbase
;
1880 struct type
*primary
;
1882 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
1885 return virtual_base_list_length (dclass
);
1887 current_vbase_list
= NULL
;
1888 virtual_base_list_aux (dclass
);
1890 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; tmp_vbase
= tmp_vbase
->next
)
1892 if (virtual_base_index (tmp_vbase
->vbasetype
, primary
) >= 0)
1900 /* Return the index (position) of type BASE, which is a virtual base
1901 class of DCLASS, in the latter's virtual base list. A return of -1
1902 indicates "not found" or a problem. */
1905 virtual_base_index (base
, dclass
)
1907 struct type
*dclass
;
1909 register struct type
*vbase
;
1912 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
1913 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
1917 vbase
= TYPE_VIRTUAL_BASE_LIST (dclass
)[0];
1922 vbase
= TYPE_VIRTUAL_BASE_LIST (dclass
)[++i
];
1925 return vbase
? i
: -1;
1930 /* Return the index (position) of type BASE, which is a virtual base
1931 class of DCLASS, in the latter's virtual base list. Skip over all
1932 bases that may appear in the virtual base list of the primary base
1933 class of DCLASS (recursively). A return of -1 indicates "not
1934 found" or a problem. */
1937 virtual_base_index_skip_primaries (base
, dclass
)
1939 struct type
*dclass
;
1941 register struct type
*vbase
;
1943 struct type
*primary
;
1945 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
1946 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
1949 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
1953 vbase
= TYPE_VIRTUAL_BASE_LIST (dclass
)[0];
1956 if (!primary
|| (virtual_base_index_skip_primaries (vbase
, primary
) < 0))
1960 vbase
= TYPE_VIRTUAL_BASE_LIST (dclass
)[++i
];
1963 return vbase
? j
: -1;
1966 /* Return position of a derived class DCLASS in the list of
1967 * primary bases starting with the remotest ancestor.
1968 * Position returned is 0-based. */
1971 class_index_in_primary_list (dclass
)
1972 struct type
*dclass
;
1974 struct type
*pbc
; /* primary base class */
1976 /* Simply recurse on primary base */
1977 pbc
= TYPE_PRIMARY_BASE (dclass
);
1979 return 1 + class_index_in_primary_list (pbc
);
1984 /* Return a count of the number of virtual functions a type has.
1985 * This includes all the virtual functions it inherits from its
1989 /* pai: FIXME This doesn't do the right thing: count redefined virtual
1990 * functions only once (latest redefinition)
1994 count_virtual_fns (dclass
)
1995 struct type
*dclass
;
1997 int fn
, oi
; /* function and overloaded instance indices */
1998 int vfuncs
; /* count to return */
2000 /* recurse on bases that can share virtual table */
2001 struct type
*pbc
= primary_base_class (dclass
);
2003 vfuncs
= count_virtual_fns (pbc
);
2005 for (fn
= 0; fn
< TYPE_NFN_FIELDS (dclass
); fn
++)
2006 for (oi
= 0; oi
< TYPE_FN_FIELDLIST_LENGTH (dclass
, fn
); oi
++)
2007 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, fn
), oi
))
2015 /* Functions for overload resolution begin here */
2017 /* Compare two badness vectors A and B and return the result.
2018 * 0 => A and B are identical
2019 * 1 => A and B are incomparable
2020 * 2 => A is better than B
2021 * 3 => A is worse than B */
2024 compare_badness (a
, b
)
2025 struct badness_vector
*a
;
2026 struct badness_vector
*b
;
2030 short found_pos
= 0; /* any positives in c? */
2031 short found_neg
= 0; /* any negatives in c? */
2033 /* differing lengths => incomparable */
2034 if (a
->length
!= b
->length
)
2037 /* Subtract b from a */
2038 for (i
= 0; i
< a
->length
; i
++)
2040 tmp
= a
->rank
[i
] - b
->rank
[i
];
2050 return 1; /* incomparable */
2052 return 3; /* A > B */
2058 return 2; /* A < B */
2060 return 0; /* A == B */
2064 /* Rank a function by comparing its parameter types (PARMS, length NPARMS),
2065 * to the types of an argument list (ARGS, length NARGS).
2066 * Return a pointer to a badness vector. This has NARGS + 1 entries. */
2068 struct badness_vector
*
2069 rank_function (parms
, nparms
, args
, nargs
)
2070 struct type
**parms
;
2076 struct badness_vector
*bv
;
2077 int min_len
= nparms
< nargs
? nparms
: nargs
;
2079 bv
= xmalloc (sizeof (struct badness_vector
));
2080 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank */
2081 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
2083 /* First compare the lengths of the supplied lists.
2084 * If there is a mismatch, set it to a high value. */
2086 /* pai/1997-06-03 FIXME: when we have debug info about default
2087 * arguments and ellipsis parameter lists, we should consider those
2088 * and rank the length-match more finely. */
2090 LENGTH_MATCH (bv
) = (nargs
!= nparms
) ? LENGTH_MISMATCH_BADNESS
: 0;
2092 /* Now rank all the parameters of the candidate function */
2093 for (i
= 1; i
<= min_len
; i
++)
2094 bv
->rank
[i
] = rank_one_type (parms
[i
- 1], args
[i
- 1]);
2096 /* If more arguments than parameters, add dummy entries */
2097 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2098 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2103 /* Compare one type (PARM) for compatibility with another (ARG).
2104 * PARM is intended to be the parameter type of a function; and
2105 * ARG is the supplied argument's type. This function tests if
2106 * the latter can be converted to the former.
2108 * Return 0 if they are identical types;
2109 * Otherwise, return an integer which corresponds to how compatible
2110 * PARM is to ARG. The higher the return value, the worse the match.
2111 * Generally the "bad" conversions are all uniformly assigned a 100 */
2114 rank_one_type (parm
, arg
)
2118 /* Identical type pointers */
2119 /* However, this still doesn't catch all cases of same type for arg
2120 * and param. The reason is that builtin types are different from
2121 * the same ones constructed from the object. */
2125 /* Resolve typedefs */
2126 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2127 parm
= check_typedef (parm
);
2128 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2129 arg
= check_typedef (arg
);
2131 /* Check if identical after resolving typedefs */
2136 /* Debugging only */
2137 printf ("------ Arg is %s [%d], parm is %s [%d]\n",
2138 TYPE_NAME (arg
), TYPE_CODE (arg
), TYPE_NAME (parm
), TYPE_CODE (parm
));
2141 /* x -> y means arg of type x being supplied for parameter of type y */
2143 switch (TYPE_CODE (parm
))
2146 switch (TYPE_CODE (arg
))
2149 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2150 return VOID_PTR_CONVERSION_BADNESS
;
2152 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2153 case TYPE_CODE_ARRAY
:
2154 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2155 case TYPE_CODE_FUNC
:
2156 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
);
2158 case TYPE_CODE_ENUM
:
2159 case TYPE_CODE_CHAR
:
2160 case TYPE_CODE_RANGE
:
2161 case TYPE_CODE_BOOL
:
2162 return POINTER_CONVERSION_BADNESS
;
2164 return INCOMPATIBLE_TYPE_BADNESS
;
2166 case TYPE_CODE_ARRAY
:
2167 switch (TYPE_CODE (arg
))
2170 case TYPE_CODE_ARRAY
:
2171 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2173 return INCOMPATIBLE_TYPE_BADNESS
;
2175 case TYPE_CODE_FUNC
:
2176 switch (TYPE_CODE (arg
))
2178 case TYPE_CODE_PTR
: /* funcptr -> func */
2179 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
));
2181 return INCOMPATIBLE_TYPE_BADNESS
;
2184 switch (TYPE_CODE (arg
))
2187 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2189 /* Deal with signed, unsigned, and plain chars and
2190 signed and unsigned ints */
2191 if (TYPE_NOSIGN (parm
))
2193 /* This case only for character types */
2194 if (TYPE_NOSIGN (arg
)) /* plain char -> plain char */
2197 return INTEGER_COERCION_BADNESS
; /* signed/unsigned char -> plain char */
2199 else if (TYPE_UNSIGNED (parm
))
2201 if (TYPE_UNSIGNED (arg
))
2203 if (!strcmp (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2204 return 0; /* unsigned int -> unsigned int, or unsigned long -> unsigned long */
2205 else if (!strcmp (TYPE_NAME (arg
), "int") && !strcmp (TYPE_NAME (parm
), "long"))
2206 return INTEGER_PROMOTION_BADNESS
; /* unsigned int -> unsigned long */
2208 return INTEGER_COERCION_BADNESS
; /* unsigned long -> unsigned int */
2212 if (!strcmp (TYPE_NAME (arg
), "long") && !strcmp (TYPE_NAME (parm
), "int"))
2213 return INTEGER_COERCION_BADNESS
; /* signed long -> unsigned int */
2215 return INTEGER_CONVERSION_BADNESS
; /* signed int/long -> unsigned int/long */
2218 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2220 if (!strcmp (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2222 else if (!strcmp (TYPE_NAME (arg
), "int") && !strcmp (TYPE_NAME (parm
), "long"))
2223 return INTEGER_PROMOTION_BADNESS
;
2225 return INTEGER_COERCION_BADNESS
;
2228 return INTEGER_COERCION_BADNESS
;
2230 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2231 return INTEGER_PROMOTION_BADNESS
;
2233 return INTEGER_COERCION_BADNESS
;
2234 case TYPE_CODE_ENUM
:
2235 case TYPE_CODE_CHAR
:
2236 case TYPE_CODE_RANGE
:
2237 case TYPE_CODE_BOOL
:
2238 return INTEGER_PROMOTION_BADNESS
;
2240 return INT_FLOAT_CONVERSION_BADNESS
;
2242 return NS_POINTER_CONVERSION_BADNESS
;
2244 return INCOMPATIBLE_TYPE_BADNESS
;
2247 case TYPE_CODE_ENUM
:
2248 switch (TYPE_CODE (arg
))
2251 case TYPE_CODE_CHAR
:
2252 case TYPE_CODE_RANGE
:
2253 case TYPE_CODE_BOOL
:
2254 case TYPE_CODE_ENUM
:
2255 return INTEGER_COERCION_BADNESS
;
2257 return INT_FLOAT_CONVERSION_BADNESS
;
2259 return INCOMPATIBLE_TYPE_BADNESS
;
2262 case TYPE_CODE_CHAR
:
2263 switch (TYPE_CODE (arg
))
2265 case TYPE_CODE_RANGE
:
2266 case TYPE_CODE_BOOL
:
2267 case TYPE_CODE_ENUM
:
2268 return INTEGER_COERCION_BADNESS
;
2270 return INT_FLOAT_CONVERSION_BADNESS
;
2272 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2273 return INTEGER_COERCION_BADNESS
;
2274 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2275 return INTEGER_PROMOTION_BADNESS
;
2276 /* >>> !! else fall through !! <<< */
2277 case TYPE_CODE_CHAR
:
2278 /* Deal with signed, unsigned, and plain chars for C++
2279 and with int cases falling through from previous case */
2280 if (TYPE_NOSIGN (parm
))
2282 if (TYPE_NOSIGN (arg
))
2285 return INTEGER_COERCION_BADNESS
;
2287 else if (TYPE_UNSIGNED (parm
))
2289 if (TYPE_UNSIGNED (arg
))
2292 return INTEGER_PROMOTION_BADNESS
;
2294 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2297 return INTEGER_COERCION_BADNESS
;
2299 return INCOMPATIBLE_TYPE_BADNESS
;
2302 case TYPE_CODE_RANGE
:
2303 switch (TYPE_CODE (arg
))
2306 case TYPE_CODE_CHAR
:
2307 case TYPE_CODE_RANGE
:
2308 case TYPE_CODE_BOOL
:
2309 case TYPE_CODE_ENUM
:
2310 return INTEGER_COERCION_BADNESS
;
2312 return INT_FLOAT_CONVERSION_BADNESS
;
2314 return INCOMPATIBLE_TYPE_BADNESS
;
2317 case TYPE_CODE_BOOL
:
2318 switch (TYPE_CODE (arg
))
2321 case TYPE_CODE_CHAR
:
2322 case TYPE_CODE_RANGE
:
2323 case TYPE_CODE_ENUM
:
2326 return BOOLEAN_CONVERSION_BADNESS
;
2327 case TYPE_CODE_BOOL
:
2330 return INCOMPATIBLE_TYPE_BADNESS
;
2334 switch (TYPE_CODE (arg
))
2337 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2338 return FLOAT_PROMOTION_BADNESS
;
2339 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2342 return FLOAT_CONVERSION_BADNESS
;
2344 case TYPE_CODE_BOOL
:
2345 case TYPE_CODE_ENUM
:
2346 case TYPE_CODE_RANGE
:
2347 case TYPE_CODE_CHAR
:
2348 return INT_FLOAT_CONVERSION_BADNESS
;
2350 return INCOMPATIBLE_TYPE_BADNESS
;
2353 case TYPE_CODE_COMPLEX
:
2354 switch (TYPE_CODE (arg
))
2355 { /* Strictly not needed for C++, but... */
2357 return FLOAT_PROMOTION_BADNESS
;
2358 case TYPE_CODE_COMPLEX
:
2361 return INCOMPATIBLE_TYPE_BADNESS
;
2364 case TYPE_CODE_STRUCT
:
2365 /* currently same as TYPE_CODE_CLASS */
2366 switch (TYPE_CODE (arg
))
2368 case TYPE_CODE_STRUCT
:
2369 /* Check for derivation */
2370 if (is_ancestor (parm
, arg
))
2371 return BASE_CONVERSION_BADNESS
;
2372 /* else fall through */
2374 return INCOMPATIBLE_TYPE_BADNESS
;
2377 case TYPE_CODE_UNION
:
2378 switch (TYPE_CODE (arg
))
2380 case TYPE_CODE_UNION
:
2382 return INCOMPATIBLE_TYPE_BADNESS
;
2385 case TYPE_CODE_MEMBER
:
2386 switch (TYPE_CODE (arg
))
2389 return INCOMPATIBLE_TYPE_BADNESS
;
2392 case TYPE_CODE_METHOD
:
2393 switch (TYPE_CODE (arg
))
2397 return INCOMPATIBLE_TYPE_BADNESS
;
2401 switch (TYPE_CODE (arg
))
2405 return INCOMPATIBLE_TYPE_BADNESS
;
2410 switch (TYPE_CODE (arg
))
2414 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0), TYPE_FIELD_TYPE (arg
, 0));
2416 return INCOMPATIBLE_TYPE_BADNESS
;
2419 case TYPE_CODE_VOID
:
2421 return INCOMPATIBLE_TYPE_BADNESS
;
2422 } /* switch (TYPE_CODE (arg)) */
2426 /* End of functions for overload resolution */
2429 print_bit_vector (bits
, nbits
)
2435 for (bitno
= 0; bitno
< nbits
; bitno
++)
2437 if ((bitno
% 8) == 0)
2439 puts_filtered (" ");
2441 if (B_TST (bits
, bitno
))
2443 printf_filtered ("1");
2447 printf_filtered ("0");
2452 /* The args list is a strange beast. It is either terminated by a NULL
2453 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
2454 type for normal fixed argcount functions. (FIXME someday)
2455 Also note the first arg should be the "this" pointer, we may not want to
2456 include it since we may get into a infinitely recursive situation. */
2459 print_arg_types (args
, spaces
)
2465 while (*args
!= NULL
)
2467 recursive_dump_type (*args
, spaces
+ 2);
2468 if ((*args
++)->code
== TYPE_CODE_VOID
)
2477 dump_fn_fieldlists (type
, spaces
)
2485 printfi_filtered (spaces
, "fn_fieldlists ");
2486 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2487 printf_filtered ("\n");
2488 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2490 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2491 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2493 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2494 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2496 printf_filtered (") length %d\n",
2497 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2498 for (overload_idx
= 0;
2499 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2502 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2504 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2505 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2507 printf_filtered (")\n");
2508 printfi_filtered (spaces
+ 8, "type ");
2509 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
2510 printf_filtered ("\n");
2512 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2515 printfi_filtered (spaces
+ 8, "args ");
2516 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
2517 printf_filtered ("\n");
2519 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
), spaces
);
2520 printfi_filtered (spaces
+ 8, "fcontext ");
2521 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2523 printf_filtered ("\n");
2525 printfi_filtered (spaces
+ 8, "is_const %d\n",
2526 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2527 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2528 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2529 printfi_filtered (spaces
+ 8, "is_private %d\n",
2530 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2531 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2532 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2533 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2534 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2535 printfi_filtered (spaces
+ 8, "voffset %u\n",
2536 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2542 print_cplus_stuff (type
, spaces
)
2546 printfi_filtered (spaces
, "n_baseclasses %d\n",
2547 TYPE_N_BASECLASSES (type
));
2548 printfi_filtered (spaces
, "nfn_fields %d\n",
2549 TYPE_NFN_FIELDS (type
));
2550 printfi_filtered (spaces
, "nfn_fields_total %d\n",
2551 TYPE_NFN_FIELDS_TOTAL (type
));
2552 if (TYPE_N_BASECLASSES (type
) > 0)
2554 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2555 TYPE_N_BASECLASSES (type
));
2556 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
2557 printf_filtered (")");
2559 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2560 TYPE_N_BASECLASSES (type
));
2561 puts_filtered ("\n");
2563 if (TYPE_NFIELDS (type
) > 0)
2565 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2567 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
2568 TYPE_NFIELDS (type
));
2569 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
2570 printf_filtered (")");
2571 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2572 TYPE_NFIELDS (type
));
2573 puts_filtered ("\n");
2575 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2577 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
2578 TYPE_NFIELDS (type
));
2579 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
2580 printf_filtered (")");
2581 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2582 TYPE_NFIELDS (type
));
2583 puts_filtered ("\n");
2586 if (TYPE_NFN_FIELDS (type
) > 0)
2588 dump_fn_fieldlists (type
, spaces
);
2592 static struct obstack dont_print_type_obstack
;
2595 recursive_dump_type (type
, spaces
)
2602 obstack_begin (&dont_print_type_obstack
, 0);
2604 if (TYPE_NFIELDS (type
) > 0
2605 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
2607 struct type
**first_dont_print
2608 = (struct type
**) obstack_base (&dont_print_type_obstack
);
2610 int i
= (struct type
**) obstack_next_free (&dont_print_type_obstack
)
2615 if (type
== first_dont_print
[i
])
2617 printfi_filtered (spaces
, "type node ");
2618 gdb_print_host_address (type
, gdb_stdout
);
2619 printf_filtered (" <same as already seen type>\n");
2624 obstack_ptr_grow (&dont_print_type_obstack
, type
);
2627 printfi_filtered (spaces
, "type node ");
2628 gdb_print_host_address (type
, gdb_stdout
);
2629 printf_filtered ("\n");
2630 printfi_filtered (spaces
, "name '%s' (",
2631 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
2632 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
2633 printf_filtered (")\n");
2634 if (TYPE_TAG_NAME (type
) != NULL
)
2636 printfi_filtered (spaces
, "tagname '%s' (",
2637 TYPE_TAG_NAME (type
));
2638 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
2639 printf_filtered (")\n");
2641 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
2642 switch (TYPE_CODE (type
))
2644 case TYPE_CODE_UNDEF
:
2645 printf_filtered ("(TYPE_CODE_UNDEF)");
2648 printf_filtered ("(TYPE_CODE_PTR)");
2650 case TYPE_CODE_ARRAY
:
2651 printf_filtered ("(TYPE_CODE_ARRAY)");
2653 case TYPE_CODE_STRUCT
:
2654 printf_filtered ("(TYPE_CODE_STRUCT)");
2656 case TYPE_CODE_UNION
:
2657 printf_filtered ("(TYPE_CODE_UNION)");
2659 case TYPE_CODE_ENUM
:
2660 printf_filtered ("(TYPE_CODE_ENUM)");
2662 case TYPE_CODE_FUNC
:
2663 printf_filtered ("(TYPE_CODE_FUNC)");
2666 printf_filtered ("(TYPE_CODE_INT)");
2669 printf_filtered ("(TYPE_CODE_FLT)");
2671 case TYPE_CODE_VOID
:
2672 printf_filtered ("(TYPE_CODE_VOID)");
2675 printf_filtered ("(TYPE_CODE_SET)");
2677 case TYPE_CODE_RANGE
:
2678 printf_filtered ("(TYPE_CODE_RANGE)");
2680 case TYPE_CODE_STRING
:
2681 printf_filtered ("(TYPE_CODE_STRING)");
2683 case TYPE_CODE_ERROR
:
2684 printf_filtered ("(TYPE_CODE_ERROR)");
2686 case TYPE_CODE_MEMBER
:
2687 printf_filtered ("(TYPE_CODE_MEMBER)");
2689 case TYPE_CODE_METHOD
:
2690 printf_filtered ("(TYPE_CODE_METHOD)");
2693 printf_filtered ("(TYPE_CODE_REF)");
2695 case TYPE_CODE_CHAR
:
2696 printf_filtered ("(TYPE_CODE_CHAR)");
2698 case TYPE_CODE_BOOL
:
2699 printf_filtered ("(TYPE_CODE_BOOL)");
2701 case TYPE_CODE_TYPEDEF
:
2702 printf_filtered ("(TYPE_CODE_TYPEDEF)");
2705 printf_filtered ("(UNKNOWN TYPE CODE)");
2708 puts_filtered ("\n");
2709 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
2710 printfi_filtered (spaces
, "objfile ");
2711 gdb_print_host_address (TYPE_OBJFILE (type
), gdb_stdout
);
2712 printf_filtered ("\n");
2713 printfi_filtered (spaces
, "target_type ");
2714 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
2715 printf_filtered ("\n");
2716 if (TYPE_TARGET_TYPE (type
) != NULL
)
2718 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
2720 printfi_filtered (spaces
, "pointer_type ");
2721 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
2722 printf_filtered ("\n");
2723 printfi_filtered (spaces
, "reference_type ");
2724 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
2725 printf_filtered ("\n");
2726 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
2727 if (TYPE_FLAGS (type
) & TYPE_FLAG_UNSIGNED
)
2729 puts_filtered (" TYPE_FLAG_UNSIGNED");
2731 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
2733 puts_filtered (" TYPE_FLAG_STUB");
2735 puts_filtered ("\n");
2736 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
2737 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
2738 puts_filtered ("\n");
2739 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
2741 printfi_filtered (spaces
+ 2,
2742 "[%d] bitpos %d bitsize %d type ",
2743 idx
, TYPE_FIELD_BITPOS (type
, idx
),
2744 TYPE_FIELD_BITSIZE (type
, idx
));
2745 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
2746 printf_filtered (" name '%s' (",
2747 TYPE_FIELD_NAME (type
, idx
) != NULL
2748 ? TYPE_FIELD_NAME (type
, idx
)
2750 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
2751 printf_filtered (")\n");
2752 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
2754 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
2757 printfi_filtered (spaces
, "vptr_basetype ");
2758 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
2759 puts_filtered ("\n");
2760 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
2762 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
2764 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
2765 switch (TYPE_CODE (type
))
2767 case TYPE_CODE_METHOD
:
2768 case TYPE_CODE_FUNC
:
2769 printfi_filtered (spaces
, "arg_types ");
2770 gdb_print_host_address (TYPE_ARG_TYPES (type
), gdb_stdout
);
2771 puts_filtered ("\n");
2772 print_arg_types (TYPE_ARG_TYPES (type
), spaces
);
2775 case TYPE_CODE_STRUCT
:
2776 printfi_filtered (spaces
, "cplus_stuff ");
2777 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
2778 puts_filtered ("\n");
2779 print_cplus_stuff (type
, spaces
);
2783 /* We have to pick one of the union types to be able print and test
2784 the value. Pick cplus_struct_type, even though we know it isn't
2785 any particular one. */
2786 printfi_filtered (spaces
, "type_specific ");
2787 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
2788 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
2790 printf_filtered (" (unknown data form)");
2792 printf_filtered ("\n");
2797 obstack_free (&dont_print_type_obstack
, NULL
);
2800 static void build_gdbtypes
PARAMS ((void));
2805 init_type (TYPE_CODE_VOID
, 1,
2807 "void", (struct objfile
*) NULL
);
2809 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
2811 "char", (struct objfile
*) NULL
);
2812 TYPE_FLAGS (builtin_type_char
) |= TYPE_FLAG_NOSIGN
;
2813 builtin_type_true_char
=
2814 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
2816 "true character", (struct objfile
*) NULL
);
2817 builtin_type_signed_char
=
2818 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
2820 "signed char", (struct objfile
*) NULL
);
2821 builtin_type_unsigned_char
=
2822 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
2824 "unsigned char", (struct objfile
*) NULL
);
2825 builtin_type_short
=
2826 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
2828 "short", (struct objfile
*) NULL
);
2829 builtin_type_unsigned_short
=
2830 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
2832 "unsigned short", (struct objfile
*) NULL
);
2834 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
2836 "int", (struct objfile
*) NULL
);
2837 builtin_type_unsigned_int
=
2838 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
2840 "unsigned int", (struct objfile
*) NULL
);
2842 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
2844 "long", (struct objfile
*) NULL
);
2845 builtin_type_unsigned_long
=
2846 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
2848 "unsigned long", (struct objfile
*) NULL
);
2849 builtin_type_long_long
=
2850 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
2852 "long long", (struct objfile
*) NULL
);
2853 builtin_type_unsigned_long_long
=
2854 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
2856 "unsigned long long", (struct objfile
*) NULL
);
2857 builtin_type_float
=
2858 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
2860 "float", (struct objfile
*) NULL
);
2861 builtin_type_double
=
2862 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
2864 "double", (struct objfile
*) NULL
);
2865 builtin_type_long_double
=
2866 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
2868 "long double", (struct objfile
*) NULL
);
2869 builtin_type_complex
=
2870 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
2872 "complex", (struct objfile
*) NULL
);
2873 TYPE_TARGET_TYPE (builtin_type_complex
) = builtin_type_float
;
2874 builtin_type_double_complex
=
2875 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
2877 "double complex", (struct objfile
*) NULL
);
2878 TYPE_TARGET_TYPE (builtin_type_double_complex
) = builtin_type_double
;
2879 builtin_type_string
=
2880 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
2882 "string", (struct objfile
*) NULL
);
2884 init_type (TYPE_CODE_INT
, 8 / 8,
2886 "int8_t", (struct objfile
*) NULL
);
2887 builtin_type_uint8
=
2888 init_type (TYPE_CODE_INT
, 8 / 8,
2890 "uint8_t", (struct objfile
*) NULL
);
2891 builtin_type_int16
=
2892 init_type (TYPE_CODE_INT
, 16 / 8,
2894 "int16_t", (struct objfile
*) NULL
);
2895 builtin_type_uint16
=
2896 init_type (TYPE_CODE_INT
, 16 / 8,
2898 "uint16_t", (struct objfile
*) NULL
);
2899 builtin_type_int32
=
2900 init_type (TYPE_CODE_INT
, 32 / 8,
2902 "int32_t", (struct objfile
*) NULL
);
2903 builtin_type_uint32
=
2904 init_type (TYPE_CODE_INT
, 32 / 8,
2906 "uint32_t", (struct objfile
*) NULL
);
2907 builtin_type_int64
=
2908 init_type (TYPE_CODE_INT
, 64 / 8,
2910 "int64_t", (struct objfile
*) NULL
);
2911 builtin_type_uint64
=
2912 init_type (TYPE_CODE_INT
, 64 / 8,
2914 "uint64_t", (struct objfile
*) NULL
);
2916 init_type (TYPE_CODE_BOOL
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
2918 "bool", (struct objfile
*) NULL
);
2920 /* Add user knob for controlling resolution of opaque types */
2922 (add_set_cmd ("opaque-type-resolution", class_support
, var_boolean
, (char *) &opaque_type_resolution
,
2923 "Set resolution of opaque struct/class/union types (if set before loading symbols).",
2926 opaque_type_resolution
= 1;
2931 extern void _initialize_gdbtypes
PARAMS ((void));
2933 _initialize_gdbtypes ()
2937 /* FIXME - For the moment, handle types by swapping them in and out.
2938 Should be using the per-architecture data-pointer and a large
2940 register_gdbarch_swap (&builtin_type_void
, sizeof (struct type
*), NULL
);
2941 register_gdbarch_swap (&builtin_type_char
, sizeof (struct type
*), NULL
);
2942 register_gdbarch_swap (&builtin_type_short
, sizeof (struct type
*), NULL
);
2943 register_gdbarch_swap (&builtin_type_int
, sizeof (struct type
*), NULL
);
2944 register_gdbarch_swap (&builtin_type_long
, sizeof (struct type
*), NULL
);
2945 register_gdbarch_swap (&builtin_type_long_long
, sizeof (struct type
*), NULL
);
2946 register_gdbarch_swap (&builtin_type_signed_char
, sizeof (struct type
*), NULL
);
2947 register_gdbarch_swap (&builtin_type_unsigned_char
, sizeof (struct type
*), NULL
);
2948 register_gdbarch_swap (&builtin_type_unsigned_short
, sizeof (struct type
*), NULL
);
2949 register_gdbarch_swap (&builtin_type_unsigned_int
, sizeof (struct type
*), NULL
);
2950 register_gdbarch_swap (&builtin_type_unsigned_long
, sizeof (struct type
*), NULL
);
2951 register_gdbarch_swap (&builtin_type_unsigned_long_long
, sizeof (struct type
*), NULL
);
2952 register_gdbarch_swap (&builtin_type_float
, sizeof (struct type
*), NULL
);
2953 register_gdbarch_swap (&builtin_type_double
, sizeof (struct type
*), NULL
);
2954 register_gdbarch_swap (&builtin_type_long_double
, sizeof (struct type
*), NULL
);
2955 register_gdbarch_swap (&builtin_type_complex
, sizeof (struct type
*), NULL
);
2956 register_gdbarch_swap (&builtin_type_double_complex
, sizeof (struct type
*), NULL
);
2957 register_gdbarch_swap (&builtin_type_string
, sizeof (struct type
*), NULL
);
2958 register_gdbarch_swap (&builtin_type_int8
, sizeof (struct type
*), NULL
);
2959 register_gdbarch_swap (&builtin_type_uint8
, sizeof (struct type
*), NULL
);
2960 register_gdbarch_swap (&builtin_type_int16
, sizeof (struct type
*), NULL
);
2961 register_gdbarch_swap (&builtin_type_uint16
, sizeof (struct type
*), NULL
);
2962 register_gdbarch_swap (&builtin_type_int32
, sizeof (struct type
*), NULL
);
2963 register_gdbarch_swap (&builtin_type_uint32
, sizeof (struct type
*), NULL
);
2964 register_gdbarch_swap (&builtin_type_int64
, sizeof (struct type
*), NULL
);
2965 register_gdbarch_swap (&builtin_type_uint64
, sizeof (struct type
*), NULL
);
2966 register_gdbarch_swap (NULL
, 0, build_gdbtypes
);