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 unsigned 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
466 function type. If the final type in PARAM_TYPES is NULL, make a
470 lookup_function_type_with_arguments (struct type *type,
472 struct type **param_types)
474 struct type *fn = make_function_type (type, (struct type **) 0);
479 if (param_types[nparams - 1] == NULL)
482 TYPE_VARARGS (fn) = 1;
484 else if (TYPE_CODE (check_typedef (param_types[nparams - 1]))
488 /* Caller should have ensured this. */
489 gdb_assert (nparams == 0);
490 TYPE_PROTOTYPED (fn) = 1;
494 TYPE_NFIELDS (fn) = nparams;
495 TYPE_FIELDS (fn) = TYPE_ZALLOC (fn, nparams * sizeof (struct field));
496 for (i = 0; i < nparams; ++i)
497 TYPE_FIELD_TYPE (fn, i) = param_types[i];
502 /* Identify address space identifier by name --
503 return the integer flag defined in gdbtypes.h. */
505 address_space_name_to_int (struct gdbarch *gdbarch, char *space_identifier)
509 /* Check for known address space delimiters. */
510 if (!strcmp (space_identifier, "code"))
511 return TYPE_INSTANCE_FLAG_CODE_SPACE;
512 else if (!strcmp (space_identifier, "data"))
513 return TYPE_INSTANCE_FLAG_DATA_SPACE;
514 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch)
515 && gdbarch_address_class_name_to_type_flags (gdbarch,
520 error (_("Unknown address space specifier: \"%s\""), space_identifier);
523 /* Identify address space identifier by integer flag as defined in
524 gdbtypes.h -- return the string version of the adress space name. */
527 address_space_int_to_name (struct gdbarch *gdbarch, int space_flag)
529 if (space_flag & TYPE_INSTANCE_FLAG_CODE_SPACE)
531 else if (space_flag & TYPE_INSTANCE_FLAG_DATA_SPACE)
533 else if ((space_flag & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
534 && gdbarch_address_class_type_flags_to_name_p (gdbarch))
535 return gdbarch_address_class_type_flags_to_name (gdbarch, space_flag);
540 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
542 If STORAGE is non-NULL, create the new type instance there.
543 STORAGE must be in the same obstack as TYPE. */
546 make_qualified_type (struct type *type, int new_flags,
547 struct type *storage)
554 if (TYPE_INSTANCE_FLAGS (ntype) == new_flags)
556 ntype = TYPE_CHAIN (ntype);
558 while (ntype != type);
560 /* Create a new type instance. */
562 ntype = alloc_type_instance (type);
565 /* If STORAGE was provided, it had better be in the same objfile
566 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
567 if one objfile is freed and the other kept, we'd have
568 dangling pointers. */
569 gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage));
572 TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type);
573 TYPE_CHAIN (ntype) = ntype;
576 /* Pointers or references to the original type are not relevant to
578 TYPE_POINTER_TYPE (ntype) = (struct type *) 0;
579 TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0;
581 /* Chain the new qualified type to the old type. */
582 TYPE_CHAIN (ntype) = TYPE_CHAIN (type);
583 TYPE_CHAIN (type) = ntype;
585 /* Now set the instance flags and return the new type. */
586 TYPE_INSTANCE_FLAGS (ntype) = new_flags;
588 /* Set length of new type to that of the original type. */
589 TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
594 /* Make an address-space-delimited variant of a type -- a type that
595 is identical to the one supplied except that it has an address
596 space attribute attached to it (such as "code" or "data").
598 The space attributes "code" and "data" are for Harvard
599 architectures. The address space attributes are for architectures
600 which have alternately sized pointers or pointers with alternate
604 make_type_with_address_space (struct type *type, int space_flag)
606 int new_flags = ((TYPE_INSTANCE_FLAGS (type)
607 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
608 | TYPE_INSTANCE_FLAG_DATA_SPACE
609 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL))
612 return make_qualified_type (type, new_flags, NULL);
615 /* Make a "c-v" variant of a type -- a type that is identical to the
616 one supplied except that it may have const or volatile attributes
617 CNST is a flag for setting the const attribute
618 VOLTL is a flag for setting the volatile attribute
619 TYPE is the base type whose variant we are creating.
621 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
622 storage to hold the new qualified type; *TYPEPTR and TYPE must be
623 in the same objfile. Otherwise, allocate fresh memory for the new
624 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
625 new type we construct. */
627 make_cv_type (int cnst, int voltl,
629 struct type **typeptr)
631 struct type *ntype; /* New type */
633 int new_flags = (TYPE_INSTANCE_FLAGS (type)
634 & ~(TYPE_INSTANCE_FLAG_CONST
635 | TYPE_INSTANCE_FLAG_VOLATILE));
638 new_flags |= TYPE_INSTANCE_FLAG_CONST;
641 new_flags |= TYPE_INSTANCE_FLAG_VOLATILE;
643 if (typeptr && *typeptr != NULL)
645 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
646 a C-V variant chain that threads across objfiles: if one
647 objfile gets freed, then the other has a broken C-V chain.
649 This code used to try to copy over the main type from TYPE to
650 *TYPEPTR if they were in different objfiles, but that's
651 wrong, too: TYPE may have a field list or member function
652 lists, which refer to types of their own, etc. etc. The
653 whole shebang would need to be copied over recursively; you
654 can't have inter-objfile pointers. The only thing to do is
655 to leave stub types as stub types, and look them up afresh by
656 name each time you encounter them. */
657 gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type));
660 ntype = make_qualified_type (type, new_flags,
661 typeptr ? *typeptr : NULL);
669 /* Replace the contents of ntype with the type *type. This changes the
670 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
671 the changes are propogated to all types in the TYPE_CHAIN.
673 In order to build recursive types, it's inevitable that we'll need
674 to update types in place --- but this sort of indiscriminate
675 smashing is ugly, and needs to be replaced with something more
676 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
677 clear if more steps are needed. */
679 replace_type (struct type *ntype, struct type *type)
683 /* These two types had better be in the same objfile. Otherwise,
684 the assignment of one type's main type structure to the other
685 will produce a type with references to objects (names; field
686 lists; etc.) allocated on an objfile other than its own. */
687 gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (ntype));
689 *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
691 /* The type length is not a part of the main type. Update it for
692 each type on the variant chain. */
696 /* Assert that this element of the chain has no address-class bits
697 set in its flags. Such type variants might have type lengths
698 which are supposed to be different from the non-address-class
699 variants. This assertion shouldn't ever be triggered because
700 symbol readers which do construct address-class variants don't
701 call replace_type(). */
702 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0);
704 TYPE_LENGTH (chain) = TYPE_LENGTH (type);
705 chain = TYPE_CHAIN (chain);
707 while (ntype != chain);
709 /* Assert that the two types have equivalent instance qualifiers.
710 This should be true for at least all of our debug readers. */
711 gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type));
714 /* Implement direct support for MEMBER_TYPE in GNU C++.
715 May need to construct such a type if this is the first use.
716 The TYPE is the type of the member. The DOMAIN is the type
717 of the aggregate that the member belongs to. */
720 lookup_memberptr_type (struct type *type, struct type *domain)
724 mtype = alloc_type_copy (type);
725 smash_to_memberptr_type (mtype, domain, type);
729 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
732 lookup_methodptr_type (struct type *to_type)
736 mtype = alloc_type_copy (to_type);
737 smash_to_methodptr_type (mtype, to_type);
741 /* Allocate a stub method whose return type is TYPE. This apparently
742 happens for speed of symbol reading, since parsing out the
743 arguments to the method is cpu-intensive, the way we are doing it.
744 So, we will fill in arguments later. This always returns a fresh
748 allocate_stub_method (struct type *type)
752 mtype = alloc_type_copy (type);
753 TYPE_CODE (mtype) = TYPE_CODE_METHOD;
754 TYPE_LENGTH (mtype) = 1;
755 TYPE_STUB (mtype) = 1;
756 TYPE_TARGET_TYPE (mtype) = type;
757 /* _DOMAIN_TYPE (mtype) = unknown yet */
761 /* Create a range type using either a blank type supplied in
762 RESULT_TYPE, or creating a new type, inheriting the objfile from
765 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
766 to HIGH_BOUND, inclusive.
768 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
769 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
772 create_range_type (struct type *result_type, struct type *index_type,
773 LONGEST low_bound, LONGEST high_bound)
775 if (result_type == NULL)
776 result_type = alloc_type_copy (index_type);
777 TYPE_CODE (result_type) = TYPE_CODE_RANGE;
778 TYPE_TARGET_TYPE (result_type) = index_type;
779 if (TYPE_STUB (index_type))
780 TYPE_TARGET_STUB (result_type) = 1;
782 TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
783 TYPE_RANGE_DATA (result_type) = (struct range_bounds *)
784 TYPE_ZALLOC (result_type, sizeof (struct range_bounds));
785 TYPE_LOW_BOUND (result_type) = low_bound;
786 TYPE_HIGH_BOUND (result_type) = high_bound;
789 TYPE_UNSIGNED (result_type) = 1;
794 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
795 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
796 bounds will fit in LONGEST), or -1 otherwise. */
799 get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
801 CHECK_TYPEDEF (type);
802 switch (TYPE_CODE (type))
804 case TYPE_CODE_RANGE:
805 *lowp = TYPE_LOW_BOUND (type);
806 *highp = TYPE_HIGH_BOUND (type);
809 if (TYPE_NFIELDS (type) > 0)
811 /* The enums may not be sorted by value, so search all
815 *lowp = *highp = TYPE_FIELD_ENUMVAL (type, 0);
816 for (i = 0; i < TYPE_NFIELDS (type); i++)
818 if (TYPE_FIELD_ENUMVAL (type, i) < *lowp)
819 *lowp = TYPE_FIELD_ENUMVAL (type, i);
820 if (TYPE_FIELD_ENUMVAL (type, i) > *highp)
821 *highp = TYPE_FIELD_ENUMVAL (type, i);
824 /* Set unsigned indicator if warranted. */
827 TYPE_UNSIGNED (type) = 1;
841 if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */
843 if (!TYPE_UNSIGNED (type))
845 *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
849 /* ... fall through for unsigned ints ... */
852 /* This round-about calculation is to avoid shifting by
853 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
854 if TYPE_LENGTH (type) == sizeof (LONGEST). */
855 *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
856 *highp = (*highp - 1) | *highp;
863 /* Assuming TYPE is a simple, non-empty array type, compute its upper
864 and lower bound. Save the low bound into LOW_BOUND if not NULL.
865 Save the high bound into HIGH_BOUND if not NULL.
867 Return 1 if the operation was successful. Return zero otherwise,
868 in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
870 We now simply use get_discrete_bounds call to get the values
871 of the low and high bounds.
872 get_discrete_bounds can return three values:
873 1, meaning that index is a range,
874 0, meaning that index is a discrete type,
875 or -1 for failure. */
878 get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound)
880 struct type *index = TYPE_INDEX_TYPE (type);
888 res = get_discrete_bounds (index, &low, &high);
892 /* Check if the array bounds are undefined. */
894 && ((low_bound && TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type))
895 || (high_bound && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))))
907 /* Create an array type using either a blank type supplied in
908 RESULT_TYPE, or creating a new type, inheriting the objfile from
911 Elements will be of type ELEMENT_TYPE, the indices will be of type
914 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
915 sure it is TYPE_CODE_UNDEF before we bash it into an array
919 create_array_type (struct type *result_type,
920 struct type *element_type,
921 struct type *range_type)
923 LONGEST low_bound, high_bound;
925 if (result_type == NULL)
926 result_type = alloc_type_copy (range_type);
928 TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
929 TYPE_TARGET_TYPE (result_type) = element_type;
930 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
931 low_bound = high_bound = 0;
932 CHECK_TYPEDEF (element_type);
933 /* Be careful when setting the array length. Ada arrays can be
934 empty arrays with the high_bound being smaller than the low_bound.
935 In such cases, the array length should be zero. */
936 if (high_bound < low_bound)
937 TYPE_LENGTH (result_type) = 0;
939 TYPE_LENGTH (result_type) =
940 TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
941 TYPE_NFIELDS (result_type) = 1;
942 TYPE_FIELDS (result_type) =
943 (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
944 TYPE_INDEX_TYPE (result_type) = range_type;
945 TYPE_VPTR_FIELDNO (result_type) = -1;
947 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays. */
948 if (TYPE_LENGTH (result_type) == 0)
949 TYPE_TARGET_STUB (result_type) = 1;
955 lookup_array_range_type (struct type *element_type,
956 int low_bound, int high_bound)
958 struct gdbarch *gdbarch = get_type_arch (element_type);
959 struct type *index_type = builtin_type (gdbarch)->builtin_int;
960 struct type *range_type
961 = create_range_type (NULL, index_type, low_bound, high_bound);
963 return create_array_type (NULL, element_type, range_type);
966 /* Create a string type using either a blank type supplied in
967 RESULT_TYPE, or creating a new type. String types are similar
968 enough to array of char types that we can use create_array_type to
969 build the basic type and then bash it into a string type.
971 For fixed length strings, the range type contains 0 as the lower
972 bound and the length of the string minus one as the upper bound.
974 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
975 sure it is TYPE_CODE_UNDEF before we bash it into a string
979 create_string_type (struct type *result_type,
980 struct type *string_char_type,
981 struct type *range_type)
983 result_type = create_array_type (result_type,
986 TYPE_CODE (result_type) = TYPE_CODE_STRING;
991 lookup_string_range_type (struct type *string_char_type,
992 int low_bound, int high_bound)
994 struct type *result_type;
996 result_type = lookup_array_range_type (string_char_type,
997 low_bound, high_bound);
998 TYPE_CODE (result_type) = TYPE_CODE_STRING;
1003 create_set_type (struct type *result_type, struct type *domain_type)
1005 if (result_type == NULL)
1006 result_type = alloc_type_copy (domain_type);
1008 TYPE_CODE (result_type) = TYPE_CODE_SET;
1009 TYPE_NFIELDS (result_type) = 1;
1010 TYPE_FIELDS (result_type) = TYPE_ZALLOC (result_type, sizeof (struct field));
1012 if (!TYPE_STUB (domain_type))
1014 LONGEST low_bound, high_bound, bit_length;
1016 if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
1017 low_bound = high_bound = 0;
1018 bit_length = high_bound - low_bound + 1;
1019 TYPE_LENGTH (result_type)
1020 = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
1022 TYPE_UNSIGNED (result_type) = 1;
1024 TYPE_FIELD_TYPE (result_type, 0) = domain_type;
1029 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
1030 and any array types nested inside it. */
1033 make_vector_type (struct type *array_type)
1035 struct type *inner_array, *elt_type;
1038 /* Find the innermost array type, in case the array is
1039 multi-dimensional. */
1040 inner_array = array_type;
1041 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
1042 inner_array = TYPE_TARGET_TYPE (inner_array);
1044 elt_type = TYPE_TARGET_TYPE (inner_array);
1045 if (TYPE_CODE (elt_type) == TYPE_CODE_INT)
1047 flags = TYPE_INSTANCE_FLAGS (elt_type) | TYPE_INSTANCE_FLAG_NOTTEXT;
1048 elt_type = make_qualified_type (elt_type, flags, NULL);
1049 TYPE_TARGET_TYPE (inner_array) = elt_type;
1052 TYPE_VECTOR (array_type) = 1;
1056 init_vector_type (struct type *elt_type, int n)
1058 struct type *array_type;
1060 array_type = lookup_array_range_type (elt_type, 0, n - 1);
1061 make_vector_type (array_type);
1065 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
1066 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1067 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1068 TYPE doesn't include the offset (that's the value of the MEMBER
1069 itself), but does include the structure type into which it points
1072 When "smashing" the type, we preserve the objfile that the old type
1073 pointed to, since we aren't changing where the type is actually
1077 smash_to_memberptr_type (struct type *type, struct type *domain,
1078 struct type *to_type)
1081 TYPE_TARGET_TYPE (type) = to_type;
1082 TYPE_DOMAIN_TYPE (type) = domain;
1083 /* Assume that a data member pointer is the same size as a normal
1086 = gdbarch_ptr_bit (get_type_arch (to_type)) / TARGET_CHAR_BIT;
1087 TYPE_CODE (type) = TYPE_CODE_MEMBERPTR;
1090 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1092 When "smashing" the type, we preserve the objfile that the old type
1093 pointed to, since we aren't changing where the type is actually
1097 smash_to_methodptr_type (struct type *type, struct type *to_type)
1100 TYPE_TARGET_TYPE (type) = to_type;
1101 TYPE_DOMAIN_TYPE (type) = TYPE_DOMAIN_TYPE (to_type);
1102 TYPE_LENGTH (type) = cplus_method_ptr_size (to_type);
1103 TYPE_CODE (type) = TYPE_CODE_METHODPTR;
1106 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
1107 METHOD just means `function that gets an extra "this" argument'.
1109 When "smashing" the type, we preserve the objfile that the old type
1110 pointed to, since we aren't changing where the type is actually
1114 smash_to_method_type (struct type *type, struct type *domain,
1115 struct type *to_type, struct field *args,
1116 int nargs, int varargs)
1119 TYPE_TARGET_TYPE (type) = to_type;
1120 TYPE_DOMAIN_TYPE (type) = domain;
1121 TYPE_FIELDS (type) = args;
1122 TYPE_NFIELDS (type) = nargs;
1124 TYPE_VARARGS (type) = 1;
1125 TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
1126 TYPE_CODE (type) = TYPE_CODE_METHOD;
1129 /* Return a typename for a struct/union/enum type without "struct ",
1130 "union ", or "enum ". If the type has a NULL name, return NULL. */
1133 type_name_no_tag (const struct type *type)
1135 if (TYPE_TAG_NAME (type) != NULL)
1136 return TYPE_TAG_NAME (type);
1138 /* Is there code which expects this to return the name if there is
1139 no tag name? My guess is that this is mainly used for C++ in
1140 cases where the two will always be the same. */
1141 return TYPE_NAME (type);
1144 /* A wrapper of type_name_no_tag which calls error if the type is anonymous.
1145 Since GCC PR debug/47510 DWARF provides associated information to detect the
1146 anonymous class linkage name from its typedef.
1148 Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
1152 type_name_no_tag_or_error (struct type *type)
1154 struct type *saved_type = type;
1156 struct objfile *objfile;
1158 CHECK_TYPEDEF (type);
1160 name = type_name_no_tag (type);
1164 name = type_name_no_tag (saved_type);
1165 objfile = TYPE_OBJFILE (saved_type);
1166 error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
1167 name ? name : "<anonymous>", objfile ? objfile->name : "<arch>");
1170 /* Lookup a typedef or primitive type named NAME, visible in lexical
1171 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1172 suitably defined. */
1175 lookup_typename (const struct language_defn *language,
1176 struct gdbarch *gdbarch, const char *name,
1177 const struct block *block, int noerr)
1182 sym = lookup_symbol (name, block, VAR_DOMAIN, 0);
1183 if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1184 return SYMBOL_TYPE (sym);
1186 type = language_lookup_primitive_type_by_name (language, gdbarch, name);
1192 error (_("No type named %s."), name);
1196 lookup_unsigned_typename (const struct language_defn *language,
1197 struct gdbarch *gdbarch, const char *name)
1199 char *uns = alloca (strlen (name) + 10);
1201 strcpy (uns, "unsigned ");
1202 strcpy (uns + 9, name);
1203 return lookup_typename (language, gdbarch, uns, (struct block *) NULL, 0);
1207 lookup_signed_typename (const struct language_defn *language,
1208 struct gdbarch *gdbarch, const char *name)
1211 char *uns = alloca (strlen (name) + 8);
1213 strcpy (uns, "signed ");
1214 strcpy (uns + 7, name);
1215 t = lookup_typename (language, gdbarch, uns, (struct block *) NULL, 1);
1216 /* If we don't find "signed FOO" just try again with plain "FOO". */
1219 return lookup_typename (language, gdbarch, name, (struct block *) NULL, 0);
1222 /* Lookup a structure type named "struct NAME",
1223 visible in lexical block BLOCK. */
1226 lookup_struct (const char *name, struct block *block)
1230 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1234 error (_("No struct type named %s."), name);
1236 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1238 error (_("This context has class, union or enum %s, not a struct."),
1241 return (SYMBOL_TYPE (sym));
1244 /* Lookup a union type named "union NAME",
1245 visible in lexical block BLOCK. */
1248 lookup_union (const char *name, struct block *block)
1253 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1256 error (_("No union type named %s."), name);
1258 t = SYMBOL_TYPE (sym);
1260 if (TYPE_CODE (t) == TYPE_CODE_UNION)
1263 /* If we get here, it's not a union. */
1264 error (_("This context has class, struct or enum %s, not a union."),
1269 /* Lookup an enum type named "enum NAME",
1270 visible in lexical block BLOCK. */
1273 lookup_enum (const char *name, struct block *block)
1277 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1280 error (_("No enum type named %s."), name);
1282 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
1284 error (_("This context has class, struct or union %s, not an enum."),
1287 return (SYMBOL_TYPE (sym));
1290 /* Lookup a template type named "template NAME<TYPE>",
1291 visible in lexical block BLOCK. */
1294 lookup_template_type (char *name, struct type *type,
1295 struct block *block)
1298 char *nam = (char *)
1299 alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4);
1303 strcat (nam, TYPE_NAME (type));
1304 strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
1306 sym = lookup_symbol (nam, block, VAR_DOMAIN, 0);
1310 error (_("No template type named %s."), name);
1312 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1314 error (_("This context has class, union or enum %s, not a struct."),
1317 return (SYMBOL_TYPE (sym));
1320 /* Given a type TYPE, lookup the type of the component of type named
1323 TYPE can be either a struct or union, or a pointer or reference to
1324 a struct or union. If it is a pointer or reference, its target
1325 type is automatically used. Thus '.' and '->' are interchangable,
1326 as specified for the definitions of the expression element types
1327 STRUCTOP_STRUCT and STRUCTOP_PTR.
1329 If NOERR is nonzero, return zero if NAME is not suitably defined.
1330 If NAME is the name of a baseclass type, return that type. */
1333 lookup_struct_elt_type (struct type *type, char *name, int noerr)
1340 CHECK_TYPEDEF (type);
1341 if (TYPE_CODE (type) != TYPE_CODE_PTR
1342 && TYPE_CODE (type) != TYPE_CODE_REF)
1344 type = TYPE_TARGET_TYPE (type);
1347 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1348 && TYPE_CODE (type) != TYPE_CODE_UNION)
1350 typename = type_to_string (type);
1351 make_cleanup (xfree, typename);
1352 error (_("Type %s is not a structure or union type."), typename);
1356 /* FIXME: This change put in by Michael seems incorrect for the case
1357 where the structure tag name is the same as the member name.
1358 I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
1359 foo; } bell;" Disabled by fnf. */
1363 typename = type_name_no_tag (type);
1364 if (typename != NULL && strcmp (typename, name) == 0)
1369 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1371 const char *t_field_name = TYPE_FIELD_NAME (type, i);
1373 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1375 return TYPE_FIELD_TYPE (type, i);
1377 else if (!t_field_name || *t_field_name == '\0')
1379 struct type *subtype
1380 = lookup_struct_elt_type (TYPE_FIELD_TYPE (type, i), name, 1);
1382 if (subtype != NULL)
1387 /* OK, it's not in this class. Recursively check the baseclasses. */
1388 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1392 t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 1);
1404 typename = type_to_string (type);
1405 make_cleanup (xfree, typename);
1406 error (_("Type %s has no component named %s."), typename, name);
1409 /* Lookup the vptr basetype/fieldno values for TYPE.
1410 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1411 vptr_fieldno. Also, if found and basetype is from the same objfile,
1413 If not found, return -1 and ignore BASETYPEP.
1414 Callers should be aware that in some cases (for example,
1415 the type or one of its baseclasses is a stub type and we are
1416 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1417 this function will not be able to find the
1418 virtual function table pointer, and vptr_fieldno will remain -1 and
1419 vptr_basetype will remain NULL or incomplete. */
1422 get_vptr_fieldno (struct type *type, struct type **basetypep)
1424 CHECK_TYPEDEF (type);
1426 if (TYPE_VPTR_FIELDNO (type) < 0)
1430 /* We must start at zero in case the first (and only) baseclass
1431 is virtual (and hence we cannot share the table pointer). */
1432 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1434 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
1436 struct type *basetype;
1438 fieldno = get_vptr_fieldno (baseclass, &basetype);
1441 /* If the type comes from a different objfile we can't cache
1442 it, it may have a different lifetime. PR 2384 */
1443 if (TYPE_OBJFILE (type) == TYPE_OBJFILE (basetype))
1445 TYPE_VPTR_FIELDNO (type) = fieldno;
1446 TYPE_VPTR_BASETYPE (type) = basetype;
1449 *basetypep = basetype;
1460 *basetypep = TYPE_VPTR_BASETYPE (type);
1461 return TYPE_VPTR_FIELDNO (type);
1466 stub_noname_complaint (void)
1468 complaint (&symfile_complaints, _("stub type has NULL name"));
1471 /* Find the real type of TYPE. This function returns the real type,
1472 after removing all layers of typedefs, and completing opaque or stub
1473 types. Completion changes the TYPE argument, but stripping of
1476 Instance flags (e.g. const/volatile) are preserved as typedefs are
1477 stripped. If necessary a new qualified form of the underlying type
1480 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
1481 not been computed and we're either in the middle of reading symbols, or
1482 there was no name for the typedef in the debug info.
1484 NOTE: Lookup of opaque types can throw errors for invalid symbol files.
1485 QUITs in the symbol reading code can also throw.
1486 Thus this function can throw an exception.
1488 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
1491 If this is a stubbed struct (i.e. declared as struct foo *), see if
1492 we can find a full definition in some other file. If so, copy this
1493 definition, so we can use it in future. There used to be a comment
1494 (but not any code) that if we don't find a full definition, we'd
1495 set a flag so we don't spend time in the future checking the same
1496 type. That would be a mistake, though--we might load in more
1497 symbols which contain a full definition for the type. */
1500 check_typedef (struct type *type)
1502 struct type *orig_type = type;
1503 /* While we're removing typedefs, we don't want to lose qualifiers.
1504 E.g., const/volatile. */
1505 int instance_flags = TYPE_INSTANCE_FLAGS (type);
1509 while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1511 if (!TYPE_TARGET_TYPE (type))
1516 /* It is dangerous to call lookup_symbol if we are currently
1517 reading a symtab. Infinite recursion is one danger. */
1518 if (currently_reading_symtab)
1519 return make_qualified_type (type, instance_flags, NULL);
1521 name = type_name_no_tag (type);
1522 /* FIXME: shouldn't we separately check the TYPE_NAME and
1523 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1524 VAR_DOMAIN as appropriate? (this code was written before
1525 TYPE_NAME and TYPE_TAG_NAME were separate). */
1528 stub_noname_complaint ();
1529 return make_qualified_type (type, instance_flags, NULL);
1531 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
1533 TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
1534 else /* TYPE_CODE_UNDEF */
1535 TYPE_TARGET_TYPE (type) = alloc_type_arch (get_type_arch (type));
1537 type = TYPE_TARGET_TYPE (type);
1539 /* Preserve the instance flags as we traverse down the typedef chain.
1541 Handling address spaces/classes is nasty, what do we do if there's a
1543 E.g., what if an outer typedef marks the type as class_1 and an inner
1544 typedef marks the type as class_2?
1545 This is the wrong place to do such error checking. We leave it to
1546 the code that created the typedef in the first place to flag the
1547 error. We just pick the outer address space (akin to letting the
1548 outer cast in a chain of casting win), instead of assuming
1549 "it can't happen". */
1551 const int ALL_SPACES = (TYPE_INSTANCE_FLAG_CODE_SPACE
1552 | TYPE_INSTANCE_FLAG_DATA_SPACE);
1553 const int ALL_CLASSES = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL;
1554 int new_instance_flags = TYPE_INSTANCE_FLAGS (type);
1556 /* Treat code vs data spaces and address classes separately. */
1557 if ((instance_flags & ALL_SPACES) != 0)
1558 new_instance_flags &= ~ALL_SPACES;
1559 if ((instance_flags & ALL_CLASSES) != 0)
1560 new_instance_flags &= ~ALL_CLASSES;
1562 instance_flags |= new_instance_flags;
1566 /* If this is a struct/class/union with no fields, then check
1567 whether a full definition exists somewhere else. This is for
1568 systems where a type definition with no fields is issued for such
1569 types, instead of identifying them as stub types in the first
1572 if (TYPE_IS_OPAQUE (type)
1573 && opaque_type_resolution
1574 && !currently_reading_symtab)
1576 const char *name = type_name_no_tag (type);
1577 struct type *newtype;
1581 stub_noname_complaint ();
1582 return make_qualified_type (type, instance_flags, NULL);
1584 newtype = lookup_transparent_type (name);
1588 /* If the resolved type and the stub are in the same
1589 objfile, then replace the stub type with the real deal.
1590 But if they're in separate objfiles, leave the stub
1591 alone; we'll just look up the transparent type every time
1592 we call check_typedef. We can't create pointers between
1593 types allocated to different objfiles, since they may
1594 have different lifetimes. Trying to copy NEWTYPE over to
1595 TYPE's objfile is pointless, too, since you'll have to
1596 move over any other types NEWTYPE refers to, which could
1597 be an unbounded amount of stuff. */
1598 if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type))
1599 type = make_qualified_type (newtype,
1600 TYPE_INSTANCE_FLAGS (type),
1606 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1608 else if (TYPE_STUB (type) && !currently_reading_symtab)
1610 const char *name = type_name_no_tag (type);
1611 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1612 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1613 as appropriate? (this code was written before TYPE_NAME and
1614 TYPE_TAG_NAME were separate). */
1619 stub_noname_complaint ();
1620 return make_qualified_type (type, instance_flags, NULL);
1622 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
1625 /* Same as above for opaque types, we can replace the stub
1626 with the complete type only if they are in the same
1628 if (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type))
1629 type = make_qualified_type (SYMBOL_TYPE (sym),
1630 TYPE_INSTANCE_FLAGS (type),
1633 type = SYMBOL_TYPE (sym);
1637 if (TYPE_TARGET_STUB (type))
1639 struct type *range_type;
1640 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1642 if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type))
1644 /* Nothing we can do. */
1646 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
1647 && TYPE_NFIELDS (type) == 1
1648 && (TYPE_CODE (range_type = TYPE_INDEX_TYPE (type))
1649 == TYPE_CODE_RANGE))
1651 /* Now recompute the length of the array type, based on its
1652 number of elements and the target type's length.
1653 Watch out for Ada null Ada arrays where the high bound
1654 is smaller than the low bound. */
1655 const LONGEST low_bound = TYPE_LOW_BOUND (range_type);
1656 const LONGEST high_bound = TYPE_HIGH_BOUND (range_type);
1659 if (high_bound < low_bound)
1663 /* For now, we conservatively take the array length to be 0
1664 if its length exceeds UINT_MAX. The code below assumes
1665 that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
1666 which is technically not guaranteed by C, but is usually true
1667 (because it would be true if x were unsigned with its
1668 high-order bit on). It uses the fact that
1669 high_bound-low_bound is always representable in
1670 ULONGEST and that if high_bound-low_bound+1 overflows,
1671 it overflows to 0. We must change these tests if we
1672 decide to increase the representation of TYPE_LENGTH
1673 from unsigned int to ULONGEST. */
1674 ULONGEST ulow = low_bound, uhigh = high_bound;
1675 ULONGEST tlen = TYPE_LENGTH (target_type);
1677 len = tlen * (uhigh - ulow + 1);
1678 if (tlen == 0 || (len / tlen - 1 + ulow) != uhigh
1682 TYPE_LENGTH (type) = len;
1683 TYPE_TARGET_STUB (type) = 0;
1685 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
1687 TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
1688 TYPE_TARGET_STUB (type) = 0;
1692 type = make_qualified_type (type, instance_flags, NULL);
1694 /* Cache TYPE_LENGTH for future use. */
1695 TYPE_LENGTH (orig_type) = TYPE_LENGTH (type);
1700 /* Parse a type expression in the string [P..P+LENGTH). If an error
1701 occurs, silently return a void type. */
1703 static struct type *
1704 safe_parse_type (struct gdbarch *gdbarch, char *p, int length)
1706 struct ui_file *saved_gdb_stderr;
1707 struct type *type = NULL; /* Initialize to keep gcc happy. */
1708 volatile struct gdb_exception except;
1710 /* Suppress error messages. */
1711 saved_gdb_stderr = gdb_stderr;
1712 gdb_stderr = ui_file_new ();
1714 /* Call parse_and_eval_type() without fear of longjmp()s. */
1715 TRY_CATCH (except, RETURN_MASK_ERROR)
1717 type = parse_and_eval_type (p, length);
1720 if (except.reason < 0)
1721 type = builtin_type (gdbarch)->builtin_void;
1723 /* Stop suppressing error messages. */
1724 ui_file_delete (gdb_stderr);
1725 gdb_stderr = saved_gdb_stderr;
1730 /* Ugly hack to convert method stubs into method types.
1732 He ain't kiddin'. This demangles the name of the method into a
1733 string including argument types, parses out each argument type,
1734 generates a string casting a zero to that type, evaluates the
1735 string, and stuffs the resulting type into an argtype vector!!!
1736 Then it knows the type of the whole function (including argument
1737 types for overloading), which info used to be in the stab's but was
1738 removed to hack back the space required for them. */
1741 check_stub_method (struct type *type, int method_id, int signature_id)
1743 struct gdbarch *gdbarch = get_type_arch (type);
1745 char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
1746 char *demangled_name = cplus_demangle (mangled_name,
1747 DMGL_PARAMS | DMGL_ANSI);
1748 char *argtypetext, *p;
1749 int depth = 0, argcount = 1;
1750 struct field *argtypes;
1753 /* Make sure we got back a function string that we can use. */
1755 p = strchr (demangled_name, '(');
1759 if (demangled_name == NULL || p == NULL)
1760 error (_("Internal: Cannot demangle mangled name `%s'."),
1763 /* Now, read in the parameters that define this type. */
1768 if (*p == '(' || *p == '<')
1772 else if (*p == ')' || *p == '>')
1776 else if (*p == ',' && depth == 0)
1784 /* If we read one argument and it was ``void'', don't count it. */
1785 if (strncmp (argtypetext, "(void)", 6) == 0)
1788 /* We need one extra slot, for the THIS pointer. */
1790 argtypes = (struct field *)
1791 TYPE_ALLOC (type, (argcount + 1) * sizeof (struct field));
1794 /* Add THIS pointer for non-static methods. */
1795 f = TYPE_FN_FIELDLIST1 (type, method_id);
1796 if (TYPE_FN_FIELD_STATIC_P (f, signature_id))
1800 argtypes[0].type = lookup_pointer_type (type);
1804 if (*p != ')') /* () means no args, skip while. */
1809 if (depth <= 0 && (*p == ',' || *p == ')'))
1811 /* Avoid parsing of ellipsis, they will be handled below.
1812 Also avoid ``void'' as above. */
1813 if (strncmp (argtypetext, "...", p - argtypetext) != 0
1814 && strncmp (argtypetext, "void", p - argtypetext) != 0)
1816 argtypes[argcount].type =
1817 safe_parse_type (gdbarch, argtypetext, p - argtypetext);
1820 argtypetext = p + 1;
1823 if (*p == '(' || *p == '<')
1827 else if (*p == ')' || *p == '>')
1836 TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name;
1838 /* Now update the old "stub" type into a real type. */
1839 mtype = TYPE_FN_FIELD_TYPE (f, signature_id);
1840 TYPE_DOMAIN_TYPE (mtype) = type;
1841 TYPE_FIELDS (mtype) = argtypes;
1842 TYPE_NFIELDS (mtype) = argcount;
1843 TYPE_STUB (mtype) = 0;
1844 TYPE_FN_FIELD_STUB (f, signature_id) = 0;
1846 TYPE_VARARGS (mtype) = 1;
1848 xfree (demangled_name);
1851 /* This is the external interface to check_stub_method, above. This
1852 function unstubs all of the signatures for TYPE's METHOD_ID method
1853 name. After calling this function TYPE_FN_FIELD_STUB will be
1854 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1857 This function unfortunately can not die until stabs do. */
1860 check_stub_method_group (struct type *type, int method_id)
1862 int len = TYPE_FN_FIELDLIST_LENGTH (type, method_id);
1863 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
1864 int j, found_stub = 0;
1866 for (j = 0; j < len; j++)
1867 if (TYPE_FN_FIELD_STUB (f, j))
1870 check_stub_method (type, method_id, j);
1873 /* GNU v3 methods with incorrect names were corrected when we read
1874 in type information, because it was cheaper to do it then. The
1875 only GNU v2 methods with incorrect method names are operators and
1876 destructors; destructors were also corrected when we read in type
1879 Therefore the only thing we need to handle here are v2 operator
1881 if (found_stub && strncmp (TYPE_FN_FIELD_PHYSNAME (f, 0), "_Z", 2) != 0)
1884 char dem_opname[256];
1886 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
1888 dem_opname, DMGL_ANSI);
1890 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
1894 TYPE_FN_FIELDLIST_NAME (type, method_id) = xstrdup (dem_opname);
1898 /* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */
1899 const struct cplus_struct_type cplus_struct_default = { };
1902 allocate_cplus_struct_type (struct type *type)
1904 if (HAVE_CPLUS_STRUCT (type))
1905 /* Structure was already allocated. Nothing more to do. */
1908 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CPLUS_STUFF;
1909 TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
1910 TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
1911 *(TYPE_RAW_CPLUS_SPECIFIC (type)) = cplus_struct_default;
1914 const struct gnat_aux_type gnat_aux_default =
1917 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
1918 and allocate the associated gnat-specific data. The gnat-specific
1919 data is also initialized to gnat_aux_default. */
1921 allocate_gnat_aux_type (struct type *type)
1923 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_GNAT_STUFF;
1924 TYPE_GNAT_SPECIFIC (type) = (struct gnat_aux_type *)
1925 TYPE_ALLOC (type, sizeof (struct gnat_aux_type));
1926 *(TYPE_GNAT_SPECIFIC (type)) = gnat_aux_default;
1930 /* Helper function to initialize the standard scalar types.
1932 If NAME is non-NULL, then we make a copy of the string pointed
1933 to by name in the objfile_obstack for that objfile, and initialize
1934 the type name to that copy. There are places (mipsread.c in particular),
1935 where init_type is called with a NULL value for NAME). */
1938 init_type (enum type_code code, int length, int flags,
1939 char *name, struct objfile *objfile)
1943 type = alloc_type (objfile);
1944 TYPE_CODE (type) = code;
1945 TYPE_LENGTH (type) = length;
1947 gdb_assert (!(flags & (TYPE_FLAG_MIN - 1)));
1948 if (flags & TYPE_FLAG_UNSIGNED)
1949 TYPE_UNSIGNED (type) = 1;
1950 if (flags & TYPE_FLAG_NOSIGN)
1951 TYPE_NOSIGN (type) = 1;
1952 if (flags & TYPE_FLAG_STUB)
1953 TYPE_STUB (type) = 1;
1954 if (flags & TYPE_FLAG_TARGET_STUB)
1955 TYPE_TARGET_STUB (type) = 1;
1956 if (flags & TYPE_FLAG_STATIC)
1957 TYPE_STATIC (type) = 1;
1958 if (flags & TYPE_FLAG_PROTOTYPED)
1959 TYPE_PROTOTYPED (type) = 1;
1960 if (flags & TYPE_FLAG_INCOMPLETE)
1961 TYPE_INCOMPLETE (type) = 1;
1962 if (flags & TYPE_FLAG_VARARGS)
1963 TYPE_VARARGS (type) = 1;
1964 if (flags & TYPE_FLAG_VECTOR)
1965 TYPE_VECTOR (type) = 1;
1966 if (flags & TYPE_FLAG_STUB_SUPPORTED)
1967 TYPE_STUB_SUPPORTED (type) = 1;
1968 if (flags & TYPE_FLAG_FIXED_INSTANCE)
1969 TYPE_FIXED_INSTANCE (type) = 1;
1970 if (flags & TYPE_FLAG_GNU_IFUNC)
1971 TYPE_GNU_IFUNC (type) = 1;
1974 TYPE_NAME (type) = obsavestring (name, strlen (name),
1975 &objfile->objfile_obstack);
1979 if (name && strcmp (name, "char") == 0)
1980 TYPE_NOSIGN (type) = 1;
1984 case TYPE_CODE_STRUCT:
1985 case TYPE_CODE_UNION:
1986 case TYPE_CODE_NAMESPACE:
1987 INIT_CPLUS_SPECIFIC (type);
1990 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FLOATFORMAT;
1992 case TYPE_CODE_FUNC:
1993 INIT_FUNC_SPECIFIC (type);
2000 can_dereference (struct type *t)
2002 /* FIXME: Should we return true for references as well as
2007 && TYPE_CODE (t) == TYPE_CODE_PTR
2008 && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
2012 is_integral_type (struct type *t)
2017 && ((TYPE_CODE (t) == TYPE_CODE_INT)
2018 || (TYPE_CODE (t) == TYPE_CODE_ENUM)
2019 || (TYPE_CODE (t) == TYPE_CODE_FLAGS)
2020 || (TYPE_CODE (t) == TYPE_CODE_CHAR)
2021 || (TYPE_CODE (t) == TYPE_CODE_RANGE)
2022 || (TYPE_CODE (t) == TYPE_CODE_BOOL)));
2025 /* Return true if TYPE is scalar. */
2028 is_scalar_type (struct type *type)
2030 CHECK_TYPEDEF (type);
2032 switch (TYPE_CODE (type))
2034 case TYPE_CODE_ARRAY:
2035 case TYPE_CODE_STRUCT:
2036 case TYPE_CODE_UNION:
2038 case TYPE_CODE_STRING:
2039 case TYPE_CODE_BITSTRING:
2046 /* Return true if T is scalar, or a composite type which in practice has
2047 the memory layout of a scalar type. E.g., an array or struct with only
2048 one scalar element inside it, or a union with only scalar elements. */
2051 is_scalar_type_recursive (struct type *t)
2055 if (is_scalar_type (t))
2057 /* Are we dealing with an array or string of known dimensions? */
2058 else if ((TYPE_CODE (t) == TYPE_CODE_ARRAY
2059 || TYPE_CODE (t) == TYPE_CODE_STRING) && TYPE_NFIELDS (t) == 1
2060 && TYPE_CODE (TYPE_INDEX_TYPE (t)) == TYPE_CODE_RANGE)
2062 LONGEST low_bound, high_bound;
2063 struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t));
2065 get_discrete_bounds (TYPE_INDEX_TYPE (t), &low_bound, &high_bound);
2067 return high_bound == low_bound && is_scalar_type_recursive (elt_type);
2069 /* Are we dealing with a struct with one element? */
2070 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT && TYPE_NFIELDS (t) == 1)
2071 return is_scalar_type_recursive (TYPE_FIELD_TYPE (t, 0));
2072 else if (TYPE_CODE (t) == TYPE_CODE_UNION)
2074 int i, n = TYPE_NFIELDS (t);
2076 /* If all elements of the union are scalar, then the union is scalar. */
2077 for (i = 0; i < n; i++)
2078 if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t, i)))
2087 /* A helper function which returns true if types A and B represent the
2088 "same" class type. This is true if the types have the same main
2089 type, or the same name. */
2092 class_types_same_p (const struct type *a, const struct type *b)
2094 return (TYPE_MAIN_TYPE (a) == TYPE_MAIN_TYPE (b)
2095 || (TYPE_NAME (a) && TYPE_NAME (b)
2096 && !strcmp (TYPE_NAME (a), TYPE_NAME (b))));
2099 /* If BASE is an ancestor of DCLASS return the distance between them.
2100 otherwise return -1;
2104 class B: public A {};
2105 class C: public B {};
2108 distance_to_ancestor (A, A, 0) = 0
2109 distance_to_ancestor (A, B, 0) = 1
2110 distance_to_ancestor (A, C, 0) = 2
2111 distance_to_ancestor (A, D, 0) = 3
2113 If PUBLIC is 1 then only public ancestors are considered,
2114 and the function returns the distance only if BASE is a public ancestor
2118 distance_to_ancestor (A, D, 1) = -1. */
2121 distance_to_ancestor (struct type *base, struct type *dclass, int public)
2126 CHECK_TYPEDEF (base);
2127 CHECK_TYPEDEF (dclass);
2129 if (class_types_same_p (base, dclass))
2132 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
2134 if (public && ! BASETYPE_VIA_PUBLIC (dclass, i))
2137 d = distance_to_ancestor (base, TYPE_BASECLASS (dclass, i), public);
2145 /* Check whether BASE is an ancestor or base class or DCLASS
2146 Return 1 if so, and 0 if not.
2147 Note: If BASE and DCLASS are of the same type, this function
2148 will return 1. So for some class A, is_ancestor (A, A) will
2152 is_ancestor (struct type *base, struct type *dclass)
2154 return distance_to_ancestor (base, dclass, 0) >= 0;
2157 /* Like is_ancestor, but only returns true when BASE is a public
2158 ancestor of DCLASS. */
2161 is_public_ancestor (struct type *base, struct type *dclass)
2163 return distance_to_ancestor (base, dclass, 1) >= 0;
2166 /* A helper function for is_unique_ancestor. */
2169 is_unique_ancestor_worker (struct type *base, struct type *dclass,
2171 const gdb_byte *valaddr, int embedded_offset,
2172 CORE_ADDR address, struct value *val)
2176 CHECK_TYPEDEF (base);
2177 CHECK_TYPEDEF (dclass);
2179 for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i)
2184 iter = check_typedef (TYPE_BASECLASS (dclass, i));
2186 this_offset = baseclass_offset (dclass, i, valaddr, embedded_offset,
2189 if (class_types_same_p (base, iter))
2191 /* If this is the first subclass, set *OFFSET and set count
2192 to 1. Otherwise, if this is at the same offset as
2193 previous instances, do nothing. Otherwise, increment
2197 *offset = this_offset;
2200 else if (this_offset == *offset)
2208 count += is_unique_ancestor_worker (base, iter, offset,
2210 embedded_offset + this_offset,
2217 /* Like is_ancestor, but only returns true if BASE is a unique base
2218 class of the type of VAL. */
2221 is_unique_ancestor (struct type *base, struct value *val)
2225 return is_unique_ancestor_worker (base, value_type (val), &offset,
2226 value_contents_for_printing (val),
2227 value_embedded_offset (val),
2228 value_address (val), val) == 1;
2233 /* Return the sum of the rank of A with the rank of B. */
2236 sum_ranks (struct rank a, struct rank b)
2239 c.rank = a.rank + b.rank;
2240 c.subrank = a.subrank + b.subrank;
2244 /* Compare rank A and B and return:
2246 1 if a is better than b
2247 -1 if b is better than a. */
2250 compare_ranks (struct rank a, struct rank b)
2252 if (a.rank == b.rank)
2254 if (a.subrank == b.subrank)
2256 if (a.subrank < b.subrank)
2258 if (a.subrank > b.subrank)
2262 if (a.rank < b.rank)
2265 /* a.rank > b.rank */
2269 /* Functions for overload resolution begin here. */
2271 /* Compare two badness vectors A and B and return the result.
2272 0 => A and B are identical
2273 1 => A and B are incomparable
2274 2 => A is better than B
2275 3 => A is worse than B */
2278 compare_badness (struct badness_vector *a, struct badness_vector *b)
2282 short found_pos = 0; /* any positives in c? */
2283 short found_neg = 0; /* any negatives in c? */
2285 /* differing lengths => incomparable */
2286 if (a->length != b->length)
2289 /* Subtract b from a */
2290 for (i = 0; i < a->length; i++)
2292 tmp = compare_ranks (b->rank[i], a->rank[i]);
2302 return 1; /* incomparable */
2304 return 3; /* A > B */
2310 return 2; /* A < B */
2312 return 0; /* A == B */
2316 /* Rank a function by comparing its parameter types (PARMS, length
2317 NPARMS), to the types of an argument list (ARGS, length NARGS).
2318 Return a pointer to a badness vector. This has NARGS + 1
2321 struct badness_vector *
2322 rank_function (struct type **parms, int nparms,
2323 struct value **args, int nargs)
2326 struct badness_vector *bv;
2327 int min_len = nparms < nargs ? nparms : nargs;
2329 bv = xmalloc (sizeof (struct badness_vector));
2330 bv->length = nargs + 1; /* add 1 for the length-match rank. */
2331 bv->rank = xmalloc ((nargs + 1) * sizeof (int));
2333 /* First compare the lengths of the supplied lists.
2334 If there is a mismatch, set it to a high value. */
2336 /* pai/1997-06-03 FIXME: when we have debug info about default
2337 arguments and ellipsis parameter lists, we should consider those
2338 and rank the length-match more finely. */
2340 LENGTH_MATCH (bv) = (nargs != nparms)
2341 ? LENGTH_MISMATCH_BADNESS
2342 : EXACT_MATCH_BADNESS;
2344 /* Now rank all the parameters of the candidate function. */
2345 for (i = 1; i <= min_len; i++)
2346 bv->rank[i] = rank_one_type (parms[i - 1], value_type (args[i - 1]),
2349 /* If more arguments than parameters, add dummy entries. */
2350 for (i = min_len + 1; i <= nargs; i++)
2351 bv->rank[i] = TOO_FEW_PARAMS_BADNESS;
2356 /* Compare the names of two integer types, assuming that any sign
2357 qualifiers have been checked already. We do it this way because
2358 there may be an "int" in the name of one of the types. */
2361 integer_types_same_name_p (const char *first, const char *second)
2363 int first_p, second_p;
2365 /* If both are shorts, return 1; if neither is a short, keep
2367 first_p = (strstr (first, "short") != NULL);
2368 second_p = (strstr (second, "short") != NULL);
2369 if (first_p && second_p)
2371 if (first_p || second_p)
2374 /* Likewise for long. */
2375 first_p = (strstr (first, "long") != NULL);
2376 second_p = (strstr (second, "long") != NULL);
2377 if (first_p && second_p)
2379 if (first_p || second_p)
2382 /* Likewise for char. */
2383 first_p = (strstr (first, "char") != NULL);
2384 second_p = (strstr (second, "char") != NULL);
2385 if (first_p && second_p)
2387 if (first_p || second_p)
2390 /* They must both be ints. */
2394 /* Compares type A to type B returns 1 if the represent the same type
2398 types_equal (struct type *a, struct type *b)
2400 /* Identical type pointers. */
2401 /* However, this still doesn't catch all cases of same type for b
2402 and a. The reason is that builtin types are different from
2403 the same ones constructed from the object. */
2407 /* Resolve typedefs */
2408 if (TYPE_CODE (a) == TYPE_CODE_TYPEDEF)
2409 a = check_typedef (a);
2410 if (TYPE_CODE (b) == TYPE_CODE_TYPEDEF)
2411 b = check_typedef (b);
2413 /* If after resolving typedefs a and b are not of the same type
2414 code then they are not equal. */
2415 if (TYPE_CODE (a) != TYPE_CODE (b))
2418 /* If a and b are both pointers types or both reference types then
2419 they are equal of the same type iff the objects they refer to are
2420 of the same type. */
2421 if (TYPE_CODE (a) == TYPE_CODE_PTR
2422 || TYPE_CODE (a) == TYPE_CODE_REF)
2423 return types_equal (TYPE_TARGET_TYPE (a),
2424 TYPE_TARGET_TYPE (b));
2426 /* Well, damnit, if the names are exactly the same, I'll say they
2427 are exactly the same. This happens when we generate method
2428 stubs. The types won't point to the same address, but they
2429 really are the same. */
2431 if (TYPE_NAME (a) && TYPE_NAME (b)
2432 && strcmp (TYPE_NAME (a), TYPE_NAME (b)) == 0)
2435 /* Check if identical after resolving typedefs. */
2442 /* Compare one type (PARM) for compatibility with another (ARG).
2443 * PARM is intended to be the parameter type of a function; and
2444 * ARG is the supplied argument's type. This function tests if
2445 * the latter can be converted to the former.
2446 * VALUE is the argument's value or NULL if none (or called recursively)
2448 * Return 0 if they are identical types;
2449 * Otherwise, return an integer which corresponds to how compatible
2450 * PARM is to ARG. The higher the return value, the worse the match.
2451 * Generally the "bad" conversions are all uniformly assigned a 100. */
2454 rank_one_type (struct type *parm, struct type *arg, struct value *value)
2456 struct rank rank = {0,0};
2458 if (types_equal (parm, arg))
2459 return EXACT_MATCH_BADNESS;
2461 /* Resolve typedefs */
2462 if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF)
2463 parm = check_typedef (parm);
2464 if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
2465 arg = check_typedef (arg);
2467 /* See through references, since we can almost make non-references
2469 if (TYPE_CODE (arg) == TYPE_CODE_REF)
2470 return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL),
2471 REFERENCE_CONVERSION_BADNESS));
2472 if (TYPE_CODE (parm) == TYPE_CODE_REF)
2473 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL),
2474 REFERENCE_CONVERSION_BADNESS));
2476 /* Debugging only. */
2477 fprintf_filtered (gdb_stderr,
2478 "------ Arg is %s [%d], parm is %s [%d]\n",
2479 TYPE_NAME (arg), TYPE_CODE (arg),
2480 TYPE_NAME (parm), TYPE_CODE (parm));
2482 /* x -> y means arg of type x being supplied for parameter of type y. */
2484 switch (TYPE_CODE (parm))
2487 switch (TYPE_CODE (arg))
2491 /* Allowed pointer conversions are:
2492 (a) pointer to void-pointer conversion. */
2493 if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID)
2494 return VOID_PTR_CONVERSION_BADNESS;
2496 /* (b) pointer to ancestor-pointer conversion. */
2497 rank.subrank = distance_to_ancestor (TYPE_TARGET_TYPE (parm),
2498 TYPE_TARGET_TYPE (arg),
2500 if (rank.subrank >= 0)
2501 return sum_ranks (BASE_PTR_CONVERSION_BADNESS, rank);
2503 return INCOMPATIBLE_TYPE_BADNESS;
2504 case TYPE_CODE_ARRAY:
2505 if (types_equal (TYPE_TARGET_TYPE (parm),
2506 TYPE_TARGET_TYPE (arg)))
2507 return EXACT_MATCH_BADNESS;
2508 return INCOMPATIBLE_TYPE_BADNESS;
2509 case TYPE_CODE_FUNC:
2510 return rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL);
2512 if (value != NULL && TYPE_CODE (value_type (value)) == TYPE_CODE_INT
2513 && value_as_long (value) == 0)
2515 /* Null pointer conversion: allow it to be cast to a pointer.
2516 [4.10.1 of C++ standard draft n3290] */
2517 return NULL_POINTER_CONVERSION_BADNESS;
2520 case TYPE_CODE_ENUM:
2521 case TYPE_CODE_FLAGS:
2522 case TYPE_CODE_CHAR:
2523 case TYPE_CODE_RANGE:
2524 case TYPE_CODE_BOOL:
2526 return INCOMPATIBLE_TYPE_BADNESS;
2528 case TYPE_CODE_ARRAY:
2529 switch (TYPE_CODE (arg))
2532 case TYPE_CODE_ARRAY:
2533 return rank_one_type (TYPE_TARGET_TYPE (parm),
2534 TYPE_TARGET_TYPE (arg), NULL);
2536 return INCOMPATIBLE_TYPE_BADNESS;
2538 case TYPE_CODE_FUNC:
2539 switch (TYPE_CODE (arg))
2541 case TYPE_CODE_PTR: /* funcptr -> func */
2542 return rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL);
2544 return INCOMPATIBLE_TYPE_BADNESS;
2547 switch (TYPE_CODE (arg))
2550 if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2552 /* Deal with signed, unsigned, and plain chars and
2553 signed and unsigned ints. */
2554 if (TYPE_NOSIGN (parm))
2556 /* This case only for character types. */
2557 if (TYPE_NOSIGN (arg))
2558 return EXACT_MATCH_BADNESS; /* plain char -> plain char */
2559 else /* signed/unsigned char -> plain char */
2560 return INTEGER_CONVERSION_BADNESS;
2562 else if (TYPE_UNSIGNED (parm))
2564 if (TYPE_UNSIGNED (arg))
2566 /* unsigned int -> unsigned int, or
2567 unsigned long -> unsigned long */
2568 if (integer_types_same_name_p (TYPE_NAME (parm),
2570 return EXACT_MATCH_BADNESS;
2571 else if (integer_types_same_name_p (TYPE_NAME (arg),
2573 && integer_types_same_name_p (TYPE_NAME (parm),
2575 /* unsigned int -> unsigned long */
2576 return INTEGER_PROMOTION_BADNESS;
2578 /* unsigned long -> unsigned int */
2579 return INTEGER_CONVERSION_BADNESS;
2583 if (integer_types_same_name_p (TYPE_NAME (arg),
2585 && integer_types_same_name_p (TYPE_NAME (parm),
2587 /* signed long -> unsigned int */
2588 return INTEGER_CONVERSION_BADNESS;
2590 /* signed int/long -> unsigned int/long */
2591 return INTEGER_CONVERSION_BADNESS;
2594 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2596 if (integer_types_same_name_p (TYPE_NAME (parm),
2598 return EXACT_MATCH_BADNESS;
2599 else if (integer_types_same_name_p (TYPE_NAME (arg),
2601 && integer_types_same_name_p (TYPE_NAME (parm),
2603 return INTEGER_PROMOTION_BADNESS;
2605 return INTEGER_CONVERSION_BADNESS;
2608 return INTEGER_CONVERSION_BADNESS;
2610 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2611 return INTEGER_PROMOTION_BADNESS;
2613 return INTEGER_CONVERSION_BADNESS;
2614 case TYPE_CODE_ENUM:
2615 case TYPE_CODE_FLAGS:
2616 case TYPE_CODE_CHAR:
2617 case TYPE_CODE_RANGE:
2618 case TYPE_CODE_BOOL:
2619 return INTEGER_PROMOTION_BADNESS;
2621 return INT_FLOAT_CONVERSION_BADNESS;
2623 return NS_POINTER_CONVERSION_BADNESS;
2625 return INCOMPATIBLE_TYPE_BADNESS;
2628 case TYPE_CODE_ENUM:
2629 switch (TYPE_CODE (arg))
2632 case TYPE_CODE_CHAR:
2633 case TYPE_CODE_RANGE:
2634 case TYPE_CODE_BOOL:
2635 case TYPE_CODE_ENUM:
2636 return INTEGER_CONVERSION_BADNESS;
2638 return INT_FLOAT_CONVERSION_BADNESS;
2640 return INCOMPATIBLE_TYPE_BADNESS;
2643 case TYPE_CODE_CHAR:
2644 switch (TYPE_CODE (arg))
2646 case TYPE_CODE_RANGE:
2647 case TYPE_CODE_BOOL:
2648 case TYPE_CODE_ENUM:
2649 return INTEGER_CONVERSION_BADNESS;
2651 return INT_FLOAT_CONVERSION_BADNESS;
2653 if (TYPE_LENGTH (arg) > TYPE_LENGTH (parm))
2654 return INTEGER_CONVERSION_BADNESS;
2655 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2656 return INTEGER_PROMOTION_BADNESS;
2657 /* >>> !! else fall through !! <<< */
2658 case TYPE_CODE_CHAR:
2659 /* Deal with signed, unsigned, and plain chars for C++ and
2660 with int cases falling through from previous case. */
2661 if (TYPE_NOSIGN (parm))
2663 if (TYPE_NOSIGN (arg))
2664 return EXACT_MATCH_BADNESS;
2666 return INTEGER_CONVERSION_BADNESS;
2668 else if (TYPE_UNSIGNED (parm))
2670 if (TYPE_UNSIGNED (arg))
2671 return EXACT_MATCH_BADNESS;
2673 return INTEGER_PROMOTION_BADNESS;
2675 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2676 return EXACT_MATCH_BADNESS;
2678 return INTEGER_CONVERSION_BADNESS;
2680 return INCOMPATIBLE_TYPE_BADNESS;
2683 case TYPE_CODE_RANGE:
2684 switch (TYPE_CODE (arg))
2687 case TYPE_CODE_CHAR:
2688 case TYPE_CODE_RANGE:
2689 case TYPE_CODE_BOOL:
2690 case TYPE_CODE_ENUM:
2691 return INTEGER_CONVERSION_BADNESS;
2693 return INT_FLOAT_CONVERSION_BADNESS;
2695 return INCOMPATIBLE_TYPE_BADNESS;
2698 case TYPE_CODE_BOOL:
2699 switch (TYPE_CODE (arg))
2702 case TYPE_CODE_CHAR:
2703 case TYPE_CODE_RANGE:
2704 case TYPE_CODE_ENUM:
2706 return INCOMPATIBLE_TYPE_BADNESS;
2708 return BOOL_PTR_CONVERSION_BADNESS;
2709 case TYPE_CODE_BOOL:
2710 return EXACT_MATCH_BADNESS;
2712 return INCOMPATIBLE_TYPE_BADNESS;
2716 switch (TYPE_CODE (arg))
2719 if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2720 return FLOAT_PROMOTION_BADNESS;
2721 else if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2722 return EXACT_MATCH_BADNESS;
2724 return FLOAT_CONVERSION_BADNESS;
2726 case TYPE_CODE_BOOL:
2727 case TYPE_CODE_ENUM:
2728 case TYPE_CODE_RANGE:
2729 case TYPE_CODE_CHAR:
2730 return INT_FLOAT_CONVERSION_BADNESS;
2732 return INCOMPATIBLE_TYPE_BADNESS;
2735 case TYPE_CODE_COMPLEX:
2736 switch (TYPE_CODE (arg))
2737 { /* Strictly not needed for C++, but... */
2739 return FLOAT_PROMOTION_BADNESS;
2740 case TYPE_CODE_COMPLEX:
2741 return EXACT_MATCH_BADNESS;
2743 return INCOMPATIBLE_TYPE_BADNESS;
2746 case TYPE_CODE_STRUCT:
2747 /* currently same as TYPE_CODE_CLASS. */
2748 switch (TYPE_CODE (arg))
2750 case TYPE_CODE_STRUCT:
2751 /* Check for derivation */
2752 rank.subrank = distance_to_ancestor (parm, arg, 0);
2753 if (rank.subrank >= 0)
2754 return sum_ranks (BASE_CONVERSION_BADNESS, rank);
2755 /* else fall through */
2757 return INCOMPATIBLE_TYPE_BADNESS;
2760 case TYPE_CODE_UNION:
2761 switch (TYPE_CODE (arg))
2763 case TYPE_CODE_UNION:
2765 return INCOMPATIBLE_TYPE_BADNESS;
2768 case TYPE_CODE_MEMBERPTR:
2769 switch (TYPE_CODE (arg))
2772 return INCOMPATIBLE_TYPE_BADNESS;
2775 case TYPE_CODE_METHOD:
2776 switch (TYPE_CODE (arg))
2780 return INCOMPATIBLE_TYPE_BADNESS;
2784 switch (TYPE_CODE (arg))
2788 return INCOMPATIBLE_TYPE_BADNESS;
2793 switch (TYPE_CODE (arg))
2797 return rank_one_type (TYPE_FIELD_TYPE (parm, 0),
2798 TYPE_FIELD_TYPE (arg, 0), NULL);
2800 return INCOMPATIBLE_TYPE_BADNESS;
2803 case TYPE_CODE_VOID:
2805 return INCOMPATIBLE_TYPE_BADNESS;
2806 } /* switch (TYPE_CODE (arg)) */
2810 /* End of functions for overload resolution. */
2813 print_bit_vector (B_TYPE *bits, int nbits)
2817 for (bitno = 0; bitno < nbits; bitno++)
2819 if ((bitno % 8) == 0)
2821 puts_filtered (" ");
2823 if (B_TST (bits, bitno))
2824 printf_filtered (("1"));
2826 printf_filtered (("0"));
2830 /* Note the first arg should be the "this" pointer, we may not want to
2831 include it since we may get into a infinitely recursive
2835 print_arg_types (struct field *args, int nargs, int spaces)
2841 for (i = 0; i < nargs; i++)
2842 recursive_dump_type (args[i].type, spaces + 2);
2847 field_is_static (struct field *f)
2849 /* "static" fields are the fields whose location is not relative
2850 to the address of the enclosing struct. It would be nice to
2851 have a dedicated flag that would be set for static fields when
2852 the type is being created. But in practice, checking the field
2853 loc_kind should give us an accurate answer. */
2854 return (FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSNAME
2855 || FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSADDR);
2859 dump_fn_fieldlists (struct type *type, int spaces)
2865 printfi_filtered (spaces, "fn_fieldlists ");
2866 gdb_print_host_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
2867 printf_filtered ("\n");
2868 for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
2870 f = TYPE_FN_FIELDLIST1 (type, method_idx);
2871 printfi_filtered (spaces + 2, "[%d] name '%s' (",
2873 TYPE_FN_FIELDLIST_NAME (type, method_idx));
2874 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
2876 printf_filtered (_(") length %d\n"),
2877 TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
2878 for (overload_idx = 0;
2879 overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
2882 printfi_filtered (spaces + 4, "[%d] physname '%s' (",
2884 TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
2885 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
2887 printf_filtered (")\n");
2888 printfi_filtered (spaces + 8, "type ");
2889 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx),
2891 printf_filtered ("\n");
2893 recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
2896 printfi_filtered (spaces + 8, "args ");
2897 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx),
2899 printf_filtered ("\n");
2901 print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx),
2902 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f,
2905 printfi_filtered (spaces + 8, "fcontext ");
2906 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
2908 printf_filtered ("\n");
2910 printfi_filtered (spaces + 8, "is_const %d\n",
2911 TYPE_FN_FIELD_CONST (f, overload_idx));
2912 printfi_filtered (spaces + 8, "is_volatile %d\n",
2913 TYPE_FN_FIELD_VOLATILE (f, overload_idx));
2914 printfi_filtered (spaces + 8, "is_private %d\n",
2915 TYPE_FN_FIELD_PRIVATE (f, overload_idx));
2916 printfi_filtered (spaces + 8, "is_protected %d\n",
2917 TYPE_FN_FIELD_PROTECTED (f, overload_idx));
2918 printfi_filtered (spaces + 8, "is_stub %d\n",
2919 TYPE_FN_FIELD_STUB (f, overload_idx));
2920 printfi_filtered (spaces + 8, "voffset %u\n",
2921 TYPE_FN_FIELD_VOFFSET (f, overload_idx));
2927 print_cplus_stuff (struct type *type, int spaces)
2929 printfi_filtered (spaces, "n_baseclasses %d\n",
2930 TYPE_N_BASECLASSES (type));
2931 printfi_filtered (spaces, "nfn_fields %d\n",
2932 TYPE_NFN_FIELDS (type));
2933 if (TYPE_N_BASECLASSES (type) > 0)
2935 printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
2936 TYPE_N_BASECLASSES (type));
2937 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type),
2939 printf_filtered (")");
2941 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
2942 TYPE_N_BASECLASSES (type));
2943 puts_filtered ("\n");
2945 if (TYPE_NFIELDS (type) > 0)
2947 if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
2949 printfi_filtered (spaces,
2950 "private_field_bits (%d bits at *",
2951 TYPE_NFIELDS (type));
2952 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type),
2954 printf_filtered (")");
2955 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
2956 TYPE_NFIELDS (type));
2957 puts_filtered ("\n");
2959 if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
2961 printfi_filtered (spaces,
2962 "protected_field_bits (%d bits at *",
2963 TYPE_NFIELDS (type));
2964 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type),
2966 printf_filtered (")");
2967 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
2968 TYPE_NFIELDS (type));
2969 puts_filtered ("\n");
2972 if (TYPE_NFN_FIELDS (type) > 0)
2974 dump_fn_fieldlists (type, spaces);
2978 /* Print the contents of the TYPE's type_specific union, assuming that
2979 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
2982 print_gnat_stuff (struct type *type, int spaces)
2984 struct type *descriptive_type = TYPE_DESCRIPTIVE_TYPE (type);
2986 recursive_dump_type (descriptive_type, spaces + 2);
2989 static struct obstack dont_print_type_obstack;
2992 recursive_dump_type (struct type *type, int spaces)
2997 obstack_begin (&dont_print_type_obstack, 0);
2999 if (TYPE_NFIELDS (type) > 0
3000 || (HAVE_CPLUS_STRUCT (type) && TYPE_NFN_FIELDS (type) > 0))
3002 struct type **first_dont_print
3003 = (struct type **) obstack_base (&dont_print_type_obstack);
3005 int i = (struct type **)
3006 obstack_next_free (&dont_print_type_obstack) - first_dont_print;
3010 if (type == first_dont_print[i])
3012 printfi_filtered (spaces, "type node ");
3013 gdb_print_host_address (type, gdb_stdout);
3014 printf_filtered (_(" <same as already seen type>\n"));
3019 obstack_ptr_grow (&dont_print_type_obstack, type);
3022 printfi_filtered (spaces, "type node ");
3023 gdb_print_host_address (type, gdb_stdout);
3024 printf_filtered ("\n");
3025 printfi_filtered (spaces, "name '%s' (",
3026 TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
3027 gdb_print_host_address (TYPE_NAME (type), gdb_stdout);
3028 printf_filtered (")\n");
3029 printfi_filtered (spaces, "tagname '%s' (",
3030 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : "<NULL>");
3031 gdb_print_host_address (TYPE_TAG_NAME (type), gdb_stdout);
3032 printf_filtered (")\n");
3033 printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
3034 switch (TYPE_CODE (type))
3036 case TYPE_CODE_UNDEF:
3037 printf_filtered ("(TYPE_CODE_UNDEF)");
3040 printf_filtered ("(TYPE_CODE_PTR)");
3042 case TYPE_CODE_ARRAY:
3043 printf_filtered ("(TYPE_CODE_ARRAY)");
3045 case TYPE_CODE_STRUCT:
3046 printf_filtered ("(TYPE_CODE_STRUCT)");
3048 case TYPE_CODE_UNION:
3049 printf_filtered ("(TYPE_CODE_UNION)");
3051 case TYPE_CODE_ENUM:
3052 printf_filtered ("(TYPE_CODE_ENUM)");
3054 case TYPE_CODE_FLAGS:
3055 printf_filtered ("(TYPE_CODE_FLAGS)");
3057 case TYPE_CODE_FUNC:
3058 printf_filtered ("(TYPE_CODE_FUNC)");
3061 printf_filtered ("(TYPE_CODE_INT)");
3064 printf_filtered ("(TYPE_CODE_FLT)");
3066 case TYPE_CODE_VOID:
3067 printf_filtered ("(TYPE_CODE_VOID)");
3070 printf_filtered ("(TYPE_CODE_SET)");
3072 case TYPE_CODE_RANGE:
3073 printf_filtered ("(TYPE_CODE_RANGE)");
3075 case TYPE_CODE_STRING:
3076 printf_filtered ("(TYPE_CODE_STRING)");
3078 case TYPE_CODE_BITSTRING:
3079 printf_filtered ("(TYPE_CODE_BITSTRING)");
3081 case TYPE_CODE_ERROR:
3082 printf_filtered ("(TYPE_CODE_ERROR)");
3084 case TYPE_CODE_MEMBERPTR:
3085 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
3087 case TYPE_CODE_METHODPTR:
3088 printf_filtered ("(TYPE_CODE_METHODPTR)");
3090 case TYPE_CODE_METHOD:
3091 printf_filtered ("(TYPE_CODE_METHOD)");
3094 printf_filtered ("(TYPE_CODE_REF)");
3096 case TYPE_CODE_CHAR:
3097 printf_filtered ("(TYPE_CODE_CHAR)");
3099 case TYPE_CODE_BOOL:
3100 printf_filtered ("(TYPE_CODE_BOOL)");
3102 case TYPE_CODE_COMPLEX:
3103 printf_filtered ("(TYPE_CODE_COMPLEX)");
3105 case TYPE_CODE_TYPEDEF:
3106 printf_filtered ("(TYPE_CODE_TYPEDEF)");
3108 case TYPE_CODE_NAMESPACE:
3109 printf_filtered ("(TYPE_CODE_NAMESPACE)");
3112 printf_filtered ("(UNKNOWN TYPE CODE)");
3115 puts_filtered ("\n");
3116 printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
3117 if (TYPE_OBJFILE_OWNED (type))
3119 printfi_filtered (spaces, "objfile ");
3120 gdb_print_host_address (TYPE_OWNER (type).objfile, gdb_stdout);
3124 printfi_filtered (spaces, "gdbarch ");
3125 gdb_print_host_address (TYPE_OWNER (type).gdbarch, gdb_stdout);
3127 printf_filtered ("\n");
3128 printfi_filtered (spaces, "target_type ");
3129 gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout);
3130 printf_filtered ("\n");
3131 if (TYPE_TARGET_TYPE (type) != NULL)
3133 recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
3135 printfi_filtered (spaces, "pointer_type ");
3136 gdb_print_host_address (TYPE_POINTER_TYPE (type), gdb_stdout);
3137 printf_filtered ("\n");
3138 printfi_filtered (spaces, "reference_type ");
3139 gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
3140 printf_filtered ("\n");
3141 printfi_filtered (spaces, "type_chain ");
3142 gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);
3143 printf_filtered ("\n");
3144 printfi_filtered (spaces, "instance_flags 0x%x",
3145 TYPE_INSTANCE_FLAGS (type));
3146 if (TYPE_CONST (type))
3148 puts_filtered (" TYPE_FLAG_CONST");
3150 if (TYPE_VOLATILE (type))
3152 puts_filtered (" TYPE_FLAG_VOLATILE");
3154 if (TYPE_CODE_SPACE (type))
3156 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3158 if (TYPE_DATA_SPACE (type))
3160 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3162 if (TYPE_ADDRESS_CLASS_1 (type))
3164 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3166 if (TYPE_ADDRESS_CLASS_2 (type))
3168 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3170 puts_filtered ("\n");
3172 printfi_filtered (spaces, "flags");
3173 if (TYPE_UNSIGNED (type))
3175 puts_filtered (" TYPE_FLAG_UNSIGNED");
3177 if (TYPE_NOSIGN (type))
3179 puts_filtered (" TYPE_FLAG_NOSIGN");
3181 if (TYPE_STUB (type))
3183 puts_filtered (" TYPE_FLAG_STUB");
3185 if (TYPE_TARGET_STUB (type))
3187 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3189 if (TYPE_STATIC (type))
3191 puts_filtered (" TYPE_FLAG_STATIC");
3193 if (TYPE_PROTOTYPED (type))
3195 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3197 if (TYPE_INCOMPLETE (type))
3199 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3201 if (TYPE_VARARGS (type))
3203 puts_filtered (" TYPE_FLAG_VARARGS");
3205 /* This is used for things like AltiVec registers on ppc. Gcc emits
3206 an attribute for the array type, which tells whether or not we
3207 have a vector, instead of a regular array. */
3208 if (TYPE_VECTOR (type))
3210 puts_filtered (" TYPE_FLAG_VECTOR");
3212 if (TYPE_FIXED_INSTANCE (type))
3214 puts_filtered (" TYPE_FIXED_INSTANCE");
3216 if (TYPE_STUB_SUPPORTED (type))
3218 puts_filtered (" TYPE_STUB_SUPPORTED");
3220 if (TYPE_NOTTEXT (type))
3222 puts_filtered (" TYPE_NOTTEXT");
3224 puts_filtered ("\n");
3225 printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
3226 gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
3227 puts_filtered ("\n");
3228 for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
3230 if (TYPE_CODE (type) == TYPE_CODE_ENUM)
3231 printfi_filtered (spaces + 2,
3232 "[%d] enumval %s type ",
3233 idx, plongest (TYPE_FIELD_ENUMVAL (type, idx)));
3235 printfi_filtered (spaces + 2,
3236 "[%d] bitpos %d bitsize %d type ",
3237 idx, TYPE_FIELD_BITPOS (type, idx),
3238 TYPE_FIELD_BITSIZE (type, idx));
3239 gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
3240 printf_filtered (" name '%s' (",
3241 TYPE_FIELD_NAME (type, idx) != NULL
3242 ? TYPE_FIELD_NAME (type, idx)
3244 gdb_print_host_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
3245 printf_filtered (")\n");
3246 if (TYPE_FIELD_TYPE (type, idx) != NULL)
3248 recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
3251 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
3253 printfi_filtered (spaces, "low %s%s high %s%s\n",
3254 plongest (TYPE_LOW_BOUND (type)),
3255 TYPE_LOW_BOUND_UNDEFINED (type) ? " (undefined)" : "",
3256 plongest (TYPE_HIGH_BOUND (type)),
3257 TYPE_HIGH_BOUND_UNDEFINED (type)
3258 ? " (undefined)" : "");
3260 printfi_filtered (spaces, "vptr_basetype ");
3261 gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
3262 puts_filtered ("\n");
3263 if (TYPE_VPTR_BASETYPE (type) != NULL)
3265 recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
3267 printfi_filtered (spaces, "vptr_fieldno %d\n",
3268 TYPE_VPTR_FIELDNO (type));
3270 switch (TYPE_SPECIFIC_FIELD (type))
3272 case TYPE_SPECIFIC_CPLUS_STUFF:
3273 printfi_filtered (spaces, "cplus_stuff ");
3274 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type),
3276 puts_filtered ("\n");
3277 print_cplus_stuff (type, spaces);
3280 case TYPE_SPECIFIC_GNAT_STUFF:
3281 printfi_filtered (spaces, "gnat_stuff ");
3282 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type), gdb_stdout);
3283 puts_filtered ("\n");
3284 print_gnat_stuff (type, spaces);
3287 case TYPE_SPECIFIC_FLOATFORMAT:
3288 printfi_filtered (spaces, "floatformat ");
3289 if (TYPE_FLOATFORMAT (type) == NULL)
3290 puts_filtered ("(null)");
3293 puts_filtered ("{ ");
3294 if (TYPE_FLOATFORMAT (type)[0] == NULL
3295 || TYPE_FLOATFORMAT (type)[0]->name == NULL)
3296 puts_filtered ("(null)");
3298 puts_filtered (TYPE_FLOATFORMAT (type)[0]->name);
3300 puts_filtered (", ");
3301 if (TYPE_FLOATFORMAT (type)[1] == NULL
3302 || TYPE_FLOATFORMAT (type)[1]->name == NULL)
3303 puts_filtered ("(null)");
3305 puts_filtered (TYPE_FLOATFORMAT (type)[1]->name);
3307 puts_filtered (" }");
3309 puts_filtered ("\n");
3312 case TYPE_SPECIFIC_FUNC:
3313 printfi_filtered (spaces, "calling_convention %d\n",
3314 TYPE_CALLING_CONVENTION (type));
3315 /* tail_call_list is not printed. */
3320 obstack_free (&dont_print_type_obstack, NULL);
3323 /* Trivial helpers for the libiberty hash table, for mapping one
3328 struct type *old, *new;
3332 type_pair_hash (const void *item)
3334 const struct type_pair *pair = item;
3336 return htab_hash_pointer (pair->old);
3340 type_pair_eq (const void *item_lhs, const void *item_rhs)
3342 const struct type_pair *lhs = item_lhs, *rhs = item_rhs;
3344 return lhs->old == rhs->old;
3347 /* Allocate the hash table used by copy_type_recursive to walk
3348 types without duplicates. We use OBJFILE's obstack, because
3349 OBJFILE is about to be deleted. */
3352 create_copied_types_hash (struct objfile *objfile)
3354 return htab_create_alloc_ex (1, type_pair_hash, type_pair_eq,
3355 NULL, &objfile->objfile_obstack,
3356 hashtab_obstack_allocate,
3357 dummy_obstack_deallocate);
3360 /* Recursively copy (deep copy) TYPE, if it is associated with
3361 OBJFILE. Return a new type allocated using malloc, a saved type if
3362 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
3363 not associated with OBJFILE. */
3366 copy_type_recursive (struct objfile *objfile,
3368 htab_t copied_types)
3370 struct type_pair *stored, pair;
3372 struct type *new_type;
3374 if (! TYPE_OBJFILE_OWNED (type))
3377 /* This type shouldn't be pointing to any types in other objfiles;
3378 if it did, the type might disappear unexpectedly. */
3379 gdb_assert (TYPE_OBJFILE (type) == objfile);
3382 slot = htab_find_slot (copied_types, &pair, INSERT);
3384 return ((struct type_pair *) *slot)->new;
3386 new_type = alloc_type_arch (get_type_arch (type));
3388 /* We must add the new type to the hash table immediately, in case
3389 we encounter this type again during a recursive call below. */
3391 = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair));
3393 stored->new = new_type;
3396 /* Copy the common fields of types. For the main type, we simply
3397 copy the entire thing and then update specific fields as needed. */
3398 *TYPE_MAIN_TYPE (new_type) = *TYPE_MAIN_TYPE (type);
3399 TYPE_OBJFILE_OWNED (new_type) = 0;
3400 TYPE_OWNER (new_type).gdbarch = get_type_arch (type);
3402 if (TYPE_NAME (type))
3403 TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type));
3404 if (TYPE_TAG_NAME (type))
3405 TYPE_TAG_NAME (new_type) = xstrdup (TYPE_TAG_NAME (type));
3407 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
3408 TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
3410 /* Copy the fields. */
3411 if (TYPE_NFIELDS (type))
3415 nfields = TYPE_NFIELDS (type);
3416 TYPE_FIELDS (new_type) = XCALLOC (nfields, struct field);
3417 for (i = 0; i < nfields; i++)
3419 TYPE_FIELD_ARTIFICIAL (new_type, i) =
3420 TYPE_FIELD_ARTIFICIAL (type, i);
3421 TYPE_FIELD_BITSIZE (new_type, i) = TYPE_FIELD_BITSIZE (type, i);
3422 if (TYPE_FIELD_TYPE (type, i))
3423 TYPE_FIELD_TYPE (new_type, i)
3424 = copy_type_recursive (objfile, TYPE_FIELD_TYPE (type, i),
3426 if (TYPE_FIELD_NAME (type, i))
3427 TYPE_FIELD_NAME (new_type, i) =
3428 xstrdup (TYPE_FIELD_NAME (type, i));
3429 switch (TYPE_FIELD_LOC_KIND (type, i))
3431 case FIELD_LOC_KIND_BITPOS:
3432 SET_FIELD_BITPOS (TYPE_FIELD (new_type, i),
3433 TYPE_FIELD_BITPOS (type, i));
3435 case FIELD_LOC_KIND_ENUMVAL:
3436 SET_FIELD_ENUMVAL (TYPE_FIELD (new_type, i),
3437 TYPE_FIELD_ENUMVAL (type, i));
3439 case FIELD_LOC_KIND_PHYSADDR:
3440 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i),
3441 TYPE_FIELD_STATIC_PHYSADDR (type, i));
3443 case FIELD_LOC_KIND_PHYSNAME:
3444 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i),
3445 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type,
3449 internal_error (__FILE__, __LINE__,
3450 _("Unexpected type field location kind: %d"),
3451 TYPE_FIELD_LOC_KIND (type, i));
3456 /* For range types, copy the bounds information. */
3457 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
3459 TYPE_RANGE_DATA (new_type) = xmalloc (sizeof (struct range_bounds));
3460 *TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type);
3463 /* Copy pointers to other types. */
3464 if (TYPE_TARGET_TYPE (type))
3465 TYPE_TARGET_TYPE (new_type) =
3466 copy_type_recursive (objfile,
3467 TYPE_TARGET_TYPE (type),
3469 if (TYPE_VPTR_BASETYPE (type))
3470 TYPE_VPTR_BASETYPE (new_type) =
3471 copy_type_recursive (objfile,
3472 TYPE_VPTR_BASETYPE (type),
3474 /* Maybe copy the type_specific bits.
3476 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3477 base classes and methods. There's no fundamental reason why we
3478 can't, but at the moment it is not needed. */
3480 if (TYPE_CODE (type) == TYPE_CODE_FLT)
3481 TYPE_FLOATFORMAT (new_type) = TYPE_FLOATFORMAT (type);
3482 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
3483 || TYPE_CODE (type) == TYPE_CODE_UNION
3484 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
3485 INIT_CPLUS_SPECIFIC (new_type);
3490 /* Make a copy of the given TYPE, except that the pointer & reference
3491 types are not preserved.
3493 This function assumes that the given type has an associated objfile.
3494 This objfile is used to allocate the new type. */
3497 copy_type (const struct type *type)
3499 struct type *new_type;
3501 gdb_assert (TYPE_OBJFILE_OWNED (type));
3503 new_type = alloc_type_copy (type);
3504 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
3505 TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
3506 memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type),
3507 sizeof (struct main_type));
3513 /* Helper functions to initialize architecture-specific types. */
3515 /* Allocate a type structure associated with GDBARCH and set its
3516 CODE, LENGTH, and NAME fields. */
3518 arch_type (struct gdbarch *gdbarch,
3519 enum type_code code, int length, char *name)
3523 type = alloc_type_arch (gdbarch);
3524 TYPE_CODE (type) = code;
3525 TYPE_LENGTH (type) = length;
3528 TYPE_NAME (type) = xstrdup (name);
3533 /* Allocate a TYPE_CODE_INT 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_integer_type (struct gdbarch *gdbarch,
3538 int bit, int unsigned_p, char *name)
3542 t = arch_type (gdbarch, TYPE_CODE_INT, bit / TARGET_CHAR_BIT, name);
3544 TYPE_UNSIGNED (t) = 1;
3545 if (name && strcmp (name, "char") == 0)
3546 TYPE_NOSIGN (t) = 1;
3551 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
3552 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3553 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3555 arch_character_type (struct gdbarch *gdbarch,
3556 int bit, int unsigned_p, char *name)
3560 t = arch_type (gdbarch, TYPE_CODE_CHAR, bit / TARGET_CHAR_BIT, name);
3562 TYPE_UNSIGNED (t) = 1;
3567 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
3568 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3569 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3571 arch_boolean_type (struct gdbarch *gdbarch,
3572 int bit, int unsigned_p, char *name)
3576 t = arch_type (gdbarch, TYPE_CODE_BOOL, bit / TARGET_CHAR_BIT, name);
3578 TYPE_UNSIGNED (t) = 1;
3583 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
3584 BIT is the type size in bits; if BIT equals -1, the size is
3585 determined by the floatformat. NAME is the type name. Set the
3586 TYPE_FLOATFORMAT from FLOATFORMATS. */
3588 arch_float_type (struct gdbarch *gdbarch,
3589 int bit, char *name, const struct floatformat **floatformats)
3595 gdb_assert (floatformats != NULL);
3596 gdb_assert (floatformats[0] != NULL && floatformats[1] != NULL);
3597 bit = floatformats[0]->totalsize;
3599 gdb_assert (bit >= 0);
3601 t = arch_type (gdbarch, TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, name);
3602 TYPE_FLOATFORMAT (t) = floatformats;
3606 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
3607 NAME is the type name. TARGET_TYPE is the component float type. */
3609 arch_complex_type (struct gdbarch *gdbarch,
3610 char *name, struct type *target_type)
3614 t = arch_type (gdbarch, TYPE_CODE_COMPLEX,
3615 2 * TYPE_LENGTH (target_type), name);
3616 TYPE_TARGET_TYPE (t) = target_type;
3620 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
3621 NAME is the type name. LENGTH is the size of the flag word in bytes. */
3623 arch_flags_type (struct gdbarch *gdbarch, char *name, int length)
3625 int nfields = length * TARGET_CHAR_BIT;
3628 type = arch_type (gdbarch, TYPE_CODE_FLAGS, length, name);
3629 TYPE_UNSIGNED (type) = 1;
3630 TYPE_NFIELDS (type) = nfields;
3631 TYPE_FIELDS (type) = TYPE_ZALLOC (type, nfields * sizeof (struct field));
3636 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
3637 position BITPOS is called NAME. */
3639 append_flags_type_flag (struct type *type, int bitpos, char *name)
3641 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS);
3642 gdb_assert (bitpos < TYPE_NFIELDS (type));
3643 gdb_assert (bitpos >= 0);
3647 TYPE_FIELD_NAME (type, bitpos) = xstrdup (name);
3648 SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), bitpos);
3652 /* Don't show this field to the user. */
3653 SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), -1);
3657 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
3658 specified by CODE) associated with GDBARCH. NAME is the type name. */
3660 arch_composite_type (struct gdbarch *gdbarch, char *name, enum type_code code)
3664 gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION);
3665 t = arch_type (gdbarch, code, 0, NULL);
3666 TYPE_TAG_NAME (t) = name;
3667 INIT_CPLUS_SPECIFIC (t);
3671 /* Add new field with name NAME and type FIELD to composite type T.
3672 Do not set the field's position or adjust the type's length;
3673 the caller should do so. Return the new field. */
3675 append_composite_type_field_raw (struct type *t, char *name,
3680 TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
3681 TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t),
3682 sizeof (struct field) * TYPE_NFIELDS (t));
3683 f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
3684 memset (f, 0, sizeof f[0]);
3685 FIELD_TYPE (f[0]) = field;
3686 FIELD_NAME (f[0]) = name;
3690 /* Add new field with name NAME and type FIELD to composite type T.
3691 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
3693 append_composite_type_field_aligned (struct type *t, char *name,
3694 struct type *field, int alignment)
3696 struct field *f = append_composite_type_field_raw (t, name, field);
3698 if (TYPE_CODE (t) == TYPE_CODE_UNION)
3700 if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
3701 TYPE_LENGTH (t) = TYPE_LENGTH (field);
3703 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
3705 TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
3706 if (TYPE_NFIELDS (t) > 1)
3708 SET_FIELD_BITPOS (f[0],
3709 (FIELD_BITPOS (f[-1])
3710 + (TYPE_LENGTH (FIELD_TYPE (f[-1]))
3711 * TARGET_CHAR_BIT)));
3717 alignment *= TARGET_CHAR_BIT;
3718 left = FIELD_BITPOS (f[0]) % alignment;
3722 SET_FIELD_BITPOS (f[0], FIELD_BITPOS (f[0]) + (alignment - left));
3723 TYPE_LENGTH (t) += (alignment - left) / TARGET_CHAR_BIT;
3730 /* Add new field with name NAME and type FIELD to composite type T. */
3732 append_composite_type_field (struct type *t, char *name,
3735 append_composite_type_field_aligned (t, name, field, 0);
3739 static struct gdbarch_data *gdbtypes_data;
3741 const struct builtin_type *
3742 builtin_type (struct gdbarch *gdbarch)
3744 return gdbarch_data (gdbarch, gdbtypes_data);
3748 gdbtypes_post_init (struct gdbarch *gdbarch)
3750 struct builtin_type *builtin_type
3751 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type);
3754 builtin_type->builtin_void
3755 = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
3756 builtin_type->builtin_char
3757 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3758 !gdbarch_char_signed (gdbarch), "char");
3759 builtin_type->builtin_signed_char
3760 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3762 builtin_type->builtin_unsigned_char
3763 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3764 1, "unsigned char");
3765 builtin_type->builtin_short
3766 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
3768 builtin_type->builtin_unsigned_short
3769 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
3770 1, "unsigned short");
3771 builtin_type->builtin_int
3772 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
3774 builtin_type->builtin_unsigned_int
3775 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
3777 builtin_type->builtin_long
3778 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
3780 builtin_type->builtin_unsigned_long
3781 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
3782 1, "unsigned long");
3783 builtin_type->builtin_long_long
3784 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
3786 builtin_type->builtin_unsigned_long_long
3787 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
3788 1, "unsigned long long");
3789 builtin_type->builtin_float
3790 = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
3791 "float", gdbarch_float_format (gdbarch));
3792 builtin_type->builtin_double
3793 = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
3794 "double", gdbarch_double_format (gdbarch));
3795 builtin_type->builtin_long_double
3796 = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
3797 "long double", gdbarch_long_double_format (gdbarch));
3798 builtin_type->builtin_complex
3799 = arch_complex_type (gdbarch, "complex",
3800 builtin_type->builtin_float);
3801 builtin_type->builtin_double_complex
3802 = arch_complex_type (gdbarch, "double complex",
3803 builtin_type->builtin_double);
3804 builtin_type->builtin_string
3805 = arch_type (gdbarch, TYPE_CODE_STRING, 1, "string");
3806 builtin_type->builtin_bool
3807 = arch_type (gdbarch, TYPE_CODE_BOOL, 1, "bool");
3809 /* The following three are about decimal floating point types, which
3810 are 32-bits, 64-bits and 128-bits respectively. */
3811 builtin_type->builtin_decfloat
3812 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 32 / 8, "_Decimal32");
3813 builtin_type->builtin_decdouble
3814 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 64 / 8, "_Decimal64");
3815 builtin_type->builtin_declong
3816 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 128 / 8, "_Decimal128");
3818 /* "True" character types. */
3819 builtin_type->builtin_true_char
3820 = arch_character_type (gdbarch, TARGET_CHAR_BIT, 0, "true character");
3821 builtin_type->builtin_true_unsigned_char
3822 = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "true character");
3824 /* Fixed-size integer types. */
3825 builtin_type->builtin_int0
3826 = arch_integer_type (gdbarch, 0, 0, "int0_t");
3827 builtin_type->builtin_int8
3828 = arch_integer_type (gdbarch, 8, 0, "int8_t");
3829 builtin_type->builtin_uint8
3830 = arch_integer_type (gdbarch, 8, 1, "uint8_t");
3831 builtin_type->builtin_int16
3832 = arch_integer_type (gdbarch, 16, 0, "int16_t");
3833 builtin_type->builtin_uint16
3834 = arch_integer_type (gdbarch, 16, 1, "uint16_t");
3835 builtin_type->builtin_int32
3836 = arch_integer_type (gdbarch, 32, 0, "int32_t");
3837 builtin_type->builtin_uint32
3838 = arch_integer_type (gdbarch, 32, 1, "uint32_t");
3839 builtin_type->builtin_int64
3840 = arch_integer_type (gdbarch, 64, 0, "int64_t");
3841 builtin_type->builtin_uint64
3842 = arch_integer_type (gdbarch, 64, 1, "uint64_t");
3843 builtin_type->builtin_int128
3844 = arch_integer_type (gdbarch, 128, 0, "int128_t");
3845 builtin_type->builtin_uint128
3846 = arch_integer_type (gdbarch, 128, 1, "uint128_t");
3847 TYPE_INSTANCE_FLAGS (builtin_type->builtin_int8) |=
3848 TYPE_INSTANCE_FLAG_NOTTEXT;
3849 TYPE_INSTANCE_FLAGS (builtin_type->builtin_uint8) |=
3850 TYPE_INSTANCE_FLAG_NOTTEXT;
3852 /* Wide character types. */
3853 builtin_type->builtin_char16
3854 = arch_integer_type (gdbarch, 16, 0, "char16_t");
3855 builtin_type->builtin_char32
3856 = arch_integer_type (gdbarch, 32, 0, "char32_t");
3859 /* Default data/code pointer types. */
3860 builtin_type->builtin_data_ptr
3861 = lookup_pointer_type (builtin_type->builtin_void);
3862 builtin_type->builtin_func_ptr
3863 = lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
3864 builtin_type->builtin_func_func
3865 = lookup_function_type (builtin_type->builtin_func_ptr);
3867 /* This type represents a GDB internal function. */
3868 builtin_type->internal_fn
3869 = arch_type (gdbarch, TYPE_CODE_INTERNAL_FUNCTION, 0,
3870 "<internal function>");
3872 return builtin_type;
3876 /* This set of objfile-based types is intended to be used by symbol
3877 readers as basic types. */
3879 static const struct objfile_data *objfile_type_data;
3881 const struct objfile_type *
3882 objfile_type (struct objfile *objfile)
3884 struct gdbarch *gdbarch;
3885 struct objfile_type *objfile_type
3886 = objfile_data (objfile, objfile_type_data);
3889 return objfile_type;
3891 objfile_type = OBSTACK_CALLOC (&objfile->objfile_obstack,
3892 1, struct objfile_type);
3894 /* Use the objfile architecture to determine basic type properties. */
3895 gdbarch = get_objfile_arch (objfile);
3898 objfile_type->builtin_void
3899 = init_type (TYPE_CODE_VOID, 1,
3903 objfile_type->builtin_char
3904 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3906 | (gdbarch_char_signed (gdbarch) ? 0 : TYPE_FLAG_UNSIGNED)),
3908 objfile_type->builtin_signed_char
3909 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3911 "signed char", objfile);
3912 objfile_type->builtin_unsigned_char
3913 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3915 "unsigned char", objfile);
3916 objfile_type->builtin_short
3917 = init_type (TYPE_CODE_INT,
3918 gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
3919 0, "short", objfile);
3920 objfile_type->builtin_unsigned_short
3921 = init_type (TYPE_CODE_INT,
3922 gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
3923 TYPE_FLAG_UNSIGNED, "unsigned short", objfile);
3924 objfile_type->builtin_int
3925 = init_type (TYPE_CODE_INT,
3926 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
3928 objfile_type->builtin_unsigned_int
3929 = init_type (TYPE_CODE_INT,
3930 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
3931 TYPE_FLAG_UNSIGNED, "unsigned int", objfile);
3932 objfile_type->builtin_long
3933 = init_type (TYPE_CODE_INT,
3934 gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
3935 0, "long", objfile);
3936 objfile_type->builtin_unsigned_long
3937 = init_type (TYPE_CODE_INT,
3938 gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
3939 TYPE_FLAG_UNSIGNED, "unsigned long", objfile);
3940 objfile_type->builtin_long_long
3941 = init_type (TYPE_CODE_INT,
3942 gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
3943 0, "long long", objfile);
3944 objfile_type->builtin_unsigned_long_long
3945 = init_type (TYPE_CODE_INT,
3946 gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
3947 TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
3949 objfile_type->builtin_float
3950 = init_type (TYPE_CODE_FLT,
3951 gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT,
3952 0, "float", objfile);
3953 TYPE_FLOATFORMAT (objfile_type->builtin_float)
3954 = gdbarch_float_format (gdbarch);
3955 objfile_type->builtin_double
3956 = init_type (TYPE_CODE_FLT,
3957 gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT,
3958 0, "double", objfile);
3959 TYPE_FLOATFORMAT (objfile_type->builtin_double)
3960 = gdbarch_double_format (gdbarch);
3961 objfile_type->builtin_long_double
3962 = init_type (TYPE_CODE_FLT,
3963 gdbarch_long_double_bit (gdbarch) / TARGET_CHAR_BIT,
3964 0, "long double", objfile);
3965 TYPE_FLOATFORMAT (objfile_type->builtin_long_double)
3966 = gdbarch_long_double_format (gdbarch);
3968 /* This type represents a type that was unrecognized in symbol read-in. */
3969 objfile_type->builtin_error
3970 = init_type (TYPE_CODE_ERROR, 0, 0, "<unknown type>", objfile);
3972 /* The following set of types is used for symbols with no
3973 debug information. */
3974 objfile_type->nodebug_text_symbol
3975 = init_type (TYPE_CODE_FUNC, 1, 0,
3976 "<text variable, no debug info>", objfile);
3977 TYPE_TARGET_TYPE (objfile_type->nodebug_text_symbol)
3978 = objfile_type->builtin_int;
3979 objfile_type->nodebug_text_gnu_ifunc_symbol
3980 = init_type (TYPE_CODE_FUNC, 1, TYPE_FLAG_GNU_IFUNC,
3981 "<text gnu-indirect-function variable, no debug info>",
3983 TYPE_TARGET_TYPE (objfile_type->nodebug_text_gnu_ifunc_symbol)
3984 = objfile_type->nodebug_text_symbol;
3985 objfile_type->nodebug_got_plt_symbol
3986 = init_type (TYPE_CODE_PTR, gdbarch_addr_bit (gdbarch) / 8, 0,
3987 "<text from jump slot in .got.plt, no debug info>",
3989 TYPE_TARGET_TYPE (objfile_type->nodebug_got_plt_symbol)
3990 = objfile_type->nodebug_text_symbol;
3991 objfile_type->nodebug_data_symbol
3992 = init_type (TYPE_CODE_INT,
3993 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
3994 "<data variable, no debug info>", objfile);
3995 objfile_type->nodebug_unknown_symbol
3996 = init_type (TYPE_CODE_INT, 1, 0,
3997 "<variable (not text or data), no debug info>", objfile);
3998 objfile_type->nodebug_tls_symbol
3999 = init_type (TYPE_CODE_INT,
4000 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
4001 "<thread local variable, no debug info>", objfile);
4003 /* NOTE: on some targets, addresses and pointers are not necessarily
4004 the same --- for example, on the D10V, pointers are 16 bits long,
4005 but addresses are 32 bits long. See doc/gdbint.texinfo,
4006 ``Pointers Are Not Always Addresses''.
4009 - gdb's `struct type' always describes the target's
4011 - gdb's `struct value' objects should always hold values in
4013 - gdb's CORE_ADDR values are addresses in the unified virtual
4014 address space that the assembler and linker work with. Thus,
4015 since target_read_memory takes a CORE_ADDR as an argument, it
4016 can access any memory on the target, even if the processor has
4017 separate code and data address spaces.
4020 - If v is a value holding a D10V code pointer, its contents are
4021 in target form: a big-endian address left-shifted two bits.
4022 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
4023 sizeof (void *) == 2 on the target.
4025 In this context, objfile_type->builtin_core_addr is a bit odd:
4026 it's a target type for a value the target will never see. It's
4027 only used to hold the values of (typeless) linker symbols, which
4028 are indeed in the unified virtual address space. */
4030 objfile_type->builtin_core_addr
4031 = init_type (TYPE_CODE_INT,
4032 gdbarch_addr_bit (gdbarch) / 8,
4033 TYPE_FLAG_UNSIGNED, "__CORE_ADDR", objfile);
4035 set_objfile_data (objfile, objfile_type_data, objfile_type);
4036 return objfile_type;
4040 extern void _initialize_gdbtypes (void);
4042 _initialize_gdbtypes (void)
4044 gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
4045 objfile_type_data = register_objfile_data ();
4047 add_setshow_zuinteger_cmd ("overload", no_class, &overload_debug,
4048 _("Set debugging of C++ overloading."),
4049 _("Show debugging of C++ overloading."),
4050 _("When enabled, ranking of the "
4051 "functions is displayed."),
4053 show_overload_debug,
4054 &setdebuglist, &showdebuglist);
4056 /* Add user knob for controlling resolution of opaque types. */
4057 add_setshow_boolean_cmd ("opaque-type-resolution", class_support,
4058 &opaque_type_resolution,
4059 _("Set resolution of opaque struct/class/union"
4060 " types (if set before loading symbols)."),
4061 _("Show resolution of opaque struct/class/union"
4062 " types (if set before loading symbols)."),
4064 show_opaque_type_resolution,
4065 &setlist, &showlist);