1 /* Support routines for manipulating internal types for GDB.
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
6 Contributed by Cygnus Support, using pieces from other GDB modules.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
30 #include "expression.h"
35 #include "complaints.h"
39 #include "gdb_assert.h"
42 /* These variables point to the objects
43 representing the predefined C data types. */
45 struct type *builtin_type_int0;
46 struct type *builtin_type_int8;
47 struct type *builtin_type_uint8;
48 struct type *builtin_type_int16;
49 struct type *builtin_type_uint16;
50 struct type *builtin_type_int32;
51 struct type *builtin_type_uint32;
52 struct type *builtin_type_int64;
53 struct type *builtin_type_uint64;
54 struct type *builtin_type_int128;
55 struct type *builtin_type_uint128;
57 /* Floatformat pairs. */
58 const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN] = {
59 &floatformat_ieee_single_big,
60 &floatformat_ieee_single_little
62 const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN] = {
63 &floatformat_ieee_double_big,
64 &floatformat_ieee_double_little
66 const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN] = {
67 &floatformat_ieee_double_big,
68 &floatformat_ieee_double_littlebyte_bigword
70 const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN] = {
71 &floatformat_i387_ext,
74 const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN] = {
75 &floatformat_m68881_ext,
76 &floatformat_m68881_ext
78 const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN] = {
79 &floatformat_arm_ext_big,
80 &floatformat_arm_ext_littlebyte_bigword
82 const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN] = {
83 &floatformat_ia64_spill_big,
84 &floatformat_ia64_spill_little
86 const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN] = {
87 &floatformat_ia64_quad_big,
88 &floatformat_ia64_quad_little
90 const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN] = {
94 const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN] = {
99 struct type *builtin_type_ieee_single;
100 struct type *builtin_type_ieee_double;
101 struct type *builtin_type_i387_ext;
102 struct type *builtin_type_m68881_ext;
103 struct type *builtin_type_arm_ext;
104 struct type *builtin_type_ia64_spill;
105 struct type *builtin_type_ia64_quad;
108 int opaque_type_resolution = 1;
110 show_opaque_type_resolution (struct ui_file *file, int from_tty,
111 struct cmd_list_element *c,
114 fprintf_filtered (file, _("\
115 Resolution of opaque struct/class/union types (if set before loading symbols) is %s.\n"),
119 int overload_debug = 0;
121 show_overload_debug (struct ui_file *file, int from_tty,
122 struct cmd_list_element *c, const char *value)
124 fprintf_filtered (file, _("Debugging of C++ overloading is %s.\n"),
132 }; /* Maximum extension is 128! FIXME */
134 static void print_bit_vector (B_TYPE *, int);
135 static void print_arg_types (struct field *, int, int);
136 static void dump_fn_fieldlists (struct type *, int);
137 static void print_cplus_stuff (struct type *, int);
138 static void virtual_base_list_aux (struct type *dclass);
141 /* Alloc a new type structure and fill it with some defaults. If
142 OBJFILE is non-NULL, then allocate the space for the type structure
143 in that objfile's objfile_obstack. Otherwise allocate the new type
144 structure by xmalloc () (for permanent types). */
147 alloc_type (struct objfile *objfile)
151 /* Alloc the structure and start off with all fields zeroed. */
155 type = xmalloc (sizeof (struct type));
156 memset (type, 0, sizeof (struct type));
157 TYPE_MAIN_TYPE (type) = xmalloc (sizeof (struct main_type));
161 type = obstack_alloc (&objfile->objfile_obstack,
162 sizeof (struct type));
163 memset (type, 0, sizeof (struct type));
164 TYPE_MAIN_TYPE (type) = obstack_alloc (&objfile->objfile_obstack,
165 sizeof (struct main_type));
166 OBJSTAT (objfile, n_types++);
168 memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
170 /* Initialize the fields that might not be zero. */
172 TYPE_CODE (type) = TYPE_CODE_UNDEF;
173 TYPE_OBJFILE (type) = objfile;
174 TYPE_VPTR_FIELDNO (type) = -1;
175 TYPE_CHAIN (type) = type; /* Chain back to itself. */
180 /* Alloc a new type instance structure, fill it with some defaults,
181 and point it at OLDTYPE. Allocate the new type instance from the
182 same place as OLDTYPE. */
185 alloc_type_instance (struct type *oldtype)
189 /* Allocate the structure. */
191 if (TYPE_OBJFILE (oldtype) == NULL)
193 type = xmalloc (sizeof (struct type));
194 memset (type, 0, sizeof (struct type));
198 type = obstack_alloc (&TYPE_OBJFILE (oldtype)->objfile_obstack,
199 sizeof (struct type));
200 memset (type, 0, sizeof (struct type));
202 TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype);
204 TYPE_CHAIN (type) = type; /* Chain back to itself for now. */
209 /* Clear all remnants of the previous type at TYPE, in preparation for
210 replacing it with something else. */
212 smash_type (struct type *type)
214 memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
216 /* For now, delete the rings. */
217 TYPE_CHAIN (type) = type;
219 /* For now, leave the pointer/reference types alone. */
222 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
223 to a pointer to memory where the pointer type should be stored.
224 If *TYPEPTR is zero, update it to point to the pointer type we return.
225 We allocate new memory if needed. */
228 make_pointer_type (struct type *type, struct type **typeptr)
230 struct type *ntype; /* New type */
231 struct objfile *objfile;
234 ntype = TYPE_POINTER_TYPE (type);
239 return ntype; /* Don't care about alloc,
240 and have new type. */
241 else if (*typeptr == 0)
243 *typeptr = ntype; /* Tracking alloc, and have new type. */
248 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
250 ntype = alloc_type (TYPE_OBJFILE (type));
254 else /* We have storage, but need to reset it. */
257 objfile = TYPE_OBJFILE (ntype);
258 chain = TYPE_CHAIN (ntype);
260 TYPE_CHAIN (ntype) = chain;
261 TYPE_OBJFILE (ntype) = objfile;
264 TYPE_TARGET_TYPE (ntype) = type;
265 TYPE_POINTER_TYPE (type) = ntype;
267 /* FIXME! Assume the machine has only one representation for
270 TYPE_LENGTH (ntype) =
271 gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT;
272 TYPE_CODE (ntype) = TYPE_CODE_PTR;
274 /* Mark pointers as unsigned. The target converts between pointers
275 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
276 gdbarch_address_to_pointer. */
277 TYPE_FLAGS (ntype) |= TYPE_FLAG_UNSIGNED;
279 if (!TYPE_POINTER_TYPE (type)) /* Remember it, if don't have one. */
280 TYPE_POINTER_TYPE (type) = ntype;
282 /* Update the length of all the other variants of this type. */
283 chain = TYPE_CHAIN (ntype);
284 while (chain != ntype)
286 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
287 chain = TYPE_CHAIN (chain);
293 /* Given a type TYPE, return a type of pointers to that type.
294 May need to construct such a type if this is the first use. */
297 lookup_pointer_type (struct type *type)
299 return make_pointer_type (type, (struct type **) 0);
302 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
303 points to a pointer to memory where the reference type should be
304 stored. If *TYPEPTR is zero, update it to point to the reference
305 type we return. We allocate new memory if needed. */
308 make_reference_type (struct type *type, struct type **typeptr)
310 struct type *ntype; /* New type */
311 struct objfile *objfile;
314 ntype = TYPE_REFERENCE_TYPE (type);
319 return ntype; /* Don't care about alloc,
320 and have new type. */
321 else if (*typeptr == 0)
323 *typeptr = ntype; /* Tracking alloc, and have new type. */
328 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
330 ntype = alloc_type (TYPE_OBJFILE (type));
334 else /* We have storage, but need to reset it. */
337 objfile = TYPE_OBJFILE (ntype);
338 chain = TYPE_CHAIN (ntype);
340 TYPE_CHAIN (ntype) = chain;
341 TYPE_OBJFILE (ntype) = objfile;
344 TYPE_TARGET_TYPE (ntype) = type;
345 TYPE_REFERENCE_TYPE (type) = ntype;
347 /* FIXME! Assume the machine has only one representation for
348 references, and that it matches the (only) representation for
351 TYPE_LENGTH (ntype) = gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT;
352 TYPE_CODE (ntype) = TYPE_CODE_REF;
354 if (!TYPE_REFERENCE_TYPE (type)) /* Remember it, if don't have one. */
355 TYPE_REFERENCE_TYPE (type) = ntype;
357 /* Update the length of all the other variants of this type. */
358 chain = TYPE_CHAIN (ntype);
359 while (chain != ntype)
361 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
362 chain = TYPE_CHAIN (chain);
368 /* Same as above, but caller doesn't care about memory allocation
372 lookup_reference_type (struct type *type)
374 return make_reference_type (type, (struct type **) 0);
377 /* Lookup a function type that returns type TYPE. TYPEPTR, if
378 nonzero, points to a pointer to memory where the function type
379 should be stored. If *TYPEPTR is zero, update it to point to the
380 function type we return. We allocate new memory if needed. */
383 make_function_type (struct type *type, struct type **typeptr)
385 struct type *ntype; /* New type */
386 struct objfile *objfile;
388 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
390 ntype = alloc_type (TYPE_OBJFILE (type));
394 else /* We have storage, but need to reset it. */
397 objfile = TYPE_OBJFILE (ntype);
399 TYPE_OBJFILE (ntype) = objfile;
402 TYPE_TARGET_TYPE (ntype) = type;
404 TYPE_LENGTH (ntype) = 1;
405 TYPE_CODE (ntype) = TYPE_CODE_FUNC;
411 /* Given a type TYPE, return a type of functions that return that type.
412 May need to construct such a type if this is the first use. */
415 lookup_function_type (struct type *type)
417 return make_function_type (type, (struct type **) 0);
420 /* Identify address space identifier by name --
421 return the integer flag defined in gdbtypes.h. */
423 address_space_name_to_int (char *space_identifier)
425 struct gdbarch *gdbarch = current_gdbarch;
427 /* Check for known address space delimiters. */
428 if (!strcmp (space_identifier, "code"))
429 return TYPE_FLAG_CODE_SPACE;
430 else if (!strcmp (space_identifier, "data"))
431 return TYPE_FLAG_DATA_SPACE;
432 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch)
433 && gdbarch_address_class_name_to_type_flags (gdbarch,
438 error (_("Unknown address space specifier: \"%s\""), space_identifier);
441 /* Identify address space identifier by integer flag as defined in
442 gdbtypes.h -- return the string version of the adress space name. */
445 address_space_int_to_name (int space_flag)
447 struct gdbarch *gdbarch = current_gdbarch;
448 if (space_flag & TYPE_FLAG_CODE_SPACE)
450 else if (space_flag & TYPE_FLAG_DATA_SPACE)
452 else if ((space_flag & TYPE_FLAG_ADDRESS_CLASS_ALL)
453 && gdbarch_address_class_type_flags_to_name_p (gdbarch))
454 return gdbarch_address_class_type_flags_to_name (gdbarch, space_flag);
459 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
461 If STORAGE is non-NULL, create the new type instance there.
462 STORAGE must be in the same obstack as TYPE. */
465 make_qualified_type (struct type *type, int new_flags,
466 struct type *storage)
472 if (TYPE_INSTANCE_FLAGS (ntype) == new_flags)
474 ntype = TYPE_CHAIN (ntype);
475 } while (ntype != type);
477 /* Create a new type instance. */
479 ntype = alloc_type_instance (type);
482 /* If STORAGE was provided, it had better be in the same objfile
483 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
484 if one objfile is freed and the other kept, we'd have
485 dangling pointers. */
486 gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage));
489 TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type);
490 TYPE_CHAIN (ntype) = ntype;
493 /* Pointers or references to the original type are not relevant to
495 TYPE_POINTER_TYPE (ntype) = (struct type *) 0;
496 TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0;
498 /* Chain the new qualified type to the old type. */
499 TYPE_CHAIN (ntype) = TYPE_CHAIN (type);
500 TYPE_CHAIN (type) = ntype;
502 /* Now set the instance flags and return the new type. */
503 TYPE_INSTANCE_FLAGS (ntype) = new_flags;
505 /* Set length of new type to that of the original type. */
506 TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
511 /* Make an address-space-delimited variant of a type -- a type that
512 is identical to the one supplied except that it has an address
513 space attribute attached to it (such as "code" or "data").
515 The space attributes "code" and "data" are for Harvard
516 architectures. The address space attributes are for architectures
517 which have alternately sized pointers or pointers with alternate
521 make_type_with_address_space (struct type *type, int space_flag)
524 int new_flags = ((TYPE_INSTANCE_FLAGS (type)
525 & ~(TYPE_FLAG_CODE_SPACE | TYPE_FLAG_DATA_SPACE
526 | TYPE_FLAG_ADDRESS_CLASS_ALL))
529 return make_qualified_type (type, new_flags, NULL);
532 /* Make a "c-v" variant of a type -- a type that is identical to the
533 one supplied except that it may have const or volatile attributes
534 CNST is a flag for setting the const attribute
535 VOLTL is a flag for setting the volatile attribute
536 TYPE is the base type whose variant we are creating.
538 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
539 storage to hold the new qualified type; *TYPEPTR and TYPE must be
540 in the same objfile. Otherwise, allocate fresh memory for the new
541 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
542 new type we construct. */
544 make_cv_type (int cnst, int voltl,
546 struct type **typeptr)
548 struct type *ntype; /* New type */
549 struct type *tmp_type = type; /* tmp type */
550 struct objfile *objfile;
552 int new_flags = (TYPE_INSTANCE_FLAGS (type)
553 & ~(TYPE_FLAG_CONST | TYPE_FLAG_VOLATILE));
556 new_flags |= TYPE_FLAG_CONST;
559 new_flags |= TYPE_FLAG_VOLATILE;
561 if (typeptr && *typeptr != NULL)
563 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
564 a C-V variant chain that threads across objfiles: if one
565 objfile gets freed, then the other has a broken C-V chain.
567 This code used to try to copy over the main type from TYPE to
568 *TYPEPTR if they were in different objfiles, but that's
569 wrong, too: TYPE may have a field list or member function
570 lists, which refer to types of their own, etc. etc. The
571 whole shebang would need to be copied over recursively; you
572 can't have inter-objfile pointers. The only thing to do is
573 to leave stub types as stub types, and look them up afresh by
574 name each time you encounter them. */
575 gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type));
578 ntype = make_qualified_type (type, new_flags,
579 typeptr ? *typeptr : NULL);
587 /* Replace the contents of ntype with the type *type. This changes the
588 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
589 the changes are propogated to all types in the TYPE_CHAIN.
591 In order to build recursive types, it's inevitable that we'll need
592 to update types in place --- but this sort of indiscriminate
593 smashing is ugly, and needs to be replaced with something more
594 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
595 clear if more steps are needed. */
597 replace_type (struct type *ntype, struct type *type)
601 /* These two types had better be in the same objfile. Otherwise,
602 the assignment of one type's main type structure to the other
603 will produce a type with references to objects (names; field
604 lists; etc.) allocated on an objfile other than its own. */
605 gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (ntype));
607 *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
609 /* The type length is not a part of the main type. Update it for
610 each type on the variant chain. */
613 /* Assert that this element of the chain has no address-class bits
614 set in its flags. Such type variants might have type lengths
615 which are supposed to be different from the non-address-class
616 variants. This assertion shouldn't ever be triggered because
617 symbol readers which do construct address-class variants don't
618 call replace_type(). */
619 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0);
621 TYPE_LENGTH (chain) = TYPE_LENGTH (type);
622 chain = TYPE_CHAIN (chain);
623 } while (ntype != chain);
625 /* Assert that the two types have equivalent instance qualifiers.
626 This should be true for at least all of our debug readers. */
627 gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type));
630 /* Implement direct support for MEMBER_TYPE in GNU C++.
631 May need to construct such a type if this is the first use.
632 The TYPE is the type of the member. The DOMAIN is the type
633 of the aggregate that the member belongs to. */
636 lookup_memberptr_type (struct type *type, struct type *domain)
640 mtype = alloc_type (TYPE_OBJFILE (type));
641 smash_to_memberptr_type (mtype, domain, type);
645 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
648 lookup_methodptr_type (struct type *to_type)
652 mtype = alloc_type (TYPE_OBJFILE (to_type));
653 TYPE_TARGET_TYPE (mtype) = to_type;
654 TYPE_DOMAIN_TYPE (mtype) = TYPE_DOMAIN_TYPE (to_type);
655 TYPE_LENGTH (mtype) = cplus_method_ptr_size ();
656 TYPE_CODE (mtype) = TYPE_CODE_METHODPTR;
660 /* Allocate a stub method whose return type is TYPE. This apparently
661 happens for speed of symbol reading, since parsing out the
662 arguments to the method is cpu-intensive, the way we are doing it.
663 So, we will fill in arguments later. This always returns a fresh
667 allocate_stub_method (struct type *type)
671 mtype = init_type (TYPE_CODE_METHOD, 1, TYPE_FLAG_STUB, NULL,
672 TYPE_OBJFILE (type));
673 TYPE_TARGET_TYPE (mtype) = type;
674 /* _DOMAIN_TYPE (mtype) = unknown yet */
678 /* Create a range type using either a blank type supplied in
679 RESULT_TYPE, or creating a new type, inheriting the objfile from
682 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
683 to HIGH_BOUND, inclusive.
685 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
686 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
689 create_range_type (struct type *result_type, struct type *index_type,
690 int low_bound, int high_bound)
692 if (result_type == NULL)
694 result_type = alloc_type (TYPE_OBJFILE (index_type));
696 TYPE_CODE (result_type) = TYPE_CODE_RANGE;
697 TYPE_TARGET_TYPE (result_type) = index_type;
698 if (TYPE_STUB (index_type))
699 TYPE_FLAGS (result_type) |= TYPE_FLAG_TARGET_STUB;
701 TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
702 TYPE_NFIELDS (result_type) = 2;
703 TYPE_FIELDS (result_type) = (struct field *)
704 TYPE_ALLOC (result_type, 2 * sizeof (struct field));
705 memset (TYPE_FIELDS (result_type), 0, 2 * sizeof (struct field));
706 TYPE_FIELD_BITPOS (result_type, 0) = low_bound;
707 TYPE_FIELD_BITPOS (result_type, 1) = high_bound;
708 TYPE_FIELD_TYPE (result_type, 0) = builtin_type_int; /* FIXME */
709 TYPE_FIELD_TYPE (result_type, 1) = builtin_type_int; /* FIXME */
712 TYPE_FLAGS (result_type) |= TYPE_FLAG_UNSIGNED;
714 return (result_type);
717 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
718 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
719 bounds will fit in LONGEST), or -1 otherwise. */
722 get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
724 CHECK_TYPEDEF (type);
725 switch (TYPE_CODE (type))
727 case TYPE_CODE_RANGE:
728 *lowp = TYPE_LOW_BOUND (type);
729 *highp = TYPE_HIGH_BOUND (type);
732 if (TYPE_NFIELDS (type) > 0)
734 /* The enums may not be sorted by value, so search all
738 *lowp = *highp = TYPE_FIELD_BITPOS (type, 0);
739 for (i = 0; i < TYPE_NFIELDS (type); i++)
741 if (TYPE_FIELD_BITPOS (type, i) < *lowp)
742 *lowp = TYPE_FIELD_BITPOS (type, i);
743 if (TYPE_FIELD_BITPOS (type, i) > *highp)
744 *highp = TYPE_FIELD_BITPOS (type, i);
747 /* Set unsigned indicator if warranted. */
750 TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
764 if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */
766 if (!TYPE_UNSIGNED (type))
768 *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
772 /* ... fall through for unsigned ints ... */
775 /* This round-about calculation is to avoid shifting by
776 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
777 if TYPE_LENGTH (type) == sizeof (LONGEST). */
778 *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
779 *highp = (*highp - 1) | *highp;
786 /* Create an array type using either a blank type supplied in
787 RESULT_TYPE, or creating a new type, inheriting the objfile from
790 Elements will be of type ELEMENT_TYPE, the indices will be of type
793 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
794 sure it is TYPE_CODE_UNDEF before we bash it into an array
798 create_array_type (struct type *result_type,
799 struct type *element_type,
800 struct type *range_type)
802 LONGEST low_bound, high_bound;
804 if (result_type == NULL)
806 result_type = alloc_type (TYPE_OBJFILE (range_type));
808 TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
809 TYPE_TARGET_TYPE (result_type) = element_type;
810 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
811 low_bound = high_bound = 0;
812 CHECK_TYPEDEF (element_type);
813 TYPE_LENGTH (result_type) =
814 TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
815 TYPE_NFIELDS (result_type) = 1;
816 TYPE_FIELDS (result_type) =
817 (struct field *) TYPE_ALLOC (result_type, sizeof (struct field));
818 memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
819 TYPE_FIELD_TYPE (result_type, 0) = range_type;
820 TYPE_VPTR_FIELDNO (result_type) = -1;
822 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
823 if (TYPE_LENGTH (result_type) == 0)
824 TYPE_FLAGS (result_type) |= TYPE_FLAG_TARGET_STUB;
826 return (result_type);
829 /* Create a string type using either a blank type supplied in
830 RESULT_TYPE, or creating a new type. String types are similar
831 enough to array of char types that we can use create_array_type to
832 build the basic type and then bash it into a string type.
834 For fixed length strings, the range type contains 0 as the lower
835 bound and the length of the string minus one as the upper bound.
837 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
838 sure it is TYPE_CODE_UNDEF before we bash it into a string
842 create_string_type (struct type *result_type,
843 struct type *range_type)
845 struct type *string_char_type;
847 string_char_type = language_string_char_type (current_language,
849 result_type = create_array_type (result_type,
852 TYPE_CODE (result_type) = TYPE_CODE_STRING;
853 return (result_type);
857 create_set_type (struct type *result_type, struct type *domain_type)
859 if (result_type == NULL)
861 result_type = alloc_type (TYPE_OBJFILE (domain_type));
863 TYPE_CODE (result_type) = TYPE_CODE_SET;
864 TYPE_NFIELDS (result_type) = 1;
865 TYPE_FIELDS (result_type) = (struct field *)
866 TYPE_ALLOC (result_type, 1 * sizeof (struct field));
867 memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
869 if (!TYPE_STUB (domain_type))
871 LONGEST low_bound, high_bound, bit_length;
872 if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
873 low_bound = high_bound = 0;
874 bit_length = high_bound - low_bound + 1;
875 TYPE_LENGTH (result_type)
876 = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
878 TYPE_FLAGS (result_type) |= TYPE_FLAG_UNSIGNED;
880 TYPE_FIELD_TYPE (result_type, 0) = domain_type;
882 return (result_type);
886 append_flags_type_flag (struct type *type, int bitpos, char *name)
888 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS);
889 gdb_assert (bitpos < TYPE_NFIELDS (type));
890 gdb_assert (bitpos >= 0);
894 TYPE_FIELD_NAME (type, bitpos) = xstrdup (name);
895 TYPE_FIELD_BITPOS (type, bitpos) = bitpos;
899 /* Don't show this field to the user. */
900 TYPE_FIELD_BITPOS (type, bitpos) = -1;
905 init_flags_type (char *name, int length)
907 int nfields = length * TARGET_CHAR_BIT;
910 type = init_type (TYPE_CODE_FLAGS, length,
911 TYPE_FLAG_UNSIGNED, name, NULL);
912 TYPE_NFIELDS (type) = nfields;
913 TYPE_FIELDS (type) = TYPE_ALLOC (type,
914 nfields * sizeof (struct field));
915 memset (TYPE_FIELDS (type), 0, nfields * sizeof (struct field));
921 init_vector_type (struct type *elt_type, int n)
923 struct type *array_type;
925 array_type = create_array_type (0, elt_type,
926 create_range_type (0,
929 TYPE_FLAGS (array_type) |= TYPE_FLAG_VECTOR;
933 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
934 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
935 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
936 TYPE doesn't include the offset (that's the value of the MEMBER
937 itself), but does include the structure type into which it points
940 When "smashing" the type, we preserve the objfile that the old type
941 pointed to, since we aren't changing where the type is actually
945 smash_to_memberptr_type (struct type *type, struct type *domain,
946 struct type *to_type)
948 struct objfile *objfile;
950 objfile = TYPE_OBJFILE (type);
953 TYPE_OBJFILE (type) = objfile;
954 TYPE_TARGET_TYPE (type) = to_type;
955 TYPE_DOMAIN_TYPE (type) = domain;
956 /* Assume that a data member pointer is the same size as a normal
958 TYPE_LENGTH (type) = gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT;
959 TYPE_CODE (type) = TYPE_CODE_MEMBERPTR;
962 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
963 METHOD just means `function that gets an extra "this" argument'.
965 When "smashing" the type, we preserve the objfile that the old type
966 pointed to, since we aren't changing where the type is actually
970 smash_to_method_type (struct type *type, struct type *domain,
971 struct type *to_type, struct field *args,
972 int nargs, int varargs)
974 struct objfile *objfile;
976 objfile = TYPE_OBJFILE (type);
979 TYPE_OBJFILE (type) = objfile;
980 TYPE_TARGET_TYPE (type) = to_type;
981 TYPE_DOMAIN_TYPE (type) = domain;
982 TYPE_FIELDS (type) = args;
983 TYPE_NFIELDS (type) = nargs;
985 TYPE_FLAGS (type) |= TYPE_FLAG_VARARGS;
986 TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
987 TYPE_CODE (type) = TYPE_CODE_METHOD;
990 /* Return a typename for a struct/union/enum type without "struct ",
991 "union ", or "enum ". If the type has a NULL name, return NULL. */
994 type_name_no_tag (const struct type *type)
996 if (TYPE_TAG_NAME (type) != NULL)
997 return TYPE_TAG_NAME (type);
999 /* Is there code which expects this to return the name if there is
1000 no tag name? My guess is that this is mainly used for C++ in
1001 cases where the two will always be the same. */
1002 return TYPE_NAME (type);
1005 /* Lookup a typedef or primitive type named NAME, visible in lexical
1006 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1007 suitably defined. */
1010 lookup_typename (char *name, struct block *block, int noerr)
1015 sym = lookup_symbol (name, block, VAR_DOMAIN, 0,
1016 (struct symtab **) NULL);
1017 if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
1019 tmp = language_lookup_primitive_type_by_name (current_language,
1026 else if (!tmp && noerr)
1032 error (_("No type named %s."), name);
1035 return (SYMBOL_TYPE (sym));
1039 lookup_unsigned_typename (char *name)
1041 char *uns = alloca (strlen (name) + 10);
1043 strcpy (uns, "unsigned ");
1044 strcpy (uns + 9, name);
1045 return (lookup_typename (uns, (struct block *) NULL, 0));
1049 lookup_signed_typename (char *name)
1052 char *uns = alloca (strlen (name) + 8);
1054 strcpy (uns, "signed ");
1055 strcpy (uns + 7, name);
1056 t = lookup_typename (uns, (struct block *) NULL, 1);
1057 /* If we don't find "signed FOO" just try again with plain "FOO". */
1060 return lookup_typename (name, (struct block *) NULL, 0);
1063 /* Lookup a structure type named "struct NAME",
1064 visible in lexical block BLOCK. */
1067 lookup_struct (char *name, struct block *block)
1071 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0,
1072 (struct symtab **) NULL);
1076 error (_("No struct type named %s."), name);
1078 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1080 error (_("This context has class, union or enum %s, not a struct."),
1083 return (SYMBOL_TYPE (sym));
1086 /* Lookup a union type named "union NAME",
1087 visible in lexical block BLOCK. */
1090 lookup_union (char *name, struct block *block)
1095 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0,
1096 (struct symtab **) NULL);
1099 error (_("No union type named %s."), name);
1101 t = SYMBOL_TYPE (sym);
1103 if (TYPE_CODE (t) == TYPE_CODE_UNION)
1106 /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
1107 * a further "declared_type" field to discover it is really a union.
1109 if (HAVE_CPLUS_STRUCT (t))
1110 if (TYPE_DECLARED_TYPE (t) == DECLARED_TYPE_UNION)
1113 /* If we get here, it's not a union. */
1114 error (_("This context has class, struct or enum %s, not a union."),
1119 /* Lookup an enum type named "enum NAME",
1120 visible in lexical block BLOCK. */
1123 lookup_enum (char *name, struct block *block)
1127 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0,
1128 (struct symtab **) NULL);
1131 error (_("No enum type named %s."), name);
1133 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
1135 error (_("This context has class, struct or union %s, not an enum."),
1138 return (SYMBOL_TYPE (sym));
1141 /* Lookup a template type named "template NAME<TYPE>",
1142 visible in lexical block BLOCK. */
1145 lookup_template_type (char *name, struct type *type,
1146 struct block *block)
1149 char *nam = (char *)
1150 alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4);
1153 strcat (nam, TYPE_NAME (type));
1154 strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
1156 sym = lookup_symbol (nam, block, VAR_DOMAIN, 0,
1157 (struct symtab **) NULL);
1161 error (_("No template type named %s."), name);
1163 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1165 error (_("This context has class, union or enum %s, not a struct."),
1168 return (SYMBOL_TYPE (sym));
1171 /* Given a type TYPE, lookup the type of the component of type named
1174 TYPE can be either a struct or union, or a pointer or reference to
1175 a struct or union. If it is a pointer or reference, its target
1176 type is automatically used. Thus '.' and '->' are interchangable,
1177 as specified for the definitions of the expression element types
1178 STRUCTOP_STRUCT and STRUCTOP_PTR.
1180 If NOERR is nonzero, return zero if NAME is not suitably defined.
1181 If NAME is the name of a baseclass type, return that type. */
1184 lookup_struct_elt_type (struct type *type, char *name, int noerr)
1190 CHECK_TYPEDEF (type);
1191 if (TYPE_CODE (type) != TYPE_CODE_PTR
1192 && TYPE_CODE (type) != TYPE_CODE_REF)
1194 type = TYPE_TARGET_TYPE (type);
1197 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1198 && TYPE_CODE (type) != TYPE_CODE_UNION)
1200 target_terminal_ours ();
1201 gdb_flush (gdb_stdout);
1202 fprintf_unfiltered (gdb_stderr, "Type ");
1203 type_print (type, "", gdb_stderr, -1);
1204 error (_(" is not a structure or union type."));
1208 /* FIXME: This change put in by Michael seems incorrect for the case
1209 where the structure tag name is the same as the member name.
1210 I.E. when doing "ptype bell->bar" for "struct foo { int bar; int
1211 foo; } bell;" Disabled by fnf. */
1215 typename = type_name_no_tag (type);
1216 if (typename != NULL && strcmp (typename, name) == 0)
1221 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1223 char *t_field_name = TYPE_FIELD_NAME (type, i);
1225 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1227 return TYPE_FIELD_TYPE (type, i);
1231 /* OK, it's not in this class. Recursively check the baseclasses. */
1232 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1236 t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 1);
1248 target_terminal_ours ();
1249 gdb_flush (gdb_stdout);
1250 fprintf_unfiltered (gdb_stderr, "Type ");
1251 type_print (type, "", gdb_stderr, -1);
1252 fprintf_unfiltered (gdb_stderr, " has no component named ");
1253 fputs_filtered (name, gdb_stderr);
1255 return (struct type *) -1; /* For lint */
1258 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
1259 valid. Callers should be aware that in some cases (for example,
1260 the type or one of its baseclasses is a stub type and we are
1261 debugging a .o file), this function will not be able to find the
1262 virtual function table pointer, and vptr_fieldno will remain -1 and
1263 vptr_basetype will remain NULL. */
1266 fill_in_vptr_fieldno (struct type *type)
1268 CHECK_TYPEDEF (type);
1270 if (TYPE_VPTR_FIELDNO (type) < 0)
1274 /* We must start at zero in case the first (and only) baseclass
1275 is virtual (and hence we cannot share the table pointer). */
1276 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1278 struct type *baseclass = check_typedef (TYPE_BASECLASS (type,
1280 fill_in_vptr_fieldno (baseclass);
1281 if (TYPE_VPTR_FIELDNO (baseclass) >= 0)
1283 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (baseclass);
1284 TYPE_VPTR_BASETYPE (type) = TYPE_VPTR_BASETYPE (baseclass);
1291 /* Find the method and field indices for the destructor in class type T.
1292 Return 1 if the destructor was found, otherwise, return 0. */
1295 get_destructor_fn_field (struct type *t,
1301 for (i = 0; i < TYPE_NFN_FIELDS (t); i++)
1304 struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
1306 for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (t, i); j++)
1308 if (is_destructor_name (TYPE_FN_FIELD_PHYSNAME (f, j)) != 0)
1320 stub_noname_complaint (void)
1322 complaint (&symfile_complaints, _("stub type has NULL name"));
1325 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1327 If this is a stubbed struct (i.e. declared as struct foo *), see if
1328 we can find a full definition in some other file. If so, copy this
1329 definition, so we can use it in future. There used to be a comment
1330 (but not any code) that if we don't find a full definition, we'd
1331 set a flag so we don't spend time in the future checking the same
1332 type. That would be a mistake, though--we might load in more
1333 symbols which contain a full definition for the type.
1335 This used to be coded as a macro, but I don't think it is called
1336 often enough to merit such treatment. */
1338 /* Find the real type of TYPE. This function returns the real type,
1339 after removing all layers of typedefs and completing opaque or stub
1340 types. Completion changes the TYPE argument, but stripping of
1341 typedefs does not. */
1344 check_typedef (struct type *type)
1346 struct type *orig_type = type;
1347 int is_const, is_volatile;
1351 while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1353 if (!TYPE_TARGET_TYPE (type))
1358 /* It is dangerous to call lookup_symbol if we are currently
1359 reading a symtab. Infinite recursion is one danger. */
1360 if (currently_reading_symtab)
1363 name = type_name_no_tag (type);
1364 /* FIXME: shouldn't we separately check the TYPE_NAME and
1365 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1366 VAR_DOMAIN as appropriate? (this code was written before
1367 TYPE_NAME and TYPE_TAG_NAME were separate). */
1370 stub_noname_complaint ();
1373 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0,
1374 (struct symtab **) NULL);
1376 TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
1377 else /* TYPE_CODE_UNDEF */
1378 TYPE_TARGET_TYPE (type) = alloc_type (NULL);
1380 type = TYPE_TARGET_TYPE (type);
1383 is_const = TYPE_CONST (type);
1384 is_volatile = TYPE_VOLATILE (type);
1386 /* If this is a struct/class/union with no fields, then check
1387 whether a full definition exists somewhere else. This is for
1388 systems where a type definition with no fields is issued for such
1389 types, instead of identifying them as stub types in the first
1392 if (TYPE_IS_OPAQUE (type)
1393 && opaque_type_resolution
1394 && !currently_reading_symtab)
1396 char *name = type_name_no_tag (type);
1397 struct type *newtype;
1400 stub_noname_complaint ();
1403 newtype = lookup_transparent_type (name);
1407 /* If the resolved type and the stub are in the same
1408 objfile, then replace the stub type with the real deal.
1409 But if they're in separate objfiles, leave the stub
1410 alone; we'll just look up the transparent type every time
1411 we call check_typedef. We can't create pointers between
1412 types allocated to different objfiles, since they may
1413 have different lifetimes. Trying to copy NEWTYPE over to
1414 TYPE's objfile is pointless, too, since you'll have to
1415 move over any other types NEWTYPE refers to, which could
1416 be an unbounded amount of stuff. */
1417 if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type))
1418 make_cv_type (is_const, is_volatile, newtype, &type);
1423 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1425 else if (TYPE_STUB (type) && !currently_reading_symtab)
1427 char *name = type_name_no_tag (type);
1428 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1429 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1430 as appropriate? (this code was written before TYPE_NAME and
1431 TYPE_TAG_NAME were separate). */
1435 stub_noname_complaint ();
1438 sym = lookup_symbol (name, 0, STRUCT_DOMAIN,
1439 0, (struct symtab **) NULL);
1442 /* Same as above for opaque types, we can replace the stub
1443 with the complete type only if they are int the same
1445 if (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type))
1446 make_cv_type (is_const, is_volatile,
1447 SYMBOL_TYPE (sym), &type);
1449 type = SYMBOL_TYPE (sym);
1453 if (TYPE_TARGET_STUB (type))
1455 struct type *range_type;
1456 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1458 if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type))
1462 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
1463 && TYPE_NFIELDS (type) == 1
1464 && (TYPE_CODE (range_type = TYPE_FIELD_TYPE (type, 0))
1465 == TYPE_CODE_RANGE))
1467 /* Now recompute the length of the array type, based on its
1468 number of elements and the target type's length. */
1469 TYPE_LENGTH (type) =
1470 ((TYPE_FIELD_BITPOS (range_type, 1)
1471 - TYPE_FIELD_BITPOS (range_type, 0) + 1)
1472 * TYPE_LENGTH (target_type));
1473 TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB;
1475 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
1477 TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
1478 TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB;
1481 /* Cache TYPE_LENGTH for future use. */
1482 TYPE_LENGTH (orig_type) = TYPE_LENGTH (type);
1486 /* Parse a type expression in the string [P..P+LENGTH). If an error
1487 occurs, silently return builtin_type_void. */
1489 static struct type *
1490 safe_parse_type (char *p, int length)
1492 struct ui_file *saved_gdb_stderr;
1495 /* Suppress error messages. */
1496 saved_gdb_stderr = gdb_stderr;
1497 gdb_stderr = ui_file_new ();
1499 /* Call parse_and_eval_type() without fear of longjmp()s. */
1500 if (!gdb_parse_and_eval_type (p, length, &type))
1501 type = builtin_type_void;
1503 /* Stop suppressing error messages. */
1504 ui_file_delete (gdb_stderr);
1505 gdb_stderr = saved_gdb_stderr;
1510 /* Ugly hack to convert method stubs into method types.
1512 He ain't kiddin'. This demangles the name of the method into a
1513 string including argument types, parses out each argument type,
1514 generates a string casting a zero to that type, evaluates the
1515 string, and stuffs the resulting type into an argtype vector!!!
1516 Then it knows the type of the whole function (including argument
1517 types for overloading), which info used to be in the stab's but was
1518 removed to hack back the space required for them. */
1521 check_stub_method (struct type *type, int method_id, int signature_id)
1524 char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
1525 char *demangled_name = cplus_demangle (mangled_name,
1526 DMGL_PARAMS | DMGL_ANSI);
1527 char *argtypetext, *p;
1528 int depth = 0, argcount = 1;
1529 struct field *argtypes;
1532 /* Make sure we got back a function string that we can use. */
1534 p = strchr (demangled_name, '(');
1538 if (demangled_name == NULL || p == NULL)
1539 error (_("Internal: Cannot demangle mangled name `%s'."),
1542 /* Now, read in the parameters that define this type. */
1547 if (*p == '(' || *p == '<')
1551 else if (*p == ')' || *p == '>')
1555 else if (*p == ',' && depth == 0)
1563 /* If we read one argument and it was ``void'', don't count it. */
1564 if (strncmp (argtypetext, "(void)", 6) == 0)
1567 /* We need one extra slot, for the THIS pointer. */
1569 argtypes = (struct field *)
1570 TYPE_ALLOC (type, (argcount + 1) * sizeof (struct field));
1573 /* Add THIS pointer for non-static methods. */
1574 f = TYPE_FN_FIELDLIST1 (type, method_id);
1575 if (TYPE_FN_FIELD_STATIC_P (f, signature_id))
1579 argtypes[0].type = lookup_pointer_type (type);
1583 if (*p != ')') /* () means no args, skip while */
1588 if (depth <= 0 && (*p == ',' || *p == ')'))
1590 /* Avoid parsing of ellipsis, they will be handled below.
1591 Also avoid ``void'' as above. */
1592 if (strncmp (argtypetext, "...", p - argtypetext) != 0
1593 && strncmp (argtypetext, "void", p - argtypetext) != 0)
1595 argtypes[argcount].type =
1596 safe_parse_type (argtypetext, p - argtypetext);
1599 argtypetext = p + 1;
1602 if (*p == '(' || *p == '<')
1606 else if (*p == ')' || *p == '>')
1615 TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name;
1617 /* Now update the old "stub" type into a real type. */
1618 mtype = TYPE_FN_FIELD_TYPE (f, signature_id);
1619 TYPE_DOMAIN_TYPE (mtype) = type;
1620 TYPE_FIELDS (mtype) = argtypes;
1621 TYPE_NFIELDS (mtype) = argcount;
1622 TYPE_FLAGS (mtype) &= ~TYPE_FLAG_STUB;
1623 TYPE_FN_FIELD_STUB (f, signature_id) = 0;
1625 TYPE_FLAGS (mtype) |= TYPE_FLAG_VARARGS;
1627 xfree (demangled_name);
1630 /* This is the external interface to check_stub_method, above. This
1631 function unstubs all of the signatures for TYPE's METHOD_ID method
1632 name. After calling this function TYPE_FN_FIELD_STUB will be
1633 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1636 This function unfortunately can not die until stabs do. */
1639 check_stub_method_group (struct type *type, int method_id)
1641 int len = TYPE_FN_FIELDLIST_LENGTH (type, method_id);
1642 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
1643 int j, found_stub = 0;
1645 for (j = 0; j < len; j++)
1646 if (TYPE_FN_FIELD_STUB (f, j))
1649 check_stub_method (type, method_id, j);
1652 /* GNU v3 methods with incorrect names were corrected when we read
1653 in type information, because it was cheaper to do it then. The
1654 only GNU v2 methods with incorrect method names are operators and
1655 destructors; destructors were also corrected when we read in type
1658 Therefore the only thing we need to handle here are v2 operator
1660 if (found_stub && strncmp (TYPE_FN_FIELD_PHYSNAME (f, 0), "_Z", 2) != 0)
1663 char dem_opname[256];
1665 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
1667 dem_opname, DMGL_ANSI);
1669 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
1673 TYPE_FN_FIELDLIST_NAME (type, method_id) = xstrdup (dem_opname);
1677 const struct cplus_struct_type cplus_struct_default;
1680 allocate_cplus_struct_type (struct type *type)
1682 if (!HAVE_CPLUS_STRUCT (type))
1684 TYPE_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
1685 TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
1686 *(TYPE_CPLUS_SPECIFIC (type)) = cplus_struct_default;
1690 /* Helper function to initialize the standard scalar types.
1692 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy of
1693 the string pointed to by name in the objfile_obstack for that
1694 objfile, and initialize the type name to that copy. There are
1695 places (mipsread.c in particular, where init_type is called with a
1696 NULL value for NAME). */
1699 init_type (enum type_code code, int length, int flags,
1700 char *name, struct objfile *objfile)
1704 type = alloc_type (objfile);
1705 TYPE_CODE (type) = code;
1706 TYPE_LENGTH (type) = length;
1707 TYPE_FLAGS (type) |= flags;
1708 if ((name != NULL) && (objfile != NULL))
1710 TYPE_NAME (type) = obsavestring (name, strlen (name),
1711 &objfile->objfile_obstack);
1715 TYPE_NAME (type) = name;
1720 if (name && strcmp (name, "char") == 0)
1721 TYPE_FLAGS (type) |= TYPE_FLAG_NOSIGN;
1723 if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION
1724 || code == TYPE_CODE_NAMESPACE)
1726 INIT_CPLUS_SPECIFIC (type);
1731 /* Helper function. Create an empty composite type. */
1734 init_composite_type (char *name, enum type_code code)
1737 gdb_assert (code == TYPE_CODE_STRUCT
1738 || code == TYPE_CODE_UNION);
1739 t = init_type (code, 0, 0, NULL, NULL);
1740 TYPE_TAG_NAME (t) = name;
1744 /* Helper function. Append a field to a composite type. */
1747 append_composite_type_field (struct type *t, char *name,
1751 TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
1752 TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t),
1753 sizeof (struct field) * TYPE_NFIELDS (t));
1754 f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
1755 memset (f, 0, sizeof f[0]);
1756 FIELD_TYPE (f[0]) = field;
1757 FIELD_NAME (f[0]) = name;
1758 if (TYPE_CODE (t) == TYPE_CODE_UNION)
1760 if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
1761 TYPE_LENGTH (t) = TYPE_LENGTH (field);
1763 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
1765 TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
1766 if (TYPE_NFIELDS (t) > 1)
1768 FIELD_BITPOS (f[0]) = (FIELD_BITPOS (f[-1])
1769 + TYPE_LENGTH (field) * TARGET_CHAR_BIT);
1774 /* Look up a fundamental type for the specified objfile.
1775 May need to construct such a type if this is the first use.
1777 Some object file formats (ELF, COFF, etc) do not define fundamental
1778 types such as "int" or "double". Others (stabs for example), do
1779 define fundamental types.
1781 For the formats which don't provide fundamental types, gdb can
1782 create such types, using defaults reasonable for the current
1783 language and the current target machine.
1785 NOTE: This routine is obsolescent. Each debugging format reader
1786 should manage it's own fundamental types, either creating them from
1787 suitable defaults or reading them from the debugging information,
1788 whichever is appropriate. The DWARF reader has already been fixed
1789 to do this. Once the other readers are fixed, this routine will go
1790 away. Also note that fundamental types should be managed on a
1791 compilation unit basis in a multi-language environment, not on a
1792 linkage unit basis as is done here. */
1796 lookup_fundamental_type (struct objfile *objfile, int typeid)
1798 struct type **typep;
1801 if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
1803 error (_("internal error - invalid fundamental type id %d"),
1807 /* If this is the first time we need a fundamental type for this
1808 objfile then we need to initialize the vector of type
1811 if (objfile->fundamental_types == NULL)
1813 nbytes = FT_NUM_MEMBERS * sizeof (struct type *);
1814 objfile->fundamental_types = (struct type **)
1815 obstack_alloc (&objfile->objfile_obstack, nbytes);
1816 memset ((char *) objfile->fundamental_types, 0, nbytes);
1817 OBJSTAT (objfile, n_types += FT_NUM_MEMBERS);
1820 /* Look for this particular type in the fundamental type vector. If
1821 one is not found, create and install one appropriate for the
1822 current language. */
1824 typep = objfile->fundamental_types + typeid;
1827 *typep = create_fundamental_type (objfile, typeid);
1834 can_dereference (struct type *t)
1836 /* FIXME: Should we return true for references as well as
1841 && TYPE_CODE (t) == TYPE_CODE_PTR
1842 && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
1846 is_integral_type (struct type *t)
1851 && ((TYPE_CODE (t) == TYPE_CODE_INT)
1852 || (TYPE_CODE (t) == TYPE_CODE_ENUM)
1853 || (TYPE_CODE (t) == TYPE_CODE_FLAGS)
1854 || (TYPE_CODE (t) == TYPE_CODE_CHAR)
1855 || (TYPE_CODE (t) == TYPE_CODE_RANGE)
1856 || (TYPE_CODE (t) == TYPE_CODE_BOOL)));
1859 /* Check whether BASE is an ancestor or base class or DCLASS
1860 Return 1 if so, and 0 if not.
1861 Note: callers may want to check for identity of the types before
1862 calling this function -- identical types are considered to satisfy
1863 the ancestor relationship even if they're identical. */
1866 is_ancestor (struct type *base, struct type *dclass)
1870 CHECK_TYPEDEF (base);
1871 CHECK_TYPEDEF (dclass);
1875 if (TYPE_NAME (base) && TYPE_NAME (dclass)
1876 && !strcmp (TYPE_NAME (base), TYPE_NAME (dclass)))
1879 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
1880 if (is_ancestor (base, TYPE_BASECLASS (dclass, i)))
1888 /* See whether DCLASS has a virtual table. This routine is aimed at
1889 the HP/Taligent ANSI C++ runtime model, and may not work with other
1890 runtime models. Return 1 => Yes, 0 => No. */
1893 has_vtable (struct type *dclass)
1895 /* In the HP ANSI C++ runtime model, a class has a vtable only if it
1896 has virtual functions or virtual bases. */
1900 if (TYPE_CODE (dclass) != TYPE_CODE_CLASS)
1903 /* First check for the presence of virtual bases. */
1904 if (TYPE_FIELD_VIRTUAL_BITS (dclass))
1905 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
1906 if (B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass), i))
1909 /* Next check for virtual functions. */
1910 if (TYPE_FN_FIELDLISTS (dclass))
1911 for (i = 0; i < TYPE_NFN_FIELDS (dclass); i++)
1912 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass, i), 0))
1915 /* Recurse on non-virtual bases to see if any of them needs a
1917 if (TYPE_FIELD_VIRTUAL_BITS (dclass))
1918 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
1919 if ((!B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass), i))
1920 && (has_vtable (TYPE_FIELD_TYPE (dclass, i))))
1923 /* Well, maybe we don't need a virtual table. */
1927 /* Return a pointer to the "primary base class" of DCLASS.
1929 A NULL return indicates that DCLASS has no primary base, or that it
1930 couldn't be found (insufficient information).
1932 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
1933 and may not work with other runtime models. */
1936 primary_base_class (struct type *dclass)
1938 /* In HP ANSI C++'s runtime model, a "primary base class" of a class
1939 is the first directly inherited, non-virtual base class that
1940 requires a virtual table. */
1944 if (TYPE_CODE (dclass) != TYPE_CODE_CLASS)
1947 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
1948 if (!TYPE_FIELD_VIRTUAL (dclass, i)
1949 && has_vtable (TYPE_FIELD_TYPE (dclass, i)))
1950 return TYPE_FIELD_TYPE (dclass, i);
1955 /* Global manipulated by virtual_base_list[_aux](). */
1957 static struct vbase *current_vbase_list = NULL;
1959 /* Return a pointer to a null-terminated list of struct vbase items.
1960 The vbasetype pointer of each item in the list points to the type
1961 information for a virtual base of the argument DCLASS.
1963 Helper function for virtual_base_list().
1964 Note: the list goes backward, right-to-left.
1965 virtual_base_list() copies the items out in reverse order. */
1968 virtual_base_list_aux (struct type *dclass)
1970 struct vbase *tmp_vbase;
1973 if (TYPE_CODE (dclass) != TYPE_CODE_CLASS)
1976 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
1978 /* Recurse on this ancestor, first */
1979 virtual_base_list_aux (TYPE_FIELD_TYPE (dclass, i));
1981 /* If this current base is itself virtual, add it to the list */
1982 if (BASETYPE_VIA_VIRTUAL (dclass, i))
1984 struct type *basetype = TYPE_FIELD_TYPE (dclass, i);
1986 /* Check if base already recorded */
1987 tmp_vbase = current_vbase_list;
1990 if (tmp_vbase->vbasetype == basetype)
1991 break; /* found it */
1992 tmp_vbase = tmp_vbase->next;
1995 if (!tmp_vbase) /* normal exit from loop */
1997 /* Allocate new item for this virtual base */
1998 tmp_vbase = (struct vbase *) xmalloc (sizeof (struct vbase));
2000 /* Stick it on at the end of the list */
2001 tmp_vbase->vbasetype = basetype;
2002 tmp_vbase->next = current_vbase_list;
2003 current_vbase_list = tmp_vbase;
2006 } /* for loop over bases */
2010 /* Compute the list of virtual bases in the right order. Virtual
2011 bases are laid out in the object's memory area in order of their
2012 occurrence in a depth-first, left-to-right search through the
2015 Argument DCLASS is the type whose virtual bases are required.
2016 Return value is the address of a null-terminated array of pointers
2017 to struct type items.
2019 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
2020 and may not work with other runtime models.
2022 This routine merely hands off the argument to virtual_base_list_aux()
2023 and then copies the result into an array to save space. */
2025 static struct type **
2026 virtual_base_list (struct type *dclass)
2028 struct vbase *tmp_vbase;
2029 struct vbase *tmp_vbase_2;
2032 struct type **vbase_array;
2034 current_vbase_list = NULL;
2035 virtual_base_list_aux (dclass);
2037 for (i = 0, tmp_vbase = current_vbase_list;
2039 i++, tmp_vbase = tmp_vbase->next)
2044 vbase_array = (struct type **)
2045 xmalloc ((count + 1) * sizeof (struct type *));
2047 for (i = count - 1, tmp_vbase = current_vbase_list;
2049 tmp_vbase = tmp_vbase->next)
2050 vbase_array[i] = tmp_vbase->vbasetype;
2052 /* Get rid of constructed chain. */
2053 tmp_vbase_2 = tmp_vbase = current_vbase_list;
2056 tmp_vbase = tmp_vbase->next;
2057 xfree (tmp_vbase_2);
2058 tmp_vbase_2 = tmp_vbase;
2061 vbase_array[count] = NULL;
2065 /* Return the length of the virtual base list of the type DCLASS. */
2068 virtual_base_list_length (struct type *dclass)
2071 struct vbase *tmp_vbase;
2073 current_vbase_list = NULL;
2074 virtual_base_list_aux (dclass);
2076 for (i = 0, tmp_vbase = current_vbase_list;
2078 i++, tmp_vbase = tmp_vbase->next)
2083 /* Return the number of elements of the virtual base list of the type
2084 DCLASS, ignoring those appearing in the primary base (and its
2085 primary base, recursively). */
2088 virtual_base_list_length_skip_primaries (struct type *dclass)
2091 struct vbase *tmp_vbase;
2092 struct type *primary;
2094 primary = TYPE_RUNTIME_PTR (dclass) ? TYPE_PRIMARY_BASE (dclass) : NULL;
2097 return virtual_base_list_length (dclass);
2099 current_vbase_list = NULL;
2100 virtual_base_list_aux (dclass);
2102 for (i = 0, tmp_vbase = current_vbase_list;
2104 tmp_vbase = tmp_vbase->next)
2106 if (virtual_base_index (tmp_vbase->vbasetype, primary) >= 0)
2113 /* Return the index (position) of type BASE, which is a virtual base
2114 class of DCLASS, in the latter's virtual base list. A return of -1
2115 indicates "not found" or a problem. */
2118 virtual_base_index (struct type *base, struct type *dclass)
2120 struct type *vbase, **vbase_list;
2123 if ((TYPE_CODE (dclass) != TYPE_CODE_CLASS)
2124 || (TYPE_CODE (base) != TYPE_CODE_CLASS))
2127 vbase_list = virtual_base_list (dclass);
2128 for (i = 0, vbase = vbase_list[0];
2130 vbase = vbase_list[++i])
2135 return vbase ? i : -1;
2138 /* Return the index (position) of type BASE, which is a virtual base
2139 class of DCLASS, in the latter's virtual base list. Skip over all
2140 bases that may appear in the virtual base list of the primary base
2141 class of DCLASS (recursively). A return of -1 indicates "not
2142 found" or a problem. */
2145 virtual_base_index_skip_primaries (struct type *base,
2146 struct type *dclass)
2148 struct type *vbase, **vbase_list;
2150 struct type *primary;
2152 if ((TYPE_CODE (dclass) != TYPE_CODE_CLASS)
2153 || (TYPE_CODE (base) != TYPE_CODE_CLASS))
2156 primary = TYPE_RUNTIME_PTR (dclass) ? TYPE_PRIMARY_BASE (dclass) : NULL;
2158 vbase_list = virtual_base_list (dclass);
2159 for (i = 0, j = -1, vbase = vbase_list[0];
2161 vbase = vbase_list[++i])
2164 || (virtual_base_index_skip_primaries (vbase, primary) < 0))
2170 return vbase ? j : -1;
2173 /* Return position of a derived class DCLASS in the list of primary
2174 bases starting with the remotest ancestor. Position returned is
2178 class_index_in_primary_list (struct type *dclass)
2180 struct type *pbc; /* primary base class */
2182 /* Simply recurse on primary base */
2183 pbc = TYPE_PRIMARY_BASE (dclass);
2185 return 1 + class_index_in_primary_list (pbc);
2190 /* Return a count of the number of virtual functions a type has. This
2191 includes all the virtual functions it inherits from its base
2194 /* pai: FIXME This doesn't do the right thing: count redefined virtual
2195 functions only once (latest redefinition). */
2198 count_virtual_fns (struct type *dclass)
2200 int fn, oi; /* function and overloaded instance indices */
2201 int vfuncs; /* count to return */
2203 /* recurse on bases that can share virtual table */
2204 struct type *pbc = primary_base_class (dclass);
2206 vfuncs = count_virtual_fns (pbc);
2210 for (fn = 0; fn < TYPE_NFN_FIELDS (dclass); fn++)
2211 for (oi = 0; oi < TYPE_FN_FIELDLIST_LENGTH (dclass, fn); oi++)
2212 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass, fn), oi))
2220 /* Functions for overload resolution begin here */
2222 /* Compare two badness vectors A and B and return the result.
2223 0 => A and B are identical
2224 1 => A and B are incomparable
2225 2 => A is better than B
2226 3 => A is worse than B */
2229 compare_badness (struct badness_vector *a, struct badness_vector *b)
2233 short found_pos = 0; /* any positives in c? */
2234 short found_neg = 0; /* any negatives in c? */
2236 /* differing lengths => incomparable */
2237 if (a->length != b->length)
2240 /* Subtract b from a */
2241 for (i = 0; i < a->length; i++)
2243 tmp = a->rank[i] - b->rank[i];
2253 return 1; /* incomparable */
2255 return 3; /* A > B */
2261 return 2; /* A < B */
2263 return 0; /* A == B */
2267 /* Rank a function by comparing its parameter types (PARMS, length
2268 NPARMS), to the types of an argument list (ARGS, length NARGS).
2269 Return a pointer to a badness vector. This has NARGS + 1
2272 struct badness_vector *
2273 rank_function (struct type **parms, int nparms,
2274 struct type **args, int nargs)
2277 struct badness_vector *bv;
2278 int min_len = nparms < nargs ? nparms : nargs;
2280 bv = xmalloc (sizeof (struct badness_vector));
2281 bv->length = nargs + 1; /* add 1 for the length-match rank */
2282 bv->rank = xmalloc ((nargs + 1) * sizeof (int));
2284 /* First compare the lengths of the supplied lists.
2285 If there is a mismatch, set it to a high value. */
2287 /* pai/1997-06-03 FIXME: when we have debug info about default
2288 arguments and ellipsis parameter lists, we should consider those
2289 and rank the length-match more finely. */
2291 LENGTH_MATCH (bv) = (nargs != nparms) ? LENGTH_MISMATCH_BADNESS : 0;
2293 /* Now rank all the parameters of the candidate function */
2294 for (i = 1; i <= min_len; i++)
2295 bv->rank[i] = rank_one_type (parms[i-1], args[i-1]);
2297 /* If more arguments than parameters, add dummy entries */
2298 for (i = min_len + 1; i <= nargs; i++)
2299 bv->rank[i] = TOO_FEW_PARAMS_BADNESS;
2304 /* Compare the names of two integer types, assuming that any sign
2305 qualifiers have been checked already. We do it this way because
2306 there may be an "int" in the name of one of the types. */
2309 integer_types_same_name_p (const char *first, const char *second)
2311 int first_p, second_p;
2313 /* If both are shorts, return 1; if neither is a short, keep
2315 first_p = (strstr (first, "short") != NULL);
2316 second_p = (strstr (second, "short") != NULL);
2317 if (first_p && second_p)
2319 if (first_p || second_p)
2322 /* Likewise for long. */
2323 first_p = (strstr (first, "long") != NULL);
2324 second_p = (strstr (second, "long") != NULL);
2325 if (first_p && second_p)
2327 if (first_p || second_p)
2330 /* Likewise for char. */
2331 first_p = (strstr (first, "char") != NULL);
2332 second_p = (strstr (second, "char") != NULL);
2333 if (first_p && second_p)
2335 if (first_p || second_p)
2338 /* They must both be ints. */
2342 /* Compare one type (PARM) for compatibility with another (ARG).
2343 * PARM is intended to be the parameter type of a function; and
2344 * ARG is the supplied argument's type. This function tests if
2345 * the latter can be converted to the former.
2347 * Return 0 if they are identical types;
2348 * Otherwise, return an integer which corresponds to how compatible
2349 * PARM is to ARG. The higher the return value, the worse the match.
2350 * Generally the "bad" conversions are all uniformly assigned a 100. */
2353 rank_one_type (struct type *parm, struct type *arg)
2355 /* Identical type pointers. */
2356 /* However, this still doesn't catch all cases of same type for arg
2357 and param. The reason is that builtin types are different from
2358 the same ones constructed from the object. */
2362 /* Resolve typedefs */
2363 if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF)
2364 parm = check_typedef (parm);
2365 if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
2366 arg = check_typedef (arg);
2369 Well, damnit, if the names are exactly the same, I'll say they
2370 are exactly the same. This happens when we generate method
2371 stubs. The types won't point to the same address, but they
2372 really are the same.
2375 if (TYPE_NAME (parm) && TYPE_NAME (arg)
2376 && !strcmp (TYPE_NAME (parm), TYPE_NAME (arg)))
2379 /* Check if identical after resolving typedefs. */
2383 /* See through references, since we can almost make non-references
2385 if (TYPE_CODE (arg) == TYPE_CODE_REF)
2386 return (rank_one_type (parm, TYPE_TARGET_TYPE (arg))
2387 + REFERENCE_CONVERSION_BADNESS);
2388 if (TYPE_CODE (parm) == TYPE_CODE_REF)
2389 return (rank_one_type (TYPE_TARGET_TYPE (parm), arg)
2390 + REFERENCE_CONVERSION_BADNESS);
2392 /* Debugging only. */
2393 fprintf_filtered (gdb_stderr,
2394 "------ Arg is %s [%d], parm is %s [%d]\n",
2395 TYPE_NAME (arg), TYPE_CODE (arg),
2396 TYPE_NAME (parm), TYPE_CODE (parm));
2398 /* x -> y means arg of type x being supplied for parameter of type y */
2400 switch (TYPE_CODE (parm))
2403 switch (TYPE_CODE (arg))
2406 if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID)
2407 return VOID_PTR_CONVERSION_BADNESS;
2409 return rank_one_type (TYPE_TARGET_TYPE (parm),
2410 TYPE_TARGET_TYPE (arg));
2411 case TYPE_CODE_ARRAY:
2412 return rank_one_type (TYPE_TARGET_TYPE (parm),
2413 TYPE_TARGET_TYPE (arg));
2414 case TYPE_CODE_FUNC:
2415 return rank_one_type (TYPE_TARGET_TYPE (parm), arg);
2417 case TYPE_CODE_ENUM:
2418 case TYPE_CODE_FLAGS:
2419 case TYPE_CODE_CHAR:
2420 case TYPE_CODE_RANGE:
2421 case TYPE_CODE_BOOL:
2422 return POINTER_CONVERSION_BADNESS;
2424 return INCOMPATIBLE_TYPE_BADNESS;
2426 case TYPE_CODE_ARRAY:
2427 switch (TYPE_CODE (arg))
2430 case TYPE_CODE_ARRAY:
2431 return rank_one_type (TYPE_TARGET_TYPE (parm),
2432 TYPE_TARGET_TYPE (arg));
2434 return INCOMPATIBLE_TYPE_BADNESS;
2436 case TYPE_CODE_FUNC:
2437 switch (TYPE_CODE (arg))
2439 case TYPE_CODE_PTR: /* funcptr -> func */
2440 return rank_one_type (parm, TYPE_TARGET_TYPE (arg));
2442 return INCOMPATIBLE_TYPE_BADNESS;
2445 switch (TYPE_CODE (arg))
2448 if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2450 /* Deal with signed, unsigned, and plain chars and
2451 signed and unsigned ints. */
2452 if (TYPE_NOSIGN (parm))
2454 /* This case only for character types */
2455 if (TYPE_NOSIGN (arg))
2456 return 0; /* plain char -> plain char */
2457 else /* signed/unsigned char -> plain char */
2458 return INTEGER_CONVERSION_BADNESS;
2460 else if (TYPE_UNSIGNED (parm))
2462 if (TYPE_UNSIGNED (arg))
2464 /* unsigned int -> unsigned int, or
2465 unsigned long -> unsigned long */
2466 if (integer_types_same_name_p (TYPE_NAME (parm),
2469 else if (integer_types_same_name_p (TYPE_NAME (arg),
2471 && integer_types_same_name_p (TYPE_NAME (parm),
2473 return INTEGER_PROMOTION_BADNESS; /* unsigned int -> unsigned long */
2475 return INTEGER_CONVERSION_BADNESS; /* unsigned long -> unsigned int */
2479 if (integer_types_same_name_p (TYPE_NAME (arg),
2481 && integer_types_same_name_p (TYPE_NAME (parm),
2483 return INTEGER_CONVERSION_BADNESS; /* signed long -> unsigned int */
2485 return INTEGER_CONVERSION_BADNESS; /* signed int/long -> unsigned int/long */
2488 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2490 if (integer_types_same_name_p (TYPE_NAME (parm),
2493 else if (integer_types_same_name_p (TYPE_NAME (arg),
2495 && integer_types_same_name_p (TYPE_NAME (parm),
2497 return INTEGER_PROMOTION_BADNESS;
2499 return INTEGER_CONVERSION_BADNESS;
2502 return INTEGER_CONVERSION_BADNESS;
2504 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2505 return INTEGER_PROMOTION_BADNESS;
2507 return INTEGER_CONVERSION_BADNESS;
2508 case TYPE_CODE_ENUM:
2509 case TYPE_CODE_FLAGS:
2510 case TYPE_CODE_CHAR:
2511 case TYPE_CODE_RANGE:
2512 case TYPE_CODE_BOOL:
2513 return INTEGER_PROMOTION_BADNESS;
2515 return INT_FLOAT_CONVERSION_BADNESS;
2517 return NS_POINTER_CONVERSION_BADNESS;
2519 return INCOMPATIBLE_TYPE_BADNESS;
2522 case TYPE_CODE_ENUM:
2523 switch (TYPE_CODE (arg))
2526 case TYPE_CODE_CHAR:
2527 case TYPE_CODE_RANGE:
2528 case TYPE_CODE_BOOL:
2529 case TYPE_CODE_ENUM:
2530 return INTEGER_CONVERSION_BADNESS;
2532 return INT_FLOAT_CONVERSION_BADNESS;
2534 return INCOMPATIBLE_TYPE_BADNESS;
2537 case TYPE_CODE_CHAR:
2538 switch (TYPE_CODE (arg))
2540 case TYPE_CODE_RANGE:
2541 case TYPE_CODE_BOOL:
2542 case TYPE_CODE_ENUM:
2543 return INTEGER_CONVERSION_BADNESS;
2545 return INT_FLOAT_CONVERSION_BADNESS;
2547 if (TYPE_LENGTH (arg) > TYPE_LENGTH (parm))
2548 return INTEGER_CONVERSION_BADNESS;
2549 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2550 return INTEGER_PROMOTION_BADNESS;
2551 /* >>> !! else fall through !! <<< */
2552 case TYPE_CODE_CHAR:
2553 /* Deal with signed, unsigned, and plain chars for C++ and
2554 with int cases falling through from previous case. */
2555 if (TYPE_NOSIGN (parm))
2557 if (TYPE_NOSIGN (arg))
2560 return INTEGER_CONVERSION_BADNESS;
2562 else if (TYPE_UNSIGNED (parm))
2564 if (TYPE_UNSIGNED (arg))
2567 return INTEGER_PROMOTION_BADNESS;
2569 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2572 return INTEGER_CONVERSION_BADNESS;
2574 return INCOMPATIBLE_TYPE_BADNESS;
2577 case TYPE_CODE_RANGE:
2578 switch (TYPE_CODE (arg))
2581 case TYPE_CODE_CHAR:
2582 case TYPE_CODE_RANGE:
2583 case TYPE_CODE_BOOL:
2584 case TYPE_CODE_ENUM:
2585 return INTEGER_CONVERSION_BADNESS;
2587 return INT_FLOAT_CONVERSION_BADNESS;
2589 return INCOMPATIBLE_TYPE_BADNESS;
2592 case TYPE_CODE_BOOL:
2593 switch (TYPE_CODE (arg))
2596 case TYPE_CODE_CHAR:
2597 case TYPE_CODE_RANGE:
2598 case TYPE_CODE_ENUM:
2601 return BOOLEAN_CONVERSION_BADNESS;
2602 case TYPE_CODE_BOOL:
2605 return INCOMPATIBLE_TYPE_BADNESS;
2609 switch (TYPE_CODE (arg))
2612 if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2613 return FLOAT_PROMOTION_BADNESS;
2614 else if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2617 return FLOAT_CONVERSION_BADNESS;
2619 case TYPE_CODE_BOOL:
2620 case TYPE_CODE_ENUM:
2621 case TYPE_CODE_RANGE:
2622 case TYPE_CODE_CHAR:
2623 return INT_FLOAT_CONVERSION_BADNESS;
2625 return INCOMPATIBLE_TYPE_BADNESS;
2628 case TYPE_CODE_COMPLEX:
2629 switch (TYPE_CODE (arg))
2630 { /* Strictly not needed for C++, but... */
2632 return FLOAT_PROMOTION_BADNESS;
2633 case TYPE_CODE_COMPLEX:
2636 return INCOMPATIBLE_TYPE_BADNESS;
2639 case TYPE_CODE_STRUCT:
2640 /* currently same as TYPE_CODE_CLASS */
2641 switch (TYPE_CODE (arg))
2643 case TYPE_CODE_STRUCT:
2644 /* Check for derivation */
2645 if (is_ancestor (parm, arg))
2646 return BASE_CONVERSION_BADNESS;
2647 /* else fall through */
2649 return INCOMPATIBLE_TYPE_BADNESS;
2652 case TYPE_CODE_UNION:
2653 switch (TYPE_CODE (arg))
2655 case TYPE_CODE_UNION:
2657 return INCOMPATIBLE_TYPE_BADNESS;
2660 case TYPE_CODE_MEMBERPTR:
2661 switch (TYPE_CODE (arg))
2664 return INCOMPATIBLE_TYPE_BADNESS;
2667 case TYPE_CODE_METHOD:
2668 switch (TYPE_CODE (arg))
2672 return INCOMPATIBLE_TYPE_BADNESS;
2676 switch (TYPE_CODE (arg))
2680 return INCOMPATIBLE_TYPE_BADNESS;
2685 switch (TYPE_CODE (arg))
2689 return rank_one_type (TYPE_FIELD_TYPE (parm, 0),
2690 TYPE_FIELD_TYPE (arg, 0));
2692 return INCOMPATIBLE_TYPE_BADNESS;
2695 case TYPE_CODE_VOID:
2697 return INCOMPATIBLE_TYPE_BADNESS;
2698 } /* switch (TYPE_CODE (arg)) */
2702 /* End of functions for overload resolution */
2705 print_bit_vector (B_TYPE *bits, int nbits)
2709 for (bitno = 0; bitno < nbits; bitno++)
2711 if ((bitno % 8) == 0)
2713 puts_filtered (" ");
2715 if (B_TST (bits, bitno))
2716 printf_filtered (("1"));
2718 printf_filtered (("0"));
2722 /* Note the first arg should be the "this" pointer, we may not want to
2723 include it since we may get into a infinitely recursive
2727 print_arg_types (struct field *args, int nargs, int spaces)
2733 for (i = 0; i < nargs; i++)
2734 recursive_dump_type (args[i].type, spaces + 2);
2739 dump_fn_fieldlists (struct type *type, int spaces)
2745 printfi_filtered (spaces, "fn_fieldlists ");
2746 gdb_print_host_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
2747 printf_filtered ("\n");
2748 for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
2750 f = TYPE_FN_FIELDLIST1 (type, method_idx);
2751 printfi_filtered (spaces + 2, "[%d] name '%s' (",
2753 TYPE_FN_FIELDLIST_NAME (type, method_idx));
2754 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
2756 printf_filtered (_(") length %d\n"),
2757 TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
2758 for (overload_idx = 0;
2759 overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
2762 printfi_filtered (spaces + 4, "[%d] physname '%s' (",
2764 TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
2765 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
2767 printf_filtered (")\n");
2768 printfi_filtered (spaces + 8, "type ");
2769 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx),
2771 printf_filtered ("\n");
2773 recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
2776 printfi_filtered (spaces + 8, "args ");
2777 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx),
2779 printf_filtered ("\n");
2781 print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx),
2782 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f,
2785 printfi_filtered (spaces + 8, "fcontext ");
2786 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
2788 printf_filtered ("\n");
2790 printfi_filtered (spaces + 8, "is_const %d\n",
2791 TYPE_FN_FIELD_CONST (f, overload_idx));
2792 printfi_filtered (spaces + 8, "is_volatile %d\n",
2793 TYPE_FN_FIELD_VOLATILE (f, overload_idx));
2794 printfi_filtered (spaces + 8, "is_private %d\n",
2795 TYPE_FN_FIELD_PRIVATE (f, overload_idx));
2796 printfi_filtered (spaces + 8, "is_protected %d\n",
2797 TYPE_FN_FIELD_PROTECTED (f, overload_idx));
2798 printfi_filtered (spaces + 8, "is_stub %d\n",
2799 TYPE_FN_FIELD_STUB (f, overload_idx));
2800 printfi_filtered (spaces + 8, "voffset %u\n",
2801 TYPE_FN_FIELD_VOFFSET (f, overload_idx));
2807 print_cplus_stuff (struct type *type, int spaces)
2809 printfi_filtered (spaces, "n_baseclasses %d\n",
2810 TYPE_N_BASECLASSES (type));
2811 printfi_filtered (spaces, "nfn_fields %d\n",
2812 TYPE_NFN_FIELDS (type));
2813 printfi_filtered (spaces, "nfn_fields_total %d\n",
2814 TYPE_NFN_FIELDS_TOTAL (type));
2815 if (TYPE_N_BASECLASSES (type) > 0)
2817 printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
2818 TYPE_N_BASECLASSES (type));
2819 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type),
2821 printf_filtered (")");
2823 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
2824 TYPE_N_BASECLASSES (type));
2825 puts_filtered ("\n");
2827 if (TYPE_NFIELDS (type) > 0)
2829 if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
2831 printfi_filtered (spaces,
2832 "private_field_bits (%d bits at *",
2833 TYPE_NFIELDS (type));
2834 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type),
2836 printf_filtered (")");
2837 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
2838 TYPE_NFIELDS (type));
2839 puts_filtered ("\n");
2841 if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
2843 printfi_filtered (spaces,
2844 "protected_field_bits (%d bits at *",
2845 TYPE_NFIELDS (type));
2846 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type),
2848 printf_filtered (")");
2849 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
2850 TYPE_NFIELDS (type));
2851 puts_filtered ("\n");
2854 if (TYPE_NFN_FIELDS (type) > 0)
2856 dump_fn_fieldlists (type, spaces);
2861 print_bound_type (int bt)
2865 case BOUND_CANNOT_BE_DETERMINED:
2866 printf_filtered ("(BOUND_CANNOT_BE_DETERMINED)");
2868 case BOUND_BY_REF_ON_STACK:
2869 printf_filtered ("(BOUND_BY_REF_ON_STACK)");
2871 case BOUND_BY_VALUE_ON_STACK:
2872 printf_filtered ("(BOUND_BY_VALUE_ON_STACK)");
2874 case BOUND_BY_REF_IN_REG:
2875 printf_filtered ("(BOUND_BY_REF_IN_REG)");
2877 case BOUND_BY_VALUE_IN_REG:
2878 printf_filtered ("(BOUND_BY_VALUE_IN_REG)");
2881 printf_filtered ("(BOUND_SIMPLE)");
2884 printf_filtered (_("(unknown bound type)"));
2889 static struct obstack dont_print_type_obstack;
2892 recursive_dump_type (struct type *type, int spaces)
2897 obstack_begin (&dont_print_type_obstack, 0);
2899 if (TYPE_NFIELDS (type) > 0
2900 || (TYPE_CPLUS_SPECIFIC (type) && TYPE_NFN_FIELDS (type) > 0))
2902 struct type **first_dont_print
2903 = (struct type **) obstack_base (&dont_print_type_obstack);
2905 int i = (struct type **)
2906 obstack_next_free (&dont_print_type_obstack) - first_dont_print;
2910 if (type == first_dont_print[i])
2912 printfi_filtered (spaces, "type node ");
2913 gdb_print_host_address (type, gdb_stdout);
2914 printf_filtered (_(" <same as already seen type>\n"));
2919 obstack_ptr_grow (&dont_print_type_obstack, type);
2922 printfi_filtered (spaces, "type node ");
2923 gdb_print_host_address (type, gdb_stdout);
2924 printf_filtered ("\n");
2925 printfi_filtered (spaces, "name '%s' (",
2926 TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
2927 gdb_print_host_address (TYPE_NAME (type), gdb_stdout);
2928 printf_filtered (")\n");
2929 printfi_filtered (spaces, "tagname '%s' (",
2930 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : "<NULL>");
2931 gdb_print_host_address (TYPE_TAG_NAME (type), gdb_stdout);
2932 printf_filtered (")\n");
2933 printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
2934 switch (TYPE_CODE (type))
2936 case TYPE_CODE_UNDEF:
2937 printf_filtered ("(TYPE_CODE_UNDEF)");
2940 printf_filtered ("(TYPE_CODE_PTR)");
2942 case TYPE_CODE_ARRAY:
2943 printf_filtered ("(TYPE_CODE_ARRAY)");
2945 case TYPE_CODE_STRUCT:
2946 printf_filtered ("(TYPE_CODE_STRUCT)");
2948 case TYPE_CODE_UNION:
2949 printf_filtered ("(TYPE_CODE_UNION)");
2951 case TYPE_CODE_ENUM:
2952 printf_filtered ("(TYPE_CODE_ENUM)");
2954 case TYPE_CODE_FLAGS:
2955 printf_filtered ("(TYPE_CODE_FLAGS)");
2957 case TYPE_CODE_FUNC:
2958 printf_filtered ("(TYPE_CODE_FUNC)");
2961 printf_filtered ("(TYPE_CODE_INT)");
2964 printf_filtered ("(TYPE_CODE_FLT)");
2966 case TYPE_CODE_VOID:
2967 printf_filtered ("(TYPE_CODE_VOID)");
2970 printf_filtered ("(TYPE_CODE_SET)");
2972 case TYPE_CODE_RANGE:
2973 printf_filtered ("(TYPE_CODE_RANGE)");
2975 case TYPE_CODE_STRING:
2976 printf_filtered ("(TYPE_CODE_STRING)");
2978 case TYPE_CODE_BITSTRING:
2979 printf_filtered ("(TYPE_CODE_BITSTRING)");
2981 case TYPE_CODE_ERROR:
2982 printf_filtered ("(TYPE_CODE_ERROR)");
2984 case TYPE_CODE_MEMBERPTR:
2985 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
2987 case TYPE_CODE_METHODPTR:
2988 printf_filtered ("(TYPE_CODE_METHODPTR)");
2990 case TYPE_CODE_METHOD:
2991 printf_filtered ("(TYPE_CODE_METHOD)");
2994 printf_filtered ("(TYPE_CODE_REF)");
2996 case TYPE_CODE_CHAR:
2997 printf_filtered ("(TYPE_CODE_CHAR)");
2999 case TYPE_CODE_BOOL:
3000 printf_filtered ("(TYPE_CODE_BOOL)");
3002 case TYPE_CODE_COMPLEX:
3003 printf_filtered ("(TYPE_CODE_COMPLEX)");
3005 case TYPE_CODE_TYPEDEF:
3006 printf_filtered ("(TYPE_CODE_TYPEDEF)");
3008 case TYPE_CODE_TEMPLATE:
3009 printf_filtered ("(TYPE_CODE_TEMPLATE)");
3011 case TYPE_CODE_TEMPLATE_ARG:
3012 printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)");
3014 case TYPE_CODE_NAMESPACE:
3015 printf_filtered ("(TYPE_CODE_NAMESPACE)");
3018 printf_filtered ("(UNKNOWN TYPE CODE)");
3021 puts_filtered ("\n");
3022 printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
3023 printfi_filtered (spaces, "upper_bound_type 0x%x ",
3024 TYPE_ARRAY_UPPER_BOUND_TYPE (type));
3025 print_bound_type (TYPE_ARRAY_UPPER_BOUND_TYPE (type));
3026 puts_filtered ("\n");
3027 printfi_filtered (spaces, "lower_bound_type 0x%x ",
3028 TYPE_ARRAY_LOWER_BOUND_TYPE (type));
3029 print_bound_type (TYPE_ARRAY_LOWER_BOUND_TYPE (type));
3030 puts_filtered ("\n");
3031 printfi_filtered (spaces, "objfile ");
3032 gdb_print_host_address (TYPE_OBJFILE (type), gdb_stdout);
3033 printf_filtered ("\n");
3034 printfi_filtered (spaces, "target_type ");
3035 gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout);
3036 printf_filtered ("\n");
3037 if (TYPE_TARGET_TYPE (type) != NULL)
3039 recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
3041 printfi_filtered (spaces, "pointer_type ");
3042 gdb_print_host_address (TYPE_POINTER_TYPE (type), gdb_stdout);
3043 printf_filtered ("\n");
3044 printfi_filtered (spaces, "reference_type ");
3045 gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
3046 printf_filtered ("\n");
3047 printfi_filtered (spaces, "type_chain ");
3048 gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);
3049 printf_filtered ("\n");
3050 printfi_filtered (spaces, "instance_flags 0x%x",
3051 TYPE_INSTANCE_FLAGS (type));
3052 if (TYPE_CONST (type))
3054 puts_filtered (" TYPE_FLAG_CONST");
3056 if (TYPE_VOLATILE (type))
3058 puts_filtered (" TYPE_FLAG_VOLATILE");
3060 if (TYPE_CODE_SPACE (type))
3062 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3064 if (TYPE_DATA_SPACE (type))
3066 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3068 if (TYPE_ADDRESS_CLASS_1 (type))
3070 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3072 if (TYPE_ADDRESS_CLASS_2 (type))
3074 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3076 puts_filtered ("\n");
3077 printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
3078 if (TYPE_UNSIGNED (type))
3080 puts_filtered (" TYPE_FLAG_UNSIGNED");
3082 if (TYPE_NOSIGN (type))
3084 puts_filtered (" TYPE_FLAG_NOSIGN");
3086 if (TYPE_STUB (type))
3088 puts_filtered (" TYPE_FLAG_STUB");
3090 if (TYPE_TARGET_STUB (type))
3092 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3094 if (TYPE_STATIC (type))
3096 puts_filtered (" TYPE_FLAG_STATIC");
3098 if (TYPE_PROTOTYPED (type))
3100 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3102 if (TYPE_INCOMPLETE (type))
3104 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3106 if (TYPE_VARARGS (type))
3108 puts_filtered (" TYPE_FLAG_VARARGS");
3110 /* This is used for things like AltiVec registers on ppc. Gcc emits
3111 an attribute for the array type, which tells whether or not we
3112 have a vector, instead of a regular array. */
3113 if (TYPE_VECTOR (type))
3115 puts_filtered (" TYPE_FLAG_VECTOR");
3117 puts_filtered ("\n");
3118 printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
3119 gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
3120 puts_filtered ("\n");
3121 for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
3123 printfi_filtered (spaces + 2,
3124 "[%d] bitpos %d bitsize %d type ",
3125 idx, TYPE_FIELD_BITPOS (type, idx),
3126 TYPE_FIELD_BITSIZE (type, idx));
3127 gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
3128 printf_filtered (" name '%s' (",
3129 TYPE_FIELD_NAME (type, idx) != NULL
3130 ? TYPE_FIELD_NAME (type, idx)
3132 gdb_print_host_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
3133 printf_filtered (")\n");
3134 if (TYPE_FIELD_TYPE (type, idx) != NULL)
3136 recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
3139 printfi_filtered (spaces, "vptr_basetype ");
3140 gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
3141 puts_filtered ("\n");
3142 if (TYPE_VPTR_BASETYPE (type) != NULL)
3144 recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
3146 printfi_filtered (spaces, "vptr_fieldno %d\n",
3147 TYPE_VPTR_FIELDNO (type));
3148 switch (TYPE_CODE (type))
3150 case TYPE_CODE_STRUCT:
3151 printfi_filtered (spaces, "cplus_stuff ");
3152 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type),
3154 puts_filtered ("\n");
3155 print_cplus_stuff (type, spaces);
3159 printfi_filtered (spaces, "floatformat ");
3160 if (TYPE_FLOATFORMAT (type) == NULL)
3161 puts_filtered ("(null)");
3164 puts_filtered ("{ ");
3165 if (TYPE_FLOATFORMAT (type)[0] == NULL
3166 || TYPE_FLOATFORMAT (type)[0]->name == NULL)
3167 puts_filtered ("(null)");
3169 puts_filtered (TYPE_FLOATFORMAT (type)[0]->name);
3171 puts_filtered (", ");
3172 if (TYPE_FLOATFORMAT (type)[1] == NULL
3173 || TYPE_FLOATFORMAT (type)[1]->name == NULL)
3174 puts_filtered ("(null)");
3176 puts_filtered (TYPE_FLOATFORMAT (type)[1]->name);
3178 puts_filtered (" }");
3180 puts_filtered ("\n");
3184 /* We have to pick one of the union types to be able print and
3185 test the value. Pick cplus_struct_type, even though we know
3186 it isn't any particular one. */
3187 printfi_filtered (spaces, "type_specific ");
3188 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
3189 if (TYPE_CPLUS_SPECIFIC (type) != NULL)
3191 printf_filtered (_(" (unknown data form)"));
3193 printf_filtered ("\n");
3198 obstack_free (&dont_print_type_obstack, NULL);
3201 /* Trivial helpers for the libiberty hash table, for mapping one
3206 struct type *old, *new;
3210 type_pair_hash (const void *item)
3212 const struct type_pair *pair = item;
3213 return htab_hash_pointer (pair->old);
3217 type_pair_eq (const void *item_lhs, const void *item_rhs)
3219 const struct type_pair *lhs = item_lhs, *rhs = item_rhs;
3220 return lhs->old == rhs->old;
3223 /* Allocate the hash table used by copy_type_recursive to walk
3224 types without duplicates. We use OBJFILE's obstack, because
3225 OBJFILE is about to be deleted. */
3228 create_copied_types_hash (struct objfile *objfile)
3230 return htab_create_alloc_ex (1, type_pair_hash, type_pair_eq,
3231 NULL, &objfile->objfile_obstack,
3232 hashtab_obstack_allocate,
3233 dummy_obstack_deallocate);
3236 /* Recursively copy (deep copy) TYPE, if it is associated with
3237 OBJFILE. Return a new type allocated using malloc, a saved type if
3238 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
3239 not associated with OBJFILE. */
3242 copy_type_recursive (struct objfile *objfile,
3244 htab_t copied_types)
3246 struct type_pair *stored, pair;
3248 struct type *new_type;
3250 if (TYPE_OBJFILE (type) == NULL)
3253 /* This type shouldn't be pointing to any types in other objfiles;
3254 if it did, the type might disappear unexpectedly. */
3255 gdb_assert (TYPE_OBJFILE (type) == objfile);
3258 slot = htab_find_slot (copied_types, &pair, INSERT);
3260 return ((struct type_pair *) *slot)->new;
3262 new_type = alloc_type (NULL);
3264 /* We must add the new type to the hash table immediately, in case
3265 we encounter this type again during a recursive call below. */
3266 stored = xmalloc (sizeof (struct type_pair));
3268 stored->new = new_type;
3271 /* Copy the common fields of types. */
3272 TYPE_CODE (new_type) = TYPE_CODE (type);
3273 TYPE_ARRAY_UPPER_BOUND_TYPE (new_type) =
3274 TYPE_ARRAY_UPPER_BOUND_TYPE (type);
3275 TYPE_ARRAY_LOWER_BOUND_TYPE (new_type) =
3276 TYPE_ARRAY_LOWER_BOUND_TYPE (type);
3277 if (TYPE_NAME (type))
3278 TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type));
3279 if (TYPE_TAG_NAME (type))
3280 TYPE_TAG_NAME (new_type) = xstrdup (TYPE_TAG_NAME (type));
3281 TYPE_FLAGS (new_type) = TYPE_FLAGS (type);
3282 TYPE_VPTR_FIELDNO (new_type) = TYPE_VPTR_FIELDNO (type);
3284 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
3285 TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
3287 /* Copy the fields. */
3288 TYPE_NFIELDS (new_type) = TYPE_NFIELDS (type);
3289 if (TYPE_NFIELDS (type))
3293 nfields = TYPE_NFIELDS (type);
3294 TYPE_FIELDS (new_type) = xmalloc (sizeof (struct field) * nfields);
3295 for (i = 0; i < nfields; i++)
3297 TYPE_FIELD_ARTIFICIAL (new_type, i) =
3298 TYPE_FIELD_ARTIFICIAL (type, i);
3299 TYPE_FIELD_BITSIZE (new_type, i) = TYPE_FIELD_BITSIZE (type, i);
3300 if (TYPE_FIELD_TYPE (type, i))
3301 TYPE_FIELD_TYPE (new_type, i)
3302 = copy_type_recursive (objfile, TYPE_FIELD_TYPE (type, i),
3304 if (TYPE_FIELD_NAME (type, i))
3305 TYPE_FIELD_NAME (new_type, i) =
3306 xstrdup (TYPE_FIELD_NAME (type, i));
3307 if (TYPE_FIELD_STATIC_HAS_ADDR (type, i))
3308 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i),
3309 TYPE_FIELD_STATIC_PHYSADDR (type, i));
3310 else if (TYPE_FIELD_STATIC (type, i))
3311 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i),
3312 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type,
3316 TYPE_FIELD_BITPOS (new_type, i) =
3317 TYPE_FIELD_BITPOS (type, i);
3318 TYPE_FIELD_STATIC_KIND (new_type, i) = 0;
3323 /* Copy pointers to other types. */
3324 if (TYPE_TARGET_TYPE (type))
3325 TYPE_TARGET_TYPE (new_type) =
3326 copy_type_recursive (objfile,
3327 TYPE_TARGET_TYPE (type),
3329 if (TYPE_VPTR_BASETYPE (type))
3330 TYPE_VPTR_BASETYPE (new_type) =
3331 copy_type_recursive (objfile,
3332 TYPE_VPTR_BASETYPE (type),
3334 /* Maybe copy the type_specific bits.
3336 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3337 base classes and methods. There's no fundamental reason why we
3338 can't, but at the moment it is not needed. */
3340 if (TYPE_CODE (type) == TYPE_CODE_FLT)
3341 TYPE_FLOATFORMAT (new_type) = TYPE_FLOATFORMAT (type);
3342 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
3343 || TYPE_CODE (type) == TYPE_CODE_UNION
3344 || TYPE_CODE (type) == TYPE_CODE_TEMPLATE
3345 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
3346 INIT_CPLUS_SPECIFIC (new_type);
3351 static struct type *
3352 build_flt (int bit, char *name, const struct floatformat **floatformats)
3358 gdb_assert (floatformats != NULL);
3359 gdb_assert (floatformats[0] != NULL && floatformats[1] != NULL);
3360 bit = floatformats[0]->totalsize;
3362 gdb_assert (bit >= 0);
3364 t = init_type (TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, 0, name, NULL);
3365 TYPE_FLOATFORMAT (t) = floatformats;
3369 static struct gdbarch_data *gdbtypes_data;
3371 const struct builtin_type *
3372 builtin_type (struct gdbarch *gdbarch)
3374 return gdbarch_data (gdbarch, gdbtypes_data);
3378 static struct type *
3379 build_complex (int bit, char *name, struct type *target_type)
3382 if (bit <= 0 || target_type == builtin_type_error)
3384 gdb_assert (builtin_type_error != NULL);
3385 return builtin_type_error;
3387 t = init_type (TYPE_CODE_COMPLEX, 2 * bit / TARGET_CHAR_BIT,
3388 0, name, (struct objfile *) NULL);
3389 TYPE_TARGET_TYPE (t) = target_type;
3394 gdbtypes_post_init (struct gdbarch *gdbarch)
3396 struct builtin_type *builtin_type
3397 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type);
3399 builtin_type->builtin_void =
3400 init_type (TYPE_CODE_VOID, 1,
3402 "void", (struct objfile *) NULL);
3403 builtin_type->builtin_char =
3404 init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3406 | (gdbarch_char_signed (current_gdbarch) ?
3407 0 : TYPE_FLAG_UNSIGNED)),
3408 "char", (struct objfile *) NULL);
3409 builtin_type->builtin_true_char =
3410 init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3412 "true character", (struct objfile *) NULL);
3413 builtin_type->builtin_signed_char =
3414 init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3416 "signed char", (struct objfile *) NULL);
3417 builtin_type->builtin_unsigned_char =
3418 init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3420 "unsigned char", (struct objfile *) NULL);
3421 builtin_type->builtin_short =
3422 init_type (TYPE_CODE_INT,
3423 gdbarch_short_bit (current_gdbarch) / TARGET_CHAR_BIT,
3424 0, "short", (struct objfile *) NULL);
3425 builtin_type->builtin_unsigned_short =
3426 init_type (TYPE_CODE_INT,
3427 gdbarch_short_bit (current_gdbarch) / TARGET_CHAR_BIT,
3428 TYPE_FLAG_UNSIGNED, "unsigned short",
3429 (struct objfile *) NULL);
3430 builtin_type->builtin_int =
3431 init_type (TYPE_CODE_INT,
3432 gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
3433 0, "int", (struct objfile *) NULL);
3434 builtin_type->builtin_unsigned_int =
3435 init_type (TYPE_CODE_INT,
3436 gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
3437 TYPE_FLAG_UNSIGNED, "unsigned int",
3438 (struct objfile *) NULL);
3439 builtin_type->builtin_long =
3440 init_type (TYPE_CODE_INT,
3441 gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT,
3442 0, "long", (struct objfile *) NULL);
3443 builtin_type->builtin_unsigned_long =
3444 init_type (TYPE_CODE_INT,
3445 gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT,
3446 TYPE_FLAG_UNSIGNED, "unsigned long",
3447 (struct objfile *) NULL);
3448 builtin_type->builtin_long_long =
3449 init_type (TYPE_CODE_INT,
3450 gdbarch_long_long_bit (current_gdbarch) / TARGET_CHAR_BIT,
3451 0, "long long", (struct objfile *) NULL);
3452 builtin_type->builtin_unsigned_long_long =
3453 init_type (TYPE_CODE_INT,
3454 gdbarch_long_long_bit (current_gdbarch) / TARGET_CHAR_BIT,
3455 TYPE_FLAG_UNSIGNED, "unsigned long long",
3456 (struct objfile *) NULL);
3457 builtin_type->builtin_float
3458 = build_flt (gdbarch_float_bit (gdbarch), "float",
3459 gdbarch_float_format (gdbarch));
3460 builtin_type->builtin_double
3461 = build_flt (gdbarch_double_bit (gdbarch), "double",
3462 gdbarch_double_format (gdbarch));
3463 builtin_type->builtin_long_double
3464 = build_flt (gdbarch_long_double_bit (gdbarch), "long double",
3465 gdbarch_long_double_format (gdbarch));
3466 builtin_type->builtin_complex
3467 = build_complex (gdbarch_float_bit (gdbarch), "complex",
3468 builtin_type->builtin_float);
3469 builtin_type->builtin_double_complex
3470 = build_complex (gdbarch_double_bit (gdbarch), "double complex",
3471 builtin_type->builtin_double);
3472 builtin_type->builtin_string =
3473 init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3475 "string", (struct objfile *) NULL);
3476 builtin_type->builtin_bool =
3477 init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3479 "bool", (struct objfile *) NULL);
3481 /* Pointer/Address types. */
3483 /* NOTE: on some targets, addresses and pointers are not necessarily
3484 the same --- for example, on the D10V, pointers are 16 bits long,
3485 but addresses are 32 bits long. See doc/gdbint.texinfo,
3486 ``Pointers Are Not Always Addresses''.
3489 - gdb's `struct type' always describes the target's
3491 - gdb's `struct value' objects should always hold values in
3493 - gdb's CORE_ADDR values are addresses in the unified virtual
3494 address space that the assembler and linker work with. Thus,
3495 since target_read_memory takes a CORE_ADDR as an argument, it
3496 can access any memory on the target, even if the processor has
3497 separate code and data address spaces.
3500 - If v is a value holding a D10V code pointer, its contents are
3501 in target form: a big-endian address left-shifted two bits.
3502 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3503 sizeof (void *) == 2 on the target.
3505 In this context, builtin_type->CORE_ADDR is a bit odd: it's a
3506 target type for a value the target will never see. It's only
3507 used to hold the values of (typeless) linker symbols, which are
3508 indeed in the unified virtual address space. */
3510 builtin_type->builtin_data_ptr =
3511 make_pointer_type (builtin_type->builtin_void, NULL);
3512 builtin_type->builtin_func_ptr =
3513 lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
3514 builtin_type->builtin_core_addr =
3515 init_type (TYPE_CODE_INT,
3516 gdbarch_addr_bit (current_gdbarch) / 8,
3518 "__CORE_ADDR", (struct objfile *) NULL);
3521 /* The following set of types is used for symbols with no
3522 debug information. */
3523 builtin_type->nodebug_text_symbol =
3524 init_type (TYPE_CODE_FUNC, 1, 0,
3525 "<text variable, no debug info>", NULL);
3526 TYPE_TARGET_TYPE (builtin_type->nodebug_text_symbol) =
3527 builtin_type->builtin_int;
3528 builtin_type->nodebug_data_symbol =
3529 init_type (TYPE_CODE_INT,
3530 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
3531 "<data variable, no debug info>", NULL);
3532 builtin_type->nodebug_unknown_symbol =
3533 init_type (TYPE_CODE_INT, 1, 0,
3534 "<variable (not text or data), no debug info>", NULL);
3535 builtin_type->nodebug_tls_symbol =
3536 init_type (TYPE_CODE_INT,
3537 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
3538 "<thread local variable, no debug info>", NULL);
3540 return builtin_type;
3543 extern void _initialize_gdbtypes (void);
3545 _initialize_gdbtypes (void)
3547 gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
3549 /* FIXME: The following types are architecture-neutral. However,
3550 they contain pointer_type and reference_type fields potentially
3551 caching pointer or reference types that *are* architecture
3555 init_type (TYPE_CODE_INT, 0 / 8,
3557 "int0_t", (struct objfile *) NULL);
3559 init_type (TYPE_CODE_INT, 8 / 8,
3561 "int8_t", (struct objfile *) NULL);
3562 builtin_type_uint8 =
3563 init_type (TYPE_CODE_INT, 8 / 8,
3565 "uint8_t", (struct objfile *) NULL);
3566 builtin_type_int16 =
3567 init_type (TYPE_CODE_INT, 16 / 8,
3569 "int16_t", (struct objfile *) NULL);
3570 builtin_type_uint16 =
3571 init_type (TYPE_CODE_INT, 16 / 8,
3573 "uint16_t", (struct objfile *) NULL);
3574 builtin_type_int32 =
3575 init_type (TYPE_CODE_INT, 32 / 8,
3577 "int32_t", (struct objfile *) NULL);
3578 builtin_type_uint32 =
3579 init_type (TYPE_CODE_INT, 32 / 8,
3581 "uint32_t", (struct objfile *) NULL);
3582 builtin_type_int64 =
3583 init_type (TYPE_CODE_INT, 64 / 8,
3585 "int64_t", (struct objfile *) NULL);
3586 builtin_type_uint64 =
3587 init_type (TYPE_CODE_INT, 64 / 8,
3589 "uint64_t", (struct objfile *) NULL);
3590 builtin_type_int128 =
3591 init_type (TYPE_CODE_INT, 128 / 8,
3593 "int128_t", (struct objfile *) NULL);
3594 builtin_type_uint128 =
3595 init_type (TYPE_CODE_INT, 128 / 8,
3597 "uint128_t", (struct objfile *) NULL);
3599 builtin_type_ieee_single =
3600 build_flt (-1, "builtin_type_ieee_single", floatformats_ieee_single);
3601 builtin_type_ieee_double =
3602 build_flt (-1, "builtin_type_ieee_double", floatformats_ieee_double);
3603 builtin_type_i387_ext =
3604 build_flt (-1, "builtin_type_i387_ext", floatformats_i387_ext);
3605 builtin_type_m68881_ext =
3606 build_flt (-1, "builtin_type_m68881_ext", floatformats_m68881_ext);
3607 builtin_type_arm_ext =
3608 build_flt (-1, "builtin_type_arm_ext", floatformats_arm_ext);
3609 builtin_type_ia64_spill =
3610 build_flt (-1, "builtin_type_ia64_spill", floatformats_ia64_spill);
3611 builtin_type_ia64_quad =
3612 build_flt (-1, "builtin_type_ia64_quad", floatformats_ia64_quad);
3614 add_setshow_zinteger_cmd ("overload", no_class, &overload_debug, _("\
3615 Set debugging of C++ overloading."), _("\
3616 Show debugging of C++ overloading."), _("\
3617 When enabled, ranking of the functions is displayed."),
3619 show_overload_debug,
3620 &setdebuglist, &showdebuglist);
3622 /* Add user knob for controlling resolution of opaque types. */
3623 add_setshow_boolean_cmd ("opaque-type-resolution", class_support,
3624 &opaque_type_resolution, _("\
3625 Set resolution of opaque struct/class/union types (if set before loading symbols)."), _("\
3626 Show resolution of opaque struct/class/union types (if set before loading symbols)."), NULL,
3628 show_opaque_type_resolution,
3629 &setlist, &showlist);