1 /* Support routines for manipulating internal types for GDB.
3 Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
5 Contributed by Cygnus Support, using pieces from other GDB modules.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_string.h"
29 #include "expression.h"
34 #include "complaints.h"
37 #include "gdb_assert.h"
39 #include "exceptions.h"
41 /* Initialize BADNESS constants. */
43 const struct rank LENGTH_MISMATCH_BADNESS = {100,0};
45 const struct rank TOO_FEW_PARAMS_BADNESS = {100,0};
46 const struct rank INCOMPATIBLE_TYPE_BADNESS = {100,0};
48 const struct rank EXACT_MATCH_BADNESS = {0,0};
50 const struct rank INTEGER_PROMOTION_BADNESS = {1,0};
51 const struct rank FLOAT_PROMOTION_BADNESS = {1,0};
52 const struct rank BASE_PTR_CONVERSION_BADNESS = {1,0};
53 const struct rank INTEGER_CONVERSION_BADNESS = {2,0};
54 const struct rank FLOAT_CONVERSION_BADNESS = {2,0};
55 const struct rank INT_FLOAT_CONVERSION_BADNESS = {2,0};
56 const struct rank VOID_PTR_CONVERSION_BADNESS = {2,0};
57 const struct rank BOOL_PTR_CONVERSION_BADNESS = {3,0};
58 const struct rank BASE_CONVERSION_BADNESS = {2,0};
59 const struct rank REFERENCE_CONVERSION_BADNESS = {2,0};
60 const struct rank NULL_POINTER_CONVERSION_BADNESS = {2,0};
61 const struct rank NS_POINTER_CONVERSION_BADNESS = {10,0};
63 /* Floatformat pairs. */
64 const struct floatformat *floatformats_ieee_half[BFD_ENDIAN_UNKNOWN] = {
65 &floatformat_ieee_half_big,
66 &floatformat_ieee_half_little
68 const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN] = {
69 &floatformat_ieee_single_big,
70 &floatformat_ieee_single_little
72 const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN] = {
73 &floatformat_ieee_double_big,
74 &floatformat_ieee_double_little
76 const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN] = {
77 &floatformat_ieee_double_big,
78 &floatformat_ieee_double_littlebyte_bigword
80 const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN] = {
81 &floatformat_i387_ext,
84 const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN] = {
85 &floatformat_m68881_ext,
86 &floatformat_m68881_ext
88 const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN] = {
89 &floatformat_arm_ext_big,
90 &floatformat_arm_ext_littlebyte_bigword
92 const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN] = {
93 &floatformat_ia64_spill_big,
94 &floatformat_ia64_spill_little
96 const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN] = {
97 &floatformat_ia64_quad_big,
98 &floatformat_ia64_quad_little
100 const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN] = {
104 const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN] = {
108 const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN] = {
109 &floatformat_ibm_long_double,
110 &floatformat_ibm_long_double
114 int opaque_type_resolution = 1;
116 show_opaque_type_resolution (struct ui_file *file, int from_tty,
117 struct cmd_list_element *c,
120 fprintf_filtered (file, _("Resolution of opaque struct/class/union types "
121 "(if set before loading symbols) is %s.\n"),
125 int overload_debug = 0;
127 show_overload_debug (struct ui_file *file, int from_tty,
128 struct cmd_list_element *c, const char *value)
130 fprintf_filtered (file, _("Debugging of C++ overloading is %s.\n"),
138 }; /* Maximum extension is 128! FIXME */
140 static void print_bit_vector (B_TYPE *, int);
141 static void print_arg_types (struct field *, int, int);
142 static void dump_fn_fieldlists (struct type *, int);
143 static void print_cplus_stuff (struct type *, int);
146 /* Allocate a new OBJFILE-associated type structure and fill it
147 with some defaults. Space for the type structure is allocated
148 on the objfile's objfile_obstack. */
151 alloc_type (struct objfile *objfile)
155 gdb_assert (objfile != NULL);
157 /* Alloc the structure and start off with all fields zeroed. */
158 type = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct type);
159 TYPE_MAIN_TYPE (type) = OBSTACK_ZALLOC (&objfile->objfile_obstack,
161 OBJSTAT (objfile, n_types++);
163 TYPE_OBJFILE_OWNED (type) = 1;
164 TYPE_OWNER (type).objfile = objfile;
166 /* Initialize the fields that might not be zero. */
168 TYPE_CODE (type) = TYPE_CODE_UNDEF;
169 TYPE_VPTR_FIELDNO (type) = -1;
170 TYPE_CHAIN (type) = type; /* Chain back to itself. */
175 /* Allocate a new GDBARCH-associated type structure and fill it
176 with some defaults. Space for the type structure is allocated
180 alloc_type_arch (struct gdbarch *gdbarch)
184 gdb_assert (gdbarch != NULL);
186 /* Alloc the structure and start off with all fields zeroed. */
188 type = XZALLOC (struct type);
189 TYPE_MAIN_TYPE (type) = XZALLOC (struct main_type);
191 TYPE_OBJFILE_OWNED (type) = 0;
192 TYPE_OWNER (type).gdbarch = gdbarch;
194 /* Initialize the fields that might not be zero. */
196 TYPE_CODE (type) = TYPE_CODE_UNDEF;
197 TYPE_VPTR_FIELDNO (type) = -1;
198 TYPE_CHAIN (type) = type; /* Chain back to itself. */
203 /* If TYPE is objfile-associated, allocate a new type structure
204 associated with the same objfile. If TYPE is gdbarch-associated,
205 allocate a new type structure associated with the same gdbarch. */
208 alloc_type_copy (const struct type *type)
210 if (TYPE_OBJFILE_OWNED (type))
211 return alloc_type (TYPE_OWNER (type).objfile);
213 return alloc_type_arch (TYPE_OWNER (type).gdbarch);
216 /* If TYPE is gdbarch-associated, return that architecture.
217 If TYPE is objfile-associated, return that objfile's architecture. */
220 get_type_arch (const struct type *type)
222 if (TYPE_OBJFILE_OWNED (type))
223 return get_objfile_arch (TYPE_OWNER (type).objfile);
225 return TYPE_OWNER (type).gdbarch;
229 /* Alloc a new type instance structure, fill it with some defaults,
230 and point it at OLDTYPE. Allocate the new type instance from the
231 same place as OLDTYPE. */
234 alloc_type_instance (struct type *oldtype)
238 /* Allocate the structure. */
240 if (! TYPE_OBJFILE_OWNED (oldtype))
241 type = XZALLOC (struct type);
243 type = OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype)->objfile_obstack,
246 TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype);
248 TYPE_CHAIN (type) = type; /* Chain back to itself for now. */
253 /* Clear all remnants of the previous type at TYPE, in preparation for
254 replacing it with something else. Preserve owner information. */
256 smash_type (struct type *type)
258 int objfile_owned = TYPE_OBJFILE_OWNED (type);
259 union type_owner owner = TYPE_OWNER (type);
261 memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
263 /* Restore owner information. */
264 TYPE_OBJFILE_OWNED (type) = objfile_owned;
265 TYPE_OWNER (type) = owner;
267 /* For now, delete the rings. */
268 TYPE_CHAIN (type) = type;
270 /* For now, leave the pointer/reference types alone. */
273 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
274 to a pointer to memory where the pointer type should be stored.
275 If *TYPEPTR is zero, update it to point to the pointer type we return.
276 We allocate new memory if needed. */
279 make_pointer_type (struct type *type, struct type **typeptr)
281 struct type *ntype; /* New type */
284 ntype = TYPE_POINTER_TYPE (type);
289 return ntype; /* Don't care about alloc,
290 and have new type. */
291 else if (*typeptr == 0)
293 *typeptr = ntype; /* Tracking alloc, and have new type. */
298 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
300 ntype = alloc_type_copy (type);
304 else /* We have storage, but need to reset it. */
307 chain = TYPE_CHAIN (ntype);
309 TYPE_CHAIN (ntype) = chain;
312 TYPE_TARGET_TYPE (ntype) = type;
313 TYPE_POINTER_TYPE (type) = ntype;
315 /* FIXME! Assume the machine has only one representation for
319 = gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
320 TYPE_CODE (ntype) = TYPE_CODE_PTR;
322 /* Mark pointers as unsigned. The target converts between pointers
323 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
324 gdbarch_address_to_pointer. */
325 TYPE_UNSIGNED (ntype) = 1;
327 if (!TYPE_POINTER_TYPE (type)) /* Remember it, if don't have one. */
328 TYPE_POINTER_TYPE (type) = ntype;
330 /* Update the length of all the other variants of this type. */
331 chain = TYPE_CHAIN (ntype);
332 while (chain != ntype)
334 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
335 chain = TYPE_CHAIN (chain);
341 /* Given a type TYPE, return a type of pointers to that type.
342 May need to construct such a type if this is the first use. */
345 lookup_pointer_type (struct type *type)
347 return make_pointer_type (type, (struct type **) 0);
350 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
351 points to a pointer to memory where the reference type should be
352 stored. If *TYPEPTR is zero, update it to point to the reference
353 type we return. We allocate new memory if needed. */
356 make_reference_type (struct type *type, struct type **typeptr)
358 struct type *ntype; /* New type */
361 ntype = TYPE_REFERENCE_TYPE (type);
366 return ntype; /* Don't care about alloc,
367 and have new type. */
368 else if (*typeptr == 0)
370 *typeptr = ntype; /* Tracking alloc, and have new type. */
375 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
377 ntype = alloc_type_copy (type);
381 else /* We have storage, but need to reset it. */
384 chain = TYPE_CHAIN (ntype);
386 TYPE_CHAIN (ntype) = chain;
389 TYPE_TARGET_TYPE (ntype) = type;
390 TYPE_REFERENCE_TYPE (type) = ntype;
392 /* FIXME! Assume the machine has only one representation for
393 references, and that it matches the (only) representation for
396 TYPE_LENGTH (ntype) =
397 gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
398 TYPE_CODE (ntype) = TYPE_CODE_REF;
400 if (!TYPE_REFERENCE_TYPE (type)) /* Remember it, if don't have one. */
401 TYPE_REFERENCE_TYPE (type) = ntype;
403 /* Update the length of all the other variants of this type. */
404 chain = TYPE_CHAIN (ntype);
405 while (chain != ntype)
407 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
408 chain = TYPE_CHAIN (chain);
414 /* Same as above, but caller doesn't care about memory allocation
418 lookup_reference_type (struct type *type)
420 return make_reference_type (type, (struct type **) 0);
423 /* Lookup a function type that returns type TYPE. TYPEPTR, if
424 nonzero, points to a pointer to memory where the function type
425 should be stored. If *TYPEPTR is zero, update it to point to the
426 function type we return. We allocate new memory if needed. */
429 make_function_type (struct type *type, struct type **typeptr)
431 struct type *ntype; /* New type */
433 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
435 ntype = alloc_type_copy (type);
439 else /* We have storage, but need to reset it. */
445 TYPE_TARGET_TYPE (ntype) = type;
447 TYPE_LENGTH (ntype) = 1;
448 TYPE_CODE (ntype) = TYPE_CODE_FUNC;
450 INIT_FUNC_SPECIFIC (ntype);
456 /* Given a type TYPE, return a type of functions that return that type.
457 May need to construct such a type if this is the first use. */
460 lookup_function_type (struct type *type)
462 return make_function_type (type, (struct type **) 0);
465 /* Given a type TYPE and argument types, return the appropriate
469 lookup_function_type_with_arguments (struct type *type,
471 struct type **param_types)
473 struct type *fn = make_function_type (type, (struct type **) 0);
476 TYPE_NFIELDS (fn) = nparams;
477 TYPE_FIELDS (fn) = TYPE_ZALLOC (fn, nparams * sizeof (struct field));
478 for (i = 0; i < nparams; ++i)
479 TYPE_FIELD_TYPE (fn, i) = param_types[i];
484 /* Identify address space identifier by name --
485 return the integer flag defined in gdbtypes.h. */
487 address_space_name_to_int (struct gdbarch *gdbarch, char *space_identifier)
491 /* Check for known address space delimiters. */
492 if (!strcmp (space_identifier, "code"))
493 return TYPE_INSTANCE_FLAG_CODE_SPACE;
494 else if (!strcmp (space_identifier, "data"))
495 return TYPE_INSTANCE_FLAG_DATA_SPACE;
496 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch)
497 && gdbarch_address_class_name_to_type_flags (gdbarch,
502 error (_("Unknown address space specifier: \"%s\""), space_identifier);
505 /* Identify address space identifier by integer flag as defined in
506 gdbtypes.h -- return the string version of the adress space name. */
509 address_space_int_to_name (struct gdbarch *gdbarch, int space_flag)
511 if (space_flag & TYPE_INSTANCE_FLAG_CODE_SPACE)
513 else if (space_flag & TYPE_INSTANCE_FLAG_DATA_SPACE)
515 else if ((space_flag & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
516 && gdbarch_address_class_type_flags_to_name_p (gdbarch))
517 return gdbarch_address_class_type_flags_to_name (gdbarch, space_flag);
522 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
524 If STORAGE is non-NULL, create the new type instance there.
525 STORAGE must be in the same obstack as TYPE. */
528 make_qualified_type (struct type *type, int new_flags,
529 struct type *storage)
536 if (TYPE_INSTANCE_FLAGS (ntype) == new_flags)
538 ntype = TYPE_CHAIN (ntype);
540 while (ntype != type);
542 /* Create a new type instance. */
544 ntype = alloc_type_instance (type);
547 /* If STORAGE was provided, it had better be in the same objfile
548 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
549 if one objfile is freed and the other kept, we'd have
550 dangling pointers. */
551 gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage));
554 TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type);
555 TYPE_CHAIN (ntype) = ntype;
558 /* Pointers or references to the original type are not relevant to
560 TYPE_POINTER_TYPE (ntype) = (struct type *) 0;
561 TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0;
563 /* Chain the new qualified type to the old type. */
564 TYPE_CHAIN (ntype) = TYPE_CHAIN (type);
565 TYPE_CHAIN (type) = ntype;
567 /* Now set the instance flags and return the new type. */
568 TYPE_INSTANCE_FLAGS (ntype) = new_flags;
570 /* Set length of new type to that of the original type. */
571 TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
576 /* Make an address-space-delimited variant of a type -- a type that
577 is identical to the one supplied except that it has an address
578 space attribute attached to it (such as "code" or "data").
580 The space attributes "code" and "data" are for Harvard
581 architectures. The address space attributes are for architectures
582 which have alternately sized pointers or pointers with alternate
586 make_type_with_address_space (struct type *type, int space_flag)
588 int new_flags = ((TYPE_INSTANCE_FLAGS (type)
589 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
590 | TYPE_INSTANCE_FLAG_DATA_SPACE
591 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL))
594 return make_qualified_type (type, new_flags, NULL);
597 /* Make a "c-v" variant of a type -- a type that is identical to the
598 one supplied except that it may have const or volatile attributes
599 CNST is a flag for setting the const attribute
600 VOLTL is a flag for setting the volatile attribute
601 TYPE is the base type whose variant we are creating.
603 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
604 storage to hold the new qualified type; *TYPEPTR and TYPE must be
605 in the same objfile. Otherwise, allocate fresh memory for the new
606 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
607 new type we construct. */
609 make_cv_type (int cnst, int voltl,
611 struct type **typeptr)
613 struct type *ntype; /* New type */
615 int new_flags = (TYPE_INSTANCE_FLAGS (type)
616 & ~(TYPE_INSTANCE_FLAG_CONST
617 | TYPE_INSTANCE_FLAG_VOLATILE));
620 new_flags |= TYPE_INSTANCE_FLAG_CONST;
623 new_flags |= TYPE_INSTANCE_FLAG_VOLATILE;
625 if (typeptr && *typeptr != NULL)
627 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
628 a C-V variant chain that threads across objfiles: if one
629 objfile gets freed, then the other has a broken C-V chain.
631 This code used to try to copy over the main type from TYPE to
632 *TYPEPTR if they were in different objfiles, but that's
633 wrong, too: TYPE may have a field list or member function
634 lists, which refer to types of their own, etc. etc. The
635 whole shebang would need to be copied over recursively; you
636 can't have inter-objfile pointers. The only thing to do is
637 to leave stub types as stub types, and look them up afresh by
638 name each time you encounter them. */
639 gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type));
642 ntype = make_qualified_type (type, new_flags,
643 typeptr ? *typeptr : NULL);
651 /* Replace the contents of ntype with the type *type. This changes the
652 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
653 the changes are propogated to all types in the TYPE_CHAIN.
655 In order to build recursive types, it's inevitable that we'll need
656 to update types in place --- but this sort of indiscriminate
657 smashing is ugly, and needs to be replaced with something more
658 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
659 clear if more steps are needed. */
661 replace_type (struct type *ntype, struct type *type)
665 /* These two types had better be in the same objfile. Otherwise,
666 the assignment of one type's main type structure to the other
667 will produce a type with references to objects (names; field
668 lists; etc.) allocated on an objfile other than its own. */
669 gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (ntype));
671 *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
673 /* The type length is not a part of the main type. Update it for
674 each type on the variant chain. */
678 /* Assert that this element of the chain has no address-class bits
679 set in its flags. Such type variants might have type lengths
680 which are supposed to be different from the non-address-class
681 variants. This assertion shouldn't ever be triggered because
682 symbol readers which do construct address-class variants don't
683 call replace_type(). */
684 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0);
686 TYPE_LENGTH (chain) = TYPE_LENGTH (type);
687 chain = TYPE_CHAIN (chain);
689 while (ntype != chain);
691 /* Assert that the two types have equivalent instance qualifiers.
692 This should be true for at least all of our debug readers. */
693 gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type));
696 /* Implement direct support for MEMBER_TYPE in GNU C++.
697 May need to construct such a type if this is the first use.
698 The TYPE is the type of the member. The DOMAIN is the type
699 of the aggregate that the member belongs to. */
702 lookup_memberptr_type (struct type *type, struct type *domain)
706 mtype = alloc_type_copy (type);
707 smash_to_memberptr_type (mtype, domain, type);
711 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
714 lookup_methodptr_type (struct type *to_type)
718 mtype = alloc_type_copy (to_type);
719 smash_to_methodptr_type (mtype, to_type);
723 /* Allocate a stub method whose return type is TYPE. This apparently
724 happens for speed of symbol reading, since parsing out the
725 arguments to the method is cpu-intensive, the way we are doing it.
726 So, we will fill in arguments later. This always returns a fresh
730 allocate_stub_method (struct type *type)
734 mtype = alloc_type_copy (type);
735 TYPE_CODE (mtype) = TYPE_CODE_METHOD;
736 TYPE_LENGTH (mtype) = 1;
737 TYPE_STUB (mtype) = 1;
738 TYPE_TARGET_TYPE (mtype) = type;
739 /* _DOMAIN_TYPE (mtype) = unknown yet */
743 /* Create a range type using either a blank type supplied in
744 RESULT_TYPE, or creating a new type, inheriting the objfile from
747 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
748 to HIGH_BOUND, inclusive.
750 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
751 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
754 create_range_type (struct type *result_type, struct type *index_type,
755 LONGEST low_bound, LONGEST high_bound)
757 if (result_type == NULL)
758 result_type = alloc_type_copy (index_type);
759 TYPE_CODE (result_type) = TYPE_CODE_RANGE;
760 TYPE_TARGET_TYPE (result_type) = index_type;
761 if (TYPE_STUB (index_type))
762 TYPE_TARGET_STUB (result_type) = 1;
764 TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
765 TYPE_RANGE_DATA (result_type) = (struct range_bounds *)
766 TYPE_ZALLOC (result_type, sizeof (struct range_bounds));
767 TYPE_LOW_BOUND (result_type) = low_bound;
768 TYPE_HIGH_BOUND (result_type) = high_bound;
771 TYPE_UNSIGNED (result_type) = 1;
776 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
777 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
778 bounds will fit in LONGEST), or -1 otherwise. */
781 get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
783 CHECK_TYPEDEF (type);
784 switch (TYPE_CODE (type))
786 case TYPE_CODE_RANGE:
787 *lowp = TYPE_LOW_BOUND (type);
788 *highp = TYPE_HIGH_BOUND (type);
791 if (TYPE_NFIELDS (type) > 0)
793 /* The enums may not be sorted by value, so search all
797 *lowp = *highp = TYPE_FIELD_ENUMVAL (type, 0);
798 for (i = 0; i < TYPE_NFIELDS (type); i++)
800 if (TYPE_FIELD_ENUMVAL (type, i) < *lowp)
801 *lowp = TYPE_FIELD_ENUMVAL (type, i);
802 if (TYPE_FIELD_ENUMVAL (type, i) > *highp)
803 *highp = TYPE_FIELD_ENUMVAL (type, i);
806 /* Set unsigned indicator if warranted. */
809 TYPE_UNSIGNED (type) = 1;
823 if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */
825 if (!TYPE_UNSIGNED (type))
827 *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
831 /* ... fall through for unsigned ints ... */
834 /* This round-about calculation is to avoid shifting by
835 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
836 if TYPE_LENGTH (type) == sizeof (LONGEST). */
837 *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
838 *highp = (*highp - 1) | *highp;
845 /* Assuming TYPE is a simple, non-empty array type, compute its upper
846 and lower bound. Save the low bound into LOW_BOUND if not NULL.
847 Save the high bound into HIGH_BOUND if not NULL.
849 Return 1 if the operation was successful. Return zero otherwise,
850 in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
852 We now simply use get_discrete_bounds call to get the values
853 of the low and high bounds.
854 get_discrete_bounds can return three values:
855 1, meaning that index is a range,
856 0, meaning that index is a discrete type,
857 or -1 for failure. */
860 get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound)
862 struct type *index = TYPE_INDEX_TYPE (type);
870 res = get_discrete_bounds (index, &low, &high);
874 /* Check if the array bounds are undefined. */
876 && ((low_bound && TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type))
877 || (high_bound && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))))
889 /* Create an array type using either a blank type supplied in
890 RESULT_TYPE, or creating a new type, inheriting the objfile from
893 Elements will be of type ELEMENT_TYPE, the indices will be of type
896 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
897 sure it is TYPE_CODE_UNDEF before we bash it into an array
901 create_array_type (struct type *result_type,
902 struct type *element_type,
903 struct type *range_type)
905 LONGEST low_bound, high_bound;
907 if (result_type == NULL)
908 result_type = alloc_type_copy (range_type);
910 TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
911 TYPE_TARGET_TYPE (result_type) = element_type;
912 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
913 low_bound = high_bound = 0;
914 CHECK_TYPEDEF (element_type);
915 /* Be careful when setting the array length. Ada arrays can be
916 empty arrays with the high_bound being smaller than the low_bound.
917 In such cases, the array length should be zero. */
918 if (high_bound < low_bound)
919 TYPE_LENGTH (result_type) = 0;
921 TYPE_LENGTH (result_type) =
922 TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
923 TYPE_NFIELDS (result_type) = 1;
924 TYPE_FIELDS (result_type) =
925 (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
926 TYPE_INDEX_TYPE (result_type) = range_type;
927 TYPE_VPTR_FIELDNO (result_type) = -1;
929 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays. */
930 if (TYPE_LENGTH (result_type) == 0)
931 TYPE_TARGET_STUB (result_type) = 1;
937 lookup_array_range_type (struct type *element_type,
938 int low_bound, int high_bound)
940 struct gdbarch *gdbarch = get_type_arch (element_type);
941 struct type *index_type = builtin_type (gdbarch)->builtin_int;
942 struct type *range_type
943 = create_range_type (NULL, index_type, low_bound, high_bound);
945 return create_array_type (NULL, element_type, range_type);
948 /* Create a string type using either a blank type supplied in
949 RESULT_TYPE, or creating a new type. String types are similar
950 enough to array of char types that we can use create_array_type to
951 build the basic type and then bash it into a string type.
953 For fixed length strings, the range type contains 0 as the lower
954 bound and the length of the string minus one as the upper bound.
956 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
957 sure it is TYPE_CODE_UNDEF before we bash it into a string
961 create_string_type (struct type *result_type,
962 struct type *string_char_type,
963 struct type *range_type)
965 result_type = create_array_type (result_type,
968 TYPE_CODE (result_type) = TYPE_CODE_STRING;
973 lookup_string_range_type (struct type *string_char_type,
974 int low_bound, int high_bound)
976 struct type *result_type;
978 result_type = lookup_array_range_type (string_char_type,
979 low_bound, high_bound);
980 TYPE_CODE (result_type) = TYPE_CODE_STRING;
985 create_set_type (struct type *result_type, struct type *domain_type)
987 if (result_type == NULL)
988 result_type = alloc_type_copy (domain_type);
990 TYPE_CODE (result_type) = TYPE_CODE_SET;
991 TYPE_NFIELDS (result_type) = 1;
992 TYPE_FIELDS (result_type) = TYPE_ZALLOC (result_type, sizeof (struct field));
994 if (!TYPE_STUB (domain_type))
996 LONGEST low_bound, high_bound, bit_length;
998 if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
999 low_bound = high_bound = 0;
1000 bit_length = high_bound - low_bound + 1;
1001 TYPE_LENGTH (result_type)
1002 = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
1004 TYPE_UNSIGNED (result_type) = 1;
1006 TYPE_FIELD_TYPE (result_type, 0) = domain_type;
1011 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
1012 and any array types nested inside it. */
1015 make_vector_type (struct type *array_type)
1017 struct type *inner_array, *elt_type;
1020 /* Find the innermost array type, in case the array is
1021 multi-dimensional. */
1022 inner_array = array_type;
1023 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
1024 inner_array = TYPE_TARGET_TYPE (inner_array);
1026 elt_type = TYPE_TARGET_TYPE (inner_array);
1027 if (TYPE_CODE (elt_type) == TYPE_CODE_INT)
1029 flags = TYPE_INSTANCE_FLAGS (elt_type) | TYPE_INSTANCE_FLAG_NOTTEXT;
1030 elt_type = make_qualified_type (elt_type, flags, NULL);
1031 TYPE_TARGET_TYPE (inner_array) = elt_type;
1034 TYPE_VECTOR (array_type) = 1;
1038 init_vector_type (struct type *elt_type, int n)
1040 struct type *array_type;
1042 array_type = lookup_array_range_type (elt_type, 0, n - 1);
1043 make_vector_type (array_type);
1047 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
1048 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1049 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1050 TYPE doesn't include the offset (that's the value of the MEMBER
1051 itself), but does include the structure type into which it points
1054 When "smashing" the type, we preserve the objfile that the old type
1055 pointed to, since we aren't changing where the type is actually
1059 smash_to_memberptr_type (struct type *type, struct type *domain,
1060 struct type *to_type)
1063 TYPE_TARGET_TYPE (type) = to_type;
1064 TYPE_DOMAIN_TYPE (type) = domain;
1065 /* Assume that a data member pointer is the same size as a normal
1068 = gdbarch_ptr_bit (get_type_arch (to_type)) / TARGET_CHAR_BIT;
1069 TYPE_CODE (type) = TYPE_CODE_MEMBERPTR;
1072 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1074 When "smashing" the type, we preserve the objfile that the old type
1075 pointed to, since we aren't changing where the type is actually
1079 smash_to_methodptr_type (struct type *type, struct type *to_type)
1082 TYPE_TARGET_TYPE (type) = to_type;
1083 TYPE_DOMAIN_TYPE (type) = TYPE_DOMAIN_TYPE (to_type);
1084 TYPE_LENGTH (type) = cplus_method_ptr_size (to_type);
1085 TYPE_CODE (type) = TYPE_CODE_METHODPTR;
1088 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
1089 METHOD just means `function that gets an extra "this" argument'.
1091 When "smashing" the type, we preserve the objfile that the old type
1092 pointed to, since we aren't changing where the type is actually
1096 smash_to_method_type (struct type *type, struct type *domain,
1097 struct type *to_type, struct field *args,
1098 int nargs, int varargs)
1101 TYPE_TARGET_TYPE (type) = to_type;
1102 TYPE_DOMAIN_TYPE (type) = domain;
1103 TYPE_FIELDS (type) = args;
1104 TYPE_NFIELDS (type) = nargs;
1106 TYPE_VARARGS (type) = 1;
1107 TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
1108 TYPE_CODE (type) = TYPE_CODE_METHOD;
1111 /* Return a typename for a struct/union/enum type without "struct ",
1112 "union ", or "enum ". If the type has a NULL name, return NULL. */
1115 type_name_no_tag (const struct type *type)
1117 if (TYPE_TAG_NAME (type) != NULL)
1118 return TYPE_TAG_NAME (type);
1120 /* Is there code which expects this to return the name if there is
1121 no tag name? My guess is that this is mainly used for C++ in
1122 cases where the two will always be the same. */
1123 return TYPE_NAME (type);
1126 /* A wrapper of type_name_no_tag which calls error if the type is anonymous.
1127 Since GCC PR debug/47510 DWARF provides associated information to detect the
1128 anonymous class linkage name from its typedef.
1130 Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
1134 type_name_no_tag_or_error (struct type *type)
1136 struct type *saved_type = type;
1138 struct objfile *objfile;
1140 CHECK_TYPEDEF (type);
1142 name = type_name_no_tag (type);
1146 name = type_name_no_tag (saved_type);
1147 objfile = TYPE_OBJFILE (saved_type);
1148 error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
1149 name ? name : "<anonymous>", objfile ? objfile->name : "<arch>");
1152 /* Lookup a typedef or primitive type named NAME, visible in lexical
1153 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1154 suitably defined. */
1157 lookup_typename (const struct language_defn *language,
1158 struct gdbarch *gdbarch, const char *name,
1159 const struct block *block, int noerr)
1164 sym = lookup_symbol (name, block, VAR_DOMAIN, 0);
1165 if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1166 return SYMBOL_TYPE (sym);
1168 type = language_lookup_primitive_type_by_name (language, gdbarch, name);
1174 error (_("No type named %s."), name);
1178 lookup_unsigned_typename (const struct language_defn *language,
1179 struct gdbarch *gdbarch, const char *name)
1181 char *uns = alloca (strlen (name) + 10);
1183 strcpy (uns, "unsigned ");
1184 strcpy (uns + 9, name);
1185 return lookup_typename (language, gdbarch, uns, (struct block *) NULL, 0);
1189 lookup_signed_typename (const struct language_defn *language,
1190 struct gdbarch *gdbarch, const char *name)
1193 char *uns = alloca (strlen (name) + 8);
1195 strcpy (uns, "signed ");
1196 strcpy (uns + 7, name);
1197 t = lookup_typename (language, gdbarch, uns, (struct block *) NULL, 1);
1198 /* If we don't find "signed FOO" just try again with plain "FOO". */
1201 return lookup_typename (language, gdbarch, name, (struct block *) NULL, 0);
1204 /* Lookup a structure type named "struct NAME",
1205 visible in lexical block BLOCK. */
1208 lookup_struct (const char *name, struct block *block)
1212 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1216 error (_("No struct type named %s."), name);
1218 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1220 error (_("This context has class, union or enum %s, not a struct."),
1223 return (SYMBOL_TYPE (sym));
1226 /* Lookup a union type named "union NAME",
1227 visible in lexical block BLOCK. */
1230 lookup_union (const char *name, struct block *block)
1235 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1238 error (_("No union type named %s."), name);
1240 t = SYMBOL_TYPE (sym);
1242 if (TYPE_CODE (t) == TYPE_CODE_UNION)
1245 /* If we get here, it's not a union. */
1246 error (_("This context has class, struct or enum %s, not a union."),
1251 /* Lookup an enum type named "enum NAME",
1252 visible in lexical block BLOCK. */
1255 lookup_enum (const char *name, struct block *block)
1259 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1262 error (_("No enum type named %s."), name);
1264 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
1266 error (_("This context has class, struct or union %s, not an enum."),
1269 return (SYMBOL_TYPE (sym));
1272 /* Lookup a template type named "template NAME<TYPE>",
1273 visible in lexical block BLOCK. */
1276 lookup_template_type (char *name, struct type *type,
1277 struct block *block)
1280 char *nam = (char *)
1281 alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4);
1285 strcat (nam, TYPE_NAME (type));
1286 strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
1288 sym = lookup_symbol (nam, block, VAR_DOMAIN, 0);
1292 error (_("No template type named %s."), name);
1294 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1296 error (_("This context has class, union or enum %s, not a struct."),
1299 return (SYMBOL_TYPE (sym));
1302 /* Given a type TYPE, lookup the type of the component of type named
1305 TYPE can be either a struct or union, or a pointer or reference to
1306 a struct or union. If it is a pointer or reference, its target
1307 type is automatically used. Thus '.' and '->' are interchangable,
1308 as specified for the definitions of the expression element types
1309 STRUCTOP_STRUCT and STRUCTOP_PTR.
1311 If NOERR is nonzero, return zero if NAME is not suitably defined.
1312 If NAME is the name of a baseclass type, return that type. */
1315 lookup_struct_elt_type (struct type *type, char *name, int noerr)
1322 CHECK_TYPEDEF (type);
1323 if (TYPE_CODE (type) != TYPE_CODE_PTR
1324 && TYPE_CODE (type) != TYPE_CODE_REF)
1326 type = TYPE_TARGET_TYPE (type);
1329 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1330 && TYPE_CODE (type) != TYPE_CODE_UNION)
1332 typename = type_to_string (type);
1333 make_cleanup (xfree, typename);
1334 error (_("Type %s is not a structure or union type."), typename);
1338 /* FIXME: This change put in by Michael seems incorrect for the case
1339 where the structure tag name is the same as the member name.
1340 I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
1341 foo; } bell;" Disabled by fnf. */
1345 typename = type_name_no_tag (type);
1346 if (typename != NULL && strcmp (typename, name) == 0)
1351 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1353 const char *t_field_name = TYPE_FIELD_NAME (type, i);
1355 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1357 return TYPE_FIELD_TYPE (type, i);
1359 else if (!t_field_name || *t_field_name == '\0')
1361 struct type *subtype
1362 = lookup_struct_elt_type (TYPE_FIELD_TYPE (type, i), name, 1);
1364 if (subtype != NULL)
1369 /* OK, it's not in this class. Recursively check the baseclasses. */
1370 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1374 t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 1);
1386 typename = type_to_string (type);
1387 make_cleanup (xfree, typename);
1388 error (_("Type %s has no component named %s."), typename, name);
1391 /* Lookup the vptr basetype/fieldno values for TYPE.
1392 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1393 vptr_fieldno. Also, if found and basetype is from the same objfile,
1395 If not found, return -1 and ignore BASETYPEP.
1396 Callers should be aware that in some cases (for example,
1397 the type or one of its baseclasses is a stub type and we are
1398 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1399 this function will not be able to find the
1400 virtual function table pointer, and vptr_fieldno will remain -1 and
1401 vptr_basetype will remain NULL or incomplete. */
1404 get_vptr_fieldno (struct type *type, struct type **basetypep)
1406 CHECK_TYPEDEF (type);
1408 if (TYPE_VPTR_FIELDNO (type) < 0)
1412 /* We must start at zero in case the first (and only) baseclass
1413 is virtual (and hence we cannot share the table pointer). */
1414 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1416 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
1418 struct type *basetype;
1420 fieldno = get_vptr_fieldno (baseclass, &basetype);
1423 /* If the type comes from a different objfile we can't cache
1424 it, it may have a different lifetime. PR 2384 */
1425 if (TYPE_OBJFILE (type) == TYPE_OBJFILE (basetype))
1427 TYPE_VPTR_FIELDNO (type) = fieldno;
1428 TYPE_VPTR_BASETYPE (type) = basetype;
1431 *basetypep = basetype;
1442 *basetypep = TYPE_VPTR_BASETYPE (type);
1443 return TYPE_VPTR_FIELDNO (type);
1448 stub_noname_complaint (void)
1450 complaint (&symfile_complaints, _("stub type has NULL name"));
1453 /* Find the real type of TYPE. This function returns the real type,
1454 after removing all layers of typedefs, and completing opaque or stub
1455 types. Completion changes the TYPE argument, but stripping of
1458 Instance flags (e.g. const/volatile) are preserved as typedefs are
1459 stripped. If necessary a new qualified form of the underlying type
1462 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
1463 not been computed and we're either in the middle of reading symbols, or
1464 there was no name for the typedef in the debug info.
1466 NOTE: Lookup of opaque types can throw errors for invalid symbol files.
1467 QUITs in the symbol reading code can also throw.
1468 Thus this function can throw an exception.
1470 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
1473 If this is a stubbed struct (i.e. declared as struct foo *), see if
1474 we can find a full definition in some other file. If so, copy this
1475 definition, so we can use it in future. There used to be a comment
1476 (but not any code) that if we don't find a full definition, we'd
1477 set a flag so we don't spend time in the future checking the same
1478 type. That would be a mistake, though--we might load in more
1479 symbols which contain a full definition for the type. */
1482 check_typedef (struct type *type)
1484 struct type *orig_type = type;
1485 /* While we're removing typedefs, we don't want to lose qualifiers.
1486 E.g., const/volatile. */
1487 int instance_flags = TYPE_INSTANCE_FLAGS (type);
1491 while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1493 if (!TYPE_TARGET_TYPE (type))
1498 /* It is dangerous to call lookup_symbol if we are currently
1499 reading a symtab. Infinite recursion is one danger. */
1500 if (currently_reading_symtab)
1501 return make_qualified_type (type, instance_flags, NULL);
1503 name = type_name_no_tag (type);
1504 /* FIXME: shouldn't we separately check the TYPE_NAME and
1505 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1506 VAR_DOMAIN as appropriate? (this code was written before
1507 TYPE_NAME and TYPE_TAG_NAME were separate). */
1510 stub_noname_complaint ();
1511 return make_qualified_type (type, instance_flags, NULL);
1513 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
1515 TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
1516 else /* TYPE_CODE_UNDEF */
1517 TYPE_TARGET_TYPE (type) = alloc_type_arch (get_type_arch (type));
1519 type = TYPE_TARGET_TYPE (type);
1521 /* Preserve the instance flags as we traverse down the typedef chain.
1523 Handling address spaces/classes is nasty, what do we do if there's a
1525 E.g., what if an outer typedef marks the type as class_1 and an inner
1526 typedef marks the type as class_2?
1527 This is the wrong place to do such error checking. We leave it to
1528 the code that created the typedef in the first place to flag the
1529 error. We just pick the outer address space (akin to letting the
1530 outer cast in a chain of casting win), instead of assuming
1531 "it can't happen". */
1533 const int ALL_SPACES = (TYPE_INSTANCE_FLAG_CODE_SPACE
1534 | TYPE_INSTANCE_FLAG_DATA_SPACE);
1535 const int ALL_CLASSES = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL;
1536 int new_instance_flags = TYPE_INSTANCE_FLAGS (type);
1538 /* Treat code vs data spaces and address classes separately. */
1539 if ((instance_flags & ALL_SPACES) != 0)
1540 new_instance_flags &= ~ALL_SPACES;
1541 if ((instance_flags & ALL_CLASSES) != 0)
1542 new_instance_flags &= ~ALL_CLASSES;
1544 instance_flags |= new_instance_flags;
1548 /* If this is a struct/class/union with no fields, then check
1549 whether a full definition exists somewhere else. This is for
1550 systems where a type definition with no fields is issued for such
1551 types, instead of identifying them as stub types in the first
1554 if (TYPE_IS_OPAQUE (type)
1555 && opaque_type_resolution
1556 && !currently_reading_symtab)
1558 const char *name = type_name_no_tag (type);
1559 struct type *newtype;
1563 stub_noname_complaint ();
1564 return make_qualified_type (type, instance_flags, NULL);
1566 newtype = lookup_transparent_type (name);
1570 /* If the resolved type and the stub are in the same
1571 objfile, then replace the stub type with the real deal.
1572 But if they're in separate objfiles, leave the stub
1573 alone; we'll just look up the transparent type every time
1574 we call check_typedef. We can't create pointers between
1575 types allocated to different objfiles, since they may
1576 have different lifetimes. Trying to copy NEWTYPE over to
1577 TYPE's objfile is pointless, too, since you'll have to
1578 move over any other types NEWTYPE refers to, which could
1579 be an unbounded amount of stuff. */
1580 if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type))
1581 type = make_qualified_type (newtype,
1582 TYPE_INSTANCE_FLAGS (type),
1588 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1590 else if (TYPE_STUB (type) && !currently_reading_symtab)
1592 const char *name = type_name_no_tag (type);
1593 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1594 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1595 as appropriate? (this code was written before TYPE_NAME and
1596 TYPE_TAG_NAME were separate). */
1601 stub_noname_complaint ();
1602 return make_qualified_type (type, instance_flags, NULL);
1604 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
1607 /* Same as above for opaque types, we can replace the stub
1608 with the complete type only if they are in the same
1610 if (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type))
1611 type = make_qualified_type (SYMBOL_TYPE (sym),
1612 TYPE_INSTANCE_FLAGS (type),
1615 type = SYMBOL_TYPE (sym);
1619 if (TYPE_TARGET_STUB (type))
1621 struct type *range_type;
1622 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1624 if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type))
1626 /* Nothing we can do. */
1628 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
1629 && TYPE_NFIELDS (type) == 1
1630 && (TYPE_CODE (range_type = TYPE_INDEX_TYPE (type))
1631 == TYPE_CODE_RANGE))
1633 /* Now recompute the length of the array type, based on its
1634 number of elements and the target type's length.
1635 Watch out for Ada null Ada arrays where the high bound
1636 is smaller than the low bound. */
1637 const LONGEST low_bound = TYPE_LOW_BOUND (range_type);
1638 const LONGEST high_bound = TYPE_HIGH_BOUND (range_type);
1641 if (high_bound < low_bound)
1645 /* For now, we conservatively take the array length to be 0
1646 if its length exceeds UINT_MAX. The code below assumes
1647 that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
1648 which is technically not guaranteed by C, but is usually true
1649 (because it would be true if x were unsigned with its
1650 high-order bit on). It uses the fact that
1651 high_bound-low_bound is always representable in
1652 ULONGEST and that if high_bound-low_bound+1 overflows,
1653 it overflows to 0. We must change these tests if we
1654 decide to increase the representation of TYPE_LENGTH
1655 from unsigned int to ULONGEST. */
1656 ULONGEST ulow = low_bound, uhigh = high_bound;
1657 ULONGEST tlen = TYPE_LENGTH (target_type);
1659 len = tlen * (uhigh - ulow + 1);
1660 if (tlen == 0 || (len / tlen - 1 + ulow) != uhigh
1664 TYPE_LENGTH (type) = len;
1665 TYPE_TARGET_STUB (type) = 0;
1667 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
1669 TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
1670 TYPE_TARGET_STUB (type) = 0;
1674 type = make_qualified_type (type, instance_flags, NULL);
1676 /* Cache TYPE_LENGTH for future use. */
1677 TYPE_LENGTH (orig_type) = TYPE_LENGTH (type);
1682 /* Parse a type expression in the string [P..P+LENGTH). If an error
1683 occurs, silently return a void type. */
1685 static struct type *
1686 safe_parse_type (struct gdbarch *gdbarch, char *p, int length)
1688 struct ui_file *saved_gdb_stderr;
1689 struct type *type = NULL; /* Initialize to keep gcc happy. */
1690 volatile struct gdb_exception except;
1692 /* Suppress error messages. */
1693 saved_gdb_stderr = gdb_stderr;
1694 gdb_stderr = ui_file_new ();
1696 /* Call parse_and_eval_type() without fear of longjmp()s. */
1697 TRY_CATCH (except, RETURN_MASK_ERROR)
1699 type = parse_and_eval_type (p, length);
1702 if (except.reason < 0)
1703 type = builtin_type (gdbarch)->builtin_void;
1705 /* Stop suppressing error messages. */
1706 ui_file_delete (gdb_stderr);
1707 gdb_stderr = saved_gdb_stderr;
1712 /* Ugly hack to convert method stubs into method types.
1714 He ain't kiddin'. This demangles the name of the method into a
1715 string including argument types, parses out each argument type,
1716 generates a string casting a zero to that type, evaluates the
1717 string, and stuffs the resulting type into an argtype vector!!!
1718 Then it knows the type of the whole function (including argument
1719 types for overloading), which info used to be in the stab's but was
1720 removed to hack back the space required for them. */
1723 check_stub_method (struct type *type, int method_id, int signature_id)
1725 struct gdbarch *gdbarch = get_type_arch (type);
1727 char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
1728 char *demangled_name = cplus_demangle (mangled_name,
1729 DMGL_PARAMS | DMGL_ANSI);
1730 char *argtypetext, *p;
1731 int depth = 0, argcount = 1;
1732 struct field *argtypes;
1735 /* Make sure we got back a function string that we can use. */
1737 p = strchr (demangled_name, '(');
1741 if (demangled_name == NULL || p == NULL)
1742 error (_("Internal: Cannot demangle mangled name `%s'."),
1745 /* Now, read in the parameters that define this type. */
1750 if (*p == '(' || *p == '<')
1754 else if (*p == ')' || *p == '>')
1758 else if (*p == ',' && depth == 0)
1766 /* If we read one argument and it was ``void'', don't count it. */
1767 if (strncmp (argtypetext, "(void)", 6) == 0)
1770 /* We need one extra slot, for the THIS pointer. */
1772 argtypes = (struct field *)
1773 TYPE_ALLOC (type, (argcount + 1) * sizeof (struct field));
1776 /* Add THIS pointer for non-static methods. */
1777 f = TYPE_FN_FIELDLIST1 (type, method_id);
1778 if (TYPE_FN_FIELD_STATIC_P (f, signature_id))
1782 argtypes[0].type = lookup_pointer_type (type);
1786 if (*p != ')') /* () means no args, skip while. */
1791 if (depth <= 0 && (*p == ',' || *p == ')'))
1793 /* Avoid parsing of ellipsis, they will be handled below.
1794 Also avoid ``void'' as above. */
1795 if (strncmp (argtypetext, "...", p - argtypetext) != 0
1796 && strncmp (argtypetext, "void", p - argtypetext) != 0)
1798 argtypes[argcount].type =
1799 safe_parse_type (gdbarch, argtypetext, p - argtypetext);
1802 argtypetext = p + 1;
1805 if (*p == '(' || *p == '<')
1809 else if (*p == ')' || *p == '>')
1818 TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name;
1820 /* Now update the old "stub" type into a real type. */
1821 mtype = TYPE_FN_FIELD_TYPE (f, signature_id);
1822 TYPE_DOMAIN_TYPE (mtype) = type;
1823 TYPE_FIELDS (mtype) = argtypes;
1824 TYPE_NFIELDS (mtype) = argcount;
1825 TYPE_STUB (mtype) = 0;
1826 TYPE_FN_FIELD_STUB (f, signature_id) = 0;
1828 TYPE_VARARGS (mtype) = 1;
1830 xfree (demangled_name);
1833 /* This is the external interface to check_stub_method, above. This
1834 function unstubs all of the signatures for TYPE's METHOD_ID method
1835 name. After calling this function TYPE_FN_FIELD_STUB will be
1836 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1839 This function unfortunately can not die until stabs do. */
1842 check_stub_method_group (struct type *type, int method_id)
1844 int len = TYPE_FN_FIELDLIST_LENGTH (type, method_id);
1845 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
1846 int j, found_stub = 0;
1848 for (j = 0; j < len; j++)
1849 if (TYPE_FN_FIELD_STUB (f, j))
1852 check_stub_method (type, method_id, j);
1855 /* GNU v3 methods with incorrect names were corrected when we read
1856 in type information, because it was cheaper to do it then. The
1857 only GNU v2 methods with incorrect method names are operators and
1858 destructors; destructors were also corrected when we read in type
1861 Therefore the only thing we need to handle here are v2 operator
1863 if (found_stub && strncmp (TYPE_FN_FIELD_PHYSNAME (f, 0), "_Z", 2) != 0)
1866 char dem_opname[256];
1868 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
1870 dem_opname, DMGL_ANSI);
1872 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
1876 TYPE_FN_FIELDLIST_NAME (type, method_id) = xstrdup (dem_opname);
1880 /* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */
1881 const struct cplus_struct_type cplus_struct_default = { };
1884 allocate_cplus_struct_type (struct type *type)
1886 if (HAVE_CPLUS_STRUCT (type))
1887 /* Structure was already allocated. Nothing more to do. */
1890 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CPLUS_STUFF;
1891 TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
1892 TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
1893 *(TYPE_RAW_CPLUS_SPECIFIC (type)) = cplus_struct_default;
1896 const struct gnat_aux_type gnat_aux_default =
1899 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
1900 and allocate the associated gnat-specific data. The gnat-specific
1901 data is also initialized to gnat_aux_default. */
1903 allocate_gnat_aux_type (struct type *type)
1905 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_GNAT_STUFF;
1906 TYPE_GNAT_SPECIFIC (type) = (struct gnat_aux_type *)
1907 TYPE_ALLOC (type, sizeof (struct gnat_aux_type));
1908 *(TYPE_GNAT_SPECIFIC (type)) = gnat_aux_default;
1912 /* Helper function to initialize the standard scalar types.
1914 If NAME is non-NULL, then we make a copy of the string pointed
1915 to by name in the objfile_obstack for that objfile, and initialize
1916 the type name to that copy. There are places (mipsread.c in particular),
1917 where init_type is called with a NULL value for NAME). */
1920 init_type (enum type_code code, int length, int flags,
1921 char *name, struct objfile *objfile)
1925 type = alloc_type (objfile);
1926 TYPE_CODE (type) = code;
1927 TYPE_LENGTH (type) = length;
1929 gdb_assert (!(flags & (TYPE_FLAG_MIN - 1)));
1930 if (flags & TYPE_FLAG_UNSIGNED)
1931 TYPE_UNSIGNED (type) = 1;
1932 if (flags & TYPE_FLAG_NOSIGN)
1933 TYPE_NOSIGN (type) = 1;
1934 if (flags & TYPE_FLAG_STUB)
1935 TYPE_STUB (type) = 1;
1936 if (flags & TYPE_FLAG_TARGET_STUB)
1937 TYPE_TARGET_STUB (type) = 1;
1938 if (flags & TYPE_FLAG_STATIC)
1939 TYPE_STATIC (type) = 1;
1940 if (flags & TYPE_FLAG_PROTOTYPED)
1941 TYPE_PROTOTYPED (type) = 1;
1942 if (flags & TYPE_FLAG_INCOMPLETE)
1943 TYPE_INCOMPLETE (type) = 1;
1944 if (flags & TYPE_FLAG_VARARGS)
1945 TYPE_VARARGS (type) = 1;
1946 if (flags & TYPE_FLAG_VECTOR)
1947 TYPE_VECTOR (type) = 1;
1948 if (flags & TYPE_FLAG_STUB_SUPPORTED)
1949 TYPE_STUB_SUPPORTED (type) = 1;
1950 if (flags & TYPE_FLAG_FIXED_INSTANCE)
1951 TYPE_FIXED_INSTANCE (type) = 1;
1952 if (flags & TYPE_FLAG_GNU_IFUNC)
1953 TYPE_GNU_IFUNC (type) = 1;
1956 TYPE_NAME (type) = obsavestring (name, strlen (name),
1957 &objfile->objfile_obstack);
1961 if (name && strcmp (name, "char") == 0)
1962 TYPE_NOSIGN (type) = 1;
1966 case TYPE_CODE_STRUCT:
1967 case TYPE_CODE_UNION:
1968 case TYPE_CODE_NAMESPACE:
1969 INIT_CPLUS_SPECIFIC (type);
1972 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FLOATFORMAT;
1974 case TYPE_CODE_FUNC:
1975 INIT_FUNC_SPECIFIC (type);
1982 can_dereference (struct type *t)
1984 /* FIXME: Should we return true for references as well as
1989 && TYPE_CODE (t) == TYPE_CODE_PTR
1990 && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
1994 is_integral_type (struct type *t)
1999 && ((TYPE_CODE (t) == TYPE_CODE_INT)
2000 || (TYPE_CODE (t) == TYPE_CODE_ENUM)
2001 || (TYPE_CODE (t) == TYPE_CODE_FLAGS)
2002 || (TYPE_CODE (t) == TYPE_CODE_CHAR)
2003 || (TYPE_CODE (t) == TYPE_CODE_RANGE)
2004 || (TYPE_CODE (t) == TYPE_CODE_BOOL)));
2007 /* Return true if TYPE is scalar. */
2010 is_scalar_type (struct type *type)
2012 CHECK_TYPEDEF (type);
2014 switch (TYPE_CODE (type))
2016 case TYPE_CODE_ARRAY:
2017 case TYPE_CODE_STRUCT:
2018 case TYPE_CODE_UNION:
2020 case TYPE_CODE_STRING:
2021 case TYPE_CODE_BITSTRING:
2028 /* Return true if T is scalar, or a composite type which in practice has
2029 the memory layout of a scalar type. E.g., an array or struct with only
2030 one scalar element inside it, or a union with only scalar elements. */
2033 is_scalar_type_recursive (struct type *t)
2037 if (is_scalar_type (t))
2039 /* Are we dealing with an array or string of known dimensions? */
2040 else if ((TYPE_CODE (t) == TYPE_CODE_ARRAY
2041 || TYPE_CODE (t) == TYPE_CODE_STRING) && TYPE_NFIELDS (t) == 1
2042 && TYPE_CODE (TYPE_INDEX_TYPE (t)) == TYPE_CODE_RANGE)
2044 LONGEST low_bound, high_bound;
2045 struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t));
2047 get_discrete_bounds (TYPE_INDEX_TYPE (t), &low_bound, &high_bound);
2049 return high_bound == low_bound && is_scalar_type_recursive (elt_type);
2051 /* Are we dealing with a struct with one element? */
2052 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT && TYPE_NFIELDS (t) == 1)
2053 return is_scalar_type_recursive (TYPE_FIELD_TYPE (t, 0));
2054 else if (TYPE_CODE (t) == TYPE_CODE_UNION)
2056 int i, n = TYPE_NFIELDS (t);
2058 /* If all elements of the union are scalar, then the union is scalar. */
2059 for (i = 0; i < n; i++)
2060 if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t, i)))
2069 /* A helper function which returns true if types A and B represent the
2070 "same" class type. This is true if the types have the same main
2071 type, or the same name. */
2074 class_types_same_p (const struct type *a, const struct type *b)
2076 return (TYPE_MAIN_TYPE (a) == TYPE_MAIN_TYPE (b)
2077 || (TYPE_NAME (a) && TYPE_NAME (b)
2078 && !strcmp (TYPE_NAME (a), TYPE_NAME (b))));
2081 /* If BASE is an ancestor of DCLASS return the distance between them.
2082 otherwise return -1;
2086 class B: public A {};
2087 class C: public B {};
2090 distance_to_ancestor (A, A, 0) = 0
2091 distance_to_ancestor (A, B, 0) = 1
2092 distance_to_ancestor (A, C, 0) = 2
2093 distance_to_ancestor (A, D, 0) = 3
2095 If PUBLIC is 1 then only public ancestors are considered,
2096 and the function returns the distance only if BASE is a public ancestor
2100 distance_to_ancestor (A, D, 1) = -1. */
2103 distance_to_ancestor (struct type *base, struct type *dclass, int public)
2108 CHECK_TYPEDEF (base);
2109 CHECK_TYPEDEF (dclass);
2111 if (class_types_same_p (base, dclass))
2114 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
2116 if (public && ! BASETYPE_VIA_PUBLIC (dclass, i))
2119 d = distance_to_ancestor (base, TYPE_BASECLASS (dclass, i), public);
2127 /* Check whether BASE is an ancestor or base class or DCLASS
2128 Return 1 if so, and 0 if not.
2129 Note: If BASE and DCLASS are of the same type, this function
2130 will return 1. So for some class A, is_ancestor (A, A) will
2134 is_ancestor (struct type *base, struct type *dclass)
2136 return distance_to_ancestor (base, dclass, 0) >= 0;
2139 /* Like is_ancestor, but only returns true when BASE is a public
2140 ancestor of DCLASS. */
2143 is_public_ancestor (struct type *base, struct type *dclass)
2145 return distance_to_ancestor (base, dclass, 1) >= 0;
2148 /* A helper function for is_unique_ancestor. */
2151 is_unique_ancestor_worker (struct type *base, struct type *dclass,
2153 const gdb_byte *valaddr, int embedded_offset,
2154 CORE_ADDR address, struct value *val)
2158 CHECK_TYPEDEF (base);
2159 CHECK_TYPEDEF (dclass);
2161 for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i)
2166 iter = check_typedef (TYPE_BASECLASS (dclass, i));
2168 this_offset = baseclass_offset (dclass, i, valaddr, embedded_offset,
2171 if (class_types_same_p (base, iter))
2173 /* If this is the first subclass, set *OFFSET and set count
2174 to 1. Otherwise, if this is at the same offset as
2175 previous instances, do nothing. Otherwise, increment
2179 *offset = this_offset;
2182 else if (this_offset == *offset)
2190 count += is_unique_ancestor_worker (base, iter, offset,
2192 embedded_offset + this_offset,
2199 /* Like is_ancestor, but only returns true if BASE is a unique base
2200 class of the type of VAL. */
2203 is_unique_ancestor (struct type *base, struct value *val)
2207 return is_unique_ancestor_worker (base, value_type (val), &offset,
2208 value_contents_for_printing (val),
2209 value_embedded_offset (val),
2210 value_address (val), val) == 1;
2215 /* Return the sum of the rank of A with the rank of B. */
2218 sum_ranks (struct rank a, struct rank b)
2221 c.rank = a.rank + b.rank;
2222 c.subrank = a.subrank + b.subrank;
2226 /* Compare rank A and B and return:
2228 1 if a is better than b
2229 -1 if b is better than a. */
2232 compare_ranks (struct rank a, struct rank b)
2234 if (a.rank == b.rank)
2236 if (a.subrank == b.subrank)
2238 if (a.subrank < b.subrank)
2240 if (a.subrank > b.subrank)
2244 if (a.rank < b.rank)
2247 /* a.rank > b.rank */
2251 /* Functions for overload resolution begin here. */
2253 /* Compare two badness vectors A and B and return the result.
2254 0 => A and B are identical
2255 1 => A and B are incomparable
2256 2 => A is better than B
2257 3 => A is worse than B */
2260 compare_badness (struct badness_vector *a, struct badness_vector *b)
2264 short found_pos = 0; /* any positives in c? */
2265 short found_neg = 0; /* any negatives in c? */
2267 /* differing lengths => incomparable */
2268 if (a->length != b->length)
2271 /* Subtract b from a */
2272 for (i = 0; i < a->length; i++)
2274 tmp = compare_ranks (b->rank[i], a->rank[i]);
2284 return 1; /* incomparable */
2286 return 3; /* A > B */
2292 return 2; /* A < B */
2294 return 0; /* A == B */
2298 /* Rank a function by comparing its parameter types (PARMS, length
2299 NPARMS), to the types of an argument list (ARGS, length NARGS).
2300 Return a pointer to a badness vector. This has NARGS + 1
2303 struct badness_vector *
2304 rank_function (struct type **parms, int nparms,
2305 struct value **args, int nargs)
2308 struct badness_vector *bv;
2309 int min_len = nparms < nargs ? nparms : nargs;
2311 bv = xmalloc (sizeof (struct badness_vector));
2312 bv->length = nargs + 1; /* add 1 for the length-match rank. */
2313 bv->rank = xmalloc ((nargs + 1) * sizeof (int));
2315 /* First compare the lengths of the supplied lists.
2316 If there is a mismatch, set it to a high value. */
2318 /* pai/1997-06-03 FIXME: when we have debug info about default
2319 arguments and ellipsis parameter lists, we should consider those
2320 and rank the length-match more finely. */
2322 LENGTH_MATCH (bv) = (nargs != nparms)
2323 ? LENGTH_MISMATCH_BADNESS
2324 : EXACT_MATCH_BADNESS;
2326 /* Now rank all the parameters of the candidate function. */
2327 for (i = 1; i <= min_len; i++)
2328 bv->rank[i] = rank_one_type (parms[i - 1], value_type (args[i - 1]),
2331 /* If more arguments than parameters, add dummy entries. */
2332 for (i = min_len + 1; i <= nargs; i++)
2333 bv->rank[i] = TOO_FEW_PARAMS_BADNESS;
2338 /* Compare the names of two integer types, assuming that any sign
2339 qualifiers have been checked already. We do it this way because
2340 there may be an "int" in the name of one of the types. */
2343 integer_types_same_name_p (const char *first, const char *second)
2345 int first_p, second_p;
2347 /* If both are shorts, return 1; if neither is a short, keep
2349 first_p = (strstr (first, "short") != NULL);
2350 second_p = (strstr (second, "short") != NULL);
2351 if (first_p && second_p)
2353 if (first_p || second_p)
2356 /* Likewise for long. */
2357 first_p = (strstr (first, "long") != NULL);
2358 second_p = (strstr (second, "long") != NULL);
2359 if (first_p && second_p)
2361 if (first_p || second_p)
2364 /* Likewise for char. */
2365 first_p = (strstr (first, "char") != NULL);
2366 second_p = (strstr (second, "char") != NULL);
2367 if (first_p && second_p)
2369 if (first_p || second_p)
2372 /* They must both be ints. */
2376 /* Compares type A to type B returns 1 if the represent the same type
2380 types_equal (struct type *a, struct type *b)
2382 /* Identical type pointers. */
2383 /* However, this still doesn't catch all cases of same type for b
2384 and a. The reason is that builtin types are different from
2385 the same ones constructed from the object. */
2389 /* Resolve typedefs */
2390 if (TYPE_CODE (a) == TYPE_CODE_TYPEDEF)
2391 a = check_typedef (a);
2392 if (TYPE_CODE (b) == TYPE_CODE_TYPEDEF)
2393 b = check_typedef (b);
2395 /* If after resolving typedefs a and b are not of the same type
2396 code then they are not equal. */
2397 if (TYPE_CODE (a) != TYPE_CODE (b))
2400 /* If a and b are both pointers types or both reference types then
2401 they are equal of the same type iff the objects they refer to are
2402 of the same type. */
2403 if (TYPE_CODE (a) == TYPE_CODE_PTR
2404 || TYPE_CODE (a) == TYPE_CODE_REF)
2405 return types_equal (TYPE_TARGET_TYPE (a),
2406 TYPE_TARGET_TYPE (b));
2408 /* Well, damnit, if the names are exactly the same, I'll say they
2409 are exactly the same. This happens when we generate method
2410 stubs. The types won't point to the same address, but they
2411 really are the same. */
2413 if (TYPE_NAME (a) && TYPE_NAME (b)
2414 && strcmp (TYPE_NAME (a), TYPE_NAME (b)) == 0)
2417 /* Check if identical after resolving typedefs. */
2424 /* Compare one type (PARM) for compatibility with another (ARG).
2425 * PARM is intended to be the parameter type of a function; and
2426 * ARG is the supplied argument's type. This function tests if
2427 * the latter can be converted to the former.
2428 * VALUE is the argument's value or NULL if none (or called recursively)
2430 * Return 0 if they are identical types;
2431 * Otherwise, return an integer which corresponds to how compatible
2432 * PARM is to ARG. The higher the return value, the worse the match.
2433 * Generally the "bad" conversions are all uniformly assigned a 100. */
2436 rank_one_type (struct type *parm, struct type *arg, struct value *value)
2438 struct rank rank = {0,0};
2440 if (types_equal (parm, arg))
2441 return EXACT_MATCH_BADNESS;
2443 /* Resolve typedefs */
2444 if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF)
2445 parm = check_typedef (parm);
2446 if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
2447 arg = check_typedef (arg);
2449 /* See through references, since we can almost make non-references
2451 if (TYPE_CODE (arg) == TYPE_CODE_REF)
2452 return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL),
2453 REFERENCE_CONVERSION_BADNESS));
2454 if (TYPE_CODE (parm) == TYPE_CODE_REF)
2455 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL),
2456 REFERENCE_CONVERSION_BADNESS));
2458 /* Debugging only. */
2459 fprintf_filtered (gdb_stderr,
2460 "------ Arg is %s [%d], parm is %s [%d]\n",
2461 TYPE_NAME (arg), TYPE_CODE (arg),
2462 TYPE_NAME (parm), TYPE_CODE (parm));
2464 /* x -> y means arg of type x being supplied for parameter of type y. */
2466 switch (TYPE_CODE (parm))
2469 switch (TYPE_CODE (arg))
2473 /* Allowed pointer conversions are:
2474 (a) pointer to void-pointer conversion. */
2475 if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID)
2476 return VOID_PTR_CONVERSION_BADNESS;
2478 /* (b) pointer to ancestor-pointer conversion. */
2479 rank.subrank = distance_to_ancestor (TYPE_TARGET_TYPE (parm),
2480 TYPE_TARGET_TYPE (arg),
2482 if (rank.subrank >= 0)
2483 return sum_ranks (BASE_PTR_CONVERSION_BADNESS, rank);
2485 return INCOMPATIBLE_TYPE_BADNESS;
2486 case TYPE_CODE_ARRAY:
2487 if (types_equal (TYPE_TARGET_TYPE (parm),
2488 TYPE_TARGET_TYPE (arg)))
2489 return EXACT_MATCH_BADNESS;
2490 return INCOMPATIBLE_TYPE_BADNESS;
2491 case TYPE_CODE_FUNC:
2492 return rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL);
2494 if (value != NULL && TYPE_CODE (value_type (value)) == TYPE_CODE_INT
2495 && value_as_long (value) == 0)
2497 /* Null pointer conversion: allow it to be cast to a pointer.
2498 [4.10.1 of C++ standard draft n3290] */
2499 return NULL_POINTER_CONVERSION_BADNESS;
2502 case TYPE_CODE_ENUM:
2503 case TYPE_CODE_FLAGS:
2504 case TYPE_CODE_CHAR:
2505 case TYPE_CODE_RANGE:
2506 case TYPE_CODE_BOOL:
2508 return INCOMPATIBLE_TYPE_BADNESS;
2510 case TYPE_CODE_ARRAY:
2511 switch (TYPE_CODE (arg))
2514 case TYPE_CODE_ARRAY:
2515 return rank_one_type (TYPE_TARGET_TYPE (parm),
2516 TYPE_TARGET_TYPE (arg), NULL);
2518 return INCOMPATIBLE_TYPE_BADNESS;
2520 case TYPE_CODE_FUNC:
2521 switch (TYPE_CODE (arg))
2523 case TYPE_CODE_PTR: /* funcptr -> func */
2524 return rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL);
2526 return INCOMPATIBLE_TYPE_BADNESS;
2529 switch (TYPE_CODE (arg))
2532 if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2534 /* Deal with signed, unsigned, and plain chars and
2535 signed and unsigned ints. */
2536 if (TYPE_NOSIGN (parm))
2538 /* This case only for character types. */
2539 if (TYPE_NOSIGN (arg))
2540 return EXACT_MATCH_BADNESS; /* plain char -> plain char */
2541 else /* signed/unsigned char -> plain char */
2542 return INTEGER_CONVERSION_BADNESS;
2544 else if (TYPE_UNSIGNED (parm))
2546 if (TYPE_UNSIGNED (arg))
2548 /* unsigned int -> unsigned int, or
2549 unsigned long -> unsigned long */
2550 if (integer_types_same_name_p (TYPE_NAME (parm),
2552 return EXACT_MATCH_BADNESS;
2553 else if (integer_types_same_name_p (TYPE_NAME (arg),
2555 && integer_types_same_name_p (TYPE_NAME (parm),
2557 /* unsigned int -> unsigned long */
2558 return INTEGER_PROMOTION_BADNESS;
2560 /* unsigned long -> unsigned int */
2561 return INTEGER_CONVERSION_BADNESS;
2565 if (integer_types_same_name_p (TYPE_NAME (arg),
2567 && integer_types_same_name_p (TYPE_NAME (parm),
2569 /* signed long -> unsigned int */
2570 return INTEGER_CONVERSION_BADNESS;
2572 /* signed int/long -> unsigned int/long */
2573 return INTEGER_CONVERSION_BADNESS;
2576 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2578 if (integer_types_same_name_p (TYPE_NAME (parm),
2580 return EXACT_MATCH_BADNESS;
2581 else if (integer_types_same_name_p (TYPE_NAME (arg),
2583 && integer_types_same_name_p (TYPE_NAME (parm),
2585 return INTEGER_PROMOTION_BADNESS;
2587 return INTEGER_CONVERSION_BADNESS;
2590 return INTEGER_CONVERSION_BADNESS;
2592 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2593 return INTEGER_PROMOTION_BADNESS;
2595 return INTEGER_CONVERSION_BADNESS;
2596 case TYPE_CODE_ENUM:
2597 case TYPE_CODE_FLAGS:
2598 case TYPE_CODE_CHAR:
2599 case TYPE_CODE_RANGE:
2600 case TYPE_CODE_BOOL:
2601 return INTEGER_PROMOTION_BADNESS;
2603 return INT_FLOAT_CONVERSION_BADNESS;
2605 return NS_POINTER_CONVERSION_BADNESS;
2607 return INCOMPATIBLE_TYPE_BADNESS;
2610 case TYPE_CODE_ENUM:
2611 switch (TYPE_CODE (arg))
2614 case TYPE_CODE_CHAR:
2615 case TYPE_CODE_RANGE:
2616 case TYPE_CODE_BOOL:
2617 case TYPE_CODE_ENUM:
2618 return INTEGER_CONVERSION_BADNESS;
2620 return INT_FLOAT_CONVERSION_BADNESS;
2622 return INCOMPATIBLE_TYPE_BADNESS;
2625 case TYPE_CODE_CHAR:
2626 switch (TYPE_CODE (arg))
2628 case TYPE_CODE_RANGE:
2629 case TYPE_CODE_BOOL:
2630 case TYPE_CODE_ENUM:
2631 return INTEGER_CONVERSION_BADNESS;
2633 return INT_FLOAT_CONVERSION_BADNESS;
2635 if (TYPE_LENGTH (arg) > TYPE_LENGTH (parm))
2636 return INTEGER_CONVERSION_BADNESS;
2637 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2638 return INTEGER_PROMOTION_BADNESS;
2639 /* >>> !! else fall through !! <<< */
2640 case TYPE_CODE_CHAR:
2641 /* Deal with signed, unsigned, and plain chars for C++ and
2642 with int cases falling through from previous case. */
2643 if (TYPE_NOSIGN (parm))
2645 if (TYPE_NOSIGN (arg))
2646 return EXACT_MATCH_BADNESS;
2648 return INTEGER_CONVERSION_BADNESS;
2650 else if (TYPE_UNSIGNED (parm))
2652 if (TYPE_UNSIGNED (arg))
2653 return EXACT_MATCH_BADNESS;
2655 return INTEGER_PROMOTION_BADNESS;
2657 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2658 return EXACT_MATCH_BADNESS;
2660 return INTEGER_CONVERSION_BADNESS;
2662 return INCOMPATIBLE_TYPE_BADNESS;
2665 case TYPE_CODE_RANGE:
2666 switch (TYPE_CODE (arg))
2669 case TYPE_CODE_CHAR:
2670 case TYPE_CODE_RANGE:
2671 case TYPE_CODE_BOOL:
2672 case TYPE_CODE_ENUM:
2673 return INTEGER_CONVERSION_BADNESS;
2675 return INT_FLOAT_CONVERSION_BADNESS;
2677 return INCOMPATIBLE_TYPE_BADNESS;
2680 case TYPE_CODE_BOOL:
2681 switch (TYPE_CODE (arg))
2684 case TYPE_CODE_CHAR:
2685 case TYPE_CODE_RANGE:
2686 case TYPE_CODE_ENUM:
2688 return INCOMPATIBLE_TYPE_BADNESS;
2690 return BOOL_PTR_CONVERSION_BADNESS;
2691 case TYPE_CODE_BOOL:
2692 return EXACT_MATCH_BADNESS;
2694 return INCOMPATIBLE_TYPE_BADNESS;
2698 switch (TYPE_CODE (arg))
2701 if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2702 return FLOAT_PROMOTION_BADNESS;
2703 else if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2704 return EXACT_MATCH_BADNESS;
2706 return FLOAT_CONVERSION_BADNESS;
2708 case TYPE_CODE_BOOL:
2709 case TYPE_CODE_ENUM:
2710 case TYPE_CODE_RANGE:
2711 case TYPE_CODE_CHAR:
2712 return INT_FLOAT_CONVERSION_BADNESS;
2714 return INCOMPATIBLE_TYPE_BADNESS;
2717 case TYPE_CODE_COMPLEX:
2718 switch (TYPE_CODE (arg))
2719 { /* Strictly not needed for C++, but... */
2721 return FLOAT_PROMOTION_BADNESS;
2722 case TYPE_CODE_COMPLEX:
2723 return EXACT_MATCH_BADNESS;
2725 return INCOMPATIBLE_TYPE_BADNESS;
2728 case TYPE_CODE_STRUCT:
2729 /* currently same as TYPE_CODE_CLASS. */
2730 switch (TYPE_CODE (arg))
2732 case TYPE_CODE_STRUCT:
2733 /* Check for derivation */
2734 rank.subrank = distance_to_ancestor (parm, arg, 0);
2735 if (rank.subrank >= 0)
2736 return sum_ranks (BASE_CONVERSION_BADNESS, rank);
2737 /* else fall through */
2739 return INCOMPATIBLE_TYPE_BADNESS;
2742 case TYPE_CODE_UNION:
2743 switch (TYPE_CODE (arg))
2745 case TYPE_CODE_UNION:
2747 return INCOMPATIBLE_TYPE_BADNESS;
2750 case TYPE_CODE_MEMBERPTR:
2751 switch (TYPE_CODE (arg))
2754 return INCOMPATIBLE_TYPE_BADNESS;
2757 case TYPE_CODE_METHOD:
2758 switch (TYPE_CODE (arg))
2762 return INCOMPATIBLE_TYPE_BADNESS;
2766 switch (TYPE_CODE (arg))
2770 return INCOMPATIBLE_TYPE_BADNESS;
2775 switch (TYPE_CODE (arg))
2779 return rank_one_type (TYPE_FIELD_TYPE (parm, 0),
2780 TYPE_FIELD_TYPE (arg, 0), NULL);
2782 return INCOMPATIBLE_TYPE_BADNESS;
2785 case TYPE_CODE_VOID:
2787 return INCOMPATIBLE_TYPE_BADNESS;
2788 } /* switch (TYPE_CODE (arg)) */
2792 /* End of functions for overload resolution. */
2795 print_bit_vector (B_TYPE *bits, int nbits)
2799 for (bitno = 0; bitno < nbits; bitno++)
2801 if ((bitno % 8) == 0)
2803 puts_filtered (" ");
2805 if (B_TST (bits, bitno))
2806 printf_filtered (("1"));
2808 printf_filtered (("0"));
2812 /* Note the first arg should be the "this" pointer, we may not want to
2813 include it since we may get into a infinitely recursive
2817 print_arg_types (struct field *args, int nargs, int spaces)
2823 for (i = 0; i < nargs; i++)
2824 recursive_dump_type (args[i].type, spaces + 2);
2829 field_is_static (struct field *f)
2831 /* "static" fields are the fields whose location is not relative
2832 to the address of the enclosing struct. It would be nice to
2833 have a dedicated flag that would be set for static fields when
2834 the type is being created. But in practice, checking the field
2835 loc_kind should give us an accurate answer. */
2836 return (FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSNAME
2837 || FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSADDR);
2841 dump_fn_fieldlists (struct type *type, int spaces)
2847 printfi_filtered (spaces, "fn_fieldlists ");
2848 gdb_print_host_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
2849 printf_filtered ("\n");
2850 for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
2852 f = TYPE_FN_FIELDLIST1 (type, method_idx);
2853 printfi_filtered (spaces + 2, "[%d] name '%s' (",
2855 TYPE_FN_FIELDLIST_NAME (type, method_idx));
2856 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
2858 printf_filtered (_(") length %d\n"),
2859 TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
2860 for (overload_idx = 0;
2861 overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
2864 printfi_filtered (spaces + 4, "[%d] physname '%s' (",
2866 TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
2867 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
2869 printf_filtered (")\n");
2870 printfi_filtered (spaces + 8, "type ");
2871 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx),
2873 printf_filtered ("\n");
2875 recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
2878 printfi_filtered (spaces + 8, "args ");
2879 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx),
2881 printf_filtered ("\n");
2883 print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx),
2884 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f,
2887 printfi_filtered (spaces + 8, "fcontext ");
2888 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
2890 printf_filtered ("\n");
2892 printfi_filtered (spaces + 8, "is_const %d\n",
2893 TYPE_FN_FIELD_CONST (f, overload_idx));
2894 printfi_filtered (spaces + 8, "is_volatile %d\n",
2895 TYPE_FN_FIELD_VOLATILE (f, overload_idx));
2896 printfi_filtered (spaces + 8, "is_private %d\n",
2897 TYPE_FN_FIELD_PRIVATE (f, overload_idx));
2898 printfi_filtered (spaces + 8, "is_protected %d\n",
2899 TYPE_FN_FIELD_PROTECTED (f, overload_idx));
2900 printfi_filtered (spaces + 8, "is_stub %d\n",
2901 TYPE_FN_FIELD_STUB (f, overload_idx));
2902 printfi_filtered (spaces + 8, "voffset %u\n",
2903 TYPE_FN_FIELD_VOFFSET (f, overload_idx));
2909 print_cplus_stuff (struct type *type, int spaces)
2911 printfi_filtered (spaces, "n_baseclasses %d\n",
2912 TYPE_N_BASECLASSES (type));
2913 printfi_filtered (spaces, "nfn_fields %d\n",
2914 TYPE_NFN_FIELDS (type));
2915 if (TYPE_N_BASECLASSES (type) > 0)
2917 printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
2918 TYPE_N_BASECLASSES (type));
2919 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type),
2921 printf_filtered (")");
2923 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
2924 TYPE_N_BASECLASSES (type));
2925 puts_filtered ("\n");
2927 if (TYPE_NFIELDS (type) > 0)
2929 if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
2931 printfi_filtered (spaces,
2932 "private_field_bits (%d bits at *",
2933 TYPE_NFIELDS (type));
2934 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type),
2936 printf_filtered (")");
2937 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
2938 TYPE_NFIELDS (type));
2939 puts_filtered ("\n");
2941 if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
2943 printfi_filtered (spaces,
2944 "protected_field_bits (%d bits at *",
2945 TYPE_NFIELDS (type));
2946 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type),
2948 printf_filtered (")");
2949 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
2950 TYPE_NFIELDS (type));
2951 puts_filtered ("\n");
2954 if (TYPE_NFN_FIELDS (type) > 0)
2956 dump_fn_fieldlists (type, spaces);
2960 /* Print the contents of the TYPE's type_specific union, assuming that
2961 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
2964 print_gnat_stuff (struct type *type, int spaces)
2966 struct type *descriptive_type = TYPE_DESCRIPTIVE_TYPE (type);
2968 recursive_dump_type (descriptive_type, spaces + 2);
2971 static struct obstack dont_print_type_obstack;
2974 recursive_dump_type (struct type *type, int spaces)
2979 obstack_begin (&dont_print_type_obstack, 0);
2981 if (TYPE_NFIELDS (type) > 0
2982 || (HAVE_CPLUS_STRUCT (type) && TYPE_NFN_FIELDS (type) > 0))
2984 struct type **first_dont_print
2985 = (struct type **) obstack_base (&dont_print_type_obstack);
2987 int i = (struct type **)
2988 obstack_next_free (&dont_print_type_obstack) - first_dont_print;
2992 if (type == first_dont_print[i])
2994 printfi_filtered (spaces, "type node ");
2995 gdb_print_host_address (type, gdb_stdout);
2996 printf_filtered (_(" <same as already seen type>\n"));
3001 obstack_ptr_grow (&dont_print_type_obstack, type);
3004 printfi_filtered (spaces, "type node ");
3005 gdb_print_host_address (type, gdb_stdout);
3006 printf_filtered ("\n");
3007 printfi_filtered (spaces, "name '%s' (",
3008 TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
3009 gdb_print_host_address (TYPE_NAME (type), gdb_stdout);
3010 printf_filtered (")\n");
3011 printfi_filtered (spaces, "tagname '%s' (",
3012 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : "<NULL>");
3013 gdb_print_host_address (TYPE_TAG_NAME (type), gdb_stdout);
3014 printf_filtered (")\n");
3015 printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
3016 switch (TYPE_CODE (type))
3018 case TYPE_CODE_UNDEF:
3019 printf_filtered ("(TYPE_CODE_UNDEF)");
3022 printf_filtered ("(TYPE_CODE_PTR)");
3024 case TYPE_CODE_ARRAY:
3025 printf_filtered ("(TYPE_CODE_ARRAY)");
3027 case TYPE_CODE_STRUCT:
3028 printf_filtered ("(TYPE_CODE_STRUCT)");
3030 case TYPE_CODE_UNION:
3031 printf_filtered ("(TYPE_CODE_UNION)");
3033 case TYPE_CODE_ENUM:
3034 printf_filtered ("(TYPE_CODE_ENUM)");
3036 case TYPE_CODE_FLAGS:
3037 printf_filtered ("(TYPE_CODE_FLAGS)");
3039 case TYPE_CODE_FUNC:
3040 printf_filtered ("(TYPE_CODE_FUNC)");
3043 printf_filtered ("(TYPE_CODE_INT)");
3046 printf_filtered ("(TYPE_CODE_FLT)");
3048 case TYPE_CODE_VOID:
3049 printf_filtered ("(TYPE_CODE_VOID)");
3052 printf_filtered ("(TYPE_CODE_SET)");
3054 case TYPE_CODE_RANGE:
3055 printf_filtered ("(TYPE_CODE_RANGE)");
3057 case TYPE_CODE_STRING:
3058 printf_filtered ("(TYPE_CODE_STRING)");
3060 case TYPE_CODE_BITSTRING:
3061 printf_filtered ("(TYPE_CODE_BITSTRING)");
3063 case TYPE_CODE_ERROR:
3064 printf_filtered ("(TYPE_CODE_ERROR)");
3066 case TYPE_CODE_MEMBERPTR:
3067 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
3069 case TYPE_CODE_METHODPTR:
3070 printf_filtered ("(TYPE_CODE_METHODPTR)");
3072 case TYPE_CODE_METHOD:
3073 printf_filtered ("(TYPE_CODE_METHOD)");
3076 printf_filtered ("(TYPE_CODE_REF)");
3078 case TYPE_CODE_CHAR:
3079 printf_filtered ("(TYPE_CODE_CHAR)");
3081 case TYPE_CODE_BOOL:
3082 printf_filtered ("(TYPE_CODE_BOOL)");
3084 case TYPE_CODE_COMPLEX:
3085 printf_filtered ("(TYPE_CODE_COMPLEX)");
3087 case TYPE_CODE_TYPEDEF:
3088 printf_filtered ("(TYPE_CODE_TYPEDEF)");
3090 case TYPE_CODE_NAMESPACE:
3091 printf_filtered ("(TYPE_CODE_NAMESPACE)");
3094 printf_filtered ("(UNKNOWN TYPE CODE)");
3097 puts_filtered ("\n");
3098 printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
3099 if (TYPE_OBJFILE_OWNED (type))
3101 printfi_filtered (spaces, "objfile ");
3102 gdb_print_host_address (TYPE_OWNER (type).objfile, gdb_stdout);
3106 printfi_filtered (spaces, "gdbarch ");
3107 gdb_print_host_address (TYPE_OWNER (type).gdbarch, gdb_stdout);
3109 printf_filtered ("\n");
3110 printfi_filtered (spaces, "target_type ");
3111 gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout);
3112 printf_filtered ("\n");
3113 if (TYPE_TARGET_TYPE (type) != NULL)
3115 recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
3117 printfi_filtered (spaces, "pointer_type ");
3118 gdb_print_host_address (TYPE_POINTER_TYPE (type), gdb_stdout);
3119 printf_filtered ("\n");
3120 printfi_filtered (spaces, "reference_type ");
3121 gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
3122 printf_filtered ("\n");
3123 printfi_filtered (spaces, "type_chain ");
3124 gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);
3125 printf_filtered ("\n");
3126 printfi_filtered (spaces, "instance_flags 0x%x",
3127 TYPE_INSTANCE_FLAGS (type));
3128 if (TYPE_CONST (type))
3130 puts_filtered (" TYPE_FLAG_CONST");
3132 if (TYPE_VOLATILE (type))
3134 puts_filtered (" TYPE_FLAG_VOLATILE");
3136 if (TYPE_CODE_SPACE (type))
3138 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3140 if (TYPE_DATA_SPACE (type))
3142 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3144 if (TYPE_ADDRESS_CLASS_1 (type))
3146 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3148 if (TYPE_ADDRESS_CLASS_2 (type))
3150 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3152 puts_filtered ("\n");
3154 printfi_filtered (spaces, "flags");
3155 if (TYPE_UNSIGNED (type))
3157 puts_filtered (" TYPE_FLAG_UNSIGNED");
3159 if (TYPE_NOSIGN (type))
3161 puts_filtered (" TYPE_FLAG_NOSIGN");
3163 if (TYPE_STUB (type))
3165 puts_filtered (" TYPE_FLAG_STUB");
3167 if (TYPE_TARGET_STUB (type))
3169 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3171 if (TYPE_STATIC (type))
3173 puts_filtered (" TYPE_FLAG_STATIC");
3175 if (TYPE_PROTOTYPED (type))
3177 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3179 if (TYPE_INCOMPLETE (type))
3181 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3183 if (TYPE_VARARGS (type))
3185 puts_filtered (" TYPE_FLAG_VARARGS");
3187 /* This is used for things like AltiVec registers on ppc. Gcc emits
3188 an attribute for the array type, which tells whether or not we
3189 have a vector, instead of a regular array. */
3190 if (TYPE_VECTOR (type))
3192 puts_filtered (" TYPE_FLAG_VECTOR");
3194 if (TYPE_FIXED_INSTANCE (type))
3196 puts_filtered (" TYPE_FIXED_INSTANCE");
3198 if (TYPE_STUB_SUPPORTED (type))
3200 puts_filtered (" TYPE_STUB_SUPPORTED");
3202 if (TYPE_NOTTEXT (type))
3204 puts_filtered (" TYPE_NOTTEXT");
3206 puts_filtered ("\n");
3207 printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
3208 gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
3209 puts_filtered ("\n");
3210 for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
3212 if (TYPE_CODE (type) == TYPE_CODE_ENUM)
3213 printfi_filtered (spaces + 2,
3214 "[%d] enumval %s type ",
3215 idx, plongest (TYPE_FIELD_ENUMVAL (type, idx)));
3217 printfi_filtered (spaces + 2,
3218 "[%d] bitpos %d bitsize %d type ",
3219 idx, TYPE_FIELD_BITPOS (type, idx),
3220 TYPE_FIELD_BITSIZE (type, idx));
3221 gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
3222 printf_filtered (" name '%s' (",
3223 TYPE_FIELD_NAME (type, idx) != NULL
3224 ? TYPE_FIELD_NAME (type, idx)
3226 gdb_print_host_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
3227 printf_filtered (")\n");
3228 if (TYPE_FIELD_TYPE (type, idx) != NULL)
3230 recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
3233 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
3235 printfi_filtered (spaces, "low %s%s high %s%s\n",
3236 plongest (TYPE_LOW_BOUND (type)),
3237 TYPE_LOW_BOUND_UNDEFINED (type) ? " (undefined)" : "",
3238 plongest (TYPE_HIGH_BOUND (type)),
3239 TYPE_HIGH_BOUND_UNDEFINED (type)
3240 ? " (undefined)" : "");
3242 printfi_filtered (spaces, "vptr_basetype ");
3243 gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
3244 puts_filtered ("\n");
3245 if (TYPE_VPTR_BASETYPE (type) != NULL)
3247 recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
3249 printfi_filtered (spaces, "vptr_fieldno %d\n",
3250 TYPE_VPTR_FIELDNO (type));
3252 switch (TYPE_SPECIFIC_FIELD (type))
3254 case TYPE_SPECIFIC_CPLUS_STUFF:
3255 printfi_filtered (spaces, "cplus_stuff ");
3256 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type),
3258 puts_filtered ("\n");
3259 print_cplus_stuff (type, spaces);
3262 case TYPE_SPECIFIC_GNAT_STUFF:
3263 printfi_filtered (spaces, "gnat_stuff ");
3264 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type), gdb_stdout);
3265 puts_filtered ("\n");
3266 print_gnat_stuff (type, spaces);
3269 case TYPE_SPECIFIC_FLOATFORMAT:
3270 printfi_filtered (spaces, "floatformat ");
3271 if (TYPE_FLOATFORMAT (type) == NULL)
3272 puts_filtered ("(null)");
3275 puts_filtered ("{ ");
3276 if (TYPE_FLOATFORMAT (type)[0] == NULL
3277 || TYPE_FLOATFORMAT (type)[0]->name == NULL)
3278 puts_filtered ("(null)");
3280 puts_filtered (TYPE_FLOATFORMAT (type)[0]->name);
3282 puts_filtered (", ");
3283 if (TYPE_FLOATFORMAT (type)[1] == NULL
3284 || TYPE_FLOATFORMAT (type)[1]->name == NULL)
3285 puts_filtered ("(null)");
3287 puts_filtered (TYPE_FLOATFORMAT (type)[1]->name);
3289 puts_filtered (" }");
3291 puts_filtered ("\n");
3294 case TYPE_SPECIFIC_FUNC:
3295 printfi_filtered (spaces, "calling_convention %d\n",
3296 TYPE_CALLING_CONVENTION (type));
3297 /* tail_call_list is not printed. */
3302 obstack_free (&dont_print_type_obstack, NULL);
3305 /* Trivial helpers for the libiberty hash table, for mapping one
3310 struct type *old, *new;
3314 type_pair_hash (const void *item)
3316 const struct type_pair *pair = item;
3318 return htab_hash_pointer (pair->old);
3322 type_pair_eq (const void *item_lhs, const void *item_rhs)
3324 const struct type_pair *lhs = item_lhs, *rhs = item_rhs;
3326 return lhs->old == rhs->old;
3329 /* Allocate the hash table used by copy_type_recursive to walk
3330 types without duplicates. We use OBJFILE's obstack, because
3331 OBJFILE is about to be deleted. */
3334 create_copied_types_hash (struct objfile *objfile)
3336 return htab_create_alloc_ex (1, type_pair_hash, type_pair_eq,
3337 NULL, &objfile->objfile_obstack,
3338 hashtab_obstack_allocate,
3339 dummy_obstack_deallocate);
3342 /* Recursively copy (deep copy) TYPE, if it is associated with
3343 OBJFILE. Return a new type allocated using malloc, a saved type if
3344 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
3345 not associated with OBJFILE. */
3348 copy_type_recursive (struct objfile *objfile,
3350 htab_t copied_types)
3352 struct type_pair *stored, pair;
3354 struct type *new_type;
3356 if (! TYPE_OBJFILE_OWNED (type))
3359 /* This type shouldn't be pointing to any types in other objfiles;
3360 if it did, the type might disappear unexpectedly. */
3361 gdb_assert (TYPE_OBJFILE (type) == objfile);
3364 slot = htab_find_slot (copied_types, &pair, INSERT);
3366 return ((struct type_pair *) *slot)->new;
3368 new_type = alloc_type_arch (get_type_arch (type));
3370 /* We must add the new type to the hash table immediately, in case
3371 we encounter this type again during a recursive call below. */
3373 = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair));
3375 stored->new = new_type;
3378 /* Copy the common fields of types. For the main type, we simply
3379 copy the entire thing and then update specific fields as needed. */
3380 *TYPE_MAIN_TYPE (new_type) = *TYPE_MAIN_TYPE (type);
3381 TYPE_OBJFILE_OWNED (new_type) = 0;
3382 TYPE_OWNER (new_type).gdbarch = get_type_arch (type);
3384 if (TYPE_NAME (type))
3385 TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type));
3386 if (TYPE_TAG_NAME (type))
3387 TYPE_TAG_NAME (new_type) = xstrdup (TYPE_TAG_NAME (type));
3389 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
3390 TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
3392 /* Copy the fields. */
3393 if (TYPE_NFIELDS (type))
3397 nfields = TYPE_NFIELDS (type);
3398 TYPE_FIELDS (new_type) = XCALLOC (nfields, struct field);
3399 for (i = 0; i < nfields; i++)
3401 TYPE_FIELD_ARTIFICIAL (new_type, i) =
3402 TYPE_FIELD_ARTIFICIAL (type, i);
3403 TYPE_FIELD_BITSIZE (new_type, i) = TYPE_FIELD_BITSIZE (type, i);
3404 if (TYPE_FIELD_TYPE (type, i))
3405 TYPE_FIELD_TYPE (new_type, i)
3406 = copy_type_recursive (objfile, TYPE_FIELD_TYPE (type, i),
3408 if (TYPE_FIELD_NAME (type, i))
3409 TYPE_FIELD_NAME (new_type, i) =
3410 xstrdup (TYPE_FIELD_NAME (type, i));
3411 switch (TYPE_FIELD_LOC_KIND (type, i))
3413 case FIELD_LOC_KIND_BITPOS:
3414 SET_FIELD_BITPOS (TYPE_FIELD (new_type, i),
3415 TYPE_FIELD_BITPOS (type, i));
3417 case FIELD_LOC_KIND_ENUMVAL:
3418 SET_FIELD_ENUMVAL (TYPE_FIELD (new_type, i),
3419 TYPE_FIELD_ENUMVAL (type, i));
3421 case FIELD_LOC_KIND_PHYSADDR:
3422 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i),
3423 TYPE_FIELD_STATIC_PHYSADDR (type, i));
3425 case FIELD_LOC_KIND_PHYSNAME:
3426 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i),
3427 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type,
3431 internal_error (__FILE__, __LINE__,
3432 _("Unexpected type field location kind: %d"),
3433 TYPE_FIELD_LOC_KIND (type, i));
3438 /* For range types, copy the bounds information. */
3439 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
3441 TYPE_RANGE_DATA (new_type) = xmalloc (sizeof (struct range_bounds));
3442 *TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type);
3445 /* Copy pointers to other types. */
3446 if (TYPE_TARGET_TYPE (type))
3447 TYPE_TARGET_TYPE (new_type) =
3448 copy_type_recursive (objfile,
3449 TYPE_TARGET_TYPE (type),
3451 if (TYPE_VPTR_BASETYPE (type))
3452 TYPE_VPTR_BASETYPE (new_type) =
3453 copy_type_recursive (objfile,
3454 TYPE_VPTR_BASETYPE (type),
3456 /* Maybe copy the type_specific bits.
3458 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3459 base classes and methods. There's no fundamental reason why we
3460 can't, but at the moment it is not needed. */
3462 if (TYPE_CODE (type) == TYPE_CODE_FLT)
3463 TYPE_FLOATFORMAT (new_type) = TYPE_FLOATFORMAT (type);
3464 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
3465 || TYPE_CODE (type) == TYPE_CODE_UNION
3466 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
3467 INIT_CPLUS_SPECIFIC (new_type);
3472 /* Make a copy of the given TYPE, except that the pointer & reference
3473 types are not preserved.
3475 This function assumes that the given type has an associated objfile.
3476 This objfile is used to allocate the new type. */
3479 copy_type (const struct type *type)
3481 struct type *new_type;
3483 gdb_assert (TYPE_OBJFILE_OWNED (type));
3485 new_type = alloc_type_copy (type);
3486 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
3487 TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
3488 memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type),
3489 sizeof (struct main_type));
3495 /* Helper functions to initialize architecture-specific types. */
3497 /* Allocate a type structure associated with GDBARCH and set its
3498 CODE, LENGTH, and NAME fields. */
3500 arch_type (struct gdbarch *gdbarch,
3501 enum type_code code, int length, char *name)
3505 type = alloc_type_arch (gdbarch);
3506 TYPE_CODE (type) = code;
3507 TYPE_LENGTH (type) = length;
3510 TYPE_NAME (type) = xstrdup (name);
3515 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
3516 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3517 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3519 arch_integer_type (struct gdbarch *gdbarch,
3520 int bit, int unsigned_p, char *name)
3524 t = arch_type (gdbarch, TYPE_CODE_INT, bit / TARGET_CHAR_BIT, name);
3526 TYPE_UNSIGNED (t) = 1;
3527 if (name && strcmp (name, "char") == 0)
3528 TYPE_NOSIGN (t) = 1;
3533 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
3534 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3535 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3537 arch_character_type (struct gdbarch *gdbarch,
3538 int bit, int unsigned_p, char *name)
3542 t = arch_type (gdbarch, TYPE_CODE_CHAR, bit / TARGET_CHAR_BIT, name);
3544 TYPE_UNSIGNED (t) = 1;
3549 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
3550 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3551 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3553 arch_boolean_type (struct gdbarch *gdbarch,
3554 int bit, int unsigned_p, char *name)
3558 t = arch_type (gdbarch, TYPE_CODE_BOOL, bit / TARGET_CHAR_BIT, name);
3560 TYPE_UNSIGNED (t) = 1;
3565 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
3566 BIT is the type size in bits; if BIT equals -1, the size is
3567 determined by the floatformat. NAME is the type name. Set the
3568 TYPE_FLOATFORMAT from FLOATFORMATS. */
3570 arch_float_type (struct gdbarch *gdbarch,
3571 int bit, char *name, const struct floatformat **floatformats)
3577 gdb_assert (floatformats != NULL);
3578 gdb_assert (floatformats[0] != NULL && floatformats[1] != NULL);
3579 bit = floatformats[0]->totalsize;
3581 gdb_assert (bit >= 0);
3583 t = arch_type (gdbarch, TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, name);
3584 TYPE_FLOATFORMAT (t) = floatformats;
3588 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
3589 NAME is the type name. TARGET_TYPE is the component float type. */
3591 arch_complex_type (struct gdbarch *gdbarch,
3592 char *name, struct type *target_type)
3596 t = arch_type (gdbarch, TYPE_CODE_COMPLEX,
3597 2 * TYPE_LENGTH (target_type), name);
3598 TYPE_TARGET_TYPE (t) = target_type;
3602 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
3603 NAME is the type name. LENGTH is the size of the flag word in bytes. */
3605 arch_flags_type (struct gdbarch *gdbarch, char *name, int length)
3607 int nfields = length * TARGET_CHAR_BIT;
3610 type = arch_type (gdbarch, TYPE_CODE_FLAGS, length, name);
3611 TYPE_UNSIGNED (type) = 1;
3612 TYPE_NFIELDS (type) = nfields;
3613 TYPE_FIELDS (type) = TYPE_ZALLOC (type, nfields * sizeof (struct field));
3618 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
3619 position BITPOS is called NAME. */
3621 append_flags_type_flag (struct type *type, int bitpos, char *name)
3623 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS);
3624 gdb_assert (bitpos < TYPE_NFIELDS (type));
3625 gdb_assert (bitpos >= 0);
3629 TYPE_FIELD_NAME (type, bitpos) = xstrdup (name);
3630 SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), bitpos);
3634 /* Don't show this field to the user. */
3635 SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), -1);
3639 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
3640 specified by CODE) associated with GDBARCH. NAME is the type name. */
3642 arch_composite_type (struct gdbarch *gdbarch, char *name, enum type_code code)
3646 gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION);
3647 t = arch_type (gdbarch, code, 0, NULL);
3648 TYPE_TAG_NAME (t) = name;
3649 INIT_CPLUS_SPECIFIC (t);
3653 /* Add new field with name NAME and type FIELD to composite type T.
3654 Do not set the field's position or adjust the type's length;
3655 the caller should do so. Return the new field. */
3657 append_composite_type_field_raw (struct type *t, char *name,
3662 TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
3663 TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t),
3664 sizeof (struct field) * TYPE_NFIELDS (t));
3665 f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
3666 memset (f, 0, sizeof f[0]);
3667 FIELD_TYPE (f[0]) = field;
3668 FIELD_NAME (f[0]) = name;
3672 /* Add new field with name NAME and type FIELD to composite type T.
3673 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
3675 append_composite_type_field_aligned (struct type *t, char *name,
3676 struct type *field, int alignment)
3678 struct field *f = append_composite_type_field_raw (t, name, field);
3680 if (TYPE_CODE (t) == TYPE_CODE_UNION)
3682 if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
3683 TYPE_LENGTH (t) = TYPE_LENGTH (field);
3685 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
3687 TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
3688 if (TYPE_NFIELDS (t) > 1)
3690 SET_FIELD_BITPOS (f[0],
3691 (FIELD_BITPOS (f[-1])
3692 + (TYPE_LENGTH (FIELD_TYPE (f[-1]))
3693 * TARGET_CHAR_BIT)));
3699 alignment *= TARGET_CHAR_BIT;
3700 left = FIELD_BITPOS (f[0]) % alignment;
3704 SET_FIELD_BITPOS (f[0], FIELD_BITPOS (f[0]) + (alignment - left));
3705 TYPE_LENGTH (t) += (alignment - left) / TARGET_CHAR_BIT;
3712 /* Add new field with name NAME and type FIELD to composite type T. */
3714 append_composite_type_field (struct type *t, char *name,
3717 append_composite_type_field_aligned (t, name, field, 0);
3721 static struct gdbarch_data *gdbtypes_data;
3723 const struct builtin_type *
3724 builtin_type (struct gdbarch *gdbarch)
3726 return gdbarch_data (gdbarch, gdbtypes_data);
3730 gdbtypes_post_init (struct gdbarch *gdbarch)
3732 struct builtin_type *builtin_type
3733 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type);
3736 builtin_type->builtin_void
3737 = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
3738 builtin_type->builtin_char
3739 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3740 !gdbarch_char_signed (gdbarch), "char");
3741 builtin_type->builtin_signed_char
3742 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3744 builtin_type->builtin_unsigned_char
3745 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3746 1, "unsigned char");
3747 builtin_type->builtin_short
3748 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
3750 builtin_type->builtin_unsigned_short
3751 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
3752 1, "unsigned short");
3753 builtin_type->builtin_int
3754 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
3756 builtin_type->builtin_unsigned_int
3757 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
3759 builtin_type->builtin_long
3760 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
3762 builtin_type->builtin_unsigned_long
3763 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
3764 1, "unsigned long");
3765 builtin_type->builtin_long_long
3766 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
3768 builtin_type->builtin_unsigned_long_long
3769 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
3770 1, "unsigned long long");
3771 builtin_type->builtin_float
3772 = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
3773 "float", gdbarch_float_format (gdbarch));
3774 builtin_type->builtin_double
3775 = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
3776 "double", gdbarch_double_format (gdbarch));
3777 builtin_type->builtin_long_double
3778 = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
3779 "long double", gdbarch_long_double_format (gdbarch));
3780 builtin_type->builtin_complex
3781 = arch_complex_type (gdbarch, "complex",
3782 builtin_type->builtin_float);
3783 builtin_type->builtin_double_complex
3784 = arch_complex_type (gdbarch, "double complex",
3785 builtin_type->builtin_double);
3786 builtin_type->builtin_string
3787 = arch_type (gdbarch, TYPE_CODE_STRING, 1, "string");
3788 builtin_type->builtin_bool
3789 = arch_type (gdbarch, TYPE_CODE_BOOL, 1, "bool");
3791 /* The following three are about decimal floating point types, which
3792 are 32-bits, 64-bits and 128-bits respectively. */
3793 builtin_type->builtin_decfloat
3794 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 32 / 8, "_Decimal32");
3795 builtin_type->builtin_decdouble
3796 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 64 / 8, "_Decimal64");
3797 builtin_type->builtin_declong
3798 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 128 / 8, "_Decimal128");
3800 /* "True" character types. */
3801 builtin_type->builtin_true_char
3802 = arch_character_type (gdbarch, TARGET_CHAR_BIT, 0, "true character");
3803 builtin_type->builtin_true_unsigned_char
3804 = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "true character");
3806 /* Fixed-size integer types. */
3807 builtin_type->builtin_int0
3808 = arch_integer_type (gdbarch, 0, 0, "int0_t");
3809 builtin_type->builtin_int8
3810 = arch_integer_type (gdbarch, 8, 0, "int8_t");
3811 builtin_type->builtin_uint8
3812 = arch_integer_type (gdbarch, 8, 1, "uint8_t");
3813 builtin_type->builtin_int16
3814 = arch_integer_type (gdbarch, 16, 0, "int16_t");
3815 builtin_type->builtin_uint16
3816 = arch_integer_type (gdbarch, 16, 1, "uint16_t");
3817 builtin_type->builtin_int32
3818 = arch_integer_type (gdbarch, 32, 0, "int32_t");
3819 builtin_type->builtin_uint32
3820 = arch_integer_type (gdbarch, 32, 1, "uint32_t");
3821 builtin_type->builtin_int64
3822 = arch_integer_type (gdbarch, 64, 0, "int64_t");
3823 builtin_type->builtin_uint64
3824 = arch_integer_type (gdbarch, 64, 1, "uint64_t");
3825 builtin_type->builtin_int128
3826 = arch_integer_type (gdbarch, 128, 0, "int128_t");
3827 builtin_type->builtin_uint128
3828 = arch_integer_type (gdbarch, 128, 1, "uint128_t");
3829 TYPE_INSTANCE_FLAGS (builtin_type->builtin_int8) |=
3830 TYPE_INSTANCE_FLAG_NOTTEXT;
3831 TYPE_INSTANCE_FLAGS (builtin_type->builtin_uint8) |=
3832 TYPE_INSTANCE_FLAG_NOTTEXT;
3834 /* Wide character types. */
3835 builtin_type->builtin_char16
3836 = arch_integer_type (gdbarch, 16, 0, "char16_t");
3837 builtin_type->builtin_char32
3838 = arch_integer_type (gdbarch, 32, 0, "char32_t");
3841 /* Default data/code pointer types. */
3842 builtin_type->builtin_data_ptr
3843 = lookup_pointer_type (builtin_type->builtin_void);
3844 builtin_type->builtin_func_ptr
3845 = lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
3846 builtin_type->builtin_func_func
3847 = lookup_function_type (builtin_type->builtin_func_ptr);
3849 /* This type represents a GDB internal function. */
3850 builtin_type->internal_fn
3851 = arch_type (gdbarch, TYPE_CODE_INTERNAL_FUNCTION, 0,
3852 "<internal function>");
3854 return builtin_type;
3858 /* This set of objfile-based types is intended to be used by symbol
3859 readers as basic types. */
3861 static const struct objfile_data *objfile_type_data;
3863 const struct objfile_type *
3864 objfile_type (struct objfile *objfile)
3866 struct gdbarch *gdbarch;
3867 struct objfile_type *objfile_type
3868 = objfile_data (objfile, objfile_type_data);
3871 return objfile_type;
3873 objfile_type = OBSTACK_CALLOC (&objfile->objfile_obstack,
3874 1, struct objfile_type);
3876 /* Use the objfile architecture to determine basic type properties. */
3877 gdbarch = get_objfile_arch (objfile);
3880 objfile_type->builtin_void
3881 = init_type (TYPE_CODE_VOID, 1,
3885 objfile_type->builtin_char
3886 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3888 | (gdbarch_char_signed (gdbarch) ? 0 : TYPE_FLAG_UNSIGNED)),
3890 objfile_type->builtin_signed_char
3891 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3893 "signed char", objfile);
3894 objfile_type->builtin_unsigned_char
3895 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3897 "unsigned char", objfile);
3898 objfile_type->builtin_short
3899 = init_type (TYPE_CODE_INT,
3900 gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
3901 0, "short", objfile);
3902 objfile_type->builtin_unsigned_short
3903 = init_type (TYPE_CODE_INT,
3904 gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
3905 TYPE_FLAG_UNSIGNED, "unsigned short", objfile);
3906 objfile_type->builtin_int
3907 = init_type (TYPE_CODE_INT,
3908 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
3910 objfile_type->builtin_unsigned_int
3911 = init_type (TYPE_CODE_INT,
3912 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
3913 TYPE_FLAG_UNSIGNED, "unsigned int", objfile);
3914 objfile_type->builtin_long
3915 = init_type (TYPE_CODE_INT,
3916 gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
3917 0, "long", objfile);
3918 objfile_type->builtin_unsigned_long
3919 = init_type (TYPE_CODE_INT,
3920 gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
3921 TYPE_FLAG_UNSIGNED, "unsigned long", objfile);
3922 objfile_type->builtin_long_long
3923 = init_type (TYPE_CODE_INT,
3924 gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
3925 0, "long long", objfile);
3926 objfile_type->builtin_unsigned_long_long
3927 = init_type (TYPE_CODE_INT,
3928 gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
3929 TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
3931 objfile_type->builtin_float
3932 = init_type (TYPE_CODE_FLT,
3933 gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT,
3934 0, "float", objfile);
3935 TYPE_FLOATFORMAT (objfile_type->builtin_float)
3936 = gdbarch_float_format (gdbarch);
3937 objfile_type->builtin_double
3938 = init_type (TYPE_CODE_FLT,
3939 gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT,
3940 0, "double", objfile);
3941 TYPE_FLOATFORMAT (objfile_type->builtin_double)
3942 = gdbarch_double_format (gdbarch);
3943 objfile_type->builtin_long_double
3944 = init_type (TYPE_CODE_FLT,
3945 gdbarch_long_double_bit (gdbarch) / TARGET_CHAR_BIT,
3946 0, "long double", objfile);
3947 TYPE_FLOATFORMAT (objfile_type->builtin_long_double)
3948 = gdbarch_long_double_format (gdbarch);
3950 /* This type represents a type that was unrecognized in symbol read-in. */
3951 objfile_type->builtin_error
3952 = init_type (TYPE_CODE_ERROR, 0, 0, "<unknown type>", objfile);
3954 /* The following set of types is used for symbols with no
3955 debug information. */
3956 objfile_type->nodebug_text_symbol
3957 = init_type (TYPE_CODE_FUNC, 1, 0,
3958 "<text variable, no debug info>", objfile);
3959 TYPE_TARGET_TYPE (objfile_type->nodebug_text_symbol)
3960 = objfile_type->builtin_int;
3961 objfile_type->nodebug_text_gnu_ifunc_symbol
3962 = init_type (TYPE_CODE_FUNC, 1, TYPE_FLAG_GNU_IFUNC,
3963 "<text gnu-indirect-function variable, no debug info>",
3965 TYPE_TARGET_TYPE (objfile_type->nodebug_text_gnu_ifunc_symbol)
3966 = objfile_type->nodebug_text_symbol;
3967 objfile_type->nodebug_got_plt_symbol
3968 = init_type (TYPE_CODE_PTR, gdbarch_addr_bit (gdbarch) / 8, 0,
3969 "<text from jump slot in .got.plt, no debug info>",
3971 TYPE_TARGET_TYPE (objfile_type->nodebug_got_plt_symbol)
3972 = objfile_type->nodebug_text_symbol;
3973 objfile_type->nodebug_data_symbol
3974 = init_type (TYPE_CODE_INT,
3975 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
3976 "<data variable, no debug info>", objfile);
3977 objfile_type->nodebug_unknown_symbol
3978 = init_type (TYPE_CODE_INT, 1, 0,
3979 "<variable (not text or data), no debug info>", objfile);
3980 objfile_type->nodebug_tls_symbol
3981 = init_type (TYPE_CODE_INT,
3982 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
3983 "<thread local variable, no debug info>", objfile);
3985 /* NOTE: on some targets, addresses and pointers are not necessarily
3986 the same --- for example, on the D10V, pointers are 16 bits long,
3987 but addresses are 32 bits long. See doc/gdbint.texinfo,
3988 ``Pointers Are Not Always Addresses''.
3991 - gdb's `struct type' always describes the target's
3993 - gdb's `struct value' objects should always hold values in
3995 - gdb's CORE_ADDR values are addresses in the unified virtual
3996 address space that the assembler and linker work with. Thus,
3997 since target_read_memory takes a CORE_ADDR as an argument, it
3998 can access any memory on the target, even if the processor has
3999 separate code and data address spaces.
4002 - If v is a value holding a D10V code pointer, its contents are
4003 in target form: a big-endian address left-shifted two bits.
4004 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
4005 sizeof (void *) == 2 on the target.
4007 In this context, objfile_type->builtin_core_addr is a bit odd:
4008 it's a target type for a value the target will never see. It's
4009 only used to hold the values of (typeless) linker symbols, which
4010 are indeed in the unified virtual address space. */
4012 objfile_type->builtin_core_addr
4013 = init_type (TYPE_CODE_INT,
4014 gdbarch_addr_bit (gdbarch) / 8,
4015 TYPE_FLAG_UNSIGNED, "__CORE_ADDR", objfile);
4017 set_objfile_data (objfile, objfile_type_data, objfile_type);
4018 return objfile_type;
4022 extern void _initialize_gdbtypes (void);
4024 _initialize_gdbtypes (void)
4026 gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
4027 objfile_type_data = register_objfile_data ();
4029 add_setshow_zinteger_cmd ("overload", no_class, &overload_debug,
4030 _("Set debugging of C++ overloading."),
4031 _("Show debugging of C++ overloading."),
4032 _("When enabled, ranking of the "
4033 "functions is displayed."),
4035 show_overload_debug,
4036 &setdebuglist, &showdebuglist);
4038 /* Add user knob for controlling resolution of opaque types. */
4039 add_setshow_boolean_cmd ("opaque-type-resolution", class_support,
4040 &opaque_type_resolution,
4041 _("Set resolution of opaque struct/class/union"
4042 " types (if set before loading symbols)."),
4043 _("Show resolution of opaque struct/class/union"
4044 " types (if set before loading symbols)."),
4046 show_opaque_type_resolution,
4047 &setlist, &showlist);