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
113 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;
128 show_overload_debug (struct ui_file *file, int from_tty,
129 struct cmd_list_element *c, const char *value)
131 fprintf_filtered (file, _("Debugging of C++ overloading is %s.\n"),
139 }; /* Maximum extension is 128! FIXME */
141 static void print_bit_vector (B_TYPE *, int);
142 static void print_arg_types (struct field *, int, int);
143 static void dump_fn_fieldlists (struct type *, int);
144 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;
228 /* Alloc a new type instance structure, fill it with some defaults,
229 and point it at OLDTYPE. Allocate the new type instance from the
230 same place as OLDTYPE. */
233 alloc_type_instance (struct type *oldtype)
237 /* Allocate the structure. */
239 if (! TYPE_OBJFILE_OWNED (oldtype))
240 type = XZALLOC (struct type);
242 type = OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype)->objfile_obstack,
245 TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype);
247 TYPE_CHAIN (type) = type; /* Chain back to itself for now. */
252 /* Clear all remnants of the previous type at TYPE, in preparation for
253 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! Assumes the machine has only one representation for pointers! */
318 = gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
319 TYPE_CODE (ntype) = TYPE_CODE_PTR;
321 /* Mark pointers as unsigned. The target converts between pointers
322 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
323 gdbarch_address_to_pointer. */
324 TYPE_UNSIGNED (ntype) = 1;
326 /* Update the length of all the other variants of this type. */
327 chain = TYPE_CHAIN (ntype);
328 while (chain != ntype)
330 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
331 chain = TYPE_CHAIN (chain);
337 /* Given a type TYPE, return a type of pointers to that type.
338 May need to construct such a type if this is the first use. */
341 lookup_pointer_type (struct type *type)
343 return make_pointer_type (type, (struct type **) 0);
346 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
347 points to a pointer to memory where the reference type should be
348 stored. If *TYPEPTR is zero, update it to point to the reference
349 type we return. We allocate new memory if needed. */
352 make_reference_type (struct type *type, struct type **typeptr)
354 struct type *ntype; /* New type */
357 ntype = TYPE_REFERENCE_TYPE (type);
362 return ntype; /* Don't care about alloc,
363 and have new type. */
364 else if (*typeptr == 0)
366 *typeptr = ntype; /* Tracking alloc, and have new type. */
371 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
373 ntype = alloc_type_copy (type);
377 else /* We have storage, but need to reset it. */
380 chain = TYPE_CHAIN (ntype);
382 TYPE_CHAIN (ntype) = chain;
385 TYPE_TARGET_TYPE (ntype) = type;
386 TYPE_REFERENCE_TYPE (type) = ntype;
388 /* FIXME! Assume the machine has only one representation for
389 references, and that it matches the (only) representation for
392 TYPE_LENGTH (ntype) =
393 gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
394 TYPE_CODE (ntype) = TYPE_CODE_REF;
396 if (!TYPE_REFERENCE_TYPE (type)) /* Remember it, if don't have one. */
397 TYPE_REFERENCE_TYPE (type) = ntype;
399 /* Update the length of all the other variants of this type. */
400 chain = TYPE_CHAIN (ntype);
401 while (chain != ntype)
403 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
404 chain = TYPE_CHAIN (chain);
410 /* Same as above, but caller doesn't care about memory allocation
414 lookup_reference_type (struct type *type)
416 return make_reference_type (type, (struct type **) 0);
419 /* Lookup a function type that returns type TYPE. TYPEPTR, if
420 nonzero, points to a pointer to memory where the function type
421 should be stored. If *TYPEPTR is zero, update it to point to the
422 function type we return. We allocate new memory if needed. */
425 make_function_type (struct type *type, struct type **typeptr)
427 struct type *ntype; /* New type */
429 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
431 ntype = alloc_type_copy (type);
435 else /* We have storage, but need to reset it. */
441 TYPE_TARGET_TYPE (ntype) = type;
443 TYPE_LENGTH (ntype) = 1;
444 TYPE_CODE (ntype) = TYPE_CODE_FUNC;
446 INIT_FUNC_SPECIFIC (ntype);
451 /* Given a type TYPE, return a type of functions that return that type.
452 May need to construct such a type if this is the first use. */
455 lookup_function_type (struct type *type)
457 return make_function_type (type, (struct type **) 0);
460 /* Given a type TYPE and argument types, return the appropriate
461 function type. If the final type in PARAM_TYPES is NULL, make a
465 lookup_function_type_with_arguments (struct type *type,
467 struct type **param_types)
469 struct type *fn = make_function_type (type, (struct type **) 0);
474 if (param_types[nparams - 1] == NULL)
477 TYPE_VARARGS (fn) = 1;
479 else if (TYPE_CODE (check_typedef (param_types[nparams - 1]))
483 /* Caller should have ensured this. */
484 gdb_assert (nparams == 0);
485 TYPE_PROTOTYPED (fn) = 1;
489 TYPE_NFIELDS (fn) = nparams;
490 TYPE_FIELDS (fn) = TYPE_ZALLOC (fn, nparams * sizeof (struct field));
491 for (i = 0; i < nparams; ++i)
492 TYPE_FIELD_TYPE (fn, i) = param_types[i];
497 /* Identify address space identifier by name --
498 return the integer flag defined in gdbtypes.h. */
501 address_space_name_to_int (struct gdbarch *gdbarch, char *space_identifier)
505 /* Check for known address space delimiters. */
506 if (!strcmp (space_identifier, "code"))
507 return TYPE_INSTANCE_FLAG_CODE_SPACE;
508 else if (!strcmp (space_identifier, "data"))
509 return TYPE_INSTANCE_FLAG_DATA_SPACE;
510 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch)
511 && gdbarch_address_class_name_to_type_flags (gdbarch,
516 error (_("Unknown address space specifier: \"%s\""), space_identifier);
519 /* Identify address space identifier by integer flag as defined in
520 gdbtypes.h -- return the string version of the adress space name. */
523 address_space_int_to_name (struct gdbarch *gdbarch, int space_flag)
525 if (space_flag & TYPE_INSTANCE_FLAG_CODE_SPACE)
527 else if (space_flag & TYPE_INSTANCE_FLAG_DATA_SPACE)
529 else if ((space_flag & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
530 && gdbarch_address_class_type_flags_to_name_p (gdbarch))
531 return gdbarch_address_class_type_flags_to_name (gdbarch, space_flag);
536 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
538 If STORAGE is non-NULL, create the new type instance there.
539 STORAGE must be in the same obstack as TYPE. */
542 make_qualified_type (struct type *type, int new_flags,
543 struct type *storage)
550 if (TYPE_INSTANCE_FLAGS (ntype) == new_flags)
552 ntype = TYPE_CHAIN (ntype);
554 while (ntype != type);
556 /* Create a new type instance. */
558 ntype = alloc_type_instance (type);
561 /* If STORAGE was provided, it had better be in the same objfile
562 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
563 if one objfile is freed and the other kept, we'd have
564 dangling pointers. */
565 gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage));
568 TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type);
569 TYPE_CHAIN (ntype) = ntype;
572 /* Pointers or references to the original type are not relevant to
574 TYPE_POINTER_TYPE (ntype) = (struct type *) 0;
575 TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0;
577 /* Chain the new qualified type to the old type. */
578 TYPE_CHAIN (ntype) = TYPE_CHAIN (type);
579 TYPE_CHAIN (type) = ntype;
581 /* Now set the instance flags and return the new type. */
582 TYPE_INSTANCE_FLAGS (ntype) = new_flags;
584 /* Set length of new type to that of the original type. */
585 TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
590 /* Make an address-space-delimited variant of a type -- a type that
591 is identical to the one supplied except that it has an address
592 space attribute attached to it (such as "code" or "data").
594 The space attributes "code" and "data" are for Harvard
595 architectures. The address space attributes are for architectures
596 which have alternately sized pointers or pointers with alternate
600 make_type_with_address_space (struct type *type, int space_flag)
602 int new_flags = ((TYPE_INSTANCE_FLAGS (type)
603 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
604 | TYPE_INSTANCE_FLAG_DATA_SPACE
605 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL))
608 return make_qualified_type (type, new_flags, NULL);
611 /* Make a "c-v" variant of a type -- a type that is identical to the
612 one supplied except that it may have const or volatile attributes
613 CNST is a flag for setting the const attribute
614 VOLTL is a flag for setting the volatile attribute
615 TYPE is the base type whose variant we are creating.
617 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
618 storage to hold the new qualified type; *TYPEPTR and TYPE must be
619 in the same objfile. Otherwise, allocate fresh memory for the new
620 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
621 new type we construct. */
624 make_cv_type (int cnst, int voltl,
626 struct type **typeptr)
628 struct type *ntype; /* New type */
630 int new_flags = (TYPE_INSTANCE_FLAGS (type)
631 & ~(TYPE_INSTANCE_FLAG_CONST
632 | TYPE_INSTANCE_FLAG_VOLATILE));
635 new_flags |= TYPE_INSTANCE_FLAG_CONST;
638 new_flags |= TYPE_INSTANCE_FLAG_VOLATILE;
640 if (typeptr && *typeptr != NULL)
642 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
643 a C-V variant chain that threads across objfiles: if one
644 objfile gets freed, then the other has a broken C-V chain.
646 This code used to try to copy over the main type from TYPE to
647 *TYPEPTR if they were in different objfiles, but that's
648 wrong, too: TYPE may have a field list or member function
649 lists, which refer to types of their own, etc. etc. The
650 whole shebang would need to be copied over recursively; you
651 can't have inter-objfile pointers. The only thing to do is
652 to leave stub types as stub types, and look them up afresh by
653 name each time you encounter them. */
654 gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type));
657 ntype = make_qualified_type (type, new_flags,
658 typeptr ? *typeptr : NULL);
666 /* Replace the contents of ntype with the type *type. This changes the
667 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
668 the changes are propogated to all types in the TYPE_CHAIN.
670 In order to build recursive types, it's inevitable that we'll need
671 to update types in place --- but this sort of indiscriminate
672 smashing is ugly, and needs to be replaced with something more
673 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
674 clear if more steps are needed. */
677 replace_type (struct type *ntype, struct type *type)
681 /* These two types had better be in the same objfile. Otherwise,
682 the assignment of one type's main type structure to the other
683 will produce a type with references to objects (names; field
684 lists; etc.) allocated on an objfile other than its own. */
685 gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (ntype));
687 *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
689 /* The type length is not a part of the main type. Update it for
690 each type on the variant chain. */
694 /* Assert that this element of the chain has no address-class bits
695 set in its flags. Such type variants might have type lengths
696 which are supposed to be different from the non-address-class
697 variants. This assertion shouldn't ever be triggered because
698 symbol readers which do construct address-class variants don't
699 call replace_type(). */
700 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0);
702 TYPE_LENGTH (chain) = TYPE_LENGTH (type);
703 chain = TYPE_CHAIN (chain);
705 while (ntype != chain);
707 /* Assert that the two types have equivalent instance qualifiers.
708 This should be true for at least all of our debug readers. */
709 gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type));
712 /* Implement direct support for MEMBER_TYPE in GNU C++.
713 May need to construct such a type if this is the first use.
714 The TYPE is the type of the member. The DOMAIN is the type
715 of the aggregate that the member belongs to. */
718 lookup_memberptr_type (struct type *type, struct type *domain)
722 mtype = alloc_type_copy (type);
723 smash_to_memberptr_type (mtype, domain, type);
727 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
730 lookup_methodptr_type (struct type *to_type)
734 mtype = alloc_type_copy (to_type);
735 smash_to_methodptr_type (mtype, to_type);
739 /* Allocate a stub method whose return type is TYPE. This apparently
740 happens for speed of symbol reading, since parsing out the
741 arguments to the method is cpu-intensive, the way we are doing it.
742 So, we will fill in arguments later. This always returns a fresh
746 allocate_stub_method (struct type *type)
750 mtype = alloc_type_copy (type);
751 TYPE_CODE (mtype) = TYPE_CODE_METHOD;
752 TYPE_LENGTH (mtype) = 1;
753 TYPE_STUB (mtype) = 1;
754 TYPE_TARGET_TYPE (mtype) = type;
755 /* _DOMAIN_TYPE (mtype) = unknown yet */
759 /* Create a range type using either a blank type supplied in
760 RESULT_TYPE, or creating a new type, inheriting the objfile from
763 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
764 to HIGH_BOUND, inclusive.
766 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
767 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
770 create_range_type (struct type *result_type, struct type *index_type,
771 LONGEST low_bound, LONGEST high_bound)
773 if (result_type == NULL)
774 result_type = alloc_type_copy (index_type);
775 TYPE_CODE (result_type) = TYPE_CODE_RANGE;
776 TYPE_TARGET_TYPE (result_type) = index_type;
777 if (TYPE_STUB (index_type))
778 TYPE_TARGET_STUB (result_type) = 1;
780 TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
781 TYPE_RANGE_DATA (result_type) = (struct range_bounds *)
782 TYPE_ZALLOC (result_type, sizeof (struct range_bounds));
783 TYPE_LOW_BOUND (result_type) = low_bound;
784 TYPE_HIGH_BOUND (result_type) = high_bound;
787 TYPE_UNSIGNED (result_type) = 1;
792 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
793 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
794 bounds will fit in LONGEST), or -1 otherwise. */
797 get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
799 CHECK_TYPEDEF (type);
800 switch (TYPE_CODE (type))
802 case TYPE_CODE_RANGE:
803 *lowp = TYPE_LOW_BOUND (type);
804 *highp = TYPE_HIGH_BOUND (type);
807 if (TYPE_NFIELDS (type) > 0)
809 /* The enums may not be sorted by value, so search all
813 *lowp = *highp = TYPE_FIELD_ENUMVAL (type, 0);
814 for (i = 0; i < TYPE_NFIELDS (type); i++)
816 if (TYPE_FIELD_ENUMVAL (type, i) < *lowp)
817 *lowp = TYPE_FIELD_ENUMVAL (type, i);
818 if (TYPE_FIELD_ENUMVAL (type, i) > *highp)
819 *highp = TYPE_FIELD_ENUMVAL (type, i);
822 /* Set unsigned indicator if warranted. */
825 TYPE_UNSIGNED (type) = 1;
839 if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */
841 if (!TYPE_UNSIGNED (type))
843 *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
847 /* ... fall through for unsigned ints ... */
850 /* This round-about calculation is to avoid shifting by
851 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
852 if TYPE_LENGTH (type) == sizeof (LONGEST). */
853 *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
854 *highp = (*highp - 1) | *highp;
861 /* Assuming TYPE is a simple, non-empty array type, compute its upper
862 and lower bound. Save the low bound into LOW_BOUND if not NULL.
863 Save the high bound into HIGH_BOUND if not NULL.
865 Return 1 if the operation was successful. Return zero otherwise,
866 in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
868 We now simply use get_discrete_bounds call to get the values
869 of the low and high bounds.
870 get_discrete_bounds can return three values:
871 1, meaning that index is a range,
872 0, meaning that index is a discrete type,
873 or -1 for failure. */
876 get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound)
878 struct type *index = TYPE_INDEX_TYPE (type);
886 res = get_discrete_bounds (index, &low, &high);
890 /* Check if the array bounds are undefined. */
892 && ((low_bound && TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type))
893 || (high_bound && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))))
905 /* Create an array type using either a blank type supplied in
906 RESULT_TYPE, or creating a new type, inheriting the objfile from
909 Elements will be of type ELEMENT_TYPE, the indices will be of type
912 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
913 sure it is TYPE_CODE_UNDEF before we bash it into an array
917 create_array_type (struct type *result_type,
918 struct type *element_type,
919 struct type *range_type)
921 LONGEST low_bound, high_bound;
923 if (result_type == NULL)
924 result_type = alloc_type_copy (range_type);
926 TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
927 TYPE_TARGET_TYPE (result_type) = element_type;
928 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
929 low_bound = high_bound = 0;
930 CHECK_TYPEDEF (element_type);
931 /* Be careful when setting the array length. Ada arrays can be
932 empty arrays with the high_bound being smaller than the low_bound.
933 In such cases, the array length should be zero. */
934 if (high_bound < low_bound)
935 TYPE_LENGTH (result_type) = 0;
937 TYPE_LENGTH (result_type) =
938 TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
939 TYPE_NFIELDS (result_type) = 1;
940 TYPE_FIELDS (result_type) =
941 (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
942 TYPE_INDEX_TYPE (result_type) = range_type;
943 TYPE_VPTR_FIELDNO (result_type) = -1;
945 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays. */
946 if (TYPE_LENGTH (result_type) == 0)
947 TYPE_TARGET_STUB (result_type) = 1;
953 lookup_array_range_type (struct type *element_type,
954 int low_bound, int high_bound)
956 struct gdbarch *gdbarch = get_type_arch (element_type);
957 struct type *index_type = builtin_type (gdbarch)->builtin_int;
958 struct type *range_type
959 = create_range_type (NULL, index_type, low_bound, high_bound);
961 return create_array_type (NULL, element_type, range_type);
964 /* Create a string type using either a blank type supplied in
965 RESULT_TYPE, or creating a new type. String types are similar
966 enough to array of char types that we can use create_array_type to
967 build the basic type and then bash it into a string type.
969 For fixed length strings, the range type contains 0 as the lower
970 bound and the length of the string minus one as the upper bound.
972 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
973 sure it is TYPE_CODE_UNDEF before we bash it into a string
977 create_string_type (struct type *result_type,
978 struct type *string_char_type,
979 struct type *range_type)
981 result_type = create_array_type (result_type,
984 TYPE_CODE (result_type) = TYPE_CODE_STRING;
989 lookup_string_range_type (struct type *string_char_type,
990 int low_bound, int high_bound)
992 struct type *result_type;
994 result_type = lookup_array_range_type (string_char_type,
995 low_bound, high_bound);
996 TYPE_CODE (result_type) = TYPE_CODE_STRING;
1001 create_set_type (struct type *result_type, struct type *domain_type)
1003 if (result_type == NULL)
1004 result_type = alloc_type_copy (domain_type);
1006 TYPE_CODE (result_type) = TYPE_CODE_SET;
1007 TYPE_NFIELDS (result_type) = 1;
1008 TYPE_FIELDS (result_type) = TYPE_ZALLOC (result_type, sizeof (struct field));
1010 if (!TYPE_STUB (domain_type))
1012 LONGEST low_bound, high_bound, bit_length;
1014 if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
1015 low_bound = high_bound = 0;
1016 bit_length = high_bound - low_bound + 1;
1017 TYPE_LENGTH (result_type)
1018 = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
1020 TYPE_UNSIGNED (result_type) = 1;
1022 TYPE_FIELD_TYPE (result_type, 0) = domain_type;
1027 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
1028 and any array types nested inside it. */
1031 make_vector_type (struct type *array_type)
1033 struct type *inner_array, *elt_type;
1036 /* Find the innermost array type, in case the array is
1037 multi-dimensional. */
1038 inner_array = array_type;
1039 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
1040 inner_array = TYPE_TARGET_TYPE (inner_array);
1042 elt_type = TYPE_TARGET_TYPE (inner_array);
1043 if (TYPE_CODE (elt_type) == TYPE_CODE_INT)
1045 flags = TYPE_INSTANCE_FLAGS (elt_type) | TYPE_INSTANCE_FLAG_NOTTEXT;
1046 elt_type = make_qualified_type (elt_type, flags, NULL);
1047 TYPE_TARGET_TYPE (inner_array) = elt_type;
1050 TYPE_VECTOR (array_type) = 1;
1054 init_vector_type (struct type *elt_type, int n)
1056 struct type *array_type;
1058 array_type = lookup_array_range_type (elt_type, 0, n - 1);
1059 make_vector_type (array_type);
1063 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
1064 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1065 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1066 TYPE doesn't include the offset (that's the value of the MEMBER
1067 itself), but does include the structure type into which it points
1070 When "smashing" the type, we preserve the objfile that the old type
1071 pointed to, since we aren't changing where the type is actually
1075 smash_to_memberptr_type (struct type *type, struct type *domain,
1076 struct type *to_type)
1079 TYPE_TARGET_TYPE (type) = to_type;
1080 TYPE_DOMAIN_TYPE (type) = domain;
1081 /* Assume that a data member pointer is the same size as a normal
1084 = gdbarch_ptr_bit (get_type_arch (to_type)) / TARGET_CHAR_BIT;
1085 TYPE_CODE (type) = TYPE_CODE_MEMBERPTR;
1088 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1090 When "smashing" the type, we preserve the objfile that the old type
1091 pointed to, since we aren't changing where the type is actually
1095 smash_to_methodptr_type (struct type *type, struct type *to_type)
1098 TYPE_TARGET_TYPE (type) = to_type;
1099 TYPE_DOMAIN_TYPE (type) = TYPE_DOMAIN_TYPE (to_type);
1100 TYPE_LENGTH (type) = cplus_method_ptr_size (to_type);
1101 TYPE_CODE (type) = TYPE_CODE_METHODPTR;
1104 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
1105 METHOD just means `function that gets an extra "this" argument'.
1107 When "smashing" the type, we preserve the objfile that the old type
1108 pointed to, since we aren't changing where the type is actually
1112 smash_to_method_type (struct type *type, struct type *domain,
1113 struct type *to_type, struct field *args,
1114 int nargs, int varargs)
1117 TYPE_TARGET_TYPE (type) = to_type;
1118 TYPE_DOMAIN_TYPE (type) = domain;
1119 TYPE_FIELDS (type) = args;
1120 TYPE_NFIELDS (type) = nargs;
1122 TYPE_VARARGS (type) = 1;
1123 TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
1124 TYPE_CODE (type) = TYPE_CODE_METHOD;
1127 /* Return a typename for a struct/union/enum type without "struct ",
1128 "union ", or "enum ". If the type has a NULL name, return NULL. */
1131 type_name_no_tag (const struct type *type)
1133 if (TYPE_TAG_NAME (type) != NULL)
1134 return TYPE_TAG_NAME (type);
1136 /* Is there code which expects this to return the name if there is
1137 no tag name? My guess is that this is mainly used for C++ in
1138 cases where the two will always be the same. */
1139 return TYPE_NAME (type);
1142 /* A wrapper of type_name_no_tag which calls error if the type is anonymous.
1143 Since GCC PR debug/47510 DWARF provides associated information to detect the
1144 anonymous class linkage name from its typedef.
1146 Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
1150 type_name_no_tag_or_error (struct type *type)
1152 struct type *saved_type = type;
1154 struct objfile *objfile;
1156 CHECK_TYPEDEF (type);
1158 name = type_name_no_tag (type);
1162 name = type_name_no_tag (saved_type);
1163 objfile = TYPE_OBJFILE (saved_type);
1164 error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
1165 name ? name : "<anonymous>", objfile ? objfile->name : "<arch>");
1168 /* Lookup a typedef or primitive type named NAME, visible in lexical
1169 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1170 suitably defined. */
1173 lookup_typename (const struct language_defn *language,
1174 struct gdbarch *gdbarch, const char *name,
1175 const struct block *block, int noerr)
1180 sym = lookup_symbol (name, block, VAR_DOMAIN, 0);
1181 if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1182 return SYMBOL_TYPE (sym);
1184 type = language_lookup_primitive_type_by_name (language, gdbarch, name);
1190 error (_("No type named %s."), name);
1194 lookup_unsigned_typename (const struct language_defn *language,
1195 struct gdbarch *gdbarch, const char *name)
1197 char *uns = alloca (strlen (name) + 10);
1199 strcpy (uns, "unsigned ");
1200 strcpy (uns + 9, name);
1201 return lookup_typename (language, gdbarch, uns, (struct block *) NULL, 0);
1205 lookup_signed_typename (const struct language_defn *language,
1206 struct gdbarch *gdbarch, const char *name)
1209 char *uns = alloca (strlen (name) + 8);
1211 strcpy (uns, "signed ");
1212 strcpy (uns + 7, name);
1213 t = lookup_typename (language, gdbarch, uns, (struct block *) NULL, 1);
1214 /* If we don't find "signed FOO" just try again with plain "FOO". */
1217 return lookup_typename (language, gdbarch, name, (struct block *) NULL, 0);
1220 /* Lookup a structure type named "struct NAME",
1221 visible in lexical block BLOCK. */
1224 lookup_struct (const char *name, struct block *block)
1228 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1232 error (_("No struct type named %s."), name);
1234 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1236 error (_("This context has class, union or enum %s, not a struct."),
1239 return (SYMBOL_TYPE (sym));
1242 /* Lookup a union type named "union NAME",
1243 visible in lexical block BLOCK. */
1246 lookup_union (const char *name, struct block *block)
1251 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1254 error (_("No union type named %s."), name);
1256 t = SYMBOL_TYPE (sym);
1258 if (TYPE_CODE (t) == TYPE_CODE_UNION)
1261 /* If we get here, it's not a union. */
1262 error (_("This context has class, struct or enum %s, not a union."),
1266 /* Lookup an enum type named "enum NAME",
1267 visible in lexical block BLOCK. */
1270 lookup_enum (const char *name, struct block *block)
1274 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1277 error (_("No enum type named %s."), name);
1279 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
1281 error (_("This context has class, struct or union %s, not an enum."),
1284 return (SYMBOL_TYPE (sym));
1287 /* Lookup a template type named "template NAME<TYPE>",
1288 visible in lexical block BLOCK. */
1291 lookup_template_type (char *name, struct type *type,
1292 struct block *block)
1295 char *nam = (char *)
1296 alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4);
1300 strcat (nam, TYPE_NAME (type));
1301 strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
1303 sym = lookup_symbol (nam, block, VAR_DOMAIN, 0);
1307 error (_("No template type named %s."), name);
1309 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1311 error (_("This context has class, union or enum %s, not a struct."),
1314 return (SYMBOL_TYPE (sym));
1317 /* Given a type TYPE, lookup the type of the component of type named
1320 TYPE can be either a struct or union, or a pointer or reference to
1321 a struct or union. If it is a pointer or reference, its target
1322 type is automatically used. Thus '.' and '->' are interchangable,
1323 as specified for the definitions of the expression element types
1324 STRUCTOP_STRUCT and STRUCTOP_PTR.
1326 If NOERR is nonzero, return zero if NAME is not suitably defined.
1327 If NAME is the name of a baseclass type, return that type. */
1330 lookup_struct_elt_type (struct type *type, char *name, int noerr)
1337 CHECK_TYPEDEF (type);
1338 if (TYPE_CODE (type) != TYPE_CODE_PTR
1339 && TYPE_CODE (type) != TYPE_CODE_REF)
1341 type = TYPE_TARGET_TYPE (type);
1344 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1345 && TYPE_CODE (type) != TYPE_CODE_UNION)
1347 typename = type_to_string (type);
1348 make_cleanup (xfree, typename);
1349 error (_("Type %s is not a structure or union type."), typename);
1353 /* FIXME: This change put in by Michael seems incorrect for the case
1354 where the structure tag name is the same as the member name.
1355 I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
1356 foo; } bell;" Disabled by fnf. */
1360 typename = type_name_no_tag (type);
1361 if (typename != NULL && strcmp (typename, name) == 0)
1366 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1368 const char *t_field_name = TYPE_FIELD_NAME (type, i);
1370 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1372 return TYPE_FIELD_TYPE (type, i);
1374 else if (!t_field_name || *t_field_name == '\0')
1376 struct type *subtype
1377 = lookup_struct_elt_type (TYPE_FIELD_TYPE (type, i), name, 1);
1379 if (subtype != NULL)
1384 /* OK, it's not in this class. Recursively check the baseclasses. */
1385 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1389 t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 1);
1401 typename = type_to_string (type);
1402 make_cleanup (xfree, typename);
1403 error (_("Type %s has no component named %s."), typename, name);
1406 /* Lookup the vptr basetype/fieldno values for TYPE.
1407 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1408 vptr_fieldno. Also, if found and basetype is from the same objfile,
1410 If not found, return -1 and ignore BASETYPEP.
1411 Callers should be aware that in some cases (for example,
1412 the type or one of its baseclasses is a stub type and we are
1413 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1414 this function will not be able to find the
1415 virtual function table pointer, and vptr_fieldno will remain -1 and
1416 vptr_basetype will remain NULL or incomplete. */
1419 get_vptr_fieldno (struct type *type, struct type **basetypep)
1421 CHECK_TYPEDEF (type);
1423 if (TYPE_VPTR_FIELDNO (type) < 0)
1427 /* We must start at zero in case the first (and only) baseclass
1428 is virtual (and hence we cannot share the table pointer). */
1429 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1431 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
1433 struct type *basetype;
1435 fieldno = get_vptr_fieldno (baseclass, &basetype);
1438 /* If the type comes from a different objfile we can't cache
1439 it, it may have a different lifetime. PR 2384 */
1440 if (TYPE_OBJFILE (type) == TYPE_OBJFILE (basetype))
1442 TYPE_VPTR_FIELDNO (type) = fieldno;
1443 TYPE_VPTR_BASETYPE (type) = basetype;
1446 *basetypep = basetype;
1457 *basetypep = TYPE_VPTR_BASETYPE (type);
1458 return TYPE_VPTR_FIELDNO (type);
1463 stub_noname_complaint (void)
1465 complaint (&symfile_complaints, _("stub type has NULL name"));
1468 /* Find the real type of TYPE. This function returns the real type,
1469 after removing all layers of typedefs, and completing opaque or stub
1470 types. Completion changes the TYPE argument, but stripping of
1473 Instance flags (e.g. const/volatile) are preserved as typedefs are
1474 stripped. If necessary a new qualified form of the underlying type
1477 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
1478 not been computed and we're either in the middle of reading symbols, or
1479 there was no name for the typedef in the debug info.
1481 NOTE: Lookup of opaque types can throw errors for invalid symbol files.
1482 QUITs in the symbol reading code can also throw.
1483 Thus this function can throw an exception.
1485 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
1488 If this is a stubbed struct (i.e. declared as struct foo *), see if
1489 we can find a full definition in some other file. If so, copy this
1490 definition, so we can use it in future. There used to be a comment
1491 (but not any code) that if we don't find a full definition, we'd
1492 set a flag so we don't spend time in the future checking the same
1493 type. That would be a mistake, though--we might load in more
1494 symbols which contain a full definition for the type. */
1497 check_typedef (struct type *type)
1499 struct type *orig_type = type;
1500 /* While we're removing typedefs, we don't want to lose qualifiers.
1501 E.g., const/volatile. */
1502 int instance_flags = TYPE_INSTANCE_FLAGS (type);
1506 while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1508 if (!TYPE_TARGET_TYPE (type))
1513 /* It is dangerous to call lookup_symbol if we are currently
1514 reading a symtab. Infinite recursion is one danger. */
1515 if (currently_reading_symtab)
1516 return make_qualified_type (type, instance_flags, NULL);
1518 name = type_name_no_tag (type);
1519 /* FIXME: shouldn't we separately check the TYPE_NAME and
1520 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1521 VAR_DOMAIN as appropriate? (this code was written before
1522 TYPE_NAME and TYPE_TAG_NAME were separate). */
1525 stub_noname_complaint ();
1526 return make_qualified_type (type, instance_flags, NULL);
1528 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
1530 TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
1531 else /* TYPE_CODE_UNDEF */
1532 TYPE_TARGET_TYPE (type) = alloc_type_arch (get_type_arch (type));
1534 type = TYPE_TARGET_TYPE (type);
1536 /* Preserve the instance flags as we traverse down the typedef chain.
1538 Handling address spaces/classes is nasty, what do we do if there's a
1540 E.g., what if an outer typedef marks the type as class_1 and an inner
1541 typedef marks the type as class_2?
1542 This is the wrong place to do such error checking. We leave it to
1543 the code that created the typedef in the first place to flag the
1544 error. We just pick the outer address space (akin to letting the
1545 outer cast in a chain of casting win), instead of assuming
1546 "it can't happen". */
1548 const int ALL_SPACES = (TYPE_INSTANCE_FLAG_CODE_SPACE
1549 | TYPE_INSTANCE_FLAG_DATA_SPACE);
1550 const int ALL_CLASSES = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL;
1551 int new_instance_flags = TYPE_INSTANCE_FLAGS (type);
1553 /* Treat code vs data spaces and address classes separately. */
1554 if ((instance_flags & ALL_SPACES) != 0)
1555 new_instance_flags &= ~ALL_SPACES;
1556 if ((instance_flags & ALL_CLASSES) != 0)
1557 new_instance_flags &= ~ALL_CLASSES;
1559 instance_flags |= new_instance_flags;
1563 /* If this is a struct/class/union with no fields, then check
1564 whether a full definition exists somewhere else. This is for
1565 systems where a type definition with no fields is issued for such
1566 types, instead of identifying them as stub types in the first
1569 if (TYPE_IS_OPAQUE (type)
1570 && opaque_type_resolution
1571 && !currently_reading_symtab)
1573 const char *name = type_name_no_tag (type);
1574 struct type *newtype;
1578 stub_noname_complaint ();
1579 return make_qualified_type (type, instance_flags, NULL);
1581 newtype = lookup_transparent_type (name);
1585 /* If the resolved type and the stub are in the same
1586 objfile, then replace the stub type with the real deal.
1587 But if they're in separate objfiles, leave the stub
1588 alone; we'll just look up the transparent type every time
1589 we call check_typedef. We can't create pointers between
1590 types allocated to different objfiles, since they may
1591 have different lifetimes. Trying to copy NEWTYPE over to
1592 TYPE's objfile is pointless, too, since you'll have to
1593 move over any other types NEWTYPE refers to, which could
1594 be an unbounded amount of stuff. */
1595 if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type))
1596 type = make_qualified_type (newtype,
1597 TYPE_INSTANCE_FLAGS (type),
1603 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1605 else if (TYPE_STUB (type) && !currently_reading_symtab)
1607 const char *name = type_name_no_tag (type);
1608 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1609 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1610 as appropriate? (this code was written before TYPE_NAME and
1611 TYPE_TAG_NAME were separate). */
1616 stub_noname_complaint ();
1617 return make_qualified_type (type, instance_flags, NULL);
1619 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
1622 /* Same as above for opaque types, we can replace the stub
1623 with the complete type only if they are in the same
1625 if (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type))
1626 type = make_qualified_type (SYMBOL_TYPE (sym),
1627 TYPE_INSTANCE_FLAGS (type),
1630 type = SYMBOL_TYPE (sym);
1634 if (TYPE_TARGET_STUB (type))
1636 struct type *range_type;
1637 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1639 if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type))
1641 /* Nothing we can do. */
1643 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
1644 && TYPE_NFIELDS (type) == 1
1645 && (TYPE_CODE (range_type = TYPE_INDEX_TYPE (type))
1646 == TYPE_CODE_RANGE))
1648 /* Now recompute the length of the array type, based on its
1649 number of elements and the target type's length.
1650 Watch out for Ada null Ada arrays where the high bound
1651 is smaller than the low bound. */
1652 const LONGEST low_bound = TYPE_LOW_BOUND (range_type);
1653 const LONGEST high_bound = TYPE_HIGH_BOUND (range_type);
1656 if (high_bound < low_bound)
1660 /* For now, we conservatively take the array length to be 0
1661 if its length exceeds UINT_MAX. The code below assumes
1662 that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
1663 which is technically not guaranteed by C, but is usually true
1664 (because it would be true if x were unsigned with its
1665 high-order bit on). It uses the fact that
1666 high_bound-low_bound is always representable in
1667 ULONGEST and that if high_bound-low_bound+1 overflows,
1668 it overflows to 0. We must change these tests if we
1669 decide to increase the representation of TYPE_LENGTH
1670 from unsigned int to ULONGEST. */
1671 ULONGEST ulow = low_bound, uhigh = high_bound;
1672 ULONGEST tlen = TYPE_LENGTH (target_type);
1674 len = tlen * (uhigh - ulow + 1);
1675 if (tlen == 0 || (len / tlen - 1 + ulow) != uhigh
1679 TYPE_LENGTH (type) = len;
1680 TYPE_TARGET_STUB (type) = 0;
1682 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
1684 TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
1685 TYPE_TARGET_STUB (type) = 0;
1689 type = make_qualified_type (type, instance_flags, NULL);
1691 /* Cache TYPE_LENGTH for future use. */
1692 TYPE_LENGTH (orig_type) = TYPE_LENGTH (type);
1697 /* Parse a type expression in the string [P..P+LENGTH). If an error
1698 occurs, silently return a void type. */
1700 static struct type *
1701 safe_parse_type (struct gdbarch *gdbarch, char *p, int length)
1703 struct ui_file *saved_gdb_stderr;
1704 struct type *type = NULL; /* Initialize to keep gcc happy. */
1705 volatile struct gdb_exception except;
1707 /* Suppress error messages. */
1708 saved_gdb_stderr = gdb_stderr;
1709 gdb_stderr = ui_file_new ();
1711 /* Call parse_and_eval_type() without fear of longjmp()s. */
1712 TRY_CATCH (except, RETURN_MASK_ERROR)
1714 type = parse_and_eval_type (p, length);
1717 if (except.reason < 0)
1718 type = builtin_type (gdbarch)->builtin_void;
1720 /* Stop suppressing error messages. */
1721 ui_file_delete (gdb_stderr);
1722 gdb_stderr = saved_gdb_stderr;
1727 /* Ugly hack to convert method stubs into method types.
1729 He ain't kiddin'. This demangles the name of the method into a
1730 string including argument types, parses out each argument type,
1731 generates a string casting a zero to that type, evaluates the
1732 string, and stuffs the resulting type into an argtype vector!!!
1733 Then it knows the type of the whole function (including argument
1734 types for overloading), which info used to be in the stab's but was
1735 removed to hack back the space required for them. */
1738 check_stub_method (struct type *type, int method_id, int signature_id)
1740 struct gdbarch *gdbarch = get_type_arch (type);
1742 char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
1743 char *demangled_name = cplus_demangle (mangled_name,
1744 DMGL_PARAMS | DMGL_ANSI);
1745 char *argtypetext, *p;
1746 int depth = 0, argcount = 1;
1747 struct field *argtypes;
1750 /* Make sure we got back a function string that we can use. */
1752 p = strchr (demangled_name, '(');
1756 if (demangled_name == NULL || p == NULL)
1757 error (_("Internal: Cannot demangle mangled name `%s'."),
1760 /* Now, read in the parameters that define this type. */
1765 if (*p == '(' || *p == '<')
1769 else if (*p == ')' || *p == '>')
1773 else if (*p == ',' && depth == 0)
1781 /* If we read one argument and it was ``void'', don't count it. */
1782 if (strncmp (argtypetext, "(void)", 6) == 0)
1785 /* We need one extra slot, for the THIS pointer. */
1787 argtypes = (struct field *)
1788 TYPE_ALLOC (type, (argcount + 1) * sizeof (struct field));
1791 /* Add THIS pointer for non-static methods. */
1792 f = TYPE_FN_FIELDLIST1 (type, method_id);
1793 if (TYPE_FN_FIELD_STATIC_P (f, signature_id))
1797 argtypes[0].type = lookup_pointer_type (type);
1801 if (*p != ')') /* () means no args, skip while. */
1806 if (depth <= 0 && (*p == ',' || *p == ')'))
1808 /* Avoid parsing of ellipsis, they will be handled below.
1809 Also avoid ``void'' as above. */
1810 if (strncmp (argtypetext, "...", p - argtypetext) != 0
1811 && strncmp (argtypetext, "void", p - argtypetext) != 0)
1813 argtypes[argcount].type =
1814 safe_parse_type (gdbarch, argtypetext, p - argtypetext);
1817 argtypetext = p + 1;
1820 if (*p == '(' || *p == '<')
1824 else if (*p == ')' || *p == '>')
1833 TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name;
1835 /* Now update the old "stub" type into a real type. */
1836 mtype = TYPE_FN_FIELD_TYPE (f, signature_id);
1837 TYPE_DOMAIN_TYPE (mtype) = type;
1838 TYPE_FIELDS (mtype) = argtypes;
1839 TYPE_NFIELDS (mtype) = argcount;
1840 TYPE_STUB (mtype) = 0;
1841 TYPE_FN_FIELD_STUB (f, signature_id) = 0;
1843 TYPE_VARARGS (mtype) = 1;
1845 xfree (demangled_name);
1848 /* This is the external interface to check_stub_method, above. This
1849 function unstubs all of the signatures for TYPE's METHOD_ID method
1850 name. After calling this function TYPE_FN_FIELD_STUB will be
1851 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1854 This function unfortunately can not die until stabs do. */
1857 check_stub_method_group (struct type *type, int method_id)
1859 int len = TYPE_FN_FIELDLIST_LENGTH (type, method_id);
1860 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
1861 int j, found_stub = 0;
1863 for (j = 0; j < len; j++)
1864 if (TYPE_FN_FIELD_STUB (f, j))
1867 check_stub_method (type, method_id, j);
1870 /* GNU v3 methods with incorrect names were corrected when we read
1871 in type information, because it was cheaper to do it then. The
1872 only GNU v2 methods with incorrect method names are operators and
1873 destructors; destructors were also corrected when we read in type
1876 Therefore the only thing we need to handle here are v2 operator
1878 if (found_stub && strncmp (TYPE_FN_FIELD_PHYSNAME (f, 0), "_Z", 2) != 0)
1881 char dem_opname[256];
1883 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
1885 dem_opname, DMGL_ANSI);
1887 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
1891 TYPE_FN_FIELDLIST_NAME (type, method_id) = xstrdup (dem_opname);
1895 /* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */
1896 const struct cplus_struct_type cplus_struct_default = { };
1899 allocate_cplus_struct_type (struct type *type)
1901 if (HAVE_CPLUS_STRUCT (type))
1902 /* Structure was already allocated. Nothing more to do. */
1905 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CPLUS_STUFF;
1906 TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
1907 TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
1908 *(TYPE_RAW_CPLUS_SPECIFIC (type)) = cplus_struct_default;
1911 const struct gnat_aux_type gnat_aux_default =
1914 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
1915 and allocate the associated gnat-specific data. The gnat-specific
1916 data is also initialized to gnat_aux_default. */
1919 allocate_gnat_aux_type (struct type *type)
1921 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_GNAT_STUFF;
1922 TYPE_GNAT_SPECIFIC (type) = (struct gnat_aux_type *)
1923 TYPE_ALLOC (type, sizeof (struct gnat_aux_type));
1924 *(TYPE_GNAT_SPECIFIC (type)) = gnat_aux_default;
1927 /* Helper function to initialize the standard scalar types.
1929 If NAME is non-NULL, then we make a copy of the string pointed
1930 to by name in the objfile_obstack for that objfile, and initialize
1931 the type name to that copy. There are places (mipsread.c in particular),
1932 where init_type is called with a NULL value for NAME). */
1935 init_type (enum type_code code, int length, int flags,
1936 char *name, struct objfile *objfile)
1940 type = alloc_type (objfile);
1941 TYPE_CODE (type) = code;
1942 TYPE_LENGTH (type) = length;
1944 gdb_assert (!(flags & (TYPE_FLAG_MIN - 1)));
1945 if (flags & TYPE_FLAG_UNSIGNED)
1946 TYPE_UNSIGNED (type) = 1;
1947 if (flags & TYPE_FLAG_NOSIGN)
1948 TYPE_NOSIGN (type) = 1;
1949 if (flags & TYPE_FLAG_STUB)
1950 TYPE_STUB (type) = 1;
1951 if (flags & TYPE_FLAG_TARGET_STUB)
1952 TYPE_TARGET_STUB (type) = 1;
1953 if (flags & TYPE_FLAG_STATIC)
1954 TYPE_STATIC (type) = 1;
1955 if (flags & TYPE_FLAG_PROTOTYPED)
1956 TYPE_PROTOTYPED (type) = 1;
1957 if (flags & TYPE_FLAG_INCOMPLETE)
1958 TYPE_INCOMPLETE (type) = 1;
1959 if (flags & TYPE_FLAG_VARARGS)
1960 TYPE_VARARGS (type) = 1;
1961 if (flags & TYPE_FLAG_VECTOR)
1962 TYPE_VECTOR (type) = 1;
1963 if (flags & TYPE_FLAG_STUB_SUPPORTED)
1964 TYPE_STUB_SUPPORTED (type) = 1;
1965 if (flags & TYPE_FLAG_FIXED_INSTANCE)
1966 TYPE_FIXED_INSTANCE (type) = 1;
1967 if (flags & TYPE_FLAG_GNU_IFUNC)
1968 TYPE_GNU_IFUNC (type) = 1;
1971 TYPE_NAME (type) = obsavestring (name, strlen (name),
1972 &objfile->objfile_obstack);
1976 if (name && strcmp (name, "char") == 0)
1977 TYPE_NOSIGN (type) = 1;
1981 case TYPE_CODE_STRUCT:
1982 case TYPE_CODE_UNION:
1983 case TYPE_CODE_NAMESPACE:
1984 INIT_CPLUS_SPECIFIC (type);
1987 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FLOATFORMAT;
1989 case TYPE_CODE_FUNC:
1990 INIT_FUNC_SPECIFIC (type);
1996 /* Queries on types. */
1999 can_dereference (struct type *t)
2001 /* FIXME: Should we return true for references as well as
2006 && TYPE_CODE (t) == TYPE_CODE_PTR
2007 && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
2011 is_integral_type (struct type *t)
2016 && ((TYPE_CODE (t) == TYPE_CODE_INT)
2017 || (TYPE_CODE (t) == TYPE_CODE_ENUM)
2018 || (TYPE_CODE (t) == TYPE_CODE_FLAGS)
2019 || (TYPE_CODE (t) == TYPE_CODE_CHAR)
2020 || (TYPE_CODE (t) == TYPE_CODE_RANGE)
2021 || (TYPE_CODE (t) == TYPE_CODE_BOOL)));
2024 /* Return true if TYPE is scalar. */
2027 is_scalar_type (struct type *type)
2029 CHECK_TYPEDEF (type);
2031 switch (TYPE_CODE (type))
2033 case TYPE_CODE_ARRAY:
2034 case TYPE_CODE_STRUCT:
2035 case TYPE_CODE_UNION:
2037 case TYPE_CODE_STRING:
2038 case TYPE_CODE_BITSTRING:
2045 /* Return true if T is scalar, or a composite type which in practice has
2046 the memory layout of a scalar type. E.g., an array or struct with only
2047 one scalar element inside it, or a union with only scalar elements. */
2050 is_scalar_type_recursive (struct type *t)
2054 if (is_scalar_type (t))
2056 /* Are we dealing with an array or string of known dimensions? */
2057 else if ((TYPE_CODE (t) == TYPE_CODE_ARRAY
2058 || TYPE_CODE (t) == TYPE_CODE_STRING) && TYPE_NFIELDS (t) == 1
2059 && TYPE_CODE (TYPE_INDEX_TYPE (t)) == TYPE_CODE_RANGE)
2061 LONGEST low_bound, high_bound;
2062 struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t));
2064 get_discrete_bounds (TYPE_INDEX_TYPE (t), &low_bound, &high_bound);
2066 return high_bound == low_bound && is_scalar_type_recursive (elt_type);
2068 /* Are we dealing with a struct with one element? */
2069 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT && TYPE_NFIELDS (t) == 1)
2070 return is_scalar_type_recursive (TYPE_FIELD_TYPE (t, 0));
2071 else if (TYPE_CODE (t) == TYPE_CODE_UNION)
2073 int i, n = TYPE_NFIELDS (t);
2075 /* If all elements of the union are scalar, then the union is scalar. */
2076 for (i = 0; i < n; i++)
2077 if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t, i)))
2086 /* A helper function which returns true if types A and B represent the
2087 "same" class type. This is true if the types have the same main
2088 type, or the same name. */
2091 class_types_same_p (const struct type *a, const struct type *b)
2093 return (TYPE_MAIN_TYPE (a) == TYPE_MAIN_TYPE (b)
2094 || (TYPE_NAME (a) && TYPE_NAME (b)
2095 && !strcmp (TYPE_NAME (a), TYPE_NAME (b))));
2098 /* If BASE is an ancestor of DCLASS return the distance between them.
2099 otherwise return -1;
2103 class B: public A {};
2104 class C: public B {};
2107 distance_to_ancestor (A, A, 0) = 0
2108 distance_to_ancestor (A, B, 0) = 1
2109 distance_to_ancestor (A, C, 0) = 2
2110 distance_to_ancestor (A, D, 0) = 3
2112 If PUBLIC is 1 then only public ancestors are considered,
2113 and the function returns the distance only if BASE is a public ancestor
2117 distance_to_ancestor (A, D, 1) = -1. */
2120 distance_to_ancestor (struct type *base, struct type *dclass, int public)
2125 CHECK_TYPEDEF (base);
2126 CHECK_TYPEDEF (dclass);
2128 if (class_types_same_p (base, dclass))
2131 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
2133 if (public && ! BASETYPE_VIA_PUBLIC (dclass, i))
2136 d = distance_to_ancestor (base, TYPE_BASECLASS (dclass, i), public);
2144 /* Check whether BASE is an ancestor or base class or DCLASS
2145 Return 1 if so, and 0 if not.
2146 Note: If BASE and DCLASS are of the same type, this function
2147 will return 1. So for some class A, is_ancestor (A, A) will
2151 is_ancestor (struct type *base, struct type *dclass)
2153 return distance_to_ancestor (base, dclass, 0) >= 0;
2156 /* Like is_ancestor, but only returns true when BASE is a public
2157 ancestor of DCLASS. */
2160 is_public_ancestor (struct type *base, struct type *dclass)
2162 return distance_to_ancestor (base, dclass, 1) >= 0;
2165 /* A helper function for is_unique_ancestor. */
2168 is_unique_ancestor_worker (struct type *base, struct type *dclass,
2170 const gdb_byte *valaddr, int embedded_offset,
2171 CORE_ADDR address, struct value *val)
2175 CHECK_TYPEDEF (base);
2176 CHECK_TYPEDEF (dclass);
2178 for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i)
2183 iter = check_typedef (TYPE_BASECLASS (dclass, i));
2185 this_offset = baseclass_offset (dclass, i, valaddr, embedded_offset,
2188 if (class_types_same_p (base, iter))
2190 /* If this is the first subclass, set *OFFSET and set count
2191 to 1. Otherwise, if this is at the same offset as
2192 previous instances, do nothing. Otherwise, increment
2196 *offset = this_offset;
2199 else if (this_offset == *offset)
2207 count += is_unique_ancestor_worker (base, iter, offset,
2209 embedded_offset + this_offset,
2216 /* Like is_ancestor, but only returns true if BASE is a unique base
2217 class of the type of VAL. */
2220 is_unique_ancestor (struct type *base, struct value *val)
2224 return is_unique_ancestor_worker (base, value_type (val), &offset,
2225 value_contents_for_printing (val),
2226 value_embedded_offset (val),
2227 value_address (val), val) == 1;
2231 /* Overload resolution. */
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)) */
2809 /* End of functions for overload resolution. */
2811 /* Routines to pretty-print types. */
2814 print_bit_vector (B_TYPE *bits, int nbits)
2818 for (bitno = 0; bitno < nbits; bitno++)
2820 if ((bitno % 8) == 0)
2822 puts_filtered (" ");
2824 if (B_TST (bits, bitno))
2825 printf_filtered (("1"));
2827 printf_filtered (("0"));
2831 /* Note the first arg should be the "this" pointer, we may not want to
2832 include it since we may get into a infinitely recursive
2836 print_arg_types (struct field *args, int nargs, int spaces)
2842 for (i = 0; i < nargs; i++)
2843 recursive_dump_type (args[i].type, spaces + 2);
2848 field_is_static (struct field *f)
2850 /* "static" fields are the fields whose location is not relative
2851 to the address of the enclosing struct. It would be nice to
2852 have a dedicated flag that would be set for static fields when
2853 the type is being created. But in practice, checking the field
2854 loc_kind should give us an accurate answer. */
2855 return (FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSNAME
2856 || FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSADDR);
2860 dump_fn_fieldlists (struct type *type, int spaces)
2866 printfi_filtered (spaces, "fn_fieldlists ");
2867 gdb_print_host_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
2868 printf_filtered ("\n");
2869 for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
2871 f = TYPE_FN_FIELDLIST1 (type, method_idx);
2872 printfi_filtered (spaces + 2, "[%d] name '%s' (",
2874 TYPE_FN_FIELDLIST_NAME (type, method_idx));
2875 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
2877 printf_filtered (_(") length %d\n"),
2878 TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
2879 for (overload_idx = 0;
2880 overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
2883 printfi_filtered (spaces + 4, "[%d] physname '%s' (",
2885 TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
2886 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
2888 printf_filtered (")\n");
2889 printfi_filtered (spaces + 8, "type ");
2890 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx),
2892 printf_filtered ("\n");
2894 recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
2897 printfi_filtered (spaces + 8, "args ");
2898 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx),
2900 printf_filtered ("\n");
2902 print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx),
2903 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f,
2906 printfi_filtered (spaces + 8, "fcontext ");
2907 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
2909 printf_filtered ("\n");
2911 printfi_filtered (spaces + 8, "is_const %d\n",
2912 TYPE_FN_FIELD_CONST (f, overload_idx));
2913 printfi_filtered (spaces + 8, "is_volatile %d\n",
2914 TYPE_FN_FIELD_VOLATILE (f, overload_idx));
2915 printfi_filtered (spaces + 8, "is_private %d\n",
2916 TYPE_FN_FIELD_PRIVATE (f, overload_idx));
2917 printfi_filtered (spaces + 8, "is_protected %d\n",
2918 TYPE_FN_FIELD_PROTECTED (f, overload_idx));
2919 printfi_filtered (spaces + 8, "is_stub %d\n",
2920 TYPE_FN_FIELD_STUB (f, overload_idx));
2921 printfi_filtered (spaces + 8, "voffset %u\n",
2922 TYPE_FN_FIELD_VOFFSET (f, overload_idx));
2928 print_cplus_stuff (struct type *type, int spaces)
2930 printfi_filtered (spaces, "n_baseclasses %d\n",
2931 TYPE_N_BASECLASSES (type));
2932 printfi_filtered (spaces, "nfn_fields %d\n",
2933 TYPE_NFN_FIELDS (type));
2934 if (TYPE_N_BASECLASSES (type) > 0)
2936 printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
2937 TYPE_N_BASECLASSES (type));
2938 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type),
2940 printf_filtered (")");
2942 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
2943 TYPE_N_BASECLASSES (type));
2944 puts_filtered ("\n");
2946 if (TYPE_NFIELDS (type) > 0)
2948 if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
2950 printfi_filtered (spaces,
2951 "private_field_bits (%d bits at *",
2952 TYPE_NFIELDS (type));
2953 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type),
2955 printf_filtered (")");
2956 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
2957 TYPE_NFIELDS (type));
2958 puts_filtered ("\n");
2960 if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
2962 printfi_filtered (spaces,
2963 "protected_field_bits (%d bits at *",
2964 TYPE_NFIELDS (type));
2965 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type),
2967 printf_filtered (")");
2968 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
2969 TYPE_NFIELDS (type));
2970 puts_filtered ("\n");
2973 if (TYPE_NFN_FIELDS (type) > 0)
2975 dump_fn_fieldlists (type, spaces);
2979 /* Print the contents of the TYPE's type_specific union, assuming that
2980 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
2983 print_gnat_stuff (struct type *type, int spaces)
2985 struct type *descriptive_type = TYPE_DESCRIPTIVE_TYPE (type);
2987 recursive_dump_type (descriptive_type, spaces + 2);
2990 static struct obstack dont_print_type_obstack;
2993 recursive_dump_type (struct type *type, int spaces)
2998 obstack_begin (&dont_print_type_obstack, 0);
3000 if (TYPE_NFIELDS (type) > 0
3001 || (HAVE_CPLUS_STRUCT (type) && TYPE_NFN_FIELDS (type) > 0))
3003 struct type **first_dont_print
3004 = (struct type **) obstack_base (&dont_print_type_obstack);
3006 int i = (struct type **)
3007 obstack_next_free (&dont_print_type_obstack) - first_dont_print;
3011 if (type == first_dont_print[i])
3013 printfi_filtered (spaces, "type node ");
3014 gdb_print_host_address (type, gdb_stdout);
3015 printf_filtered (_(" <same as already seen type>\n"));
3020 obstack_ptr_grow (&dont_print_type_obstack, type);
3023 printfi_filtered (spaces, "type node ");
3024 gdb_print_host_address (type, gdb_stdout);
3025 printf_filtered ("\n");
3026 printfi_filtered (spaces, "name '%s' (",
3027 TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
3028 gdb_print_host_address (TYPE_NAME (type), gdb_stdout);
3029 printf_filtered (")\n");
3030 printfi_filtered (spaces, "tagname '%s' (",
3031 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : "<NULL>");
3032 gdb_print_host_address (TYPE_TAG_NAME (type), gdb_stdout);
3033 printf_filtered (")\n");
3034 printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
3035 switch (TYPE_CODE (type))
3037 case TYPE_CODE_UNDEF:
3038 printf_filtered ("(TYPE_CODE_UNDEF)");
3041 printf_filtered ("(TYPE_CODE_PTR)");
3043 case TYPE_CODE_ARRAY:
3044 printf_filtered ("(TYPE_CODE_ARRAY)");
3046 case TYPE_CODE_STRUCT:
3047 printf_filtered ("(TYPE_CODE_STRUCT)");
3049 case TYPE_CODE_UNION:
3050 printf_filtered ("(TYPE_CODE_UNION)");
3052 case TYPE_CODE_ENUM:
3053 printf_filtered ("(TYPE_CODE_ENUM)");
3055 case TYPE_CODE_FLAGS:
3056 printf_filtered ("(TYPE_CODE_FLAGS)");
3058 case TYPE_CODE_FUNC:
3059 printf_filtered ("(TYPE_CODE_FUNC)");
3062 printf_filtered ("(TYPE_CODE_INT)");
3065 printf_filtered ("(TYPE_CODE_FLT)");
3067 case TYPE_CODE_VOID:
3068 printf_filtered ("(TYPE_CODE_VOID)");
3071 printf_filtered ("(TYPE_CODE_SET)");
3073 case TYPE_CODE_RANGE:
3074 printf_filtered ("(TYPE_CODE_RANGE)");
3076 case TYPE_CODE_STRING:
3077 printf_filtered ("(TYPE_CODE_STRING)");
3079 case TYPE_CODE_BITSTRING:
3080 printf_filtered ("(TYPE_CODE_BITSTRING)");
3082 case TYPE_CODE_ERROR:
3083 printf_filtered ("(TYPE_CODE_ERROR)");
3085 case TYPE_CODE_MEMBERPTR:
3086 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
3088 case TYPE_CODE_METHODPTR:
3089 printf_filtered ("(TYPE_CODE_METHODPTR)");
3091 case TYPE_CODE_METHOD:
3092 printf_filtered ("(TYPE_CODE_METHOD)");
3095 printf_filtered ("(TYPE_CODE_REF)");
3097 case TYPE_CODE_CHAR:
3098 printf_filtered ("(TYPE_CODE_CHAR)");
3100 case TYPE_CODE_BOOL:
3101 printf_filtered ("(TYPE_CODE_BOOL)");
3103 case TYPE_CODE_COMPLEX:
3104 printf_filtered ("(TYPE_CODE_COMPLEX)");
3106 case TYPE_CODE_TYPEDEF:
3107 printf_filtered ("(TYPE_CODE_TYPEDEF)");
3109 case TYPE_CODE_NAMESPACE:
3110 printf_filtered ("(TYPE_CODE_NAMESPACE)");
3113 printf_filtered ("(UNKNOWN TYPE CODE)");
3116 puts_filtered ("\n");
3117 printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
3118 if (TYPE_OBJFILE_OWNED (type))
3120 printfi_filtered (spaces, "objfile ");
3121 gdb_print_host_address (TYPE_OWNER (type).objfile, gdb_stdout);
3125 printfi_filtered (spaces, "gdbarch ");
3126 gdb_print_host_address (TYPE_OWNER (type).gdbarch, gdb_stdout);
3128 printf_filtered ("\n");
3129 printfi_filtered (spaces, "target_type ");
3130 gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout);
3131 printf_filtered ("\n");
3132 if (TYPE_TARGET_TYPE (type) != NULL)
3134 recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
3136 printfi_filtered (spaces, "pointer_type ");
3137 gdb_print_host_address (TYPE_POINTER_TYPE (type), gdb_stdout);
3138 printf_filtered ("\n");
3139 printfi_filtered (spaces, "reference_type ");
3140 gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
3141 printf_filtered ("\n");
3142 printfi_filtered (spaces, "type_chain ");
3143 gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);
3144 printf_filtered ("\n");
3145 printfi_filtered (spaces, "instance_flags 0x%x",
3146 TYPE_INSTANCE_FLAGS (type));
3147 if (TYPE_CONST (type))
3149 puts_filtered (" TYPE_FLAG_CONST");
3151 if (TYPE_VOLATILE (type))
3153 puts_filtered (" TYPE_FLAG_VOLATILE");
3155 if (TYPE_CODE_SPACE (type))
3157 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3159 if (TYPE_DATA_SPACE (type))
3161 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3163 if (TYPE_ADDRESS_CLASS_1 (type))
3165 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3167 if (TYPE_ADDRESS_CLASS_2 (type))
3169 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3171 puts_filtered ("\n");
3173 printfi_filtered (spaces, "flags");
3174 if (TYPE_UNSIGNED (type))
3176 puts_filtered (" TYPE_FLAG_UNSIGNED");
3178 if (TYPE_NOSIGN (type))
3180 puts_filtered (" TYPE_FLAG_NOSIGN");
3182 if (TYPE_STUB (type))
3184 puts_filtered (" TYPE_FLAG_STUB");
3186 if (TYPE_TARGET_STUB (type))
3188 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3190 if (TYPE_STATIC (type))
3192 puts_filtered (" TYPE_FLAG_STATIC");
3194 if (TYPE_PROTOTYPED (type))
3196 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3198 if (TYPE_INCOMPLETE (type))
3200 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3202 if (TYPE_VARARGS (type))
3204 puts_filtered (" TYPE_FLAG_VARARGS");
3206 /* This is used for things like AltiVec registers on ppc. Gcc emits
3207 an attribute for the array type, which tells whether or not we
3208 have a vector, instead of a regular array. */
3209 if (TYPE_VECTOR (type))
3211 puts_filtered (" TYPE_FLAG_VECTOR");
3213 if (TYPE_FIXED_INSTANCE (type))
3215 puts_filtered (" TYPE_FIXED_INSTANCE");
3217 if (TYPE_STUB_SUPPORTED (type))
3219 puts_filtered (" TYPE_STUB_SUPPORTED");
3221 if (TYPE_NOTTEXT (type))
3223 puts_filtered (" TYPE_NOTTEXT");
3225 puts_filtered ("\n");
3226 printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
3227 gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
3228 puts_filtered ("\n");
3229 for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
3231 if (TYPE_CODE (type) == TYPE_CODE_ENUM)
3232 printfi_filtered (spaces + 2,
3233 "[%d] enumval %s type ",
3234 idx, plongest (TYPE_FIELD_ENUMVAL (type, idx)));
3236 printfi_filtered (spaces + 2,
3237 "[%d] bitpos %d bitsize %d type ",
3238 idx, TYPE_FIELD_BITPOS (type, idx),
3239 TYPE_FIELD_BITSIZE (type, idx));
3240 gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
3241 printf_filtered (" name '%s' (",
3242 TYPE_FIELD_NAME (type, idx) != NULL
3243 ? TYPE_FIELD_NAME (type, idx)
3245 gdb_print_host_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
3246 printf_filtered (")\n");
3247 if (TYPE_FIELD_TYPE (type, idx) != NULL)
3249 recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
3252 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
3254 printfi_filtered (spaces, "low %s%s high %s%s\n",
3255 plongest (TYPE_LOW_BOUND (type)),
3256 TYPE_LOW_BOUND_UNDEFINED (type) ? " (undefined)" : "",
3257 plongest (TYPE_HIGH_BOUND (type)),
3258 TYPE_HIGH_BOUND_UNDEFINED (type)
3259 ? " (undefined)" : "");
3261 printfi_filtered (spaces, "vptr_basetype ");
3262 gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
3263 puts_filtered ("\n");
3264 if (TYPE_VPTR_BASETYPE (type) != NULL)
3266 recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
3268 printfi_filtered (spaces, "vptr_fieldno %d\n",
3269 TYPE_VPTR_FIELDNO (type));
3271 switch (TYPE_SPECIFIC_FIELD (type))
3273 case TYPE_SPECIFIC_CPLUS_STUFF:
3274 printfi_filtered (spaces, "cplus_stuff ");
3275 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type),
3277 puts_filtered ("\n");
3278 print_cplus_stuff (type, spaces);
3281 case TYPE_SPECIFIC_GNAT_STUFF:
3282 printfi_filtered (spaces, "gnat_stuff ");
3283 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type), gdb_stdout);
3284 puts_filtered ("\n");
3285 print_gnat_stuff (type, spaces);
3288 case TYPE_SPECIFIC_FLOATFORMAT:
3289 printfi_filtered (spaces, "floatformat ");
3290 if (TYPE_FLOATFORMAT (type) == NULL)
3291 puts_filtered ("(null)");
3294 puts_filtered ("{ ");
3295 if (TYPE_FLOATFORMAT (type)[0] == NULL
3296 || TYPE_FLOATFORMAT (type)[0]->name == NULL)
3297 puts_filtered ("(null)");
3299 puts_filtered (TYPE_FLOATFORMAT (type)[0]->name);
3301 puts_filtered (", ");
3302 if (TYPE_FLOATFORMAT (type)[1] == NULL
3303 || TYPE_FLOATFORMAT (type)[1]->name == NULL)
3304 puts_filtered ("(null)");
3306 puts_filtered (TYPE_FLOATFORMAT (type)[1]->name);
3308 puts_filtered (" }");
3310 puts_filtered ("\n");
3313 case TYPE_SPECIFIC_FUNC:
3314 printfi_filtered (spaces, "calling_convention %d\n",
3315 TYPE_CALLING_CONVENTION (type));
3316 /* tail_call_list is not printed. */
3321 obstack_free (&dont_print_type_obstack, NULL);
3324 /* Trivial helpers for the libiberty hash table, for mapping one
3329 struct type *old, *new;
3333 type_pair_hash (const void *item)
3335 const struct type_pair *pair = item;
3337 return htab_hash_pointer (pair->old);
3341 type_pair_eq (const void *item_lhs, const void *item_rhs)
3343 const struct type_pair *lhs = item_lhs, *rhs = item_rhs;
3345 return lhs->old == rhs->old;
3348 /* Allocate the hash table used by copy_type_recursive to walk
3349 types without duplicates. We use OBJFILE's obstack, because
3350 OBJFILE is about to be deleted. */
3353 create_copied_types_hash (struct objfile *objfile)
3355 return htab_create_alloc_ex (1, type_pair_hash, type_pair_eq,
3356 NULL, &objfile->objfile_obstack,
3357 hashtab_obstack_allocate,
3358 dummy_obstack_deallocate);
3361 /* Recursively copy (deep copy) TYPE, if it is associated with
3362 OBJFILE. Return a new type allocated using malloc, a saved type if
3363 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
3364 not associated with OBJFILE. */
3367 copy_type_recursive (struct objfile *objfile,
3369 htab_t copied_types)
3371 struct type_pair *stored, pair;
3373 struct type *new_type;
3375 if (! TYPE_OBJFILE_OWNED (type))
3378 /* This type shouldn't be pointing to any types in other objfiles;
3379 if it did, the type might disappear unexpectedly. */
3380 gdb_assert (TYPE_OBJFILE (type) == objfile);
3383 slot = htab_find_slot (copied_types, &pair, INSERT);
3385 return ((struct type_pair *) *slot)->new;
3387 new_type = alloc_type_arch (get_type_arch (type));
3389 /* We must add the new type to the hash table immediately, in case
3390 we encounter this type again during a recursive call below. */
3392 = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair));
3394 stored->new = new_type;
3397 /* Copy the common fields of types. For the main type, we simply
3398 copy the entire thing and then update specific fields as needed. */
3399 *TYPE_MAIN_TYPE (new_type) = *TYPE_MAIN_TYPE (type);
3400 TYPE_OBJFILE_OWNED (new_type) = 0;
3401 TYPE_OWNER (new_type).gdbarch = get_type_arch (type);
3403 if (TYPE_NAME (type))
3404 TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type));
3405 if (TYPE_TAG_NAME (type))
3406 TYPE_TAG_NAME (new_type) = xstrdup (TYPE_TAG_NAME (type));
3408 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
3409 TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
3411 /* Copy the fields. */
3412 if (TYPE_NFIELDS (type))
3416 nfields = TYPE_NFIELDS (type);
3417 TYPE_FIELDS (new_type) = XCALLOC (nfields, struct field);
3418 for (i = 0; i < nfields; i++)
3420 TYPE_FIELD_ARTIFICIAL (new_type, i) =
3421 TYPE_FIELD_ARTIFICIAL (type, i);
3422 TYPE_FIELD_BITSIZE (new_type, i) = TYPE_FIELD_BITSIZE (type, i);
3423 if (TYPE_FIELD_TYPE (type, i))
3424 TYPE_FIELD_TYPE (new_type, i)
3425 = copy_type_recursive (objfile, TYPE_FIELD_TYPE (type, i),
3427 if (TYPE_FIELD_NAME (type, i))
3428 TYPE_FIELD_NAME (new_type, i) =
3429 xstrdup (TYPE_FIELD_NAME (type, i));
3430 switch (TYPE_FIELD_LOC_KIND (type, i))
3432 case FIELD_LOC_KIND_BITPOS:
3433 SET_FIELD_BITPOS (TYPE_FIELD (new_type, i),
3434 TYPE_FIELD_BITPOS (type, i));
3436 case FIELD_LOC_KIND_ENUMVAL:
3437 SET_FIELD_ENUMVAL (TYPE_FIELD (new_type, i),
3438 TYPE_FIELD_ENUMVAL (type, i));
3440 case FIELD_LOC_KIND_PHYSADDR:
3441 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i),
3442 TYPE_FIELD_STATIC_PHYSADDR (type, i));
3444 case FIELD_LOC_KIND_PHYSNAME:
3445 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i),
3446 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type,
3450 internal_error (__FILE__, __LINE__,
3451 _("Unexpected type field location kind: %d"),
3452 TYPE_FIELD_LOC_KIND (type, i));
3457 /* For range types, copy the bounds information. */
3458 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
3460 TYPE_RANGE_DATA (new_type) = xmalloc (sizeof (struct range_bounds));
3461 *TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type);
3464 /* Copy pointers to other types. */
3465 if (TYPE_TARGET_TYPE (type))
3466 TYPE_TARGET_TYPE (new_type) =
3467 copy_type_recursive (objfile,
3468 TYPE_TARGET_TYPE (type),
3470 if (TYPE_VPTR_BASETYPE (type))
3471 TYPE_VPTR_BASETYPE (new_type) =
3472 copy_type_recursive (objfile,
3473 TYPE_VPTR_BASETYPE (type),
3475 /* Maybe copy the type_specific bits.
3477 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3478 base classes and methods. There's no fundamental reason why we
3479 can't, but at the moment it is not needed. */
3481 if (TYPE_CODE (type) == TYPE_CODE_FLT)
3482 TYPE_FLOATFORMAT (new_type) = TYPE_FLOATFORMAT (type);
3483 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
3484 || TYPE_CODE (type) == TYPE_CODE_UNION
3485 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
3486 INIT_CPLUS_SPECIFIC (new_type);
3491 /* Make a copy of the given TYPE, except that the pointer & reference
3492 types are not preserved.
3494 This function assumes that the given type has an associated objfile.
3495 This objfile is used to allocate the new type. */
3498 copy_type (const struct type *type)
3500 struct type *new_type;
3502 gdb_assert (TYPE_OBJFILE_OWNED (type));
3504 new_type = alloc_type_copy (type);
3505 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
3506 TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
3507 memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type),
3508 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. */
3519 arch_type (struct gdbarch *gdbarch,
3520 enum type_code code, int length, char *name)
3524 type = alloc_type_arch (gdbarch);
3525 TYPE_CODE (type) = code;
3526 TYPE_LENGTH (type) = length;
3529 TYPE_NAME (type) = xstrdup (name);
3534 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
3535 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3536 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3539 arch_integer_type (struct gdbarch *gdbarch,
3540 int bit, int unsigned_p, char *name)
3544 t = arch_type (gdbarch, TYPE_CODE_INT, bit / TARGET_CHAR_BIT, name);
3546 TYPE_UNSIGNED (t) = 1;
3547 if (name && strcmp (name, "char") == 0)
3548 TYPE_NOSIGN (t) = 1;
3553 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
3554 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3555 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3558 arch_character_type (struct gdbarch *gdbarch,
3559 int bit, int unsigned_p, char *name)
3563 t = arch_type (gdbarch, TYPE_CODE_CHAR, bit / TARGET_CHAR_BIT, name);
3565 TYPE_UNSIGNED (t) = 1;
3570 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
3571 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3572 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3575 arch_boolean_type (struct gdbarch *gdbarch,
3576 int bit, int unsigned_p, char *name)
3580 t = arch_type (gdbarch, TYPE_CODE_BOOL, bit / TARGET_CHAR_BIT, name);
3582 TYPE_UNSIGNED (t) = 1;
3587 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
3588 BIT is the type size in bits; if BIT equals -1, the size is
3589 determined by the floatformat. NAME is the type name. Set the
3590 TYPE_FLOATFORMAT from FLOATFORMATS. */
3593 arch_float_type (struct gdbarch *gdbarch,
3594 int bit, char *name, const struct floatformat **floatformats)
3600 gdb_assert (floatformats != NULL);
3601 gdb_assert (floatformats[0] != NULL && floatformats[1] != NULL);
3602 bit = floatformats[0]->totalsize;
3604 gdb_assert (bit >= 0);
3606 t = arch_type (gdbarch, TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, name);
3607 TYPE_FLOATFORMAT (t) = floatformats;
3611 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
3612 NAME is the type name. TARGET_TYPE is the component float type. */
3615 arch_complex_type (struct gdbarch *gdbarch,
3616 char *name, struct type *target_type)
3620 t = arch_type (gdbarch, TYPE_CODE_COMPLEX,
3621 2 * TYPE_LENGTH (target_type), name);
3622 TYPE_TARGET_TYPE (t) = target_type;
3626 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
3627 NAME is the type name. LENGTH is the size of the flag word in bytes. */
3630 arch_flags_type (struct gdbarch *gdbarch, char *name, int length)
3632 int nfields = length * TARGET_CHAR_BIT;
3635 type = arch_type (gdbarch, TYPE_CODE_FLAGS, length, name);
3636 TYPE_UNSIGNED (type) = 1;
3637 TYPE_NFIELDS (type) = nfields;
3638 TYPE_FIELDS (type) = TYPE_ZALLOC (type, nfields * sizeof (struct field));
3643 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
3644 position BITPOS is called NAME. */
3647 append_flags_type_flag (struct type *type, int bitpos, char *name)
3649 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS);
3650 gdb_assert (bitpos < TYPE_NFIELDS (type));
3651 gdb_assert (bitpos >= 0);
3655 TYPE_FIELD_NAME (type, bitpos) = xstrdup (name);
3656 SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), bitpos);
3660 /* Don't show this field to the user. */
3661 SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), -1);
3665 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
3666 specified by CODE) associated with GDBARCH. NAME is the type name. */
3669 arch_composite_type (struct gdbarch *gdbarch, char *name, enum type_code code)
3673 gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION);
3674 t = arch_type (gdbarch, code, 0, NULL);
3675 TYPE_TAG_NAME (t) = name;
3676 INIT_CPLUS_SPECIFIC (t);
3680 /* Add new field with name NAME and type FIELD to composite type T.
3681 Do not set the field's position or adjust the type's length;
3682 the caller should do so. Return the new field. */
3685 append_composite_type_field_raw (struct type *t, char *name,
3690 TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
3691 TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t),
3692 sizeof (struct field) * TYPE_NFIELDS (t));
3693 f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
3694 memset (f, 0, sizeof f[0]);
3695 FIELD_TYPE (f[0]) = field;
3696 FIELD_NAME (f[0]) = name;
3700 /* Add new field with name NAME and type FIELD to composite type T.
3701 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
3704 append_composite_type_field_aligned (struct type *t, char *name,
3705 struct type *field, int alignment)
3707 struct field *f = append_composite_type_field_raw (t, name, field);
3709 if (TYPE_CODE (t) == TYPE_CODE_UNION)
3711 if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
3712 TYPE_LENGTH (t) = TYPE_LENGTH (field);
3714 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
3716 TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
3717 if (TYPE_NFIELDS (t) > 1)
3719 SET_FIELD_BITPOS (f[0],
3720 (FIELD_BITPOS (f[-1])
3721 + (TYPE_LENGTH (FIELD_TYPE (f[-1]))
3722 * TARGET_CHAR_BIT)));
3728 alignment *= TARGET_CHAR_BIT;
3729 left = FIELD_BITPOS (f[0]) % alignment;
3733 SET_FIELD_BITPOS (f[0], FIELD_BITPOS (f[0]) + (alignment - left));
3734 TYPE_LENGTH (t) += (alignment - left) / TARGET_CHAR_BIT;
3741 /* Add new field with name NAME and type FIELD to composite type T. */
3744 append_composite_type_field (struct type *t, char *name,
3747 append_composite_type_field_aligned (t, name, field, 0);
3750 static struct gdbarch_data *gdbtypes_data;
3752 const struct builtin_type *
3753 builtin_type (struct gdbarch *gdbarch)
3755 return gdbarch_data (gdbarch, gdbtypes_data);
3759 gdbtypes_post_init (struct gdbarch *gdbarch)
3761 struct builtin_type *builtin_type
3762 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type);
3765 builtin_type->builtin_void
3766 = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
3767 builtin_type->builtin_char
3768 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3769 !gdbarch_char_signed (gdbarch), "char");
3770 builtin_type->builtin_signed_char
3771 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3773 builtin_type->builtin_unsigned_char
3774 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3775 1, "unsigned char");
3776 builtin_type->builtin_short
3777 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
3779 builtin_type->builtin_unsigned_short
3780 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
3781 1, "unsigned short");
3782 builtin_type->builtin_int
3783 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
3785 builtin_type->builtin_unsigned_int
3786 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
3788 builtin_type->builtin_long
3789 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
3791 builtin_type->builtin_unsigned_long
3792 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
3793 1, "unsigned long");
3794 builtin_type->builtin_long_long
3795 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
3797 builtin_type->builtin_unsigned_long_long
3798 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
3799 1, "unsigned long long");
3800 builtin_type->builtin_float
3801 = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
3802 "float", gdbarch_float_format (gdbarch));
3803 builtin_type->builtin_double
3804 = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
3805 "double", gdbarch_double_format (gdbarch));
3806 builtin_type->builtin_long_double
3807 = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
3808 "long double", gdbarch_long_double_format (gdbarch));
3809 builtin_type->builtin_complex
3810 = arch_complex_type (gdbarch, "complex",
3811 builtin_type->builtin_float);
3812 builtin_type->builtin_double_complex
3813 = arch_complex_type (gdbarch, "double complex",
3814 builtin_type->builtin_double);
3815 builtin_type->builtin_string
3816 = arch_type (gdbarch, TYPE_CODE_STRING, 1, "string");
3817 builtin_type->builtin_bool
3818 = arch_type (gdbarch, TYPE_CODE_BOOL, 1, "bool");
3820 /* The following three are about decimal floating point types, which
3821 are 32-bits, 64-bits and 128-bits respectively. */
3822 builtin_type->builtin_decfloat
3823 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 32 / 8, "_Decimal32");
3824 builtin_type->builtin_decdouble
3825 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 64 / 8, "_Decimal64");
3826 builtin_type->builtin_declong
3827 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 128 / 8, "_Decimal128");
3829 /* "True" character types. */
3830 builtin_type->builtin_true_char
3831 = arch_character_type (gdbarch, TARGET_CHAR_BIT, 0, "true character");
3832 builtin_type->builtin_true_unsigned_char
3833 = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "true character");
3835 /* Fixed-size integer types. */
3836 builtin_type->builtin_int0
3837 = arch_integer_type (gdbarch, 0, 0, "int0_t");
3838 builtin_type->builtin_int8
3839 = arch_integer_type (gdbarch, 8, 0, "int8_t");
3840 builtin_type->builtin_uint8
3841 = arch_integer_type (gdbarch, 8, 1, "uint8_t");
3842 builtin_type->builtin_int16
3843 = arch_integer_type (gdbarch, 16, 0, "int16_t");
3844 builtin_type->builtin_uint16
3845 = arch_integer_type (gdbarch, 16, 1, "uint16_t");
3846 builtin_type->builtin_int32
3847 = arch_integer_type (gdbarch, 32, 0, "int32_t");
3848 builtin_type->builtin_uint32
3849 = arch_integer_type (gdbarch, 32, 1, "uint32_t");
3850 builtin_type->builtin_int64
3851 = arch_integer_type (gdbarch, 64, 0, "int64_t");
3852 builtin_type->builtin_uint64
3853 = arch_integer_type (gdbarch, 64, 1, "uint64_t");
3854 builtin_type->builtin_int128
3855 = arch_integer_type (gdbarch, 128, 0, "int128_t");
3856 builtin_type->builtin_uint128
3857 = arch_integer_type (gdbarch, 128, 1, "uint128_t");
3858 TYPE_INSTANCE_FLAGS (builtin_type->builtin_int8) |=
3859 TYPE_INSTANCE_FLAG_NOTTEXT;
3860 TYPE_INSTANCE_FLAGS (builtin_type->builtin_uint8) |=
3861 TYPE_INSTANCE_FLAG_NOTTEXT;
3863 /* Wide character types. */
3864 builtin_type->builtin_char16
3865 = arch_integer_type (gdbarch, 16, 0, "char16_t");
3866 builtin_type->builtin_char32
3867 = arch_integer_type (gdbarch, 32, 0, "char32_t");
3870 /* Default data/code pointer types. */
3871 builtin_type->builtin_data_ptr
3872 = lookup_pointer_type (builtin_type->builtin_void);
3873 builtin_type->builtin_func_ptr
3874 = lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
3875 builtin_type->builtin_func_func
3876 = lookup_function_type (builtin_type->builtin_func_ptr);
3878 /* This type represents a GDB internal function. */
3879 builtin_type->internal_fn
3880 = arch_type (gdbarch, TYPE_CODE_INTERNAL_FUNCTION, 0,
3881 "<internal function>");
3883 return builtin_type;
3886 /* This set of objfile-based types is intended to be used by symbol
3887 readers as basic types. */
3889 static const struct objfile_data *objfile_type_data;
3891 const struct objfile_type *
3892 objfile_type (struct objfile *objfile)
3894 struct gdbarch *gdbarch;
3895 struct objfile_type *objfile_type
3896 = objfile_data (objfile, objfile_type_data);
3899 return objfile_type;
3901 objfile_type = OBSTACK_CALLOC (&objfile->objfile_obstack,
3902 1, struct objfile_type);
3904 /* Use the objfile architecture to determine basic type properties. */
3905 gdbarch = get_objfile_arch (objfile);
3908 objfile_type->builtin_void
3909 = init_type (TYPE_CODE_VOID, 1,
3913 objfile_type->builtin_char
3914 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3916 | (gdbarch_char_signed (gdbarch) ? 0 : TYPE_FLAG_UNSIGNED)),
3918 objfile_type->builtin_signed_char
3919 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3921 "signed char", objfile);
3922 objfile_type->builtin_unsigned_char
3923 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3925 "unsigned char", objfile);
3926 objfile_type->builtin_short
3927 = init_type (TYPE_CODE_INT,
3928 gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
3929 0, "short", objfile);
3930 objfile_type->builtin_unsigned_short
3931 = init_type (TYPE_CODE_INT,
3932 gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
3933 TYPE_FLAG_UNSIGNED, "unsigned short", objfile);
3934 objfile_type->builtin_int
3935 = init_type (TYPE_CODE_INT,
3936 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
3938 objfile_type->builtin_unsigned_int
3939 = init_type (TYPE_CODE_INT,
3940 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
3941 TYPE_FLAG_UNSIGNED, "unsigned int", objfile);
3942 objfile_type->builtin_long
3943 = init_type (TYPE_CODE_INT,
3944 gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
3945 0, "long", objfile);
3946 objfile_type->builtin_unsigned_long
3947 = init_type (TYPE_CODE_INT,
3948 gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
3949 TYPE_FLAG_UNSIGNED, "unsigned long", objfile);
3950 objfile_type->builtin_long_long
3951 = init_type (TYPE_CODE_INT,
3952 gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
3953 0, "long long", objfile);
3954 objfile_type->builtin_unsigned_long_long
3955 = init_type (TYPE_CODE_INT,
3956 gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
3957 TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
3959 objfile_type->builtin_float
3960 = init_type (TYPE_CODE_FLT,
3961 gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT,
3962 0, "float", objfile);
3963 TYPE_FLOATFORMAT (objfile_type->builtin_float)
3964 = gdbarch_float_format (gdbarch);
3965 objfile_type->builtin_double
3966 = init_type (TYPE_CODE_FLT,
3967 gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT,
3968 0, "double", objfile);
3969 TYPE_FLOATFORMAT (objfile_type->builtin_double)
3970 = gdbarch_double_format (gdbarch);
3971 objfile_type->builtin_long_double
3972 = init_type (TYPE_CODE_FLT,
3973 gdbarch_long_double_bit (gdbarch) / TARGET_CHAR_BIT,
3974 0, "long double", objfile);
3975 TYPE_FLOATFORMAT (objfile_type->builtin_long_double)
3976 = gdbarch_long_double_format (gdbarch);
3978 /* This type represents a type that was unrecognized in symbol read-in. */
3979 objfile_type->builtin_error
3980 = init_type (TYPE_CODE_ERROR, 0, 0, "<unknown type>", objfile);
3982 /* The following set of types is used for symbols with no
3983 debug information. */
3984 objfile_type->nodebug_text_symbol
3985 = init_type (TYPE_CODE_FUNC, 1, 0,
3986 "<text variable, no debug info>", objfile);
3987 TYPE_TARGET_TYPE (objfile_type->nodebug_text_symbol)
3988 = objfile_type->builtin_int;
3989 objfile_type->nodebug_text_gnu_ifunc_symbol
3990 = init_type (TYPE_CODE_FUNC, 1, TYPE_FLAG_GNU_IFUNC,
3991 "<text gnu-indirect-function variable, no debug info>",
3993 TYPE_TARGET_TYPE (objfile_type->nodebug_text_gnu_ifunc_symbol)
3994 = objfile_type->nodebug_text_symbol;
3995 objfile_type->nodebug_got_plt_symbol
3996 = init_type (TYPE_CODE_PTR, gdbarch_addr_bit (gdbarch) / 8, 0,
3997 "<text from jump slot in .got.plt, no debug info>",
3999 TYPE_TARGET_TYPE (objfile_type->nodebug_got_plt_symbol)
4000 = objfile_type->nodebug_text_symbol;
4001 objfile_type->nodebug_data_symbol
4002 = init_type (TYPE_CODE_INT,
4003 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
4004 "<data variable, no debug info>", objfile);
4005 objfile_type->nodebug_unknown_symbol
4006 = init_type (TYPE_CODE_INT, 1, 0,
4007 "<variable (not text or data), no debug info>", objfile);
4008 objfile_type->nodebug_tls_symbol
4009 = init_type (TYPE_CODE_INT,
4010 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
4011 "<thread local variable, no debug info>", objfile);
4013 /* NOTE: on some targets, addresses and pointers are not necessarily
4014 the same --- for example, on the D10V, pointers are 16 bits long,
4015 but addresses are 32 bits long. See doc/gdbint.texinfo,
4016 ``Pointers Are Not Always Addresses''.
4019 - gdb's `struct type' always describes the target's
4021 - gdb's `struct value' objects should always hold values in
4023 - gdb's CORE_ADDR values are addresses in the unified virtual
4024 address space that the assembler and linker work with. Thus,
4025 since target_read_memory takes a CORE_ADDR as an argument, it
4026 can access any memory on the target, even if the processor has
4027 separate code and data address spaces.
4030 - If v is a value holding a D10V code pointer, its contents are
4031 in target form: a big-endian address left-shifted two bits.
4032 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
4033 sizeof (void *) == 2 on the target.
4035 In this context, objfile_type->builtin_core_addr is a bit odd:
4036 it's a target type for a value the target will never see. It's
4037 only used to hold the values of (typeless) linker symbols, which
4038 are indeed in the unified virtual address space. */
4040 objfile_type->builtin_core_addr
4041 = init_type (TYPE_CODE_INT,
4042 gdbarch_addr_bit (gdbarch) / 8,
4043 TYPE_FLAG_UNSIGNED, "__CORE_ADDR", objfile);
4045 set_objfile_data (objfile, objfile_type_data, objfile_type);
4046 return objfile_type;
4049 extern initialize_file_ftype _initialize_gdbtypes;
4052 _initialize_gdbtypes (void)
4054 gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
4055 objfile_type_data = register_objfile_data ();
4057 add_setshow_zuinteger_cmd ("overload", no_class, &overload_debug,
4058 _("Set debugging of C++ overloading."),
4059 _("Show debugging of C++ overloading."),
4060 _("When enabled, ranking of the "
4061 "functions is displayed."),
4063 show_overload_debug,
4064 &setdebuglist, &showdebuglist);
4066 /* Add user knob for controlling resolution of opaque types. */
4067 add_setshow_boolean_cmd ("opaque-type-resolution", class_support,
4068 &opaque_type_resolution,
4069 _("Set resolution of opaque struct/class/union"
4070 " types (if set before loading symbols)."),
4071 _("Show resolution of opaque struct/class/union"
4072 " types (if set before loading symbols)."),
4074 show_opaque_type_resolution,
4075 &setlist, &showlist);