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};
62 const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS = {3,0};
64 /* Floatformat pairs. */
65 const struct floatformat *floatformats_ieee_half[BFD_ENDIAN_UNKNOWN] = {
66 &floatformat_ieee_half_big,
67 &floatformat_ieee_half_little
69 const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN] = {
70 &floatformat_ieee_single_big,
71 &floatformat_ieee_single_little
73 const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN] = {
74 &floatformat_ieee_double_big,
75 &floatformat_ieee_double_little
77 const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN] = {
78 &floatformat_ieee_double_big,
79 &floatformat_ieee_double_littlebyte_bigword
81 const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN] = {
82 &floatformat_i387_ext,
85 const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN] = {
86 &floatformat_m68881_ext,
87 &floatformat_m68881_ext
89 const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN] = {
90 &floatformat_arm_ext_big,
91 &floatformat_arm_ext_littlebyte_bigword
93 const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN] = {
94 &floatformat_ia64_spill_big,
95 &floatformat_ia64_spill_little
97 const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN] = {
98 &floatformat_ia64_quad_big,
99 &floatformat_ia64_quad_little
101 const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN] = {
105 const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN] = {
109 const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN] = {
110 &floatformat_ibm_long_double,
111 &floatformat_ibm_long_double
114 /* Should opaque types be resolved? */
116 static int opaque_type_resolution = 1;
118 /* A flag to enable printing of debugging information of C++
121 unsigned int overload_debug = 0;
123 /* A flag to enable strict type checking. */
125 static int strict_type_checking = 1;
127 /* A function to show whether opaque types are resolved. */
130 show_opaque_type_resolution (struct ui_file *file, int from_tty,
131 struct cmd_list_element *c,
134 fprintf_filtered (file, _("Resolution of opaque struct/class/union types "
135 "(if set before loading symbols) is %s.\n"),
139 /* A function to show whether C++ overload debugging is enabled. */
142 show_overload_debug (struct ui_file *file, int from_tty,
143 struct cmd_list_element *c, const char *value)
145 fprintf_filtered (file, _("Debugging of C++ overloading is %s.\n"),
149 /* A function to show the status of strict type checking. */
152 show_strict_type_checking (struct ui_file *file, int from_tty,
153 struct cmd_list_element *c, const char *value)
155 fprintf_filtered (file, _("Strict type checking is %s.\n"), value);
159 /* Allocate a new OBJFILE-associated type structure and fill it
160 with some defaults. Space for the type structure is allocated
161 on the objfile's objfile_obstack. */
164 alloc_type (struct objfile *objfile)
168 gdb_assert (objfile != NULL);
170 /* Alloc the structure and start off with all fields zeroed. */
171 type = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct type);
172 TYPE_MAIN_TYPE (type) = OBSTACK_ZALLOC (&objfile->objfile_obstack,
174 OBJSTAT (objfile, n_types++);
176 TYPE_OBJFILE_OWNED (type) = 1;
177 TYPE_OWNER (type).objfile = objfile;
179 /* Initialize the fields that might not be zero. */
181 TYPE_CODE (type) = TYPE_CODE_UNDEF;
182 TYPE_VPTR_FIELDNO (type) = -1;
183 TYPE_CHAIN (type) = type; /* Chain back to itself. */
188 /* Allocate a new GDBARCH-associated type structure and fill it
189 with some defaults. Space for the type structure is allocated
193 alloc_type_arch (struct gdbarch *gdbarch)
197 gdb_assert (gdbarch != NULL);
199 /* Alloc the structure and start off with all fields zeroed. */
201 type = XZALLOC (struct type);
202 TYPE_MAIN_TYPE (type) = XZALLOC (struct main_type);
204 TYPE_OBJFILE_OWNED (type) = 0;
205 TYPE_OWNER (type).gdbarch = gdbarch;
207 /* Initialize the fields that might not be zero. */
209 TYPE_CODE (type) = TYPE_CODE_UNDEF;
210 TYPE_VPTR_FIELDNO (type) = -1;
211 TYPE_CHAIN (type) = type; /* Chain back to itself. */
216 /* If TYPE is objfile-associated, allocate a new type structure
217 associated with the same objfile. If TYPE is gdbarch-associated,
218 allocate a new type structure associated with the same gdbarch. */
221 alloc_type_copy (const struct type *type)
223 if (TYPE_OBJFILE_OWNED (type))
224 return alloc_type (TYPE_OWNER (type).objfile);
226 return alloc_type_arch (TYPE_OWNER (type).gdbarch);
229 /* If TYPE is gdbarch-associated, return that architecture.
230 If TYPE is objfile-associated, return that objfile's architecture. */
233 get_type_arch (const struct type *type)
235 if (TYPE_OBJFILE_OWNED (type))
236 return get_objfile_arch (TYPE_OWNER (type).objfile);
238 return TYPE_OWNER (type).gdbarch;
241 /* Alloc a new type instance structure, fill it with some defaults,
242 and point it at OLDTYPE. Allocate the new type instance from the
243 same place as OLDTYPE. */
246 alloc_type_instance (struct type *oldtype)
250 /* Allocate the structure. */
252 if (! TYPE_OBJFILE_OWNED (oldtype))
253 type = XZALLOC (struct type);
255 type = OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype)->objfile_obstack,
258 TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype);
260 TYPE_CHAIN (type) = type; /* Chain back to itself for now. */
265 /* Clear all remnants of the previous type at TYPE, in preparation for
266 replacing it with something else. Preserve owner information. */
269 smash_type (struct type *type)
271 int objfile_owned = TYPE_OBJFILE_OWNED (type);
272 union type_owner owner = TYPE_OWNER (type);
274 memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
276 /* Restore owner information. */
277 TYPE_OBJFILE_OWNED (type) = objfile_owned;
278 TYPE_OWNER (type) = owner;
280 /* For now, delete the rings. */
281 TYPE_CHAIN (type) = type;
283 /* For now, leave the pointer/reference types alone. */
286 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
287 to a pointer to memory where the pointer type should be stored.
288 If *TYPEPTR is zero, update it to point to the pointer type we return.
289 We allocate new memory if needed. */
292 make_pointer_type (struct type *type, struct type **typeptr)
294 struct type *ntype; /* New type */
297 ntype = TYPE_POINTER_TYPE (type);
302 return ntype; /* Don't care about alloc,
303 and have new type. */
304 else if (*typeptr == 0)
306 *typeptr = ntype; /* Tracking alloc, and have new type. */
311 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
313 ntype = alloc_type_copy (type);
317 else /* We have storage, but need to reset it. */
320 chain = TYPE_CHAIN (ntype);
322 TYPE_CHAIN (ntype) = chain;
325 TYPE_TARGET_TYPE (ntype) = type;
326 TYPE_POINTER_TYPE (type) = ntype;
328 /* FIXME! Assumes the machine has only one representation for pointers! */
331 = gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
332 TYPE_CODE (ntype) = TYPE_CODE_PTR;
334 /* Mark pointers as unsigned. The target converts between pointers
335 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
336 gdbarch_address_to_pointer. */
337 TYPE_UNSIGNED (ntype) = 1;
339 /* Update the length of all the other variants of this type. */
340 chain = TYPE_CHAIN (ntype);
341 while (chain != ntype)
343 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
344 chain = TYPE_CHAIN (chain);
350 /* Given a type TYPE, return a type of pointers to that type.
351 May need to construct such a type if this is the first use. */
354 lookup_pointer_type (struct type *type)
356 return make_pointer_type (type, (struct type **) 0);
359 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
360 points to a pointer to memory where the reference type should be
361 stored. If *TYPEPTR is zero, update it to point to the reference
362 type we return. We allocate new memory if needed. */
365 make_reference_type (struct type *type, struct type **typeptr)
367 struct type *ntype; /* New type */
370 ntype = TYPE_REFERENCE_TYPE (type);
375 return ntype; /* Don't care about alloc,
376 and have new type. */
377 else if (*typeptr == 0)
379 *typeptr = ntype; /* Tracking alloc, and have new type. */
384 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
386 ntype = alloc_type_copy (type);
390 else /* We have storage, but need to reset it. */
393 chain = TYPE_CHAIN (ntype);
395 TYPE_CHAIN (ntype) = chain;
398 TYPE_TARGET_TYPE (ntype) = type;
399 TYPE_REFERENCE_TYPE (type) = ntype;
401 /* FIXME! Assume the machine has only one representation for
402 references, and that it matches the (only) representation for
405 TYPE_LENGTH (ntype) =
406 gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
407 TYPE_CODE (ntype) = TYPE_CODE_REF;
409 if (!TYPE_REFERENCE_TYPE (type)) /* Remember it, if don't have one. */
410 TYPE_REFERENCE_TYPE (type) = ntype;
412 /* Update the length of all the other variants of this type. */
413 chain = TYPE_CHAIN (ntype);
414 while (chain != ntype)
416 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
417 chain = TYPE_CHAIN (chain);
423 /* Same as above, but caller doesn't care about memory allocation
427 lookup_reference_type (struct type *type)
429 return make_reference_type (type, (struct type **) 0);
432 /* Lookup a function type that returns type TYPE. TYPEPTR, if
433 nonzero, points to a pointer to memory where the function type
434 should be stored. If *TYPEPTR is zero, update it to point to the
435 function type we return. We allocate new memory if needed. */
438 make_function_type (struct type *type, struct type **typeptr)
440 struct type *ntype; /* New type */
442 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
444 ntype = alloc_type_copy (type);
448 else /* We have storage, but need to reset it. */
454 TYPE_TARGET_TYPE (ntype) = type;
456 TYPE_LENGTH (ntype) = 1;
457 TYPE_CODE (ntype) = TYPE_CODE_FUNC;
459 INIT_FUNC_SPECIFIC (ntype);
464 /* Given a type TYPE, return a type of functions that return that type.
465 May need to construct such a type if this is the first use. */
468 lookup_function_type (struct type *type)
470 return make_function_type (type, (struct type **) 0);
473 /* Given a type TYPE and argument types, return the appropriate
474 function type. If the final type in PARAM_TYPES is NULL, make a
478 lookup_function_type_with_arguments (struct type *type,
480 struct type **param_types)
482 struct type *fn = make_function_type (type, (struct type **) 0);
487 if (param_types[nparams - 1] == NULL)
490 TYPE_VARARGS (fn) = 1;
492 else if (TYPE_CODE (check_typedef (param_types[nparams - 1]))
496 /* Caller should have ensured this. */
497 gdb_assert (nparams == 0);
498 TYPE_PROTOTYPED (fn) = 1;
502 TYPE_NFIELDS (fn) = nparams;
503 TYPE_FIELDS (fn) = TYPE_ZALLOC (fn, nparams * sizeof (struct field));
504 for (i = 0; i < nparams; ++i)
505 TYPE_FIELD_TYPE (fn, i) = param_types[i];
510 /* Identify address space identifier by name --
511 return the integer flag defined in gdbtypes.h. */
514 address_space_name_to_int (struct gdbarch *gdbarch, char *space_identifier)
518 /* Check for known address space delimiters. */
519 if (!strcmp (space_identifier, "code"))
520 return TYPE_INSTANCE_FLAG_CODE_SPACE;
521 else if (!strcmp (space_identifier, "data"))
522 return TYPE_INSTANCE_FLAG_DATA_SPACE;
523 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch)
524 && gdbarch_address_class_name_to_type_flags (gdbarch,
529 error (_("Unknown address space specifier: \"%s\""), space_identifier);
532 /* Identify address space identifier by integer flag as defined in
533 gdbtypes.h -- return the string version of the adress space name. */
536 address_space_int_to_name (struct gdbarch *gdbarch, int space_flag)
538 if (space_flag & TYPE_INSTANCE_FLAG_CODE_SPACE)
540 else if (space_flag & TYPE_INSTANCE_FLAG_DATA_SPACE)
542 else if ((space_flag & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
543 && gdbarch_address_class_type_flags_to_name_p (gdbarch))
544 return gdbarch_address_class_type_flags_to_name (gdbarch, space_flag);
549 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
551 If STORAGE is non-NULL, create the new type instance there.
552 STORAGE must be in the same obstack as TYPE. */
555 make_qualified_type (struct type *type, int new_flags,
556 struct type *storage)
563 if (TYPE_INSTANCE_FLAGS (ntype) == new_flags)
565 ntype = TYPE_CHAIN (ntype);
567 while (ntype != type);
569 /* Create a new type instance. */
571 ntype = alloc_type_instance (type);
574 /* If STORAGE was provided, it had better be in the same objfile
575 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
576 if one objfile is freed and the other kept, we'd have
577 dangling pointers. */
578 gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage));
581 TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type);
582 TYPE_CHAIN (ntype) = ntype;
585 /* Pointers or references to the original type are not relevant to
587 TYPE_POINTER_TYPE (ntype) = (struct type *) 0;
588 TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0;
590 /* Chain the new qualified type to the old type. */
591 TYPE_CHAIN (ntype) = TYPE_CHAIN (type);
592 TYPE_CHAIN (type) = ntype;
594 /* Now set the instance flags and return the new type. */
595 TYPE_INSTANCE_FLAGS (ntype) = new_flags;
597 /* Set length of new type to that of the original type. */
598 TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
603 /* Make an address-space-delimited variant of a type -- a type that
604 is identical to the one supplied except that it has an address
605 space attribute attached to it (such as "code" or "data").
607 The space attributes "code" and "data" are for Harvard
608 architectures. The address space attributes are for architectures
609 which have alternately sized pointers or pointers with alternate
613 make_type_with_address_space (struct type *type, int space_flag)
615 int new_flags = ((TYPE_INSTANCE_FLAGS (type)
616 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
617 | TYPE_INSTANCE_FLAG_DATA_SPACE
618 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL))
621 return make_qualified_type (type, new_flags, NULL);
624 /* Make a "c-v" variant of a type -- a type that is identical to the
625 one supplied except that it may have const or volatile attributes
626 CNST is a flag for setting the const attribute
627 VOLTL is a flag for setting the volatile attribute
628 TYPE is the base type whose variant we are creating.
630 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
631 storage to hold the new qualified type; *TYPEPTR and TYPE must be
632 in the same objfile. Otherwise, allocate fresh memory for the new
633 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
634 new type we construct. */
637 make_cv_type (int cnst, int voltl,
639 struct type **typeptr)
641 struct type *ntype; /* New type */
643 int new_flags = (TYPE_INSTANCE_FLAGS (type)
644 & ~(TYPE_INSTANCE_FLAG_CONST
645 | TYPE_INSTANCE_FLAG_VOLATILE));
648 new_flags |= TYPE_INSTANCE_FLAG_CONST;
651 new_flags |= TYPE_INSTANCE_FLAG_VOLATILE;
653 if (typeptr && *typeptr != NULL)
655 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
656 a C-V variant chain that threads across objfiles: if one
657 objfile gets freed, then the other has a broken C-V chain.
659 This code used to try to copy over the main type from TYPE to
660 *TYPEPTR if they were in different objfiles, but that's
661 wrong, too: TYPE may have a field list or member function
662 lists, which refer to types of their own, etc. etc. The
663 whole shebang would need to be copied over recursively; you
664 can't have inter-objfile pointers. The only thing to do is
665 to leave stub types as stub types, and look them up afresh by
666 name each time you encounter them. */
667 gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type));
670 ntype = make_qualified_type (type, new_flags,
671 typeptr ? *typeptr : NULL);
679 /* Replace the contents of ntype with the type *type. This changes the
680 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
681 the changes are propogated to all types in the TYPE_CHAIN.
683 In order to build recursive types, it's inevitable that we'll need
684 to update types in place --- but this sort of indiscriminate
685 smashing is ugly, and needs to be replaced with something more
686 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
687 clear if more steps are needed. */
690 replace_type (struct type *ntype, struct type *type)
694 /* These two types had better be in the same objfile. Otherwise,
695 the assignment of one type's main type structure to the other
696 will produce a type with references to objects (names; field
697 lists; etc.) allocated on an objfile other than its own. */
698 gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (ntype));
700 *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
702 /* The type length is not a part of the main type. Update it for
703 each type on the variant chain. */
707 /* Assert that this element of the chain has no address-class bits
708 set in its flags. Such type variants might have type lengths
709 which are supposed to be different from the non-address-class
710 variants. This assertion shouldn't ever be triggered because
711 symbol readers which do construct address-class variants don't
712 call replace_type(). */
713 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0);
715 TYPE_LENGTH (chain) = TYPE_LENGTH (type);
716 chain = TYPE_CHAIN (chain);
718 while (ntype != chain);
720 /* Assert that the two types have equivalent instance qualifiers.
721 This should be true for at least all of our debug readers. */
722 gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type));
725 /* Implement direct support for MEMBER_TYPE in GNU C++.
726 May need to construct such a type if this is the first use.
727 The TYPE is the type of the member. The DOMAIN is the type
728 of the aggregate that the member belongs to. */
731 lookup_memberptr_type (struct type *type, struct type *domain)
735 mtype = alloc_type_copy (type);
736 smash_to_memberptr_type (mtype, domain, type);
740 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
743 lookup_methodptr_type (struct type *to_type)
747 mtype = alloc_type_copy (to_type);
748 smash_to_methodptr_type (mtype, to_type);
752 /* Allocate a stub method whose return type is TYPE. This apparently
753 happens for speed of symbol reading, since parsing out the
754 arguments to the method is cpu-intensive, the way we are doing it.
755 So, we will fill in arguments later. This always returns a fresh
759 allocate_stub_method (struct type *type)
763 mtype = alloc_type_copy (type);
764 TYPE_CODE (mtype) = TYPE_CODE_METHOD;
765 TYPE_LENGTH (mtype) = 1;
766 TYPE_STUB (mtype) = 1;
767 TYPE_TARGET_TYPE (mtype) = type;
768 /* _DOMAIN_TYPE (mtype) = unknown yet */
772 /* Create a range type using either a blank type supplied in
773 RESULT_TYPE, or creating a new type, inheriting the objfile from
776 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
777 to HIGH_BOUND, inclusive.
779 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
780 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
783 create_range_type (struct type *result_type, struct type *index_type,
784 LONGEST low_bound, LONGEST high_bound)
786 if (result_type == NULL)
787 result_type = alloc_type_copy (index_type);
788 TYPE_CODE (result_type) = TYPE_CODE_RANGE;
789 TYPE_TARGET_TYPE (result_type) = index_type;
790 if (TYPE_STUB (index_type))
791 TYPE_TARGET_STUB (result_type) = 1;
793 TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
794 TYPE_RANGE_DATA (result_type) = (struct range_bounds *)
795 TYPE_ZALLOC (result_type, sizeof (struct range_bounds));
796 TYPE_LOW_BOUND (result_type) = low_bound;
797 TYPE_HIGH_BOUND (result_type) = high_bound;
800 TYPE_UNSIGNED (result_type) = 1;
805 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
806 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
807 bounds will fit in LONGEST), or -1 otherwise. */
810 get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
812 CHECK_TYPEDEF (type);
813 switch (TYPE_CODE (type))
815 case TYPE_CODE_RANGE:
816 *lowp = TYPE_LOW_BOUND (type);
817 *highp = TYPE_HIGH_BOUND (type);
820 if (TYPE_NFIELDS (type) > 0)
822 /* The enums may not be sorted by value, so search all
826 *lowp = *highp = TYPE_FIELD_ENUMVAL (type, 0);
827 for (i = 0; i < TYPE_NFIELDS (type); i++)
829 if (TYPE_FIELD_ENUMVAL (type, i) < *lowp)
830 *lowp = TYPE_FIELD_ENUMVAL (type, i);
831 if (TYPE_FIELD_ENUMVAL (type, i) > *highp)
832 *highp = TYPE_FIELD_ENUMVAL (type, i);
835 /* Set unsigned indicator if warranted. */
838 TYPE_UNSIGNED (type) = 1;
852 if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */
854 if (!TYPE_UNSIGNED (type))
856 *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
860 /* ... fall through for unsigned ints ... */
863 /* This round-about calculation is to avoid shifting by
864 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
865 if TYPE_LENGTH (type) == sizeof (LONGEST). */
866 *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
867 *highp = (*highp - 1) | *highp;
874 /* Assuming TYPE is a simple, non-empty array type, compute its upper
875 and lower bound. Save the low bound into LOW_BOUND if not NULL.
876 Save the high bound into HIGH_BOUND if not NULL.
878 Return 1 if the operation was successful. Return zero otherwise,
879 in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
881 We now simply use get_discrete_bounds call to get the values
882 of the low and high bounds.
883 get_discrete_bounds can return three values:
884 1, meaning that index is a range,
885 0, meaning that index is a discrete type,
886 or -1 for failure. */
889 get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound)
891 struct type *index = TYPE_INDEX_TYPE (type);
899 res = get_discrete_bounds (index, &low, &high);
903 /* Check if the array bounds are undefined. */
905 && ((low_bound && TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type))
906 || (high_bound && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))))
918 /* Create an array type using either a blank type supplied in
919 RESULT_TYPE, or creating a new type, inheriting the objfile from
922 Elements will be of type ELEMENT_TYPE, the indices will be of type
925 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
926 sure it is TYPE_CODE_UNDEF before we bash it into an array
930 create_array_type (struct type *result_type,
931 struct type *element_type,
932 struct type *range_type)
934 LONGEST low_bound, high_bound;
936 if (result_type == NULL)
937 result_type = alloc_type_copy (range_type);
939 TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
940 TYPE_TARGET_TYPE (result_type) = element_type;
941 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
942 low_bound = high_bound = 0;
943 CHECK_TYPEDEF (element_type);
944 /* Be careful when setting the array length. Ada arrays can be
945 empty arrays with the high_bound being smaller than the low_bound.
946 In such cases, the array length should be zero. */
947 if (high_bound < low_bound)
948 TYPE_LENGTH (result_type) = 0;
950 TYPE_LENGTH (result_type) =
951 TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
952 TYPE_NFIELDS (result_type) = 1;
953 TYPE_FIELDS (result_type) =
954 (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
955 TYPE_INDEX_TYPE (result_type) = range_type;
956 TYPE_VPTR_FIELDNO (result_type) = -1;
958 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays. */
959 if (TYPE_LENGTH (result_type) == 0)
960 TYPE_TARGET_STUB (result_type) = 1;
966 lookup_array_range_type (struct type *element_type,
967 int low_bound, int high_bound)
969 struct gdbarch *gdbarch = get_type_arch (element_type);
970 struct type *index_type = builtin_type (gdbarch)->builtin_int;
971 struct type *range_type
972 = create_range_type (NULL, index_type, low_bound, high_bound);
974 return create_array_type (NULL, element_type, range_type);
977 /* Create a string type using either a blank type supplied in
978 RESULT_TYPE, or creating a new type. String types are similar
979 enough to array of char types that we can use create_array_type to
980 build the basic type and then bash it into a string type.
982 For fixed length strings, the range type contains 0 as the lower
983 bound and the length of the string minus one as the upper bound.
985 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
986 sure it is TYPE_CODE_UNDEF before we bash it into a string
990 create_string_type (struct type *result_type,
991 struct type *string_char_type,
992 struct type *range_type)
994 result_type = create_array_type (result_type,
997 TYPE_CODE (result_type) = TYPE_CODE_STRING;
1002 lookup_string_range_type (struct type *string_char_type,
1003 int low_bound, int high_bound)
1005 struct type *result_type;
1007 result_type = lookup_array_range_type (string_char_type,
1008 low_bound, high_bound);
1009 TYPE_CODE (result_type) = TYPE_CODE_STRING;
1014 create_set_type (struct type *result_type, struct type *domain_type)
1016 if (result_type == NULL)
1017 result_type = alloc_type_copy (domain_type);
1019 TYPE_CODE (result_type) = TYPE_CODE_SET;
1020 TYPE_NFIELDS (result_type) = 1;
1021 TYPE_FIELDS (result_type) = TYPE_ZALLOC (result_type, sizeof (struct field));
1023 if (!TYPE_STUB (domain_type))
1025 LONGEST low_bound, high_bound, bit_length;
1027 if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
1028 low_bound = high_bound = 0;
1029 bit_length = high_bound - low_bound + 1;
1030 TYPE_LENGTH (result_type)
1031 = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
1033 TYPE_UNSIGNED (result_type) = 1;
1035 TYPE_FIELD_TYPE (result_type, 0) = domain_type;
1040 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
1041 and any array types nested inside it. */
1044 make_vector_type (struct type *array_type)
1046 struct type *inner_array, *elt_type;
1049 /* Find the innermost array type, in case the array is
1050 multi-dimensional. */
1051 inner_array = array_type;
1052 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
1053 inner_array = TYPE_TARGET_TYPE (inner_array);
1055 elt_type = TYPE_TARGET_TYPE (inner_array);
1056 if (TYPE_CODE (elt_type) == TYPE_CODE_INT)
1058 flags = TYPE_INSTANCE_FLAGS (elt_type) | TYPE_INSTANCE_FLAG_NOTTEXT;
1059 elt_type = make_qualified_type (elt_type, flags, NULL);
1060 TYPE_TARGET_TYPE (inner_array) = elt_type;
1063 TYPE_VECTOR (array_type) = 1;
1067 init_vector_type (struct type *elt_type, int n)
1069 struct type *array_type;
1071 array_type = lookup_array_range_type (elt_type, 0, n - 1);
1072 make_vector_type (array_type);
1076 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
1077 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1078 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1079 TYPE doesn't include the offset (that's the value of the MEMBER
1080 itself), but does include the structure type into which it points
1083 When "smashing" the type, we preserve the objfile that the old type
1084 pointed to, since we aren't changing where the type is actually
1088 smash_to_memberptr_type (struct type *type, struct type *domain,
1089 struct type *to_type)
1092 TYPE_TARGET_TYPE (type) = to_type;
1093 TYPE_DOMAIN_TYPE (type) = domain;
1094 /* Assume that a data member pointer is the same size as a normal
1097 = gdbarch_ptr_bit (get_type_arch (to_type)) / TARGET_CHAR_BIT;
1098 TYPE_CODE (type) = TYPE_CODE_MEMBERPTR;
1101 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1103 When "smashing" the type, we preserve the objfile that the old type
1104 pointed to, since we aren't changing where the type is actually
1108 smash_to_methodptr_type (struct type *type, struct type *to_type)
1111 TYPE_TARGET_TYPE (type) = to_type;
1112 TYPE_DOMAIN_TYPE (type) = TYPE_DOMAIN_TYPE (to_type);
1113 TYPE_LENGTH (type) = cplus_method_ptr_size (to_type);
1114 TYPE_CODE (type) = TYPE_CODE_METHODPTR;
1117 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
1118 METHOD just means `function that gets an extra "this" argument'.
1120 When "smashing" the type, we preserve the objfile that the old type
1121 pointed to, since we aren't changing where the type is actually
1125 smash_to_method_type (struct type *type, struct type *domain,
1126 struct type *to_type, struct field *args,
1127 int nargs, int varargs)
1130 TYPE_TARGET_TYPE (type) = to_type;
1131 TYPE_DOMAIN_TYPE (type) = domain;
1132 TYPE_FIELDS (type) = args;
1133 TYPE_NFIELDS (type) = nargs;
1135 TYPE_VARARGS (type) = 1;
1136 TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
1137 TYPE_CODE (type) = TYPE_CODE_METHOD;
1140 /* Return a typename for a struct/union/enum type without "struct ",
1141 "union ", or "enum ". If the type has a NULL name, return NULL. */
1144 type_name_no_tag (const struct type *type)
1146 if (TYPE_TAG_NAME (type) != NULL)
1147 return TYPE_TAG_NAME (type);
1149 /* Is there code which expects this to return the name if there is
1150 no tag name? My guess is that this is mainly used for C++ in
1151 cases where the two will always be the same. */
1152 return TYPE_NAME (type);
1155 /* A wrapper of type_name_no_tag which calls error if the type is anonymous.
1156 Since GCC PR debug/47510 DWARF provides associated information to detect the
1157 anonymous class linkage name from its typedef.
1159 Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
1163 type_name_no_tag_or_error (struct type *type)
1165 struct type *saved_type = type;
1167 struct objfile *objfile;
1169 CHECK_TYPEDEF (type);
1171 name = type_name_no_tag (type);
1175 name = type_name_no_tag (saved_type);
1176 objfile = TYPE_OBJFILE (saved_type);
1177 error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
1178 name ? name : "<anonymous>", objfile ? objfile->name : "<arch>");
1181 /* Lookup a typedef or primitive type named NAME, visible in lexical
1182 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1183 suitably defined. */
1186 lookup_typename (const struct language_defn *language,
1187 struct gdbarch *gdbarch, const char *name,
1188 const struct block *block, int noerr)
1193 sym = lookup_symbol (name, block, VAR_DOMAIN, 0);
1194 if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1195 return SYMBOL_TYPE (sym);
1197 type = language_lookup_primitive_type_by_name (language, gdbarch, name);
1203 error (_("No type named %s."), name);
1207 lookup_unsigned_typename (const struct language_defn *language,
1208 struct gdbarch *gdbarch, const char *name)
1210 char *uns = alloca (strlen (name) + 10);
1212 strcpy (uns, "unsigned ");
1213 strcpy (uns + 9, name);
1214 return lookup_typename (language, gdbarch, uns, (struct block *) NULL, 0);
1218 lookup_signed_typename (const struct language_defn *language,
1219 struct gdbarch *gdbarch, const char *name)
1222 char *uns = alloca (strlen (name) + 8);
1224 strcpy (uns, "signed ");
1225 strcpy (uns + 7, name);
1226 t = lookup_typename (language, gdbarch, uns, (struct block *) NULL, 1);
1227 /* If we don't find "signed FOO" just try again with plain "FOO". */
1230 return lookup_typename (language, gdbarch, name, (struct block *) NULL, 0);
1233 /* Lookup a structure type named "struct NAME",
1234 visible in lexical block BLOCK. */
1237 lookup_struct (const char *name, struct block *block)
1241 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1245 error (_("No struct type named %s."), name);
1247 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1249 error (_("This context has class, union or enum %s, not a struct."),
1252 return (SYMBOL_TYPE (sym));
1255 /* Lookup a union type named "union NAME",
1256 visible in lexical block BLOCK. */
1259 lookup_union (const char *name, struct block *block)
1264 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1267 error (_("No union type named %s."), name);
1269 t = SYMBOL_TYPE (sym);
1271 if (TYPE_CODE (t) == TYPE_CODE_UNION)
1274 /* If we get here, it's not a union. */
1275 error (_("This context has class, struct or enum %s, not a union."),
1279 /* Lookup an enum type named "enum NAME",
1280 visible in lexical block BLOCK. */
1283 lookup_enum (const char *name, struct block *block)
1287 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1290 error (_("No enum type named %s."), name);
1292 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
1294 error (_("This context has class, struct or union %s, not an enum."),
1297 return (SYMBOL_TYPE (sym));
1300 /* Lookup a template type named "template NAME<TYPE>",
1301 visible in lexical block BLOCK. */
1304 lookup_template_type (char *name, struct type *type,
1305 struct block *block)
1308 char *nam = (char *)
1309 alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4);
1313 strcat (nam, TYPE_NAME (type));
1314 strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
1316 sym = lookup_symbol (nam, block, VAR_DOMAIN, 0);
1320 error (_("No template type named %s."), name);
1322 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1324 error (_("This context has class, union or enum %s, not a struct."),
1327 return (SYMBOL_TYPE (sym));
1330 /* Given a type TYPE, lookup the type of the component of type named
1333 TYPE can be either a struct or union, or a pointer or reference to
1334 a struct or union. If it is a pointer or reference, its target
1335 type is automatically used. Thus '.' and '->' are interchangable,
1336 as specified for the definitions of the expression element types
1337 STRUCTOP_STRUCT and STRUCTOP_PTR.
1339 If NOERR is nonzero, return zero if NAME is not suitably defined.
1340 If NAME is the name of a baseclass type, return that type. */
1343 lookup_struct_elt_type (struct type *type, char *name, int noerr)
1350 CHECK_TYPEDEF (type);
1351 if (TYPE_CODE (type) != TYPE_CODE_PTR
1352 && TYPE_CODE (type) != TYPE_CODE_REF)
1354 type = TYPE_TARGET_TYPE (type);
1357 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1358 && TYPE_CODE (type) != TYPE_CODE_UNION)
1360 typename = type_to_string (type);
1361 make_cleanup (xfree, typename);
1362 error (_("Type %s is not a structure or union type."), typename);
1366 /* FIXME: This change put in by Michael seems incorrect for the case
1367 where the structure tag name is the same as the member name.
1368 I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
1369 foo; } bell;" Disabled by fnf. */
1373 typename = type_name_no_tag (type);
1374 if (typename != NULL && strcmp (typename, name) == 0)
1379 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1381 const char *t_field_name = TYPE_FIELD_NAME (type, i);
1383 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1385 return TYPE_FIELD_TYPE (type, i);
1387 else if (!t_field_name || *t_field_name == '\0')
1389 struct type *subtype
1390 = lookup_struct_elt_type (TYPE_FIELD_TYPE (type, i), name, 1);
1392 if (subtype != NULL)
1397 /* OK, it's not in this class. Recursively check the baseclasses. */
1398 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1402 t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 1);
1414 typename = type_to_string (type);
1415 make_cleanup (xfree, typename);
1416 error (_("Type %s has no component named %s."), typename, name);
1419 /* Lookup the vptr basetype/fieldno values for TYPE.
1420 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1421 vptr_fieldno. Also, if found and basetype is from the same objfile,
1423 If not found, return -1 and ignore BASETYPEP.
1424 Callers should be aware that in some cases (for example,
1425 the type or one of its baseclasses is a stub type and we are
1426 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1427 this function will not be able to find the
1428 virtual function table pointer, and vptr_fieldno will remain -1 and
1429 vptr_basetype will remain NULL or incomplete. */
1432 get_vptr_fieldno (struct type *type, struct type **basetypep)
1434 CHECK_TYPEDEF (type);
1436 if (TYPE_VPTR_FIELDNO (type) < 0)
1440 /* We must start at zero in case the first (and only) baseclass
1441 is virtual (and hence we cannot share the table pointer). */
1442 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1444 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
1446 struct type *basetype;
1448 fieldno = get_vptr_fieldno (baseclass, &basetype);
1451 /* If the type comes from a different objfile we can't cache
1452 it, it may have a different lifetime. PR 2384 */
1453 if (TYPE_OBJFILE (type) == TYPE_OBJFILE (basetype))
1455 TYPE_VPTR_FIELDNO (type) = fieldno;
1456 TYPE_VPTR_BASETYPE (type) = basetype;
1459 *basetypep = basetype;
1470 *basetypep = TYPE_VPTR_BASETYPE (type);
1471 return TYPE_VPTR_FIELDNO (type);
1476 stub_noname_complaint (void)
1478 complaint (&symfile_complaints, _("stub type has NULL name"));
1481 /* Find the real type of TYPE. This function returns the real type,
1482 after removing all layers of typedefs, and completing opaque or stub
1483 types. Completion changes the TYPE argument, but stripping of
1486 Instance flags (e.g. const/volatile) are preserved as typedefs are
1487 stripped. If necessary a new qualified form of the underlying type
1490 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
1491 not been computed and we're either in the middle of reading symbols, or
1492 there was no name for the typedef in the debug info.
1494 NOTE: Lookup of opaque types can throw errors for invalid symbol files.
1495 QUITs in the symbol reading code can also throw.
1496 Thus this function can throw an exception.
1498 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
1501 If this is a stubbed struct (i.e. declared as struct foo *), see if
1502 we can find a full definition in some other file. If so, copy this
1503 definition, so we can use it in future. There used to be a comment
1504 (but not any code) that if we don't find a full definition, we'd
1505 set a flag so we don't spend time in the future checking the same
1506 type. That would be a mistake, though--we might load in more
1507 symbols which contain a full definition for the type. */
1510 check_typedef (struct type *type)
1512 struct type *orig_type = type;
1513 /* While we're removing typedefs, we don't want to lose qualifiers.
1514 E.g., const/volatile. */
1515 int instance_flags = TYPE_INSTANCE_FLAGS (type);
1519 while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1521 if (!TYPE_TARGET_TYPE (type))
1526 /* It is dangerous to call lookup_symbol if we are currently
1527 reading a symtab. Infinite recursion is one danger. */
1528 if (currently_reading_symtab)
1529 return make_qualified_type (type, instance_flags, NULL);
1531 name = type_name_no_tag (type);
1532 /* FIXME: shouldn't we separately check the TYPE_NAME and
1533 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1534 VAR_DOMAIN as appropriate? (this code was written before
1535 TYPE_NAME and TYPE_TAG_NAME were separate). */
1538 stub_noname_complaint ();
1539 return make_qualified_type (type, instance_flags, NULL);
1541 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
1543 TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
1544 else /* TYPE_CODE_UNDEF */
1545 TYPE_TARGET_TYPE (type) = alloc_type_arch (get_type_arch (type));
1547 type = TYPE_TARGET_TYPE (type);
1549 /* Preserve the instance flags as we traverse down the typedef chain.
1551 Handling address spaces/classes is nasty, what do we do if there's a
1553 E.g., what if an outer typedef marks the type as class_1 and an inner
1554 typedef marks the type as class_2?
1555 This is the wrong place to do such error checking. We leave it to
1556 the code that created the typedef in the first place to flag the
1557 error. We just pick the outer address space (akin to letting the
1558 outer cast in a chain of casting win), instead of assuming
1559 "it can't happen". */
1561 const int ALL_SPACES = (TYPE_INSTANCE_FLAG_CODE_SPACE
1562 | TYPE_INSTANCE_FLAG_DATA_SPACE);
1563 const int ALL_CLASSES = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL;
1564 int new_instance_flags = TYPE_INSTANCE_FLAGS (type);
1566 /* Treat code vs data spaces and address classes separately. */
1567 if ((instance_flags & ALL_SPACES) != 0)
1568 new_instance_flags &= ~ALL_SPACES;
1569 if ((instance_flags & ALL_CLASSES) != 0)
1570 new_instance_flags &= ~ALL_CLASSES;
1572 instance_flags |= new_instance_flags;
1576 /* If this is a struct/class/union with no fields, then check
1577 whether a full definition exists somewhere else. This is for
1578 systems where a type definition with no fields is issued for such
1579 types, instead of identifying them as stub types in the first
1582 if (TYPE_IS_OPAQUE (type)
1583 && opaque_type_resolution
1584 && !currently_reading_symtab)
1586 const char *name = type_name_no_tag (type);
1587 struct type *newtype;
1591 stub_noname_complaint ();
1592 return make_qualified_type (type, instance_flags, NULL);
1594 newtype = lookup_transparent_type (name);
1598 /* If the resolved type and the stub are in the same
1599 objfile, then replace the stub type with the real deal.
1600 But if they're in separate objfiles, leave the stub
1601 alone; we'll just look up the transparent type every time
1602 we call check_typedef. We can't create pointers between
1603 types allocated to different objfiles, since they may
1604 have different lifetimes. Trying to copy NEWTYPE over to
1605 TYPE's objfile is pointless, too, since you'll have to
1606 move over any other types NEWTYPE refers to, which could
1607 be an unbounded amount of stuff. */
1608 if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type))
1609 type = make_qualified_type (newtype,
1610 TYPE_INSTANCE_FLAGS (type),
1616 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1618 else if (TYPE_STUB (type) && !currently_reading_symtab)
1620 const char *name = type_name_no_tag (type);
1621 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1622 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1623 as appropriate? (this code was written before TYPE_NAME and
1624 TYPE_TAG_NAME were separate). */
1629 stub_noname_complaint ();
1630 return make_qualified_type (type, instance_flags, NULL);
1632 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
1635 /* Same as above for opaque types, we can replace the stub
1636 with the complete type only if they are in the same
1638 if (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type))
1639 type = make_qualified_type (SYMBOL_TYPE (sym),
1640 TYPE_INSTANCE_FLAGS (type),
1643 type = SYMBOL_TYPE (sym);
1647 if (TYPE_TARGET_STUB (type))
1649 struct type *range_type;
1650 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1652 if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type))
1654 /* Nothing we can do. */
1656 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
1657 && TYPE_NFIELDS (type) == 1
1658 && (TYPE_CODE (range_type = TYPE_INDEX_TYPE (type))
1659 == TYPE_CODE_RANGE))
1661 /* Now recompute the length of the array type, based on its
1662 number of elements and the target type's length.
1663 Watch out for Ada null Ada arrays where the high bound
1664 is smaller than the low bound. */
1665 const LONGEST low_bound = TYPE_LOW_BOUND (range_type);
1666 const LONGEST high_bound = TYPE_HIGH_BOUND (range_type);
1669 if (high_bound < low_bound)
1673 /* For now, we conservatively take the array length to be 0
1674 if its length exceeds UINT_MAX. The code below assumes
1675 that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
1676 which is technically not guaranteed by C, but is usually true
1677 (because it would be true if x were unsigned with its
1678 high-order bit on). It uses the fact that
1679 high_bound-low_bound is always representable in
1680 ULONGEST and that if high_bound-low_bound+1 overflows,
1681 it overflows to 0. We must change these tests if we
1682 decide to increase the representation of TYPE_LENGTH
1683 from unsigned int to ULONGEST. */
1684 ULONGEST ulow = low_bound, uhigh = high_bound;
1685 ULONGEST tlen = TYPE_LENGTH (target_type);
1687 len = tlen * (uhigh - ulow + 1);
1688 if (tlen == 0 || (len / tlen - 1 + ulow) != uhigh
1692 TYPE_LENGTH (type) = len;
1693 TYPE_TARGET_STUB (type) = 0;
1695 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
1697 TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
1698 TYPE_TARGET_STUB (type) = 0;
1702 type = make_qualified_type (type, instance_flags, NULL);
1704 /* Cache TYPE_LENGTH for future use. */
1705 TYPE_LENGTH (orig_type) = TYPE_LENGTH (type);
1710 /* Parse a type expression in the string [P..P+LENGTH). If an error
1711 occurs, silently return a void type. */
1713 static struct type *
1714 safe_parse_type (struct gdbarch *gdbarch, char *p, int length)
1716 struct ui_file *saved_gdb_stderr;
1717 struct type *type = NULL; /* Initialize to keep gcc happy. */
1718 volatile struct gdb_exception except;
1720 /* Suppress error messages. */
1721 saved_gdb_stderr = gdb_stderr;
1722 gdb_stderr = ui_file_new ();
1724 /* Call parse_and_eval_type() without fear of longjmp()s. */
1725 TRY_CATCH (except, RETURN_MASK_ERROR)
1727 type = parse_and_eval_type (p, length);
1730 if (except.reason < 0)
1731 type = builtin_type (gdbarch)->builtin_void;
1733 /* Stop suppressing error messages. */
1734 ui_file_delete (gdb_stderr);
1735 gdb_stderr = saved_gdb_stderr;
1740 /* Ugly hack to convert method stubs into method types.
1742 He ain't kiddin'. This demangles the name of the method into a
1743 string including argument types, parses out each argument type,
1744 generates a string casting a zero to that type, evaluates the
1745 string, and stuffs the resulting type into an argtype vector!!!
1746 Then it knows the type of the whole function (including argument
1747 types for overloading), which info used to be in the stab's but was
1748 removed to hack back the space required for them. */
1751 check_stub_method (struct type *type, int method_id, int signature_id)
1753 struct gdbarch *gdbarch = get_type_arch (type);
1755 char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
1756 char *demangled_name = cplus_demangle (mangled_name,
1757 DMGL_PARAMS | DMGL_ANSI);
1758 char *argtypetext, *p;
1759 int depth = 0, argcount = 1;
1760 struct field *argtypes;
1763 /* Make sure we got back a function string that we can use. */
1765 p = strchr (demangled_name, '(');
1769 if (demangled_name == NULL || p == NULL)
1770 error (_("Internal: Cannot demangle mangled name `%s'."),
1773 /* Now, read in the parameters that define this type. */
1778 if (*p == '(' || *p == '<')
1782 else if (*p == ')' || *p == '>')
1786 else if (*p == ',' && depth == 0)
1794 /* If we read one argument and it was ``void'', don't count it. */
1795 if (strncmp (argtypetext, "(void)", 6) == 0)
1798 /* We need one extra slot, for the THIS pointer. */
1800 argtypes = (struct field *)
1801 TYPE_ALLOC (type, (argcount + 1) * sizeof (struct field));
1804 /* Add THIS pointer for non-static methods. */
1805 f = TYPE_FN_FIELDLIST1 (type, method_id);
1806 if (TYPE_FN_FIELD_STATIC_P (f, signature_id))
1810 argtypes[0].type = lookup_pointer_type (type);
1814 if (*p != ')') /* () means no args, skip while. */
1819 if (depth <= 0 && (*p == ',' || *p == ')'))
1821 /* Avoid parsing of ellipsis, they will be handled below.
1822 Also avoid ``void'' as above. */
1823 if (strncmp (argtypetext, "...", p - argtypetext) != 0
1824 && strncmp (argtypetext, "void", p - argtypetext) != 0)
1826 argtypes[argcount].type =
1827 safe_parse_type (gdbarch, argtypetext, p - argtypetext);
1830 argtypetext = p + 1;
1833 if (*p == '(' || *p == '<')
1837 else if (*p == ')' || *p == '>')
1846 TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name;
1848 /* Now update the old "stub" type into a real type. */
1849 mtype = TYPE_FN_FIELD_TYPE (f, signature_id);
1850 TYPE_DOMAIN_TYPE (mtype) = type;
1851 TYPE_FIELDS (mtype) = argtypes;
1852 TYPE_NFIELDS (mtype) = argcount;
1853 TYPE_STUB (mtype) = 0;
1854 TYPE_FN_FIELD_STUB (f, signature_id) = 0;
1856 TYPE_VARARGS (mtype) = 1;
1858 xfree (demangled_name);
1861 /* This is the external interface to check_stub_method, above. This
1862 function unstubs all of the signatures for TYPE's METHOD_ID method
1863 name. After calling this function TYPE_FN_FIELD_STUB will be
1864 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1867 This function unfortunately can not die until stabs do. */
1870 check_stub_method_group (struct type *type, int method_id)
1872 int len = TYPE_FN_FIELDLIST_LENGTH (type, method_id);
1873 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
1874 int j, found_stub = 0;
1876 for (j = 0; j < len; j++)
1877 if (TYPE_FN_FIELD_STUB (f, j))
1880 check_stub_method (type, method_id, j);
1883 /* GNU v3 methods with incorrect names were corrected when we read
1884 in type information, because it was cheaper to do it then. The
1885 only GNU v2 methods with incorrect method names are operators and
1886 destructors; destructors were also corrected when we read in type
1889 Therefore the only thing we need to handle here are v2 operator
1891 if (found_stub && strncmp (TYPE_FN_FIELD_PHYSNAME (f, 0), "_Z", 2) != 0)
1894 char dem_opname[256];
1896 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
1898 dem_opname, DMGL_ANSI);
1900 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
1904 TYPE_FN_FIELDLIST_NAME (type, method_id) = xstrdup (dem_opname);
1908 /* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */
1909 const struct cplus_struct_type cplus_struct_default = { };
1912 allocate_cplus_struct_type (struct type *type)
1914 if (HAVE_CPLUS_STRUCT (type))
1915 /* Structure was already allocated. Nothing more to do. */
1918 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CPLUS_STUFF;
1919 TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
1920 TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
1921 *(TYPE_RAW_CPLUS_SPECIFIC (type)) = cplus_struct_default;
1924 const struct gnat_aux_type gnat_aux_default =
1927 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
1928 and allocate the associated gnat-specific data. The gnat-specific
1929 data is also initialized to gnat_aux_default. */
1932 allocate_gnat_aux_type (struct type *type)
1934 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_GNAT_STUFF;
1935 TYPE_GNAT_SPECIFIC (type) = (struct gnat_aux_type *)
1936 TYPE_ALLOC (type, sizeof (struct gnat_aux_type));
1937 *(TYPE_GNAT_SPECIFIC (type)) = gnat_aux_default;
1940 /* Helper function to initialize the standard scalar types.
1942 If NAME is non-NULL, then we make a copy of the string pointed
1943 to by name in the objfile_obstack for that objfile, and initialize
1944 the type name to that copy. There are places (mipsread.c in particular),
1945 where init_type is called with a NULL value for NAME). */
1948 init_type (enum type_code code, int length, int flags,
1949 char *name, struct objfile *objfile)
1953 type = alloc_type (objfile);
1954 TYPE_CODE (type) = code;
1955 TYPE_LENGTH (type) = length;
1957 gdb_assert (!(flags & (TYPE_FLAG_MIN - 1)));
1958 if (flags & TYPE_FLAG_UNSIGNED)
1959 TYPE_UNSIGNED (type) = 1;
1960 if (flags & TYPE_FLAG_NOSIGN)
1961 TYPE_NOSIGN (type) = 1;
1962 if (flags & TYPE_FLAG_STUB)
1963 TYPE_STUB (type) = 1;
1964 if (flags & TYPE_FLAG_TARGET_STUB)
1965 TYPE_TARGET_STUB (type) = 1;
1966 if (flags & TYPE_FLAG_STATIC)
1967 TYPE_STATIC (type) = 1;
1968 if (flags & TYPE_FLAG_PROTOTYPED)
1969 TYPE_PROTOTYPED (type) = 1;
1970 if (flags & TYPE_FLAG_INCOMPLETE)
1971 TYPE_INCOMPLETE (type) = 1;
1972 if (flags & TYPE_FLAG_VARARGS)
1973 TYPE_VARARGS (type) = 1;
1974 if (flags & TYPE_FLAG_VECTOR)
1975 TYPE_VECTOR (type) = 1;
1976 if (flags & TYPE_FLAG_STUB_SUPPORTED)
1977 TYPE_STUB_SUPPORTED (type) = 1;
1978 if (flags & TYPE_FLAG_FIXED_INSTANCE)
1979 TYPE_FIXED_INSTANCE (type) = 1;
1980 if (flags & TYPE_FLAG_GNU_IFUNC)
1981 TYPE_GNU_IFUNC (type) = 1;
1984 TYPE_NAME (type) = obsavestring (name, strlen (name),
1985 &objfile->objfile_obstack);
1989 if (name && strcmp (name, "char") == 0)
1990 TYPE_NOSIGN (type) = 1;
1994 case TYPE_CODE_STRUCT:
1995 case TYPE_CODE_UNION:
1996 case TYPE_CODE_NAMESPACE:
1997 INIT_CPLUS_SPECIFIC (type);
2000 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FLOATFORMAT;
2002 case TYPE_CODE_FUNC:
2003 INIT_FUNC_SPECIFIC (type);
2009 /* Queries on types. */
2012 can_dereference (struct type *t)
2014 /* FIXME: Should we return true for references as well as
2019 && TYPE_CODE (t) == TYPE_CODE_PTR
2020 && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
2024 is_integral_type (struct type *t)
2029 && ((TYPE_CODE (t) == TYPE_CODE_INT)
2030 || (TYPE_CODE (t) == TYPE_CODE_ENUM)
2031 || (TYPE_CODE (t) == TYPE_CODE_FLAGS)
2032 || (TYPE_CODE (t) == TYPE_CODE_CHAR)
2033 || (TYPE_CODE (t) == TYPE_CODE_RANGE)
2034 || (TYPE_CODE (t) == TYPE_CODE_BOOL)));
2037 /* Return true if TYPE is scalar. */
2040 is_scalar_type (struct type *type)
2042 CHECK_TYPEDEF (type);
2044 switch (TYPE_CODE (type))
2046 case TYPE_CODE_ARRAY:
2047 case TYPE_CODE_STRUCT:
2048 case TYPE_CODE_UNION:
2050 case TYPE_CODE_STRING:
2057 /* Return true if T is scalar, or a composite type which in practice has
2058 the memory layout of a scalar type. E.g., an array or struct with only
2059 one scalar element inside it, or a union with only scalar elements. */
2062 is_scalar_type_recursive (struct type *t)
2066 if (is_scalar_type (t))
2068 /* Are we dealing with an array or string of known dimensions? */
2069 else if ((TYPE_CODE (t) == TYPE_CODE_ARRAY
2070 || TYPE_CODE (t) == TYPE_CODE_STRING) && TYPE_NFIELDS (t) == 1
2071 && TYPE_CODE (TYPE_INDEX_TYPE (t)) == TYPE_CODE_RANGE)
2073 LONGEST low_bound, high_bound;
2074 struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t));
2076 get_discrete_bounds (TYPE_INDEX_TYPE (t), &low_bound, &high_bound);
2078 return high_bound == low_bound && is_scalar_type_recursive (elt_type);
2080 /* Are we dealing with a struct with one element? */
2081 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT && TYPE_NFIELDS (t) == 1)
2082 return is_scalar_type_recursive (TYPE_FIELD_TYPE (t, 0));
2083 else if (TYPE_CODE (t) == TYPE_CODE_UNION)
2085 int i, n = TYPE_NFIELDS (t);
2087 /* If all elements of the union are scalar, then the union is scalar. */
2088 for (i = 0; i < n; i++)
2089 if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t, i)))
2098 /* A helper function which returns true if types A and B represent the
2099 "same" class type. This is true if the types have the same main
2100 type, or the same name. */
2103 class_types_same_p (const struct type *a, const struct type *b)
2105 return (TYPE_MAIN_TYPE (a) == TYPE_MAIN_TYPE (b)
2106 || (TYPE_NAME (a) && TYPE_NAME (b)
2107 && !strcmp (TYPE_NAME (a), TYPE_NAME (b))));
2110 /* If BASE is an ancestor of DCLASS return the distance between them.
2111 otherwise return -1;
2115 class B: public A {};
2116 class C: public B {};
2119 distance_to_ancestor (A, A, 0) = 0
2120 distance_to_ancestor (A, B, 0) = 1
2121 distance_to_ancestor (A, C, 0) = 2
2122 distance_to_ancestor (A, D, 0) = 3
2124 If PUBLIC is 1 then only public ancestors are considered,
2125 and the function returns the distance only if BASE is a public ancestor
2129 distance_to_ancestor (A, D, 1) = -1. */
2132 distance_to_ancestor (struct type *base, struct type *dclass, int public)
2137 CHECK_TYPEDEF (base);
2138 CHECK_TYPEDEF (dclass);
2140 if (class_types_same_p (base, dclass))
2143 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
2145 if (public && ! BASETYPE_VIA_PUBLIC (dclass, i))
2148 d = distance_to_ancestor (base, TYPE_BASECLASS (dclass, i), public);
2156 /* Check whether BASE is an ancestor or base class or DCLASS
2157 Return 1 if so, and 0 if not.
2158 Note: If BASE and DCLASS are of the same type, this function
2159 will return 1. So for some class A, is_ancestor (A, A) will
2163 is_ancestor (struct type *base, struct type *dclass)
2165 return distance_to_ancestor (base, dclass, 0) >= 0;
2168 /* Like is_ancestor, but only returns true when BASE is a public
2169 ancestor of DCLASS. */
2172 is_public_ancestor (struct type *base, struct type *dclass)
2174 return distance_to_ancestor (base, dclass, 1) >= 0;
2177 /* A helper function for is_unique_ancestor. */
2180 is_unique_ancestor_worker (struct type *base, struct type *dclass,
2182 const gdb_byte *valaddr, int embedded_offset,
2183 CORE_ADDR address, struct value *val)
2187 CHECK_TYPEDEF (base);
2188 CHECK_TYPEDEF (dclass);
2190 for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i)
2195 iter = check_typedef (TYPE_BASECLASS (dclass, i));
2197 this_offset = baseclass_offset (dclass, i, valaddr, embedded_offset,
2200 if (class_types_same_p (base, iter))
2202 /* If this is the first subclass, set *OFFSET and set count
2203 to 1. Otherwise, if this is at the same offset as
2204 previous instances, do nothing. Otherwise, increment
2208 *offset = this_offset;
2211 else if (this_offset == *offset)
2219 count += is_unique_ancestor_worker (base, iter, offset,
2221 embedded_offset + this_offset,
2228 /* Like is_ancestor, but only returns true if BASE is a unique base
2229 class of the type of VAL. */
2232 is_unique_ancestor (struct type *base, struct value *val)
2236 return is_unique_ancestor_worker (base, value_type (val), &offset,
2237 value_contents_for_printing (val),
2238 value_embedded_offset (val),
2239 value_address (val), val) == 1;
2243 /* Overload resolution. */
2245 /* Return the sum of the rank of A with the rank of B. */
2248 sum_ranks (struct rank a, struct rank b)
2251 c.rank = a.rank + b.rank;
2252 c.subrank = a.subrank + b.subrank;
2256 /* Compare rank A and B and return:
2258 1 if a is better than b
2259 -1 if b is better than a. */
2262 compare_ranks (struct rank a, struct rank b)
2264 if (a.rank == b.rank)
2266 if (a.subrank == b.subrank)
2268 if (a.subrank < b.subrank)
2270 if (a.subrank > b.subrank)
2274 if (a.rank < b.rank)
2277 /* a.rank > b.rank */
2281 /* Functions for overload resolution begin here. */
2283 /* Compare two badness vectors A and B and return the result.
2284 0 => A and B are identical
2285 1 => A and B are incomparable
2286 2 => A is better than B
2287 3 => A is worse than B */
2290 compare_badness (struct badness_vector *a, struct badness_vector *b)
2294 short found_pos = 0; /* any positives in c? */
2295 short found_neg = 0; /* any negatives in c? */
2297 /* differing lengths => incomparable */
2298 if (a->length != b->length)
2301 /* Subtract b from a */
2302 for (i = 0; i < a->length; i++)
2304 tmp = compare_ranks (b->rank[i], a->rank[i]);
2314 return 1; /* incomparable */
2316 return 3; /* A > B */
2322 return 2; /* A < B */
2324 return 0; /* A == B */
2328 /* Rank a function by comparing its parameter types (PARMS, length
2329 NPARMS), to the types of an argument list (ARGS, length NARGS).
2330 Return a pointer to a badness vector. This has NARGS + 1
2333 struct badness_vector *
2334 rank_function (struct type **parms, int nparms,
2335 struct value **args, int nargs)
2338 struct badness_vector *bv;
2339 int min_len = nparms < nargs ? nparms : nargs;
2341 bv = xmalloc (sizeof (struct badness_vector));
2342 bv->length = nargs + 1; /* add 1 for the length-match rank. */
2343 bv->rank = xmalloc ((nargs + 1) * sizeof (int));
2345 /* First compare the lengths of the supplied lists.
2346 If there is a mismatch, set it to a high value. */
2348 /* pai/1997-06-03 FIXME: when we have debug info about default
2349 arguments and ellipsis parameter lists, we should consider those
2350 and rank the length-match more finely. */
2352 LENGTH_MATCH (bv) = (nargs != nparms)
2353 ? LENGTH_MISMATCH_BADNESS
2354 : EXACT_MATCH_BADNESS;
2356 /* Now rank all the parameters of the candidate function. */
2357 for (i = 1; i <= min_len; i++)
2358 bv->rank[i] = rank_one_type (parms[i - 1], value_type (args[i - 1]),
2361 /* If more arguments than parameters, add dummy entries. */
2362 for (i = min_len + 1; i <= nargs; i++)
2363 bv->rank[i] = TOO_FEW_PARAMS_BADNESS;
2368 /* Compare the names of two integer types, assuming that any sign
2369 qualifiers have been checked already. We do it this way because
2370 there may be an "int" in the name of one of the types. */
2373 integer_types_same_name_p (const char *first, const char *second)
2375 int first_p, second_p;
2377 /* If both are shorts, return 1; if neither is a short, keep
2379 first_p = (strstr (first, "short") != NULL);
2380 second_p = (strstr (second, "short") != NULL);
2381 if (first_p && second_p)
2383 if (first_p || second_p)
2386 /* Likewise for long. */
2387 first_p = (strstr (first, "long") != NULL);
2388 second_p = (strstr (second, "long") != NULL);
2389 if (first_p && second_p)
2391 if (first_p || second_p)
2394 /* Likewise for char. */
2395 first_p = (strstr (first, "char") != NULL);
2396 second_p = (strstr (second, "char") != NULL);
2397 if (first_p && second_p)
2399 if (first_p || second_p)
2402 /* They must both be ints. */
2406 /* Compares type A to type B returns 1 if the represent the same type
2410 types_equal (struct type *a, struct type *b)
2412 /* Identical type pointers. */
2413 /* However, this still doesn't catch all cases of same type for b
2414 and a. The reason is that builtin types are different from
2415 the same ones constructed from the object. */
2419 /* Resolve typedefs */
2420 if (TYPE_CODE (a) == TYPE_CODE_TYPEDEF)
2421 a = check_typedef (a);
2422 if (TYPE_CODE (b) == TYPE_CODE_TYPEDEF)
2423 b = check_typedef (b);
2425 /* If after resolving typedefs a and b are not of the same type
2426 code then they are not equal. */
2427 if (TYPE_CODE (a) != TYPE_CODE (b))
2430 /* If a and b are both pointers types or both reference types then
2431 they are equal of the same type iff the objects they refer to are
2432 of the same type. */
2433 if (TYPE_CODE (a) == TYPE_CODE_PTR
2434 || TYPE_CODE (a) == TYPE_CODE_REF)
2435 return types_equal (TYPE_TARGET_TYPE (a),
2436 TYPE_TARGET_TYPE (b));
2438 /* Well, damnit, if the names are exactly the same, I'll say they
2439 are exactly the same. This happens when we generate method
2440 stubs. The types won't point to the same address, but they
2441 really are the same. */
2443 if (TYPE_NAME (a) && TYPE_NAME (b)
2444 && strcmp (TYPE_NAME (a), TYPE_NAME (b)) == 0)
2447 /* Check if identical after resolving typedefs. */
2454 /* Compare one type (PARM) for compatibility with another (ARG).
2455 * PARM is intended to be the parameter type of a function; and
2456 * ARG is the supplied argument's type. This function tests if
2457 * the latter can be converted to the former.
2458 * VALUE is the argument's value or NULL if none (or called recursively)
2460 * Return 0 if they are identical types;
2461 * Otherwise, return an integer which corresponds to how compatible
2462 * PARM is to ARG. The higher the return value, the worse the match.
2463 * Generally the "bad" conversions are all uniformly assigned a 100. */
2466 rank_one_type (struct type *parm, struct type *arg, struct value *value)
2468 struct rank rank = {0,0};
2470 if (types_equal (parm, arg))
2471 return EXACT_MATCH_BADNESS;
2473 /* Resolve typedefs */
2474 if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF)
2475 parm = check_typedef (parm);
2476 if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
2477 arg = check_typedef (arg);
2479 /* See through references, since we can almost make non-references
2481 if (TYPE_CODE (arg) == TYPE_CODE_REF)
2482 return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL),
2483 REFERENCE_CONVERSION_BADNESS));
2484 if (TYPE_CODE (parm) == TYPE_CODE_REF)
2485 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL),
2486 REFERENCE_CONVERSION_BADNESS));
2488 /* Debugging only. */
2489 fprintf_filtered (gdb_stderr,
2490 "------ Arg is %s [%d], parm is %s [%d]\n",
2491 TYPE_NAME (arg), TYPE_CODE (arg),
2492 TYPE_NAME (parm), TYPE_CODE (parm));
2494 /* x -> y means arg of type x being supplied for parameter of type y. */
2496 switch (TYPE_CODE (parm))
2499 switch (TYPE_CODE (arg))
2503 /* Allowed pointer conversions are:
2504 (a) pointer to void-pointer conversion. */
2505 if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID)
2506 return VOID_PTR_CONVERSION_BADNESS;
2508 /* (b) pointer to ancestor-pointer conversion. */
2509 rank.subrank = distance_to_ancestor (TYPE_TARGET_TYPE (parm),
2510 TYPE_TARGET_TYPE (arg),
2512 if (rank.subrank >= 0)
2513 return sum_ranks (BASE_PTR_CONVERSION_BADNESS, rank);
2515 return INCOMPATIBLE_TYPE_BADNESS;
2516 case TYPE_CODE_ARRAY:
2517 if (types_equal (TYPE_TARGET_TYPE (parm),
2518 TYPE_TARGET_TYPE (arg)))
2519 return EXACT_MATCH_BADNESS;
2520 return INCOMPATIBLE_TYPE_BADNESS;
2521 case TYPE_CODE_FUNC:
2522 return rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL);
2524 if (value != NULL && TYPE_CODE (value_type (value)) == TYPE_CODE_INT)
2526 if (value_as_long (value) == 0)
2528 /* Null pointer conversion: allow it to be cast to a pointer.
2529 [4.10.1 of C++ standard draft n3290] */
2530 return NULL_POINTER_CONVERSION_BADNESS;
2534 /* If type checking is disabled, allow the conversion. */
2535 if (!strict_type_checking)
2536 return NS_INTEGER_POINTER_CONVERSION_BADNESS;
2540 case TYPE_CODE_ENUM:
2541 case TYPE_CODE_FLAGS:
2542 case TYPE_CODE_CHAR:
2543 case TYPE_CODE_RANGE:
2544 case TYPE_CODE_BOOL:
2546 return INCOMPATIBLE_TYPE_BADNESS;
2548 case TYPE_CODE_ARRAY:
2549 switch (TYPE_CODE (arg))
2552 case TYPE_CODE_ARRAY:
2553 return rank_one_type (TYPE_TARGET_TYPE (parm),
2554 TYPE_TARGET_TYPE (arg), NULL);
2556 return INCOMPATIBLE_TYPE_BADNESS;
2558 case TYPE_CODE_FUNC:
2559 switch (TYPE_CODE (arg))
2561 case TYPE_CODE_PTR: /* funcptr -> func */
2562 return rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL);
2564 return INCOMPATIBLE_TYPE_BADNESS;
2567 switch (TYPE_CODE (arg))
2570 if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2572 /* Deal with signed, unsigned, and plain chars and
2573 signed and unsigned ints. */
2574 if (TYPE_NOSIGN (parm))
2576 /* This case only for character types. */
2577 if (TYPE_NOSIGN (arg))
2578 return EXACT_MATCH_BADNESS; /* plain char -> plain char */
2579 else /* signed/unsigned char -> plain char */
2580 return INTEGER_CONVERSION_BADNESS;
2582 else if (TYPE_UNSIGNED (parm))
2584 if (TYPE_UNSIGNED (arg))
2586 /* unsigned int -> unsigned int, or
2587 unsigned long -> unsigned long */
2588 if (integer_types_same_name_p (TYPE_NAME (parm),
2590 return EXACT_MATCH_BADNESS;
2591 else if (integer_types_same_name_p (TYPE_NAME (arg),
2593 && integer_types_same_name_p (TYPE_NAME (parm),
2595 /* unsigned int -> unsigned long */
2596 return INTEGER_PROMOTION_BADNESS;
2598 /* unsigned long -> unsigned int */
2599 return INTEGER_CONVERSION_BADNESS;
2603 if (integer_types_same_name_p (TYPE_NAME (arg),
2605 && integer_types_same_name_p (TYPE_NAME (parm),
2607 /* signed long -> unsigned int */
2608 return INTEGER_CONVERSION_BADNESS;
2610 /* signed int/long -> unsigned int/long */
2611 return INTEGER_CONVERSION_BADNESS;
2614 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2616 if (integer_types_same_name_p (TYPE_NAME (parm),
2618 return EXACT_MATCH_BADNESS;
2619 else if (integer_types_same_name_p (TYPE_NAME (arg),
2621 && integer_types_same_name_p (TYPE_NAME (parm),
2623 return INTEGER_PROMOTION_BADNESS;
2625 return INTEGER_CONVERSION_BADNESS;
2628 return INTEGER_CONVERSION_BADNESS;
2630 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2631 return INTEGER_PROMOTION_BADNESS;
2633 return INTEGER_CONVERSION_BADNESS;
2634 case TYPE_CODE_ENUM:
2635 case TYPE_CODE_FLAGS:
2636 case TYPE_CODE_CHAR:
2637 case TYPE_CODE_RANGE:
2638 case TYPE_CODE_BOOL:
2639 return INTEGER_PROMOTION_BADNESS;
2641 return INT_FLOAT_CONVERSION_BADNESS;
2643 return NS_POINTER_CONVERSION_BADNESS;
2645 return INCOMPATIBLE_TYPE_BADNESS;
2648 case TYPE_CODE_ENUM:
2649 switch (TYPE_CODE (arg))
2652 case TYPE_CODE_CHAR:
2653 case TYPE_CODE_RANGE:
2654 case TYPE_CODE_BOOL:
2655 case TYPE_CODE_ENUM:
2656 return INTEGER_CONVERSION_BADNESS;
2658 return INT_FLOAT_CONVERSION_BADNESS;
2660 return INCOMPATIBLE_TYPE_BADNESS;
2663 case TYPE_CODE_CHAR:
2664 switch (TYPE_CODE (arg))
2666 case TYPE_CODE_RANGE:
2667 case TYPE_CODE_BOOL:
2668 case TYPE_CODE_ENUM:
2669 return INTEGER_CONVERSION_BADNESS;
2671 return INT_FLOAT_CONVERSION_BADNESS;
2673 if (TYPE_LENGTH (arg) > TYPE_LENGTH (parm))
2674 return INTEGER_CONVERSION_BADNESS;
2675 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2676 return INTEGER_PROMOTION_BADNESS;
2677 /* >>> !! else fall through !! <<< */
2678 case TYPE_CODE_CHAR:
2679 /* Deal with signed, unsigned, and plain chars for C++ and
2680 with int cases falling through from previous case. */
2681 if (TYPE_NOSIGN (parm))
2683 if (TYPE_NOSIGN (arg))
2684 return EXACT_MATCH_BADNESS;
2686 return INTEGER_CONVERSION_BADNESS;
2688 else if (TYPE_UNSIGNED (parm))
2690 if (TYPE_UNSIGNED (arg))
2691 return EXACT_MATCH_BADNESS;
2693 return INTEGER_PROMOTION_BADNESS;
2695 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2696 return EXACT_MATCH_BADNESS;
2698 return INTEGER_CONVERSION_BADNESS;
2700 return INCOMPATIBLE_TYPE_BADNESS;
2703 case TYPE_CODE_RANGE:
2704 switch (TYPE_CODE (arg))
2707 case TYPE_CODE_CHAR:
2708 case TYPE_CODE_RANGE:
2709 case TYPE_CODE_BOOL:
2710 case TYPE_CODE_ENUM:
2711 return INTEGER_CONVERSION_BADNESS;
2713 return INT_FLOAT_CONVERSION_BADNESS;
2715 return INCOMPATIBLE_TYPE_BADNESS;
2718 case TYPE_CODE_BOOL:
2719 switch (TYPE_CODE (arg))
2722 case TYPE_CODE_CHAR:
2723 case TYPE_CODE_RANGE:
2724 case TYPE_CODE_ENUM:
2726 return INCOMPATIBLE_TYPE_BADNESS;
2728 return BOOL_PTR_CONVERSION_BADNESS;
2729 case TYPE_CODE_BOOL:
2730 return EXACT_MATCH_BADNESS;
2732 return INCOMPATIBLE_TYPE_BADNESS;
2736 switch (TYPE_CODE (arg))
2739 if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2740 return FLOAT_PROMOTION_BADNESS;
2741 else if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2742 return EXACT_MATCH_BADNESS;
2744 return FLOAT_CONVERSION_BADNESS;
2746 case TYPE_CODE_BOOL:
2747 case TYPE_CODE_ENUM:
2748 case TYPE_CODE_RANGE:
2749 case TYPE_CODE_CHAR:
2750 return INT_FLOAT_CONVERSION_BADNESS;
2752 return INCOMPATIBLE_TYPE_BADNESS;
2755 case TYPE_CODE_COMPLEX:
2756 switch (TYPE_CODE (arg))
2757 { /* Strictly not needed for C++, but... */
2759 return FLOAT_PROMOTION_BADNESS;
2760 case TYPE_CODE_COMPLEX:
2761 return EXACT_MATCH_BADNESS;
2763 return INCOMPATIBLE_TYPE_BADNESS;
2766 case TYPE_CODE_STRUCT:
2767 /* currently same as TYPE_CODE_CLASS. */
2768 switch (TYPE_CODE (arg))
2770 case TYPE_CODE_STRUCT:
2771 /* Check for derivation */
2772 rank.subrank = distance_to_ancestor (parm, arg, 0);
2773 if (rank.subrank >= 0)
2774 return sum_ranks (BASE_CONVERSION_BADNESS, rank);
2775 /* else fall through */
2777 return INCOMPATIBLE_TYPE_BADNESS;
2780 case TYPE_CODE_UNION:
2781 switch (TYPE_CODE (arg))
2783 case TYPE_CODE_UNION:
2785 return INCOMPATIBLE_TYPE_BADNESS;
2788 case TYPE_CODE_MEMBERPTR:
2789 switch (TYPE_CODE (arg))
2792 return INCOMPATIBLE_TYPE_BADNESS;
2795 case TYPE_CODE_METHOD:
2796 switch (TYPE_CODE (arg))
2800 return INCOMPATIBLE_TYPE_BADNESS;
2804 switch (TYPE_CODE (arg))
2808 return INCOMPATIBLE_TYPE_BADNESS;
2813 switch (TYPE_CODE (arg))
2817 return rank_one_type (TYPE_FIELD_TYPE (parm, 0),
2818 TYPE_FIELD_TYPE (arg, 0), NULL);
2820 return INCOMPATIBLE_TYPE_BADNESS;
2823 case TYPE_CODE_VOID:
2825 return INCOMPATIBLE_TYPE_BADNESS;
2826 } /* switch (TYPE_CODE (arg)) */
2829 /* End of functions for overload resolution. */
2831 /* Routines to pretty-print types. */
2834 print_bit_vector (B_TYPE *bits, int nbits)
2838 for (bitno = 0; bitno < nbits; bitno++)
2840 if ((bitno % 8) == 0)
2842 puts_filtered (" ");
2844 if (B_TST (bits, bitno))
2845 printf_filtered (("1"));
2847 printf_filtered (("0"));
2851 /* Note the first arg should be the "this" pointer, we may not want to
2852 include it since we may get into a infinitely recursive
2856 print_arg_types (struct field *args, int nargs, int spaces)
2862 for (i = 0; i < nargs; i++)
2863 recursive_dump_type (args[i].type, spaces + 2);
2868 field_is_static (struct field *f)
2870 /* "static" fields are the fields whose location is not relative
2871 to the address of the enclosing struct. It would be nice to
2872 have a dedicated flag that would be set for static fields when
2873 the type is being created. But in practice, checking the field
2874 loc_kind should give us an accurate answer. */
2875 return (FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSNAME
2876 || FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSADDR);
2880 dump_fn_fieldlists (struct type *type, int spaces)
2886 printfi_filtered (spaces, "fn_fieldlists ");
2887 gdb_print_host_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
2888 printf_filtered ("\n");
2889 for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
2891 f = TYPE_FN_FIELDLIST1 (type, method_idx);
2892 printfi_filtered (spaces + 2, "[%d] name '%s' (",
2894 TYPE_FN_FIELDLIST_NAME (type, method_idx));
2895 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
2897 printf_filtered (_(") length %d\n"),
2898 TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
2899 for (overload_idx = 0;
2900 overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
2903 printfi_filtered (spaces + 4, "[%d] physname '%s' (",
2905 TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
2906 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
2908 printf_filtered (")\n");
2909 printfi_filtered (spaces + 8, "type ");
2910 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx),
2912 printf_filtered ("\n");
2914 recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
2917 printfi_filtered (spaces + 8, "args ");
2918 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx),
2920 printf_filtered ("\n");
2922 print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx),
2923 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f,
2926 printfi_filtered (spaces + 8, "fcontext ");
2927 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
2929 printf_filtered ("\n");
2931 printfi_filtered (spaces + 8, "is_const %d\n",
2932 TYPE_FN_FIELD_CONST (f, overload_idx));
2933 printfi_filtered (spaces + 8, "is_volatile %d\n",
2934 TYPE_FN_FIELD_VOLATILE (f, overload_idx));
2935 printfi_filtered (spaces + 8, "is_private %d\n",
2936 TYPE_FN_FIELD_PRIVATE (f, overload_idx));
2937 printfi_filtered (spaces + 8, "is_protected %d\n",
2938 TYPE_FN_FIELD_PROTECTED (f, overload_idx));
2939 printfi_filtered (spaces + 8, "is_stub %d\n",
2940 TYPE_FN_FIELD_STUB (f, overload_idx));
2941 printfi_filtered (spaces + 8, "voffset %u\n",
2942 TYPE_FN_FIELD_VOFFSET (f, overload_idx));
2948 print_cplus_stuff (struct type *type, int spaces)
2950 printfi_filtered (spaces, "n_baseclasses %d\n",
2951 TYPE_N_BASECLASSES (type));
2952 printfi_filtered (spaces, "nfn_fields %d\n",
2953 TYPE_NFN_FIELDS (type));
2954 if (TYPE_N_BASECLASSES (type) > 0)
2956 printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
2957 TYPE_N_BASECLASSES (type));
2958 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type),
2960 printf_filtered (")");
2962 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
2963 TYPE_N_BASECLASSES (type));
2964 puts_filtered ("\n");
2966 if (TYPE_NFIELDS (type) > 0)
2968 if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
2970 printfi_filtered (spaces,
2971 "private_field_bits (%d bits at *",
2972 TYPE_NFIELDS (type));
2973 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type),
2975 printf_filtered (")");
2976 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
2977 TYPE_NFIELDS (type));
2978 puts_filtered ("\n");
2980 if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
2982 printfi_filtered (spaces,
2983 "protected_field_bits (%d bits at *",
2984 TYPE_NFIELDS (type));
2985 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type),
2987 printf_filtered (")");
2988 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
2989 TYPE_NFIELDS (type));
2990 puts_filtered ("\n");
2993 if (TYPE_NFN_FIELDS (type) > 0)
2995 dump_fn_fieldlists (type, spaces);
2999 /* Print the contents of the TYPE's type_specific union, assuming that
3000 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
3003 print_gnat_stuff (struct type *type, int spaces)
3005 struct type *descriptive_type = TYPE_DESCRIPTIVE_TYPE (type);
3007 recursive_dump_type (descriptive_type, spaces + 2);
3010 static struct obstack dont_print_type_obstack;
3013 recursive_dump_type (struct type *type, int spaces)
3018 obstack_begin (&dont_print_type_obstack, 0);
3020 if (TYPE_NFIELDS (type) > 0
3021 || (HAVE_CPLUS_STRUCT (type) && TYPE_NFN_FIELDS (type) > 0))
3023 struct type **first_dont_print
3024 = (struct type **) obstack_base (&dont_print_type_obstack);
3026 int i = (struct type **)
3027 obstack_next_free (&dont_print_type_obstack) - first_dont_print;
3031 if (type == first_dont_print[i])
3033 printfi_filtered (spaces, "type node ");
3034 gdb_print_host_address (type, gdb_stdout);
3035 printf_filtered (_(" <same as already seen type>\n"));
3040 obstack_ptr_grow (&dont_print_type_obstack, type);
3043 printfi_filtered (spaces, "type node ");
3044 gdb_print_host_address (type, gdb_stdout);
3045 printf_filtered ("\n");
3046 printfi_filtered (spaces, "name '%s' (",
3047 TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
3048 gdb_print_host_address (TYPE_NAME (type), gdb_stdout);
3049 printf_filtered (")\n");
3050 printfi_filtered (spaces, "tagname '%s' (",
3051 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : "<NULL>");
3052 gdb_print_host_address (TYPE_TAG_NAME (type), gdb_stdout);
3053 printf_filtered (")\n");
3054 printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
3055 switch (TYPE_CODE (type))
3057 case TYPE_CODE_UNDEF:
3058 printf_filtered ("(TYPE_CODE_UNDEF)");
3061 printf_filtered ("(TYPE_CODE_PTR)");
3063 case TYPE_CODE_ARRAY:
3064 printf_filtered ("(TYPE_CODE_ARRAY)");
3066 case TYPE_CODE_STRUCT:
3067 printf_filtered ("(TYPE_CODE_STRUCT)");
3069 case TYPE_CODE_UNION:
3070 printf_filtered ("(TYPE_CODE_UNION)");
3072 case TYPE_CODE_ENUM:
3073 printf_filtered ("(TYPE_CODE_ENUM)");
3075 case TYPE_CODE_FLAGS:
3076 printf_filtered ("(TYPE_CODE_FLAGS)");
3078 case TYPE_CODE_FUNC:
3079 printf_filtered ("(TYPE_CODE_FUNC)");
3082 printf_filtered ("(TYPE_CODE_INT)");
3085 printf_filtered ("(TYPE_CODE_FLT)");
3087 case TYPE_CODE_VOID:
3088 printf_filtered ("(TYPE_CODE_VOID)");
3091 printf_filtered ("(TYPE_CODE_SET)");
3093 case TYPE_CODE_RANGE:
3094 printf_filtered ("(TYPE_CODE_RANGE)");
3096 case TYPE_CODE_STRING:
3097 printf_filtered ("(TYPE_CODE_STRING)");
3099 case TYPE_CODE_ERROR:
3100 printf_filtered ("(TYPE_CODE_ERROR)");
3102 case TYPE_CODE_MEMBERPTR:
3103 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
3105 case TYPE_CODE_METHODPTR:
3106 printf_filtered ("(TYPE_CODE_METHODPTR)");
3108 case TYPE_CODE_METHOD:
3109 printf_filtered ("(TYPE_CODE_METHOD)");
3112 printf_filtered ("(TYPE_CODE_REF)");
3114 case TYPE_CODE_CHAR:
3115 printf_filtered ("(TYPE_CODE_CHAR)");
3117 case TYPE_CODE_BOOL:
3118 printf_filtered ("(TYPE_CODE_BOOL)");
3120 case TYPE_CODE_COMPLEX:
3121 printf_filtered ("(TYPE_CODE_COMPLEX)");
3123 case TYPE_CODE_TYPEDEF:
3124 printf_filtered ("(TYPE_CODE_TYPEDEF)");
3126 case TYPE_CODE_NAMESPACE:
3127 printf_filtered ("(TYPE_CODE_NAMESPACE)");
3130 printf_filtered ("(UNKNOWN TYPE CODE)");
3133 puts_filtered ("\n");
3134 printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
3135 if (TYPE_OBJFILE_OWNED (type))
3137 printfi_filtered (spaces, "objfile ");
3138 gdb_print_host_address (TYPE_OWNER (type).objfile, gdb_stdout);
3142 printfi_filtered (spaces, "gdbarch ");
3143 gdb_print_host_address (TYPE_OWNER (type).gdbarch, gdb_stdout);
3145 printf_filtered ("\n");
3146 printfi_filtered (spaces, "target_type ");
3147 gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout);
3148 printf_filtered ("\n");
3149 if (TYPE_TARGET_TYPE (type) != NULL)
3151 recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
3153 printfi_filtered (spaces, "pointer_type ");
3154 gdb_print_host_address (TYPE_POINTER_TYPE (type), gdb_stdout);
3155 printf_filtered ("\n");
3156 printfi_filtered (spaces, "reference_type ");
3157 gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
3158 printf_filtered ("\n");
3159 printfi_filtered (spaces, "type_chain ");
3160 gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);
3161 printf_filtered ("\n");
3162 printfi_filtered (spaces, "instance_flags 0x%x",
3163 TYPE_INSTANCE_FLAGS (type));
3164 if (TYPE_CONST (type))
3166 puts_filtered (" TYPE_FLAG_CONST");
3168 if (TYPE_VOLATILE (type))
3170 puts_filtered (" TYPE_FLAG_VOLATILE");
3172 if (TYPE_CODE_SPACE (type))
3174 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3176 if (TYPE_DATA_SPACE (type))
3178 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3180 if (TYPE_ADDRESS_CLASS_1 (type))
3182 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3184 if (TYPE_ADDRESS_CLASS_2 (type))
3186 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3188 puts_filtered ("\n");
3190 printfi_filtered (spaces, "flags");
3191 if (TYPE_UNSIGNED (type))
3193 puts_filtered (" TYPE_FLAG_UNSIGNED");
3195 if (TYPE_NOSIGN (type))
3197 puts_filtered (" TYPE_FLAG_NOSIGN");
3199 if (TYPE_STUB (type))
3201 puts_filtered (" TYPE_FLAG_STUB");
3203 if (TYPE_TARGET_STUB (type))
3205 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3207 if (TYPE_STATIC (type))
3209 puts_filtered (" TYPE_FLAG_STATIC");
3211 if (TYPE_PROTOTYPED (type))
3213 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3215 if (TYPE_INCOMPLETE (type))
3217 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3219 if (TYPE_VARARGS (type))
3221 puts_filtered (" TYPE_FLAG_VARARGS");
3223 /* This is used for things like AltiVec registers on ppc. Gcc emits
3224 an attribute for the array type, which tells whether or not we
3225 have a vector, instead of a regular array. */
3226 if (TYPE_VECTOR (type))
3228 puts_filtered (" TYPE_FLAG_VECTOR");
3230 if (TYPE_FIXED_INSTANCE (type))
3232 puts_filtered (" TYPE_FIXED_INSTANCE");
3234 if (TYPE_STUB_SUPPORTED (type))
3236 puts_filtered (" TYPE_STUB_SUPPORTED");
3238 if (TYPE_NOTTEXT (type))
3240 puts_filtered (" TYPE_NOTTEXT");
3242 puts_filtered ("\n");
3243 printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
3244 gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
3245 puts_filtered ("\n");
3246 for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
3248 if (TYPE_CODE (type) == TYPE_CODE_ENUM)
3249 printfi_filtered (spaces + 2,
3250 "[%d] enumval %s type ",
3251 idx, plongest (TYPE_FIELD_ENUMVAL (type, idx)));
3253 printfi_filtered (spaces + 2,
3254 "[%d] bitpos %d bitsize %d type ",
3255 idx, TYPE_FIELD_BITPOS (type, idx),
3256 TYPE_FIELD_BITSIZE (type, idx));
3257 gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
3258 printf_filtered (" name '%s' (",
3259 TYPE_FIELD_NAME (type, idx) != NULL
3260 ? TYPE_FIELD_NAME (type, idx)
3262 gdb_print_host_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
3263 printf_filtered (")\n");
3264 if (TYPE_FIELD_TYPE (type, idx) != NULL)
3266 recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
3269 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
3271 printfi_filtered (spaces, "low %s%s high %s%s\n",
3272 plongest (TYPE_LOW_BOUND (type)),
3273 TYPE_LOW_BOUND_UNDEFINED (type) ? " (undefined)" : "",
3274 plongest (TYPE_HIGH_BOUND (type)),
3275 TYPE_HIGH_BOUND_UNDEFINED (type)
3276 ? " (undefined)" : "");
3278 printfi_filtered (spaces, "vptr_basetype ");
3279 gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
3280 puts_filtered ("\n");
3281 if (TYPE_VPTR_BASETYPE (type) != NULL)
3283 recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
3285 printfi_filtered (spaces, "vptr_fieldno %d\n",
3286 TYPE_VPTR_FIELDNO (type));
3288 switch (TYPE_SPECIFIC_FIELD (type))
3290 case TYPE_SPECIFIC_CPLUS_STUFF:
3291 printfi_filtered (spaces, "cplus_stuff ");
3292 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type),
3294 puts_filtered ("\n");
3295 print_cplus_stuff (type, spaces);
3298 case TYPE_SPECIFIC_GNAT_STUFF:
3299 printfi_filtered (spaces, "gnat_stuff ");
3300 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type), gdb_stdout);
3301 puts_filtered ("\n");
3302 print_gnat_stuff (type, spaces);
3305 case TYPE_SPECIFIC_FLOATFORMAT:
3306 printfi_filtered (spaces, "floatformat ");
3307 if (TYPE_FLOATFORMAT (type) == NULL)
3308 puts_filtered ("(null)");
3311 puts_filtered ("{ ");
3312 if (TYPE_FLOATFORMAT (type)[0] == NULL
3313 || TYPE_FLOATFORMAT (type)[0]->name == NULL)
3314 puts_filtered ("(null)");
3316 puts_filtered (TYPE_FLOATFORMAT (type)[0]->name);
3318 puts_filtered (", ");
3319 if (TYPE_FLOATFORMAT (type)[1] == NULL
3320 || TYPE_FLOATFORMAT (type)[1]->name == NULL)
3321 puts_filtered ("(null)");
3323 puts_filtered (TYPE_FLOATFORMAT (type)[1]->name);
3325 puts_filtered (" }");
3327 puts_filtered ("\n");
3330 case TYPE_SPECIFIC_FUNC:
3331 printfi_filtered (spaces, "calling_convention %d\n",
3332 TYPE_CALLING_CONVENTION (type));
3333 /* tail_call_list is not printed. */
3338 obstack_free (&dont_print_type_obstack, NULL);
3341 /* Trivial helpers for the libiberty hash table, for mapping one
3346 struct type *old, *new;
3350 type_pair_hash (const void *item)
3352 const struct type_pair *pair = item;
3354 return htab_hash_pointer (pair->old);
3358 type_pair_eq (const void *item_lhs, const void *item_rhs)
3360 const struct type_pair *lhs = item_lhs, *rhs = item_rhs;
3362 return lhs->old == rhs->old;
3365 /* Allocate the hash table used by copy_type_recursive to walk
3366 types without duplicates. We use OBJFILE's obstack, because
3367 OBJFILE is about to be deleted. */
3370 create_copied_types_hash (struct objfile *objfile)
3372 return htab_create_alloc_ex (1, type_pair_hash, type_pair_eq,
3373 NULL, &objfile->objfile_obstack,
3374 hashtab_obstack_allocate,
3375 dummy_obstack_deallocate);
3378 /* Recursively copy (deep copy) TYPE, if it is associated with
3379 OBJFILE. Return a new type allocated using malloc, a saved type if
3380 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
3381 not associated with OBJFILE. */
3384 copy_type_recursive (struct objfile *objfile,
3386 htab_t copied_types)
3388 struct type_pair *stored, pair;
3390 struct type *new_type;
3392 if (! TYPE_OBJFILE_OWNED (type))
3395 /* This type shouldn't be pointing to any types in other objfiles;
3396 if it did, the type might disappear unexpectedly. */
3397 gdb_assert (TYPE_OBJFILE (type) == objfile);
3400 slot = htab_find_slot (copied_types, &pair, INSERT);
3402 return ((struct type_pair *) *slot)->new;
3404 new_type = alloc_type_arch (get_type_arch (type));
3406 /* We must add the new type to the hash table immediately, in case
3407 we encounter this type again during a recursive call below. */
3409 = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair));
3411 stored->new = new_type;
3414 /* Copy the common fields of types. For the main type, we simply
3415 copy the entire thing and then update specific fields as needed. */
3416 *TYPE_MAIN_TYPE (new_type) = *TYPE_MAIN_TYPE (type);
3417 TYPE_OBJFILE_OWNED (new_type) = 0;
3418 TYPE_OWNER (new_type).gdbarch = get_type_arch (type);
3420 if (TYPE_NAME (type))
3421 TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type));
3422 if (TYPE_TAG_NAME (type))
3423 TYPE_TAG_NAME (new_type) = xstrdup (TYPE_TAG_NAME (type));
3425 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
3426 TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
3428 /* Copy the fields. */
3429 if (TYPE_NFIELDS (type))
3433 nfields = TYPE_NFIELDS (type);
3434 TYPE_FIELDS (new_type) = XCALLOC (nfields, struct field);
3435 for (i = 0; i < nfields; i++)
3437 TYPE_FIELD_ARTIFICIAL (new_type, i) =
3438 TYPE_FIELD_ARTIFICIAL (type, i);
3439 TYPE_FIELD_BITSIZE (new_type, i) = TYPE_FIELD_BITSIZE (type, i);
3440 if (TYPE_FIELD_TYPE (type, i))
3441 TYPE_FIELD_TYPE (new_type, i)
3442 = copy_type_recursive (objfile, TYPE_FIELD_TYPE (type, i),
3444 if (TYPE_FIELD_NAME (type, i))
3445 TYPE_FIELD_NAME (new_type, i) =
3446 xstrdup (TYPE_FIELD_NAME (type, i));
3447 switch (TYPE_FIELD_LOC_KIND (type, i))
3449 case FIELD_LOC_KIND_BITPOS:
3450 SET_FIELD_BITPOS (TYPE_FIELD (new_type, i),
3451 TYPE_FIELD_BITPOS (type, i));
3453 case FIELD_LOC_KIND_ENUMVAL:
3454 SET_FIELD_ENUMVAL (TYPE_FIELD (new_type, i),
3455 TYPE_FIELD_ENUMVAL (type, i));
3457 case FIELD_LOC_KIND_PHYSADDR:
3458 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i),
3459 TYPE_FIELD_STATIC_PHYSADDR (type, i));
3461 case FIELD_LOC_KIND_PHYSNAME:
3462 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i),
3463 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type,
3467 internal_error (__FILE__, __LINE__,
3468 _("Unexpected type field location kind: %d"),
3469 TYPE_FIELD_LOC_KIND (type, i));
3474 /* For range types, copy the bounds information. */
3475 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
3477 TYPE_RANGE_DATA (new_type) = xmalloc (sizeof (struct range_bounds));
3478 *TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type);
3481 /* Copy pointers to other types. */
3482 if (TYPE_TARGET_TYPE (type))
3483 TYPE_TARGET_TYPE (new_type) =
3484 copy_type_recursive (objfile,
3485 TYPE_TARGET_TYPE (type),
3487 if (TYPE_VPTR_BASETYPE (type))
3488 TYPE_VPTR_BASETYPE (new_type) =
3489 copy_type_recursive (objfile,
3490 TYPE_VPTR_BASETYPE (type),
3492 /* Maybe copy the type_specific bits.
3494 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3495 base classes and methods. There's no fundamental reason why we
3496 can't, but at the moment it is not needed. */
3498 if (TYPE_CODE (type) == TYPE_CODE_FLT)
3499 TYPE_FLOATFORMAT (new_type) = TYPE_FLOATFORMAT (type);
3500 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
3501 || TYPE_CODE (type) == TYPE_CODE_UNION
3502 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
3503 INIT_CPLUS_SPECIFIC (new_type);
3508 /* Make a copy of the given TYPE, except that the pointer & reference
3509 types are not preserved.
3511 This function assumes that the given type has an associated objfile.
3512 This objfile is used to allocate the new type. */
3515 copy_type (const struct type *type)
3517 struct type *new_type;
3519 gdb_assert (TYPE_OBJFILE_OWNED (type));
3521 new_type = alloc_type_copy (type);
3522 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
3523 TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
3524 memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type),
3525 sizeof (struct main_type));
3530 /* Helper functions to initialize architecture-specific types. */
3532 /* Allocate a type structure associated with GDBARCH and set its
3533 CODE, LENGTH, and NAME fields. */
3536 arch_type (struct gdbarch *gdbarch,
3537 enum type_code code, int length, char *name)
3541 type = alloc_type_arch (gdbarch);
3542 TYPE_CODE (type) = code;
3543 TYPE_LENGTH (type) = length;
3546 TYPE_NAME (type) = xstrdup (name);
3551 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
3552 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3553 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3556 arch_integer_type (struct gdbarch *gdbarch,
3557 int bit, int unsigned_p, char *name)
3561 t = arch_type (gdbarch, TYPE_CODE_INT, bit / TARGET_CHAR_BIT, name);
3563 TYPE_UNSIGNED (t) = 1;
3564 if (name && strcmp (name, "char") == 0)
3565 TYPE_NOSIGN (t) = 1;
3570 /* Allocate a TYPE_CODE_CHAR 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_character_type (struct gdbarch *gdbarch,
3576 int bit, int unsigned_p, char *name)
3580 t = arch_type (gdbarch, TYPE_CODE_CHAR, bit / TARGET_CHAR_BIT, name);
3582 TYPE_UNSIGNED (t) = 1;
3587 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
3588 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3589 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3592 arch_boolean_type (struct gdbarch *gdbarch,
3593 int bit, int unsigned_p, char *name)
3597 t = arch_type (gdbarch, TYPE_CODE_BOOL, bit / TARGET_CHAR_BIT, name);
3599 TYPE_UNSIGNED (t) = 1;
3604 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
3605 BIT is the type size in bits; if BIT equals -1, the size is
3606 determined by the floatformat. NAME is the type name. Set the
3607 TYPE_FLOATFORMAT from FLOATFORMATS. */
3610 arch_float_type (struct gdbarch *gdbarch,
3611 int bit, char *name, const struct floatformat **floatformats)
3617 gdb_assert (floatformats != NULL);
3618 gdb_assert (floatformats[0] != NULL && floatformats[1] != NULL);
3619 bit = floatformats[0]->totalsize;
3621 gdb_assert (bit >= 0);
3623 t = arch_type (gdbarch, TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, name);
3624 TYPE_FLOATFORMAT (t) = floatformats;
3628 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
3629 NAME is the type name. TARGET_TYPE is the component float type. */
3632 arch_complex_type (struct gdbarch *gdbarch,
3633 char *name, struct type *target_type)
3637 t = arch_type (gdbarch, TYPE_CODE_COMPLEX,
3638 2 * TYPE_LENGTH (target_type), name);
3639 TYPE_TARGET_TYPE (t) = target_type;
3643 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
3644 NAME is the type name. LENGTH is the size of the flag word in bytes. */
3647 arch_flags_type (struct gdbarch *gdbarch, char *name, int length)
3649 int nfields = length * TARGET_CHAR_BIT;
3652 type = arch_type (gdbarch, TYPE_CODE_FLAGS, length, name);
3653 TYPE_UNSIGNED (type) = 1;
3654 TYPE_NFIELDS (type) = nfields;
3655 TYPE_FIELDS (type) = TYPE_ZALLOC (type, nfields * sizeof (struct field));
3660 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
3661 position BITPOS is called NAME. */
3664 append_flags_type_flag (struct type *type, int bitpos, char *name)
3666 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS);
3667 gdb_assert (bitpos < TYPE_NFIELDS (type));
3668 gdb_assert (bitpos >= 0);
3672 TYPE_FIELD_NAME (type, bitpos) = xstrdup (name);
3673 SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), bitpos);
3677 /* Don't show this field to the user. */
3678 SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), -1);
3682 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
3683 specified by CODE) associated with GDBARCH. NAME is the type name. */
3686 arch_composite_type (struct gdbarch *gdbarch, char *name, enum type_code code)
3690 gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION);
3691 t = arch_type (gdbarch, code, 0, NULL);
3692 TYPE_TAG_NAME (t) = name;
3693 INIT_CPLUS_SPECIFIC (t);
3697 /* Add new field with name NAME and type FIELD to composite type T.
3698 Do not set the field's position or adjust the type's length;
3699 the caller should do so. Return the new field. */
3702 append_composite_type_field_raw (struct type *t, char *name,
3707 TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
3708 TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t),
3709 sizeof (struct field) * TYPE_NFIELDS (t));
3710 f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
3711 memset (f, 0, sizeof f[0]);
3712 FIELD_TYPE (f[0]) = field;
3713 FIELD_NAME (f[0]) = name;
3717 /* Add new field with name NAME and type FIELD to composite type T.
3718 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
3721 append_composite_type_field_aligned (struct type *t, char *name,
3722 struct type *field, int alignment)
3724 struct field *f = append_composite_type_field_raw (t, name, field);
3726 if (TYPE_CODE (t) == TYPE_CODE_UNION)
3728 if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
3729 TYPE_LENGTH (t) = TYPE_LENGTH (field);
3731 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
3733 TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
3734 if (TYPE_NFIELDS (t) > 1)
3736 SET_FIELD_BITPOS (f[0],
3737 (FIELD_BITPOS (f[-1])
3738 + (TYPE_LENGTH (FIELD_TYPE (f[-1]))
3739 * TARGET_CHAR_BIT)));
3745 alignment *= TARGET_CHAR_BIT;
3746 left = FIELD_BITPOS (f[0]) % alignment;
3750 SET_FIELD_BITPOS (f[0], FIELD_BITPOS (f[0]) + (alignment - left));
3751 TYPE_LENGTH (t) += (alignment - left) / TARGET_CHAR_BIT;
3758 /* Add new field with name NAME and type FIELD to composite type T. */
3761 append_composite_type_field (struct type *t, char *name,
3764 append_composite_type_field_aligned (t, name, field, 0);
3767 static struct gdbarch_data *gdbtypes_data;
3769 const struct builtin_type *
3770 builtin_type (struct gdbarch *gdbarch)
3772 return gdbarch_data (gdbarch, gdbtypes_data);
3776 gdbtypes_post_init (struct gdbarch *gdbarch)
3778 struct builtin_type *builtin_type
3779 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type);
3782 builtin_type->builtin_void
3783 = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
3784 builtin_type->builtin_char
3785 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3786 !gdbarch_char_signed (gdbarch), "char");
3787 builtin_type->builtin_signed_char
3788 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3790 builtin_type->builtin_unsigned_char
3791 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3792 1, "unsigned char");
3793 builtin_type->builtin_short
3794 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
3796 builtin_type->builtin_unsigned_short
3797 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
3798 1, "unsigned short");
3799 builtin_type->builtin_int
3800 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
3802 builtin_type->builtin_unsigned_int
3803 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
3805 builtin_type->builtin_long
3806 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
3808 builtin_type->builtin_unsigned_long
3809 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
3810 1, "unsigned long");
3811 builtin_type->builtin_long_long
3812 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
3814 builtin_type->builtin_unsigned_long_long
3815 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
3816 1, "unsigned long long");
3817 builtin_type->builtin_float
3818 = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
3819 "float", gdbarch_float_format (gdbarch));
3820 builtin_type->builtin_double
3821 = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
3822 "double", gdbarch_double_format (gdbarch));
3823 builtin_type->builtin_long_double
3824 = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
3825 "long double", gdbarch_long_double_format (gdbarch));
3826 builtin_type->builtin_complex
3827 = arch_complex_type (gdbarch, "complex",
3828 builtin_type->builtin_float);
3829 builtin_type->builtin_double_complex
3830 = arch_complex_type (gdbarch, "double complex",
3831 builtin_type->builtin_double);
3832 builtin_type->builtin_string
3833 = arch_type (gdbarch, TYPE_CODE_STRING, 1, "string");
3834 builtin_type->builtin_bool
3835 = arch_type (gdbarch, TYPE_CODE_BOOL, 1, "bool");
3837 /* The following three are about decimal floating point types, which
3838 are 32-bits, 64-bits and 128-bits respectively. */
3839 builtin_type->builtin_decfloat
3840 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 32 / 8, "_Decimal32");
3841 builtin_type->builtin_decdouble
3842 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 64 / 8, "_Decimal64");
3843 builtin_type->builtin_declong
3844 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 128 / 8, "_Decimal128");
3846 /* "True" character types. */
3847 builtin_type->builtin_true_char
3848 = arch_character_type (gdbarch, TARGET_CHAR_BIT, 0, "true character");
3849 builtin_type->builtin_true_unsigned_char
3850 = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "true character");
3852 /* Fixed-size integer types. */
3853 builtin_type->builtin_int0
3854 = arch_integer_type (gdbarch, 0, 0, "int0_t");
3855 builtin_type->builtin_int8
3856 = arch_integer_type (gdbarch, 8, 0, "int8_t");
3857 builtin_type->builtin_uint8
3858 = arch_integer_type (gdbarch, 8, 1, "uint8_t");
3859 builtin_type->builtin_int16
3860 = arch_integer_type (gdbarch, 16, 0, "int16_t");
3861 builtin_type->builtin_uint16
3862 = arch_integer_type (gdbarch, 16, 1, "uint16_t");
3863 builtin_type->builtin_int32
3864 = arch_integer_type (gdbarch, 32, 0, "int32_t");
3865 builtin_type->builtin_uint32
3866 = arch_integer_type (gdbarch, 32, 1, "uint32_t");
3867 builtin_type->builtin_int64
3868 = arch_integer_type (gdbarch, 64, 0, "int64_t");
3869 builtin_type->builtin_uint64
3870 = arch_integer_type (gdbarch, 64, 1, "uint64_t");
3871 builtin_type->builtin_int128
3872 = arch_integer_type (gdbarch, 128, 0, "int128_t");
3873 builtin_type->builtin_uint128
3874 = arch_integer_type (gdbarch, 128, 1, "uint128_t");
3875 TYPE_INSTANCE_FLAGS (builtin_type->builtin_int8) |=
3876 TYPE_INSTANCE_FLAG_NOTTEXT;
3877 TYPE_INSTANCE_FLAGS (builtin_type->builtin_uint8) |=
3878 TYPE_INSTANCE_FLAG_NOTTEXT;
3880 /* Wide character types. */
3881 builtin_type->builtin_char16
3882 = arch_integer_type (gdbarch, 16, 0, "char16_t");
3883 builtin_type->builtin_char32
3884 = arch_integer_type (gdbarch, 32, 0, "char32_t");
3887 /* Default data/code pointer types. */
3888 builtin_type->builtin_data_ptr
3889 = lookup_pointer_type (builtin_type->builtin_void);
3890 builtin_type->builtin_func_ptr
3891 = lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
3892 builtin_type->builtin_func_func
3893 = lookup_function_type (builtin_type->builtin_func_ptr);
3895 /* This type represents a GDB internal function. */
3896 builtin_type->internal_fn
3897 = arch_type (gdbarch, TYPE_CODE_INTERNAL_FUNCTION, 0,
3898 "<internal function>");
3900 return builtin_type;
3903 /* This set of objfile-based types is intended to be used by symbol
3904 readers as basic types. */
3906 static const struct objfile_data *objfile_type_data;
3908 const struct objfile_type *
3909 objfile_type (struct objfile *objfile)
3911 struct gdbarch *gdbarch;
3912 struct objfile_type *objfile_type
3913 = objfile_data (objfile, objfile_type_data);
3916 return objfile_type;
3918 objfile_type = OBSTACK_CALLOC (&objfile->objfile_obstack,
3919 1, struct objfile_type);
3921 /* Use the objfile architecture to determine basic type properties. */
3922 gdbarch = get_objfile_arch (objfile);
3925 objfile_type->builtin_void
3926 = init_type (TYPE_CODE_VOID, 1,
3930 objfile_type->builtin_char
3931 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3933 | (gdbarch_char_signed (gdbarch) ? 0 : TYPE_FLAG_UNSIGNED)),
3935 objfile_type->builtin_signed_char
3936 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3938 "signed char", objfile);
3939 objfile_type->builtin_unsigned_char
3940 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3942 "unsigned char", objfile);
3943 objfile_type->builtin_short
3944 = init_type (TYPE_CODE_INT,
3945 gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
3946 0, "short", objfile);
3947 objfile_type->builtin_unsigned_short
3948 = init_type (TYPE_CODE_INT,
3949 gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
3950 TYPE_FLAG_UNSIGNED, "unsigned short", objfile);
3951 objfile_type->builtin_int
3952 = init_type (TYPE_CODE_INT,
3953 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
3955 objfile_type->builtin_unsigned_int
3956 = init_type (TYPE_CODE_INT,
3957 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
3958 TYPE_FLAG_UNSIGNED, "unsigned int", objfile);
3959 objfile_type->builtin_long
3960 = init_type (TYPE_CODE_INT,
3961 gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
3962 0, "long", objfile);
3963 objfile_type->builtin_unsigned_long
3964 = init_type (TYPE_CODE_INT,
3965 gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
3966 TYPE_FLAG_UNSIGNED, "unsigned long", objfile);
3967 objfile_type->builtin_long_long
3968 = init_type (TYPE_CODE_INT,
3969 gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
3970 0, "long long", objfile);
3971 objfile_type->builtin_unsigned_long_long
3972 = init_type (TYPE_CODE_INT,
3973 gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
3974 TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
3976 objfile_type->builtin_float
3977 = init_type (TYPE_CODE_FLT,
3978 gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT,
3979 0, "float", objfile);
3980 TYPE_FLOATFORMAT (objfile_type->builtin_float)
3981 = gdbarch_float_format (gdbarch);
3982 objfile_type->builtin_double
3983 = init_type (TYPE_CODE_FLT,
3984 gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT,
3985 0, "double", objfile);
3986 TYPE_FLOATFORMAT (objfile_type->builtin_double)
3987 = gdbarch_double_format (gdbarch);
3988 objfile_type->builtin_long_double
3989 = init_type (TYPE_CODE_FLT,
3990 gdbarch_long_double_bit (gdbarch) / TARGET_CHAR_BIT,
3991 0, "long double", objfile);
3992 TYPE_FLOATFORMAT (objfile_type->builtin_long_double)
3993 = gdbarch_long_double_format (gdbarch);
3995 /* This type represents a type that was unrecognized in symbol read-in. */
3996 objfile_type->builtin_error
3997 = init_type (TYPE_CODE_ERROR, 0, 0, "<unknown type>", objfile);
3999 /* The following set of types is used for symbols with no
4000 debug information. */
4001 objfile_type->nodebug_text_symbol
4002 = init_type (TYPE_CODE_FUNC, 1, 0,
4003 "<text variable, no debug info>", objfile);
4004 TYPE_TARGET_TYPE (objfile_type->nodebug_text_symbol)
4005 = objfile_type->builtin_int;
4006 objfile_type->nodebug_text_gnu_ifunc_symbol
4007 = init_type (TYPE_CODE_FUNC, 1, TYPE_FLAG_GNU_IFUNC,
4008 "<text gnu-indirect-function variable, no debug info>",
4010 TYPE_TARGET_TYPE (objfile_type->nodebug_text_gnu_ifunc_symbol)
4011 = objfile_type->nodebug_text_symbol;
4012 objfile_type->nodebug_got_plt_symbol
4013 = init_type (TYPE_CODE_PTR, gdbarch_addr_bit (gdbarch) / 8, 0,
4014 "<text from jump slot in .got.plt, no debug info>",
4016 TYPE_TARGET_TYPE (objfile_type->nodebug_got_plt_symbol)
4017 = objfile_type->nodebug_text_symbol;
4018 objfile_type->nodebug_data_symbol
4019 = init_type (TYPE_CODE_INT,
4020 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
4021 "<data variable, no debug info>", objfile);
4022 objfile_type->nodebug_unknown_symbol
4023 = init_type (TYPE_CODE_INT, 1, 0,
4024 "<variable (not text or data), no debug info>", objfile);
4025 objfile_type->nodebug_tls_symbol
4026 = init_type (TYPE_CODE_INT,
4027 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
4028 "<thread local variable, no debug info>", objfile);
4030 /* NOTE: on some targets, addresses and pointers are not necessarily
4031 the same --- for example, on the D10V, pointers are 16 bits long,
4032 but addresses are 32 bits long. See doc/gdbint.texinfo,
4033 ``Pointers Are Not Always Addresses''.
4036 - gdb's `struct type' always describes the target's
4038 - gdb's `struct value' objects should always hold values in
4040 - gdb's CORE_ADDR values are addresses in the unified virtual
4041 address space that the assembler and linker work with. Thus,
4042 since target_read_memory takes a CORE_ADDR as an argument, it
4043 can access any memory on the target, even if the processor has
4044 separate code and data address spaces.
4047 - If v is a value holding a D10V code pointer, its contents are
4048 in target form: a big-endian address left-shifted two bits.
4049 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
4050 sizeof (void *) == 2 on the target.
4052 In this context, objfile_type->builtin_core_addr is a bit odd:
4053 it's a target type for a value the target will never see. It's
4054 only used to hold the values of (typeless) linker symbols, which
4055 are indeed in the unified virtual address space. */
4057 objfile_type->builtin_core_addr
4058 = init_type (TYPE_CODE_INT,
4059 gdbarch_addr_bit (gdbarch) / 8,
4060 TYPE_FLAG_UNSIGNED, "__CORE_ADDR", objfile);
4062 set_objfile_data (objfile, objfile_type_data, objfile_type);
4063 return objfile_type;
4066 extern initialize_file_ftype _initialize_gdbtypes;
4069 _initialize_gdbtypes (void)
4071 gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
4072 objfile_type_data = register_objfile_data ();
4074 add_setshow_zuinteger_cmd ("overload", no_class, &overload_debug,
4075 _("Set debugging of C++ overloading."),
4076 _("Show debugging of C++ overloading."),
4077 _("When enabled, ranking of the "
4078 "functions is displayed."),
4080 show_overload_debug,
4081 &setdebuglist, &showdebuglist);
4083 /* Add user knob for controlling resolution of opaque types. */
4084 add_setshow_boolean_cmd ("opaque-type-resolution", class_support,
4085 &opaque_type_resolution,
4086 _("Set resolution of opaque struct/class/union"
4087 " types (if set before loading symbols)."),
4088 _("Show resolution of opaque struct/class/union"
4089 " types (if set before loading symbols)."),
4091 show_opaque_type_resolution,
4092 &setlist, &showlist);
4094 /* Add an option to permit non-strict type checking. */
4095 add_setshow_boolean_cmd ("type", class_support,
4096 &strict_type_checking,
4097 _("Set strict type checking."),
4098 _("Show strict type checking."),
4100 show_strict_type_checking,
4101 &setchecklist, &showchecklist);