1 /* Support routines for manipulating internal types for GDB.
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
4 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
7 Contributed by Cygnus Support, using pieces from other GDB modules.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "gdb_string.h"
31 #include "expression.h"
36 #include "complaints.h"
40 #include "gdb_assert.h"
44 /* Initialize BADNESS constants. */
46 const struct rank LENGTH_MISMATCH_BADNESS = {100,0};
48 const struct rank TOO_FEW_PARAMS_BADNESS = {100,0};
49 const struct rank INCOMPATIBLE_TYPE_BADNESS = {100,0};
51 const struct rank EXACT_MATCH_BADNESS = {0,0};
53 const struct rank INTEGER_PROMOTION_BADNESS = {1,0};
54 const struct rank FLOAT_PROMOTION_BADNESS = {1,0};
55 const struct rank BASE_PTR_CONVERSION_BADNESS = {1,0};
56 const struct rank INTEGER_CONVERSION_BADNESS = {2,0};
57 const struct rank FLOAT_CONVERSION_BADNESS = {2,0};
58 const struct rank INT_FLOAT_CONVERSION_BADNESS = {2,0};
59 const struct rank VOID_PTR_CONVERSION_BADNESS = {2,0};
60 const struct rank BOOL_PTR_CONVERSION_BADNESS = {3,0};
61 const struct rank BASE_CONVERSION_BADNESS = {2,0};
62 const struct rank REFERENCE_CONVERSION_BADNESS = {2,0};
63 const struct rank NULL_POINTER_CONVERSION_BADNESS = {2,0};
64 const struct rank NS_POINTER_CONVERSION_BADNESS = {10,0};
66 /* Floatformat pairs. */
67 const struct floatformat *floatformats_ieee_half[BFD_ENDIAN_UNKNOWN] = {
68 &floatformat_ieee_half_big,
69 &floatformat_ieee_half_little
71 const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN] = {
72 &floatformat_ieee_single_big,
73 &floatformat_ieee_single_little
75 const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN] = {
76 &floatformat_ieee_double_big,
77 &floatformat_ieee_double_little
79 const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN] = {
80 &floatformat_ieee_double_big,
81 &floatformat_ieee_double_littlebyte_bigword
83 const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN] = {
84 &floatformat_i387_ext,
87 const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN] = {
88 &floatformat_m68881_ext,
89 &floatformat_m68881_ext
91 const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN] = {
92 &floatformat_arm_ext_big,
93 &floatformat_arm_ext_littlebyte_bigword
95 const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN] = {
96 &floatformat_ia64_spill_big,
97 &floatformat_ia64_spill_little
99 const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN] = {
100 &floatformat_ia64_quad_big,
101 &floatformat_ia64_quad_little
103 const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN] = {
107 const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN] = {
111 const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN] = {
112 &floatformat_ibm_long_double,
113 &floatformat_ibm_long_double
117 int opaque_type_resolution = 1;
119 show_opaque_type_resolution (struct ui_file *file, int from_tty,
120 struct cmd_list_element *c,
123 fprintf_filtered (file, _("Resolution of opaque struct/class/union types "
124 "(if set before loading symbols) is %s.\n"),
128 int overload_debug = 0;
130 show_overload_debug (struct ui_file *file, int from_tty,
131 struct cmd_list_element *c, const char *value)
133 fprintf_filtered (file, _("Debugging of C++ overloading is %s.\n"),
141 }; /* Maximum extension is 128! FIXME */
143 static void print_bit_vector (B_TYPE *, int);
144 static void print_arg_types (struct field *, int, int);
145 static void dump_fn_fieldlists (struct type *, int);
146 static void print_cplus_stuff (struct type *, int);
149 /* Allocate a new OBJFILE-associated type structure and fill it
150 with some defaults. Space for the type structure is allocated
151 on the objfile's objfile_obstack. */
154 alloc_type (struct objfile *objfile)
158 gdb_assert (objfile != NULL);
160 /* Alloc the structure and start off with all fields zeroed. */
161 type = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct type);
162 TYPE_MAIN_TYPE (type) = OBSTACK_ZALLOC (&objfile->objfile_obstack,
164 OBJSTAT (objfile, n_types++);
166 TYPE_OBJFILE_OWNED (type) = 1;
167 TYPE_OWNER (type).objfile = objfile;
169 /* Initialize the fields that might not be zero. */
171 TYPE_CODE (type) = TYPE_CODE_UNDEF;
172 TYPE_VPTR_FIELDNO (type) = -1;
173 TYPE_CHAIN (type) = type; /* Chain back to itself. */
178 /* Allocate a new GDBARCH-associated type structure and fill it
179 with some defaults. Space for the type structure is allocated
183 alloc_type_arch (struct gdbarch *gdbarch)
187 gdb_assert (gdbarch != NULL);
189 /* Alloc the structure and start off with all fields zeroed. */
191 type = XZALLOC (struct type);
192 TYPE_MAIN_TYPE (type) = XZALLOC (struct main_type);
194 TYPE_OBJFILE_OWNED (type) = 0;
195 TYPE_OWNER (type).gdbarch = gdbarch;
197 /* Initialize the fields that might not be zero. */
199 TYPE_CODE (type) = TYPE_CODE_UNDEF;
200 TYPE_VPTR_FIELDNO (type) = -1;
201 TYPE_CHAIN (type) = type; /* Chain back to itself. */
206 /* If TYPE is objfile-associated, allocate a new type structure
207 associated with the same objfile. If TYPE is gdbarch-associated,
208 allocate a new type structure associated with the same gdbarch. */
211 alloc_type_copy (const struct type *type)
213 if (TYPE_OBJFILE_OWNED (type))
214 return alloc_type (TYPE_OWNER (type).objfile);
216 return alloc_type_arch (TYPE_OWNER (type).gdbarch);
219 /* If TYPE is gdbarch-associated, return that architecture.
220 If TYPE is objfile-associated, return that objfile's architecture. */
223 get_type_arch (const struct type *type)
225 if (TYPE_OBJFILE_OWNED (type))
226 return get_objfile_arch (TYPE_OWNER (type).objfile);
228 return TYPE_OWNER (type).gdbarch;
232 /* Alloc a new type instance structure, fill it with some defaults,
233 and point it at OLDTYPE. Allocate the new type instance from the
234 same place as OLDTYPE. */
237 alloc_type_instance (struct type *oldtype)
241 /* Allocate the structure. */
243 if (! TYPE_OBJFILE_OWNED (oldtype))
244 type = XZALLOC (struct type);
246 type = OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype)->objfile_obstack,
249 TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype);
251 TYPE_CHAIN (type) = type; /* Chain back to itself for now. */
256 /* Clear all remnants of the previous type at TYPE, in preparation for
257 replacing it with something else. Preserve owner information. */
259 smash_type (struct type *type)
261 int objfile_owned = TYPE_OBJFILE_OWNED (type);
262 union type_owner owner = TYPE_OWNER (type);
264 memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
266 /* Restore owner information. */
267 TYPE_OBJFILE_OWNED (type) = objfile_owned;
268 TYPE_OWNER (type) = owner;
270 /* For now, delete the rings. */
271 TYPE_CHAIN (type) = type;
273 /* For now, leave the pointer/reference types alone. */
276 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
277 to a pointer to memory where the pointer type should be stored.
278 If *TYPEPTR is zero, update it to point to the pointer type we return.
279 We allocate new memory if needed. */
282 make_pointer_type (struct type *type, struct type **typeptr)
284 struct type *ntype; /* New type */
287 ntype = TYPE_POINTER_TYPE (type);
292 return ntype; /* Don't care about alloc,
293 and have new type. */
294 else if (*typeptr == 0)
296 *typeptr = ntype; /* Tracking alloc, and have new type. */
301 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
303 ntype = alloc_type_copy (type);
307 else /* We have storage, but need to reset it. */
310 chain = TYPE_CHAIN (ntype);
312 TYPE_CHAIN (ntype) = chain;
315 TYPE_TARGET_TYPE (ntype) = type;
316 TYPE_POINTER_TYPE (type) = ntype;
318 /* FIXME! Assume the machine has only one representation for
322 = gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
323 TYPE_CODE (ntype) = TYPE_CODE_PTR;
325 /* Mark pointers as unsigned. The target converts between pointers
326 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
327 gdbarch_address_to_pointer. */
328 TYPE_UNSIGNED (ntype) = 1;
330 if (!TYPE_POINTER_TYPE (type)) /* Remember it, if don't have one. */
331 TYPE_POINTER_TYPE (type) = ntype;
333 /* Update the length of all the other variants of this type. */
334 chain = TYPE_CHAIN (ntype);
335 while (chain != ntype)
337 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
338 chain = TYPE_CHAIN (chain);
344 /* Given a type TYPE, return a type of pointers to that type.
345 May need to construct such a type if this is the first use. */
348 lookup_pointer_type (struct type *type)
350 return make_pointer_type (type, (struct type **) 0);
353 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
354 points to a pointer to memory where the reference type should be
355 stored. If *TYPEPTR is zero, update it to point to the reference
356 type we return. We allocate new memory if needed. */
359 make_reference_type (struct type *type, struct type **typeptr)
361 struct type *ntype; /* New type */
364 ntype = TYPE_REFERENCE_TYPE (type);
369 return ntype; /* Don't care about alloc,
370 and have new type. */
371 else if (*typeptr == 0)
373 *typeptr = ntype; /* Tracking alloc, and have new type. */
378 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
380 ntype = alloc_type_copy (type);
384 else /* We have storage, but need to reset it. */
387 chain = TYPE_CHAIN (ntype);
389 TYPE_CHAIN (ntype) = chain;
392 TYPE_TARGET_TYPE (ntype) = type;
393 TYPE_REFERENCE_TYPE (type) = ntype;
395 /* FIXME! Assume the machine has only one representation for
396 references, and that it matches the (only) representation for
399 TYPE_LENGTH (ntype) =
400 gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
401 TYPE_CODE (ntype) = TYPE_CODE_REF;
403 if (!TYPE_REFERENCE_TYPE (type)) /* Remember it, if don't have one. */
404 TYPE_REFERENCE_TYPE (type) = ntype;
406 /* Update the length of all the other variants of this type. */
407 chain = TYPE_CHAIN (ntype);
408 while (chain != ntype)
410 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
411 chain = TYPE_CHAIN (chain);
417 /* Same as above, but caller doesn't care about memory allocation
421 lookup_reference_type (struct type *type)
423 return make_reference_type (type, (struct type **) 0);
426 /* Lookup a function type that returns type TYPE. TYPEPTR, if
427 nonzero, points to a pointer to memory where the function type
428 should be stored. If *TYPEPTR is zero, update it to point to the
429 function type we return. We allocate new memory if needed. */
432 make_function_type (struct type *type, struct type **typeptr)
434 struct type *ntype; /* New type */
436 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
438 ntype = alloc_type_copy (type);
442 else /* We have storage, but need to reset it. */
448 TYPE_TARGET_TYPE (ntype) = type;
450 TYPE_LENGTH (ntype) = 1;
451 TYPE_CODE (ntype) = TYPE_CODE_FUNC;
453 INIT_FUNC_SPECIFIC (ntype);
459 /* Given a type TYPE, return a type of functions that return that type.
460 May need to construct such a type if this is the first use. */
463 lookup_function_type (struct type *type)
465 return make_function_type (type, (struct type **) 0);
468 /* Identify address space identifier by name --
469 return the integer flag defined in gdbtypes.h. */
471 address_space_name_to_int (struct gdbarch *gdbarch, char *space_identifier)
475 /* Check for known address space delimiters. */
476 if (!strcmp (space_identifier, "code"))
477 return TYPE_INSTANCE_FLAG_CODE_SPACE;
478 else if (!strcmp (space_identifier, "data"))
479 return TYPE_INSTANCE_FLAG_DATA_SPACE;
480 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch)
481 && gdbarch_address_class_name_to_type_flags (gdbarch,
486 error (_("Unknown address space specifier: \"%s\""), space_identifier);
489 /* Identify address space identifier by integer flag as defined in
490 gdbtypes.h -- return the string version of the adress space name. */
493 address_space_int_to_name (struct gdbarch *gdbarch, int space_flag)
495 if (space_flag & TYPE_INSTANCE_FLAG_CODE_SPACE)
497 else if (space_flag & TYPE_INSTANCE_FLAG_DATA_SPACE)
499 else if ((space_flag & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
500 && gdbarch_address_class_type_flags_to_name_p (gdbarch))
501 return gdbarch_address_class_type_flags_to_name (gdbarch, space_flag);
506 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
508 If STORAGE is non-NULL, create the new type instance there.
509 STORAGE must be in the same obstack as TYPE. */
512 make_qualified_type (struct type *type, int new_flags,
513 struct type *storage)
520 if (TYPE_INSTANCE_FLAGS (ntype) == new_flags)
522 ntype = TYPE_CHAIN (ntype);
524 while (ntype != type);
526 /* Create a new type instance. */
528 ntype = alloc_type_instance (type);
531 /* If STORAGE was provided, it had better be in the same objfile
532 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
533 if one objfile is freed and the other kept, we'd have
534 dangling pointers. */
535 gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage));
538 TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type);
539 TYPE_CHAIN (ntype) = ntype;
542 /* Pointers or references to the original type are not relevant to
544 TYPE_POINTER_TYPE (ntype) = (struct type *) 0;
545 TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0;
547 /* Chain the new qualified type to the old type. */
548 TYPE_CHAIN (ntype) = TYPE_CHAIN (type);
549 TYPE_CHAIN (type) = ntype;
551 /* Now set the instance flags and return the new type. */
552 TYPE_INSTANCE_FLAGS (ntype) = new_flags;
554 /* Set length of new type to that of the original type. */
555 TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
560 /* Make an address-space-delimited variant of a type -- a type that
561 is identical to the one supplied except that it has an address
562 space attribute attached to it (such as "code" or "data").
564 The space attributes "code" and "data" are for Harvard
565 architectures. The address space attributes are for architectures
566 which have alternately sized pointers or pointers with alternate
570 make_type_with_address_space (struct type *type, int space_flag)
572 int new_flags = ((TYPE_INSTANCE_FLAGS (type)
573 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
574 | TYPE_INSTANCE_FLAG_DATA_SPACE
575 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL))
578 return make_qualified_type (type, new_flags, NULL);
581 /* Make a "c-v" variant of a type -- a type that is identical to the
582 one supplied except that it may have const or volatile attributes
583 CNST is a flag for setting the const attribute
584 VOLTL is a flag for setting the volatile attribute
585 TYPE is the base type whose variant we are creating.
587 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
588 storage to hold the new qualified type; *TYPEPTR and TYPE must be
589 in the same objfile. Otherwise, allocate fresh memory for the new
590 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
591 new type we construct. */
593 make_cv_type (int cnst, int voltl,
595 struct type **typeptr)
597 struct type *ntype; /* New type */
599 int new_flags = (TYPE_INSTANCE_FLAGS (type)
600 & ~(TYPE_INSTANCE_FLAG_CONST
601 | TYPE_INSTANCE_FLAG_VOLATILE));
604 new_flags |= TYPE_INSTANCE_FLAG_CONST;
607 new_flags |= TYPE_INSTANCE_FLAG_VOLATILE;
609 if (typeptr && *typeptr != NULL)
611 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
612 a C-V variant chain that threads across objfiles: if one
613 objfile gets freed, then the other has a broken C-V chain.
615 This code used to try to copy over the main type from TYPE to
616 *TYPEPTR if they were in different objfiles, but that's
617 wrong, too: TYPE may have a field list or member function
618 lists, which refer to types of their own, etc. etc. The
619 whole shebang would need to be copied over recursively; you
620 can't have inter-objfile pointers. The only thing to do is
621 to leave stub types as stub types, and look them up afresh by
622 name each time you encounter them. */
623 gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type));
626 ntype = make_qualified_type (type, new_flags,
627 typeptr ? *typeptr : NULL);
635 /* Replace the contents of ntype with the type *type. This changes the
636 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
637 the changes are propogated to all types in the TYPE_CHAIN.
639 In order to build recursive types, it's inevitable that we'll need
640 to update types in place --- but this sort of indiscriminate
641 smashing is ugly, and needs to be replaced with something more
642 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
643 clear if more steps are needed. */
645 replace_type (struct type *ntype, struct type *type)
649 /* These two types had better be in the same objfile. Otherwise,
650 the assignment of one type's main type structure to the other
651 will produce a type with references to objects (names; field
652 lists; etc.) allocated on an objfile other than its own. */
653 gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (ntype));
655 *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
657 /* The type length is not a part of the main type. Update it for
658 each type on the variant chain. */
662 /* Assert that this element of the chain has no address-class bits
663 set in its flags. Such type variants might have type lengths
664 which are supposed to be different from the non-address-class
665 variants. This assertion shouldn't ever be triggered because
666 symbol readers which do construct address-class variants don't
667 call replace_type(). */
668 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0);
670 TYPE_LENGTH (chain) = TYPE_LENGTH (type);
671 chain = TYPE_CHAIN (chain);
673 while (ntype != chain);
675 /* Assert that the two types have equivalent instance qualifiers.
676 This should be true for at least all of our debug readers. */
677 gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type));
680 /* Implement direct support for MEMBER_TYPE in GNU C++.
681 May need to construct such a type if this is the first use.
682 The TYPE is the type of the member. The DOMAIN is the type
683 of the aggregate that the member belongs to. */
686 lookup_memberptr_type (struct type *type, struct type *domain)
690 mtype = alloc_type_copy (type);
691 smash_to_memberptr_type (mtype, domain, type);
695 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
698 lookup_methodptr_type (struct type *to_type)
702 mtype = alloc_type_copy (to_type);
703 smash_to_methodptr_type (mtype, to_type);
707 /* Allocate a stub method whose return type is TYPE. This apparently
708 happens for speed of symbol reading, since parsing out the
709 arguments to the method is cpu-intensive, the way we are doing it.
710 So, we will fill in arguments later. This always returns a fresh
714 allocate_stub_method (struct type *type)
718 mtype = alloc_type_copy (type);
719 TYPE_CODE (mtype) = TYPE_CODE_METHOD;
720 TYPE_LENGTH (mtype) = 1;
721 TYPE_STUB (mtype) = 1;
722 TYPE_TARGET_TYPE (mtype) = type;
723 /* _DOMAIN_TYPE (mtype) = unknown yet */
727 /* Create a range type using either a blank type supplied in
728 RESULT_TYPE, or creating a new type, inheriting the objfile from
731 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
732 to HIGH_BOUND, inclusive.
734 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
735 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
738 create_range_type (struct type *result_type, struct type *index_type,
739 LONGEST low_bound, LONGEST high_bound)
741 if (result_type == NULL)
742 result_type = alloc_type_copy (index_type);
743 TYPE_CODE (result_type) = TYPE_CODE_RANGE;
744 TYPE_TARGET_TYPE (result_type) = index_type;
745 if (TYPE_STUB (index_type))
746 TYPE_TARGET_STUB (result_type) = 1;
748 TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
749 TYPE_RANGE_DATA (result_type) = (struct range_bounds *)
750 TYPE_ZALLOC (result_type, sizeof (struct range_bounds));
751 TYPE_LOW_BOUND (result_type) = low_bound;
752 TYPE_HIGH_BOUND (result_type) = high_bound;
755 TYPE_UNSIGNED (result_type) = 1;
760 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
761 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
762 bounds will fit in LONGEST), or -1 otherwise. */
765 get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
767 CHECK_TYPEDEF (type);
768 switch (TYPE_CODE (type))
770 case TYPE_CODE_RANGE:
771 *lowp = TYPE_LOW_BOUND (type);
772 *highp = TYPE_HIGH_BOUND (type);
775 if (TYPE_NFIELDS (type) > 0)
777 /* The enums may not be sorted by value, so search all
781 *lowp = *highp = TYPE_FIELD_BITPOS (type, 0);
782 for (i = 0; i < TYPE_NFIELDS (type); i++)
784 if (TYPE_FIELD_BITPOS (type, i) < *lowp)
785 *lowp = TYPE_FIELD_BITPOS (type, i);
786 if (TYPE_FIELD_BITPOS (type, i) > *highp)
787 *highp = TYPE_FIELD_BITPOS (type, i);
790 /* Set unsigned indicator if warranted. */
793 TYPE_UNSIGNED (type) = 1;
807 if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */
809 if (!TYPE_UNSIGNED (type))
811 *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
815 /* ... fall through for unsigned ints ... */
818 /* This round-about calculation is to avoid shifting by
819 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
820 if TYPE_LENGTH (type) == sizeof (LONGEST). */
821 *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
822 *highp = (*highp - 1) | *highp;
829 /* Assuming TYPE is a simple, non-empty array type, compute its upper
830 and lower bound. Save the low bound into LOW_BOUND if not NULL.
831 Save the high bound into HIGH_BOUND if not NULL.
833 Return 1 if the operation was successful. Return zero otherwise,
834 in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
836 We now simply use get_discrete_bounds call to get the values
837 of the low and high bounds.
838 get_discrete_bounds can return three values:
839 1, meaning that index is a range,
840 0, meaning that index is a discrete type,
841 or -1 for failure. */
844 get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound)
846 struct type *index = TYPE_INDEX_TYPE (type);
854 res = get_discrete_bounds (index, &low, &high);
858 /* Check if the array bounds are undefined. */
860 && ((low_bound && TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type))
861 || (high_bound && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))))
873 /* Create an array type using either a blank type supplied in
874 RESULT_TYPE, or creating a new type, inheriting the objfile from
877 Elements will be of type ELEMENT_TYPE, the indices will be of type
880 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
881 sure it is TYPE_CODE_UNDEF before we bash it into an array
885 create_array_type (struct type *result_type,
886 struct type *element_type,
887 struct type *range_type)
889 LONGEST low_bound, high_bound;
891 if (result_type == NULL)
892 result_type = alloc_type_copy (range_type);
894 TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
895 TYPE_TARGET_TYPE (result_type) = element_type;
896 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
897 low_bound = high_bound = 0;
898 CHECK_TYPEDEF (element_type);
899 /* Be careful when setting the array length. Ada arrays can be
900 empty arrays with the high_bound being smaller than the low_bound.
901 In such cases, the array length should be zero. */
902 if (high_bound < low_bound)
903 TYPE_LENGTH (result_type) = 0;
905 TYPE_LENGTH (result_type) =
906 TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
907 TYPE_NFIELDS (result_type) = 1;
908 TYPE_FIELDS (result_type) =
909 (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
910 TYPE_INDEX_TYPE (result_type) = range_type;
911 TYPE_VPTR_FIELDNO (result_type) = -1;
913 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays. */
914 if (TYPE_LENGTH (result_type) == 0)
915 TYPE_TARGET_STUB (result_type) = 1;
921 lookup_array_range_type (struct type *element_type,
922 int low_bound, int high_bound)
924 struct gdbarch *gdbarch = get_type_arch (element_type);
925 struct type *index_type = builtin_type (gdbarch)->builtin_int;
926 struct type *range_type
927 = create_range_type (NULL, index_type, low_bound, high_bound);
929 return create_array_type (NULL, element_type, range_type);
932 /* Create a string type using either a blank type supplied in
933 RESULT_TYPE, or creating a new type. String types are similar
934 enough to array of char types that we can use create_array_type to
935 build the basic type and then bash it into a string type.
937 For fixed length strings, the range type contains 0 as the lower
938 bound and the length of the string minus one as the upper bound.
940 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
941 sure it is TYPE_CODE_UNDEF before we bash it into a string
945 create_string_type (struct type *result_type,
946 struct type *string_char_type,
947 struct type *range_type)
949 result_type = create_array_type (result_type,
952 TYPE_CODE (result_type) = TYPE_CODE_STRING;
957 lookup_string_range_type (struct type *string_char_type,
958 int low_bound, int high_bound)
960 struct type *result_type;
962 result_type = lookup_array_range_type (string_char_type,
963 low_bound, high_bound);
964 TYPE_CODE (result_type) = TYPE_CODE_STRING;
969 create_set_type (struct type *result_type, struct type *domain_type)
971 if (result_type == NULL)
972 result_type = alloc_type_copy (domain_type);
974 TYPE_CODE (result_type) = TYPE_CODE_SET;
975 TYPE_NFIELDS (result_type) = 1;
976 TYPE_FIELDS (result_type) = TYPE_ZALLOC (result_type, sizeof (struct field));
978 if (!TYPE_STUB (domain_type))
980 LONGEST low_bound, high_bound, bit_length;
982 if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
983 low_bound = high_bound = 0;
984 bit_length = high_bound - low_bound + 1;
985 TYPE_LENGTH (result_type)
986 = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
988 TYPE_UNSIGNED (result_type) = 1;
990 TYPE_FIELD_TYPE (result_type, 0) = domain_type;
995 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
996 and any array types nested inside it. */
999 make_vector_type (struct type *array_type)
1001 struct type *inner_array, *elt_type;
1004 /* Find the innermost array type, in case the array is
1005 multi-dimensional. */
1006 inner_array = array_type;
1007 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
1008 inner_array = TYPE_TARGET_TYPE (inner_array);
1010 elt_type = TYPE_TARGET_TYPE (inner_array);
1011 if (TYPE_CODE (elt_type) == TYPE_CODE_INT)
1013 flags = TYPE_INSTANCE_FLAGS (elt_type) | TYPE_INSTANCE_FLAG_NOTTEXT;
1014 elt_type = make_qualified_type (elt_type, flags, NULL);
1015 TYPE_TARGET_TYPE (inner_array) = elt_type;
1018 TYPE_VECTOR (array_type) = 1;
1022 init_vector_type (struct type *elt_type, int n)
1024 struct type *array_type;
1026 array_type = lookup_array_range_type (elt_type, 0, n - 1);
1027 make_vector_type (array_type);
1031 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
1032 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1033 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1034 TYPE doesn't include the offset (that's the value of the MEMBER
1035 itself), but does include the structure type into which it points
1038 When "smashing" the type, we preserve the objfile that the old type
1039 pointed to, since we aren't changing where the type is actually
1043 smash_to_memberptr_type (struct type *type, struct type *domain,
1044 struct type *to_type)
1047 TYPE_TARGET_TYPE (type) = to_type;
1048 TYPE_DOMAIN_TYPE (type) = domain;
1049 /* Assume that a data member pointer is the same size as a normal
1052 = gdbarch_ptr_bit (get_type_arch (to_type)) / TARGET_CHAR_BIT;
1053 TYPE_CODE (type) = TYPE_CODE_MEMBERPTR;
1056 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1058 When "smashing" the type, we preserve the objfile that the old type
1059 pointed to, since we aren't changing where the type is actually
1063 smash_to_methodptr_type (struct type *type, struct type *to_type)
1066 TYPE_TARGET_TYPE (type) = to_type;
1067 TYPE_DOMAIN_TYPE (type) = TYPE_DOMAIN_TYPE (to_type);
1068 TYPE_LENGTH (type) = cplus_method_ptr_size (to_type);
1069 TYPE_CODE (type) = TYPE_CODE_METHODPTR;
1072 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
1073 METHOD just means `function that gets an extra "this" argument'.
1075 When "smashing" the type, we preserve the objfile that the old type
1076 pointed to, since we aren't changing where the type is actually
1080 smash_to_method_type (struct type *type, struct type *domain,
1081 struct type *to_type, struct field *args,
1082 int nargs, int varargs)
1085 TYPE_TARGET_TYPE (type) = to_type;
1086 TYPE_DOMAIN_TYPE (type) = domain;
1087 TYPE_FIELDS (type) = args;
1088 TYPE_NFIELDS (type) = nargs;
1090 TYPE_VARARGS (type) = 1;
1091 TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
1092 TYPE_CODE (type) = TYPE_CODE_METHOD;
1095 /* Return a typename for a struct/union/enum type without "struct ",
1096 "union ", or "enum ". If the type has a NULL name, return NULL. */
1099 type_name_no_tag (const struct type *type)
1101 if (TYPE_TAG_NAME (type) != NULL)
1102 return TYPE_TAG_NAME (type);
1104 /* Is there code which expects this to return the name if there is
1105 no tag name? My guess is that this is mainly used for C++ in
1106 cases where the two will always be the same. */
1107 return TYPE_NAME (type);
1110 /* A wrapper of type_name_no_tag which calls error if the type is anonymous.
1111 Since GCC PR debug/47510 DWARF provides associated information to detect the
1112 anonymous class linkage name from its typedef.
1114 Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
1118 type_name_no_tag_or_error (struct type *type)
1120 struct type *saved_type = type;
1122 struct objfile *objfile;
1124 CHECK_TYPEDEF (type);
1126 name = type_name_no_tag (type);
1130 name = type_name_no_tag (saved_type);
1131 objfile = TYPE_OBJFILE (saved_type);
1132 error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
1133 name ? name : "<anonymous>", objfile ? objfile->name : "<arch>");
1136 /* Lookup a typedef or primitive type named NAME, visible in lexical
1137 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1138 suitably defined. */
1141 lookup_typename (const struct language_defn *language,
1142 struct gdbarch *gdbarch, const char *name,
1143 const struct block *block, int noerr)
1148 sym = lookup_symbol (name, block, VAR_DOMAIN, 0);
1149 if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
1151 tmp = language_lookup_primitive_type_by_name (language, gdbarch, name);
1156 else if (!tmp && noerr)
1162 error (_("No type named %s."), name);
1165 return (SYMBOL_TYPE (sym));
1169 lookup_unsigned_typename (const struct language_defn *language,
1170 struct gdbarch *gdbarch, char *name)
1172 char *uns = alloca (strlen (name) + 10);
1174 strcpy (uns, "unsigned ");
1175 strcpy (uns + 9, name);
1176 return lookup_typename (language, gdbarch, uns, (struct block *) NULL, 0);
1180 lookup_signed_typename (const struct language_defn *language,
1181 struct gdbarch *gdbarch, char *name)
1184 char *uns = alloca (strlen (name) + 8);
1186 strcpy (uns, "signed ");
1187 strcpy (uns + 7, name);
1188 t = lookup_typename (language, gdbarch, uns, (struct block *) NULL, 1);
1189 /* If we don't find "signed FOO" just try again with plain "FOO". */
1192 return lookup_typename (language, gdbarch, name, (struct block *) NULL, 0);
1195 /* Lookup a structure type named "struct NAME",
1196 visible in lexical block BLOCK. */
1199 lookup_struct (const char *name, struct block *block)
1203 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1207 error (_("No struct type named %s."), name);
1209 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1211 error (_("This context has class, union or enum %s, not a struct."),
1214 return (SYMBOL_TYPE (sym));
1217 /* Lookup a union type named "union NAME",
1218 visible in lexical block BLOCK. */
1221 lookup_union (const char *name, struct block *block)
1226 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1229 error (_("No union type named %s."), name);
1231 t = SYMBOL_TYPE (sym);
1233 if (TYPE_CODE (t) == TYPE_CODE_UNION)
1236 /* If we get here, it's not a union. */
1237 error (_("This context has class, struct or enum %s, not a union."),
1242 /* Lookup an enum type named "enum NAME",
1243 visible in lexical block BLOCK. */
1246 lookup_enum (const char *name, struct block *block)
1250 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1253 error (_("No enum type named %s."), name);
1255 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
1257 error (_("This context has class, struct or union %s, not an enum."),
1260 return (SYMBOL_TYPE (sym));
1263 /* Lookup a template type named "template NAME<TYPE>",
1264 visible in lexical block BLOCK. */
1267 lookup_template_type (char *name, struct type *type,
1268 struct block *block)
1271 char *nam = (char *)
1272 alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4);
1276 strcat (nam, TYPE_NAME (type));
1277 strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
1279 sym = lookup_symbol (nam, block, VAR_DOMAIN, 0);
1283 error (_("No template type named %s."), name);
1285 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1287 error (_("This context has class, union or enum %s, not a struct."),
1290 return (SYMBOL_TYPE (sym));
1293 /* Given a type TYPE, lookup the type of the component of type named
1296 TYPE can be either a struct or union, or a pointer or reference to
1297 a struct or union. If it is a pointer or reference, its target
1298 type is automatically used. Thus '.' and '->' are interchangable,
1299 as specified for the definitions of the expression element types
1300 STRUCTOP_STRUCT and STRUCTOP_PTR.
1302 If NOERR is nonzero, return zero if NAME is not suitably defined.
1303 If NAME is the name of a baseclass type, return that type. */
1306 lookup_struct_elt_type (struct type *type, char *name, int noerr)
1313 CHECK_TYPEDEF (type);
1314 if (TYPE_CODE (type) != TYPE_CODE_PTR
1315 && TYPE_CODE (type) != TYPE_CODE_REF)
1317 type = TYPE_TARGET_TYPE (type);
1320 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1321 && TYPE_CODE (type) != TYPE_CODE_UNION)
1323 typename = type_to_string (type);
1324 make_cleanup (xfree, typename);
1325 error (_("Type %s is not a structure or union type."), typename);
1329 /* FIXME: This change put in by Michael seems incorrect for the case
1330 where the structure tag name is the same as the member name.
1331 I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
1332 foo; } bell;" Disabled by fnf. */
1336 typename = type_name_no_tag (type);
1337 if (typename != NULL && strcmp (typename, name) == 0)
1342 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1344 char *t_field_name = TYPE_FIELD_NAME (type, i);
1346 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1348 return TYPE_FIELD_TYPE (type, i);
1350 else if (!t_field_name || *t_field_name == '\0')
1352 struct type *subtype
1353 = lookup_struct_elt_type (TYPE_FIELD_TYPE (type, i), name, 1);
1355 if (subtype != NULL)
1360 /* OK, it's not in this class. Recursively check the baseclasses. */
1361 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1365 t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 1);
1377 typename = type_to_string (type);
1378 make_cleanup (xfree, typename);
1379 error (_("Type %s has no component named %s."), typename, name);
1382 /* Lookup the vptr basetype/fieldno values for TYPE.
1383 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1384 vptr_fieldno. Also, if found and basetype is from the same objfile,
1386 If not found, return -1 and ignore BASETYPEP.
1387 Callers should be aware that in some cases (for example,
1388 the type or one of its baseclasses is a stub type and we are
1389 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1390 this function will not be able to find the
1391 virtual function table pointer, and vptr_fieldno will remain -1 and
1392 vptr_basetype will remain NULL or incomplete. */
1395 get_vptr_fieldno (struct type *type, struct type **basetypep)
1397 CHECK_TYPEDEF (type);
1399 if (TYPE_VPTR_FIELDNO (type) < 0)
1403 /* We must start at zero in case the first (and only) baseclass
1404 is virtual (and hence we cannot share the table pointer). */
1405 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1407 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
1409 struct type *basetype;
1411 fieldno = get_vptr_fieldno (baseclass, &basetype);
1414 /* If the type comes from a different objfile we can't cache
1415 it, it may have a different lifetime. PR 2384 */
1416 if (TYPE_OBJFILE (type) == TYPE_OBJFILE (basetype))
1418 TYPE_VPTR_FIELDNO (type) = fieldno;
1419 TYPE_VPTR_BASETYPE (type) = basetype;
1422 *basetypep = basetype;
1433 *basetypep = TYPE_VPTR_BASETYPE (type);
1434 return TYPE_VPTR_FIELDNO (type);
1439 stub_noname_complaint (void)
1441 complaint (&symfile_complaints, _("stub type has NULL name"));
1444 /* Find the real type of TYPE. This function returns the real type,
1445 after removing all layers of typedefs, and completing opaque or stub
1446 types. Completion changes the TYPE argument, but stripping of
1449 Instance flags (e.g. const/volatile) are preserved as typedefs are
1450 stripped. If necessary a new qualified form of the underlying type
1453 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
1454 not been computed and we're either in the middle of reading symbols, or
1455 there was no name for the typedef in the debug info.
1457 NOTE: Lookup of opaque types can throw errors for invalid symbol files.
1458 QUITs in the symbol reading code can also throw.
1459 Thus this function can throw an exception.
1461 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
1464 If this is a stubbed struct (i.e. declared as struct foo *), see if
1465 we can find a full definition in some other file. If so, copy this
1466 definition, so we can use it in future. There used to be a comment
1467 (but not any code) that if we don't find a full definition, we'd
1468 set a flag so we don't spend time in the future checking the same
1469 type. That would be a mistake, though--we might load in more
1470 symbols which contain a full definition for the type. */
1473 check_typedef (struct type *type)
1475 struct type *orig_type = type;
1476 /* While we're removing typedefs, we don't want to lose qualifiers.
1477 E.g., const/volatile. */
1478 int instance_flags = TYPE_INSTANCE_FLAGS (type);
1482 while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1484 if (!TYPE_TARGET_TYPE (type))
1489 /* It is dangerous to call lookup_symbol if we are currently
1490 reading a symtab. Infinite recursion is one danger. */
1491 if (currently_reading_symtab)
1492 return make_qualified_type (type, instance_flags, NULL);
1494 name = type_name_no_tag (type);
1495 /* FIXME: shouldn't we separately check the TYPE_NAME and
1496 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1497 VAR_DOMAIN as appropriate? (this code was written before
1498 TYPE_NAME and TYPE_TAG_NAME were separate). */
1501 stub_noname_complaint ();
1502 return make_qualified_type (type, instance_flags, NULL);
1504 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
1506 TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
1507 else /* TYPE_CODE_UNDEF */
1508 TYPE_TARGET_TYPE (type) = alloc_type_arch (get_type_arch (type));
1510 type = TYPE_TARGET_TYPE (type);
1512 /* Preserve the instance flags as we traverse down the typedef chain.
1514 Handling address spaces/classes is nasty, what do we do if there's a
1516 E.g., what if an outer typedef marks the type as class_1 and an inner
1517 typedef marks the type as class_2?
1518 This is the wrong place to do such error checking. We leave it to
1519 the code that created the typedef in the first place to flag the
1520 error. We just pick the outer address space (akin to letting the
1521 outer cast in a chain of casting win), instead of assuming
1522 "it can't happen". */
1524 const int ALL_SPACES = (TYPE_INSTANCE_FLAG_CODE_SPACE
1525 | TYPE_INSTANCE_FLAG_DATA_SPACE);
1526 const int ALL_CLASSES = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL;
1527 int new_instance_flags = TYPE_INSTANCE_FLAGS (type);
1529 /* Treat code vs data spaces and address classes separately. */
1530 if ((instance_flags & ALL_SPACES) != 0)
1531 new_instance_flags &= ~ALL_SPACES;
1532 if ((instance_flags & ALL_CLASSES) != 0)
1533 new_instance_flags &= ~ALL_CLASSES;
1535 instance_flags |= new_instance_flags;
1539 /* If this is a struct/class/union with no fields, then check
1540 whether a full definition exists somewhere else. This is for
1541 systems where a type definition with no fields is issued for such
1542 types, instead of identifying them as stub types in the first
1545 if (TYPE_IS_OPAQUE (type)
1546 && opaque_type_resolution
1547 && !currently_reading_symtab)
1549 char *name = type_name_no_tag (type);
1550 struct type *newtype;
1554 stub_noname_complaint ();
1555 return make_qualified_type (type, instance_flags, NULL);
1557 newtype = lookup_transparent_type (name);
1561 /* If the resolved type and the stub are in the same
1562 objfile, then replace the stub type with the real deal.
1563 But if they're in separate objfiles, leave the stub
1564 alone; we'll just look up the transparent type every time
1565 we call check_typedef. We can't create pointers between
1566 types allocated to different objfiles, since they may
1567 have different lifetimes. Trying to copy NEWTYPE over to
1568 TYPE's objfile is pointless, too, since you'll have to
1569 move over any other types NEWTYPE refers to, which could
1570 be an unbounded amount of stuff. */
1571 if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type))
1572 type = make_qualified_type (newtype,
1573 TYPE_INSTANCE_FLAGS (type),
1579 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1581 else if (TYPE_STUB (type) && !currently_reading_symtab)
1583 char *name = type_name_no_tag (type);
1584 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1585 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1586 as appropriate? (this code was written before TYPE_NAME and
1587 TYPE_TAG_NAME were separate). */
1592 stub_noname_complaint ();
1593 return make_qualified_type (type, instance_flags, NULL);
1595 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
1598 /* Same as above for opaque types, we can replace the stub
1599 with the complete type only if they are in the same
1601 if (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type))
1602 type = make_qualified_type (SYMBOL_TYPE (sym),
1603 TYPE_INSTANCE_FLAGS (type),
1606 type = SYMBOL_TYPE (sym);
1610 if (TYPE_TARGET_STUB (type))
1612 struct type *range_type;
1613 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1615 if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type))
1617 /* Nothing we can do. */
1619 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
1620 && TYPE_NFIELDS (type) == 1
1621 && (TYPE_CODE (range_type = TYPE_INDEX_TYPE (type))
1622 == TYPE_CODE_RANGE))
1624 /* Now recompute the length of the array type, based on its
1625 number of elements and the target type's length.
1626 Watch out for Ada null Ada arrays where the high bound
1627 is smaller than the low bound. */
1628 const LONGEST low_bound = TYPE_LOW_BOUND (range_type);
1629 const LONGEST high_bound = TYPE_HIGH_BOUND (range_type);
1632 if (high_bound < low_bound)
1636 /* For now, we conservatively take the array length to be 0
1637 if its length exceeds UINT_MAX. The code below assumes
1638 that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
1639 which is technically not guaranteed by C, but is usually true
1640 (because it would be true if x were unsigned with its
1641 high-order bit on). It uses the fact that
1642 high_bound-low_bound is always representable in
1643 ULONGEST and that if high_bound-low_bound+1 overflows,
1644 it overflows to 0. We must change these tests if we
1645 decide to increase the representation of TYPE_LENGTH
1646 from unsigned int to ULONGEST. */
1647 ULONGEST ulow = low_bound, uhigh = high_bound;
1648 ULONGEST tlen = TYPE_LENGTH (target_type);
1650 len = tlen * (uhigh - ulow + 1);
1651 if (tlen == 0 || (len / tlen - 1 + ulow) != uhigh
1655 TYPE_LENGTH (type) = len;
1656 TYPE_TARGET_STUB (type) = 0;
1658 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
1660 TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
1661 TYPE_TARGET_STUB (type) = 0;
1665 type = make_qualified_type (type, instance_flags, NULL);
1667 /* Cache TYPE_LENGTH for future use. */
1668 TYPE_LENGTH (orig_type) = TYPE_LENGTH (type);
1673 /* Parse a type expression in the string [P..P+LENGTH). If an error
1674 occurs, silently return a void type. */
1676 static struct type *
1677 safe_parse_type (struct gdbarch *gdbarch, char *p, int length)
1679 struct ui_file *saved_gdb_stderr;
1682 /* Suppress error messages. */
1683 saved_gdb_stderr = gdb_stderr;
1684 gdb_stderr = ui_file_new ();
1686 /* Call parse_and_eval_type() without fear of longjmp()s. */
1687 if (!gdb_parse_and_eval_type (p, length, &type))
1688 type = builtin_type (gdbarch)->builtin_void;
1690 /* Stop suppressing error messages. */
1691 ui_file_delete (gdb_stderr);
1692 gdb_stderr = saved_gdb_stderr;
1697 /* Ugly hack to convert method stubs into method types.
1699 He ain't kiddin'. This demangles the name of the method into a
1700 string including argument types, parses out each argument type,
1701 generates a string casting a zero to that type, evaluates the
1702 string, and stuffs the resulting type into an argtype vector!!!
1703 Then it knows the type of the whole function (including argument
1704 types for overloading), which info used to be in the stab's but was
1705 removed to hack back the space required for them. */
1708 check_stub_method (struct type *type, int method_id, int signature_id)
1710 struct gdbarch *gdbarch = get_type_arch (type);
1712 char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
1713 char *demangled_name = cplus_demangle (mangled_name,
1714 DMGL_PARAMS | DMGL_ANSI);
1715 char *argtypetext, *p;
1716 int depth = 0, argcount = 1;
1717 struct field *argtypes;
1720 /* Make sure we got back a function string that we can use. */
1722 p = strchr (demangled_name, '(');
1726 if (demangled_name == NULL || p == NULL)
1727 error (_("Internal: Cannot demangle mangled name `%s'."),
1730 /* Now, read in the parameters that define this type. */
1735 if (*p == '(' || *p == '<')
1739 else if (*p == ')' || *p == '>')
1743 else if (*p == ',' && depth == 0)
1751 /* If we read one argument and it was ``void'', don't count it. */
1752 if (strncmp (argtypetext, "(void)", 6) == 0)
1755 /* We need one extra slot, for the THIS pointer. */
1757 argtypes = (struct field *)
1758 TYPE_ALLOC (type, (argcount + 1) * sizeof (struct field));
1761 /* Add THIS pointer for non-static methods. */
1762 f = TYPE_FN_FIELDLIST1 (type, method_id);
1763 if (TYPE_FN_FIELD_STATIC_P (f, signature_id))
1767 argtypes[0].type = lookup_pointer_type (type);
1771 if (*p != ')') /* () means no args, skip while. */
1776 if (depth <= 0 && (*p == ',' || *p == ')'))
1778 /* Avoid parsing of ellipsis, they will be handled below.
1779 Also avoid ``void'' as above. */
1780 if (strncmp (argtypetext, "...", p - argtypetext) != 0
1781 && strncmp (argtypetext, "void", p - argtypetext) != 0)
1783 argtypes[argcount].type =
1784 safe_parse_type (gdbarch, argtypetext, p - argtypetext);
1787 argtypetext = p + 1;
1790 if (*p == '(' || *p == '<')
1794 else if (*p == ')' || *p == '>')
1803 TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name;
1805 /* Now update the old "stub" type into a real type. */
1806 mtype = TYPE_FN_FIELD_TYPE (f, signature_id);
1807 TYPE_DOMAIN_TYPE (mtype) = type;
1808 TYPE_FIELDS (mtype) = argtypes;
1809 TYPE_NFIELDS (mtype) = argcount;
1810 TYPE_STUB (mtype) = 0;
1811 TYPE_FN_FIELD_STUB (f, signature_id) = 0;
1813 TYPE_VARARGS (mtype) = 1;
1815 xfree (demangled_name);
1818 /* This is the external interface to check_stub_method, above. This
1819 function unstubs all of the signatures for TYPE's METHOD_ID method
1820 name. After calling this function TYPE_FN_FIELD_STUB will be
1821 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1824 This function unfortunately can not die until stabs do. */
1827 check_stub_method_group (struct type *type, int method_id)
1829 int len = TYPE_FN_FIELDLIST_LENGTH (type, method_id);
1830 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
1831 int j, found_stub = 0;
1833 for (j = 0; j < len; j++)
1834 if (TYPE_FN_FIELD_STUB (f, j))
1837 check_stub_method (type, method_id, j);
1840 /* GNU v3 methods with incorrect names were corrected when we read
1841 in type information, because it was cheaper to do it then. The
1842 only GNU v2 methods with incorrect method names are operators and
1843 destructors; destructors were also corrected when we read in type
1846 Therefore the only thing we need to handle here are v2 operator
1848 if (found_stub && strncmp (TYPE_FN_FIELD_PHYSNAME (f, 0), "_Z", 2) != 0)
1851 char dem_opname[256];
1853 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
1855 dem_opname, DMGL_ANSI);
1857 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
1861 TYPE_FN_FIELDLIST_NAME (type, method_id) = xstrdup (dem_opname);
1865 /* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */
1866 const struct cplus_struct_type cplus_struct_default = { };
1869 allocate_cplus_struct_type (struct type *type)
1871 if (HAVE_CPLUS_STRUCT (type))
1872 /* Structure was already allocated. Nothing more to do. */
1875 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CPLUS_STUFF;
1876 TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
1877 TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
1878 *(TYPE_RAW_CPLUS_SPECIFIC (type)) = cplus_struct_default;
1881 const struct gnat_aux_type gnat_aux_default =
1884 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
1885 and allocate the associated gnat-specific data. The gnat-specific
1886 data is also initialized to gnat_aux_default. */
1888 allocate_gnat_aux_type (struct type *type)
1890 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_GNAT_STUFF;
1891 TYPE_GNAT_SPECIFIC (type) = (struct gnat_aux_type *)
1892 TYPE_ALLOC (type, sizeof (struct gnat_aux_type));
1893 *(TYPE_GNAT_SPECIFIC (type)) = gnat_aux_default;
1897 /* Helper function to initialize the standard scalar types.
1899 If NAME is non-NULL, then we make a copy of the string pointed
1900 to by name in the objfile_obstack for that objfile, and initialize
1901 the type name to that copy. There are places (mipsread.c in particular),
1902 where init_type is called with a NULL value for NAME). */
1905 init_type (enum type_code code, int length, int flags,
1906 char *name, struct objfile *objfile)
1910 type = alloc_type (objfile);
1911 TYPE_CODE (type) = code;
1912 TYPE_LENGTH (type) = length;
1914 gdb_assert (!(flags & (TYPE_FLAG_MIN - 1)));
1915 if (flags & TYPE_FLAG_UNSIGNED)
1916 TYPE_UNSIGNED (type) = 1;
1917 if (flags & TYPE_FLAG_NOSIGN)
1918 TYPE_NOSIGN (type) = 1;
1919 if (flags & TYPE_FLAG_STUB)
1920 TYPE_STUB (type) = 1;
1921 if (flags & TYPE_FLAG_TARGET_STUB)
1922 TYPE_TARGET_STUB (type) = 1;
1923 if (flags & TYPE_FLAG_STATIC)
1924 TYPE_STATIC (type) = 1;
1925 if (flags & TYPE_FLAG_PROTOTYPED)
1926 TYPE_PROTOTYPED (type) = 1;
1927 if (flags & TYPE_FLAG_INCOMPLETE)
1928 TYPE_INCOMPLETE (type) = 1;
1929 if (flags & TYPE_FLAG_VARARGS)
1930 TYPE_VARARGS (type) = 1;
1931 if (flags & TYPE_FLAG_VECTOR)
1932 TYPE_VECTOR (type) = 1;
1933 if (flags & TYPE_FLAG_STUB_SUPPORTED)
1934 TYPE_STUB_SUPPORTED (type) = 1;
1935 if (flags & TYPE_FLAG_FIXED_INSTANCE)
1936 TYPE_FIXED_INSTANCE (type) = 1;
1937 if (flags & TYPE_FLAG_GNU_IFUNC)
1938 TYPE_GNU_IFUNC (type) = 1;
1941 TYPE_NAME (type) = obsavestring (name, strlen (name),
1942 &objfile->objfile_obstack);
1946 if (name && strcmp (name, "char") == 0)
1947 TYPE_NOSIGN (type) = 1;
1951 case TYPE_CODE_STRUCT:
1952 case TYPE_CODE_UNION:
1953 case TYPE_CODE_NAMESPACE:
1954 INIT_CPLUS_SPECIFIC (type);
1957 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FLOATFORMAT;
1959 case TYPE_CODE_FUNC:
1960 INIT_FUNC_SPECIFIC (type);
1967 can_dereference (struct type *t)
1969 /* FIXME: Should we return true for references as well as
1974 && TYPE_CODE (t) == TYPE_CODE_PTR
1975 && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
1979 is_integral_type (struct type *t)
1984 && ((TYPE_CODE (t) == TYPE_CODE_INT)
1985 || (TYPE_CODE (t) == TYPE_CODE_ENUM)
1986 || (TYPE_CODE (t) == TYPE_CODE_FLAGS)
1987 || (TYPE_CODE (t) == TYPE_CODE_CHAR)
1988 || (TYPE_CODE (t) == TYPE_CODE_RANGE)
1989 || (TYPE_CODE (t) == TYPE_CODE_BOOL)));
1992 /* Return true if TYPE is scalar. */
1995 is_scalar_type (struct type *type)
1997 CHECK_TYPEDEF (type);
1999 switch (TYPE_CODE (type))
2001 case TYPE_CODE_ARRAY:
2002 case TYPE_CODE_STRUCT:
2003 case TYPE_CODE_UNION:
2005 case TYPE_CODE_STRING:
2006 case TYPE_CODE_BITSTRING:
2013 /* Return true if T is scalar, or a composite type which in practice has
2014 the memory layout of a scalar type. E.g., an array or struct with only
2015 one scalar element inside it, or a union with only scalar elements. */
2018 is_scalar_type_recursive (struct type *t)
2022 if (is_scalar_type (t))
2024 /* Are we dealing with an array or string of known dimensions? */
2025 else if ((TYPE_CODE (t) == TYPE_CODE_ARRAY
2026 || TYPE_CODE (t) == TYPE_CODE_STRING) && TYPE_NFIELDS (t) == 1
2027 && TYPE_CODE (TYPE_INDEX_TYPE (t)) == TYPE_CODE_RANGE)
2029 LONGEST low_bound, high_bound;
2030 struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t));
2032 get_discrete_bounds (TYPE_INDEX_TYPE (t), &low_bound, &high_bound);
2034 return high_bound == low_bound && is_scalar_type_recursive (elt_type);
2036 /* Are we dealing with a struct with one element? */
2037 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT && TYPE_NFIELDS (t) == 1)
2038 return is_scalar_type_recursive (TYPE_FIELD_TYPE (t, 0));
2039 else if (TYPE_CODE (t) == TYPE_CODE_UNION)
2041 int i, n = TYPE_NFIELDS (t);
2043 /* If all elements of the union are scalar, then the union is scalar. */
2044 for (i = 0; i < n; i++)
2045 if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t, i)))
2054 /* A helper function which returns true if types A and B represent the
2055 "same" class type. This is true if the types have the same main
2056 type, or the same name. */
2059 class_types_same_p (const struct type *a, const struct type *b)
2061 return (TYPE_MAIN_TYPE (a) == TYPE_MAIN_TYPE (b)
2062 || (TYPE_NAME (a) && TYPE_NAME (b)
2063 && !strcmp (TYPE_NAME (a), TYPE_NAME (b))));
2066 /* If BASE is an ancestor of DCLASS return the distance between them.
2067 otherwise return -1;
2071 class B: public A {};
2072 class C: public B {};
2075 distance_to_ancestor (A, A, 0) = 0
2076 distance_to_ancestor (A, B, 0) = 1
2077 distance_to_ancestor (A, C, 0) = 2
2078 distance_to_ancestor (A, D, 0) = 3
2080 If PUBLIC is 1 then only public ancestors are considered,
2081 and the function returns the distance only if BASE is a public ancestor
2085 distance_to_ancestor (A, D, 1) = -1. */
2088 distance_to_ancestor (struct type *base, struct type *dclass, int public)
2093 CHECK_TYPEDEF (base);
2094 CHECK_TYPEDEF (dclass);
2096 if (class_types_same_p (base, dclass))
2099 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
2101 if (public && ! BASETYPE_VIA_PUBLIC (dclass, i))
2104 d = distance_to_ancestor (base, TYPE_BASECLASS (dclass, i), public);
2112 /* Check whether BASE is an ancestor or base class or DCLASS
2113 Return 1 if so, and 0 if not.
2114 Note: If BASE and DCLASS are of the same type, this function
2115 will return 1. So for some class A, is_ancestor (A, A) will
2119 is_ancestor (struct type *base, struct type *dclass)
2121 return distance_to_ancestor (base, dclass, 0) >= 0;
2124 /* Like is_ancestor, but only returns true when BASE is a public
2125 ancestor of DCLASS. */
2128 is_public_ancestor (struct type *base, struct type *dclass)
2130 return distance_to_ancestor (base, dclass, 1) >= 0;
2133 /* A helper function for is_unique_ancestor. */
2136 is_unique_ancestor_worker (struct type *base, struct type *dclass,
2138 const gdb_byte *valaddr, int embedded_offset,
2139 CORE_ADDR address, struct value *val)
2143 CHECK_TYPEDEF (base);
2144 CHECK_TYPEDEF (dclass);
2146 for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i)
2151 iter = check_typedef (TYPE_BASECLASS (dclass, i));
2153 this_offset = baseclass_offset (dclass, i, valaddr, embedded_offset,
2156 if (class_types_same_p (base, iter))
2158 /* If this is the first subclass, set *OFFSET and set count
2159 to 1. Otherwise, if this is at the same offset as
2160 previous instances, do nothing. Otherwise, increment
2164 *offset = this_offset;
2167 else if (this_offset == *offset)
2175 count += is_unique_ancestor_worker (base, iter, offset,
2177 embedded_offset + this_offset,
2184 /* Like is_ancestor, but only returns true if BASE is a unique base
2185 class of the type of VAL. */
2188 is_unique_ancestor (struct type *base, struct value *val)
2192 return is_unique_ancestor_worker (base, value_type (val), &offset,
2193 value_contents_for_printing (val),
2194 value_embedded_offset (val),
2195 value_address (val), val) == 1;
2200 /* Return the sum of the rank of A with the rank of B. */
2203 sum_ranks (struct rank a, struct rank b)
2206 c.rank = a.rank + b.rank;
2207 c.subrank = a.subrank + b.subrank;
2211 /* Compare rank A and B and return:
2213 1 if a is better than b
2214 -1 if b is better than a. */
2217 compare_ranks (struct rank a, struct rank b)
2219 if (a.rank == b.rank)
2221 if (a.subrank == b.subrank)
2223 if (a.subrank < b.subrank)
2225 if (a.subrank > b.subrank)
2229 if (a.rank < b.rank)
2232 /* a.rank > b.rank */
2236 /* Functions for overload resolution begin here. */
2238 /* Compare two badness vectors A and B and return the result.
2239 0 => A and B are identical
2240 1 => A and B are incomparable
2241 2 => A is better than B
2242 3 => A is worse than B */
2245 compare_badness (struct badness_vector *a, struct badness_vector *b)
2249 short found_pos = 0; /* any positives in c? */
2250 short found_neg = 0; /* any negatives in c? */
2252 /* differing lengths => incomparable */
2253 if (a->length != b->length)
2256 /* Subtract b from a */
2257 for (i = 0; i < a->length; i++)
2259 tmp = compare_ranks (b->rank[i], a->rank[i]);
2269 return 1; /* incomparable */
2271 return 3; /* A > B */
2277 return 2; /* A < B */
2279 return 0; /* A == B */
2283 /* Rank a function by comparing its parameter types (PARMS, length
2284 NPARMS), to the types of an argument list (ARGS, length NARGS).
2285 Return a pointer to a badness vector. This has NARGS + 1
2288 struct badness_vector *
2289 rank_function (struct type **parms, int nparms,
2290 struct value **args, int nargs)
2293 struct badness_vector *bv;
2294 int min_len = nparms < nargs ? nparms : nargs;
2296 bv = xmalloc (sizeof (struct badness_vector));
2297 bv->length = nargs + 1; /* add 1 for the length-match rank. */
2298 bv->rank = xmalloc ((nargs + 1) * sizeof (int));
2300 /* First compare the lengths of the supplied lists.
2301 If there is a mismatch, set it to a high value. */
2303 /* pai/1997-06-03 FIXME: when we have debug info about default
2304 arguments and ellipsis parameter lists, we should consider those
2305 and rank the length-match more finely. */
2307 LENGTH_MATCH (bv) = (nargs != nparms)
2308 ? LENGTH_MISMATCH_BADNESS
2309 : EXACT_MATCH_BADNESS;
2311 /* Now rank all the parameters of the candidate function. */
2312 for (i = 1; i <= min_len; i++)
2313 bv->rank[i] = rank_one_type (parms[i - 1], value_type (args[i - 1]),
2316 /* If more arguments than parameters, add dummy entries. */
2317 for (i = min_len + 1; i <= nargs; i++)
2318 bv->rank[i] = TOO_FEW_PARAMS_BADNESS;
2323 /* Compare the names of two integer types, assuming that any sign
2324 qualifiers have been checked already. We do it this way because
2325 there may be an "int" in the name of one of the types. */
2328 integer_types_same_name_p (const char *first, const char *second)
2330 int first_p, second_p;
2332 /* If both are shorts, return 1; if neither is a short, keep
2334 first_p = (strstr (first, "short") != NULL);
2335 second_p = (strstr (second, "short") != NULL);
2336 if (first_p && second_p)
2338 if (first_p || second_p)
2341 /* Likewise for long. */
2342 first_p = (strstr (first, "long") != NULL);
2343 second_p = (strstr (second, "long") != NULL);
2344 if (first_p && second_p)
2346 if (first_p || second_p)
2349 /* Likewise for char. */
2350 first_p = (strstr (first, "char") != NULL);
2351 second_p = (strstr (second, "char") != NULL);
2352 if (first_p && second_p)
2354 if (first_p || second_p)
2357 /* They must both be ints. */
2361 /* Compares type A to type B returns 1 if the represent the same type
2365 types_equal (struct type *a, struct type *b)
2367 /* Identical type pointers. */
2368 /* However, this still doesn't catch all cases of same type for b
2369 and a. The reason is that builtin types are different from
2370 the same ones constructed from the object. */
2374 /* Resolve typedefs */
2375 if (TYPE_CODE (a) == TYPE_CODE_TYPEDEF)
2376 a = check_typedef (a);
2377 if (TYPE_CODE (b) == TYPE_CODE_TYPEDEF)
2378 b = check_typedef (b);
2380 /* If after resolving typedefs a and b are not of the same type
2381 code then they are not equal. */
2382 if (TYPE_CODE (a) != TYPE_CODE (b))
2385 /* If a and b are both pointers types or both reference types then
2386 they are equal of the same type iff the objects they refer to are
2387 of the same type. */
2388 if (TYPE_CODE (a) == TYPE_CODE_PTR
2389 || TYPE_CODE (a) == TYPE_CODE_REF)
2390 return types_equal (TYPE_TARGET_TYPE (a),
2391 TYPE_TARGET_TYPE (b));
2393 /* Well, damnit, if the names are exactly the same, I'll say they
2394 are exactly the same. This happens when we generate method
2395 stubs. The types won't point to the same address, but they
2396 really are the same. */
2398 if (TYPE_NAME (a) && TYPE_NAME (b)
2399 && strcmp (TYPE_NAME (a), TYPE_NAME (b)) == 0)
2402 /* Check if identical after resolving typedefs. */
2409 /* Compare one type (PARM) for compatibility with another (ARG).
2410 * PARM is intended to be the parameter type of a function; and
2411 * ARG is the supplied argument's type. This function tests if
2412 * the latter can be converted to the former.
2413 * VALUE is the argument's value or NULL if none (or called recursively)
2415 * Return 0 if they are identical types;
2416 * Otherwise, return an integer which corresponds to how compatible
2417 * PARM is to ARG. The higher the return value, the worse the match.
2418 * Generally the "bad" conversions are all uniformly assigned a 100. */
2421 rank_one_type (struct type *parm, struct type *arg, struct value *value)
2423 struct rank rank = {0,0};
2425 if (types_equal (parm, arg))
2426 return EXACT_MATCH_BADNESS;
2428 /* Resolve typedefs */
2429 if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF)
2430 parm = check_typedef (parm);
2431 if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
2432 arg = check_typedef (arg);
2434 /* See through references, since we can almost make non-references
2436 if (TYPE_CODE (arg) == TYPE_CODE_REF)
2437 return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL),
2438 REFERENCE_CONVERSION_BADNESS));
2439 if (TYPE_CODE (parm) == TYPE_CODE_REF)
2440 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL),
2441 REFERENCE_CONVERSION_BADNESS));
2443 /* Debugging only. */
2444 fprintf_filtered (gdb_stderr,
2445 "------ Arg is %s [%d], parm is %s [%d]\n",
2446 TYPE_NAME (arg), TYPE_CODE (arg),
2447 TYPE_NAME (parm), TYPE_CODE (parm));
2449 /* x -> y means arg of type x being supplied for parameter of type y. */
2451 switch (TYPE_CODE (parm))
2454 switch (TYPE_CODE (arg))
2458 /* Allowed pointer conversions are:
2459 (a) pointer to void-pointer conversion. */
2460 if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID)
2461 return VOID_PTR_CONVERSION_BADNESS;
2463 /* (b) pointer to ancestor-pointer conversion. */
2464 rank.subrank = distance_to_ancestor (TYPE_TARGET_TYPE (parm),
2465 TYPE_TARGET_TYPE (arg),
2467 if (rank.subrank >= 0)
2468 return sum_ranks (BASE_PTR_CONVERSION_BADNESS, rank);
2470 return INCOMPATIBLE_TYPE_BADNESS;
2471 case TYPE_CODE_ARRAY:
2472 if (types_equal (TYPE_TARGET_TYPE (parm),
2473 TYPE_TARGET_TYPE (arg)))
2474 return EXACT_MATCH_BADNESS;
2475 return INCOMPATIBLE_TYPE_BADNESS;
2476 case TYPE_CODE_FUNC:
2477 return rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL);
2479 if (value != NULL && TYPE_CODE (value_type (value)) == TYPE_CODE_INT
2480 && value_as_long (value) == 0)
2482 /* Null pointer conversion: allow it to be cast to a pointer.
2483 [4.10.1 of C++ standard draft n3290] */
2484 return NULL_POINTER_CONVERSION_BADNESS;
2487 case TYPE_CODE_ENUM:
2488 case TYPE_CODE_FLAGS:
2489 case TYPE_CODE_CHAR:
2490 case TYPE_CODE_RANGE:
2491 case TYPE_CODE_BOOL:
2493 return INCOMPATIBLE_TYPE_BADNESS;
2495 case TYPE_CODE_ARRAY:
2496 switch (TYPE_CODE (arg))
2499 case TYPE_CODE_ARRAY:
2500 return rank_one_type (TYPE_TARGET_TYPE (parm),
2501 TYPE_TARGET_TYPE (arg), NULL);
2503 return INCOMPATIBLE_TYPE_BADNESS;
2505 case TYPE_CODE_FUNC:
2506 switch (TYPE_CODE (arg))
2508 case TYPE_CODE_PTR: /* funcptr -> func */
2509 return rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL);
2511 return INCOMPATIBLE_TYPE_BADNESS;
2514 switch (TYPE_CODE (arg))
2517 if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2519 /* Deal with signed, unsigned, and plain chars and
2520 signed and unsigned ints. */
2521 if (TYPE_NOSIGN (parm))
2523 /* This case only for character types. */
2524 if (TYPE_NOSIGN (arg))
2525 return EXACT_MATCH_BADNESS; /* plain char -> plain char */
2526 else /* signed/unsigned char -> plain char */
2527 return INTEGER_CONVERSION_BADNESS;
2529 else if (TYPE_UNSIGNED (parm))
2531 if (TYPE_UNSIGNED (arg))
2533 /* unsigned int -> unsigned int, or
2534 unsigned long -> unsigned long */
2535 if (integer_types_same_name_p (TYPE_NAME (parm),
2537 return EXACT_MATCH_BADNESS;
2538 else if (integer_types_same_name_p (TYPE_NAME (arg),
2540 && integer_types_same_name_p (TYPE_NAME (parm),
2542 /* unsigned int -> unsigned long */
2543 return INTEGER_PROMOTION_BADNESS;
2545 /* unsigned long -> unsigned int */
2546 return INTEGER_CONVERSION_BADNESS;
2550 if (integer_types_same_name_p (TYPE_NAME (arg),
2552 && integer_types_same_name_p (TYPE_NAME (parm),
2554 /* signed long -> unsigned int */
2555 return INTEGER_CONVERSION_BADNESS;
2557 /* signed int/long -> unsigned int/long */
2558 return INTEGER_CONVERSION_BADNESS;
2561 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2563 if (integer_types_same_name_p (TYPE_NAME (parm),
2565 return EXACT_MATCH_BADNESS;
2566 else if (integer_types_same_name_p (TYPE_NAME (arg),
2568 && integer_types_same_name_p (TYPE_NAME (parm),
2570 return INTEGER_PROMOTION_BADNESS;
2572 return INTEGER_CONVERSION_BADNESS;
2575 return INTEGER_CONVERSION_BADNESS;
2577 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2578 return INTEGER_PROMOTION_BADNESS;
2580 return INTEGER_CONVERSION_BADNESS;
2581 case TYPE_CODE_ENUM:
2582 case TYPE_CODE_FLAGS:
2583 case TYPE_CODE_CHAR:
2584 case TYPE_CODE_RANGE:
2585 case TYPE_CODE_BOOL:
2586 return INTEGER_PROMOTION_BADNESS;
2588 return INT_FLOAT_CONVERSION_BADNESS;
2590 return NS_POINTER_CONVERSION_BADNESS;
2592 return INCOMPATIBLE_TYPE_BADNESS;
2595 case TYPE_CODE_ENUM:
2596 switch (TYPE_CODE (arg))
2599 case TYPE_CODE_CHAR:
2600 case TYPE_CODE_RANGE:
2601 case TYPE_CODE_BOOL:
2602 case TYPE_CODE_ENUM:
2603 return INTEGER_CONVERSION_BADNESS;
2605 return INT_FLOAT_CONVERSION_BADNESS;
2607 return INCOMPATIBLE_TYPE_BADNESS;
2610 case TYPE_CODE_CHAR:
2611 switch (TYPE_CODE (arg))
2613 case TYPE_CODE_RANGE:
2614 case TYPE_CODE_BOOL:
2615 case TYPE_CODE_ENUM:
2616 return INTEGER_CONVERSION_BADNESS;
2618 return INT_FLOAT_CONVERSION_BADNESS;
2620 if (TYPE_LENGTH (arg) > TYPE_LENGTH (parm))
2621 return INTEGER_CONVERSION_BADNESS;
2622 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2623 return INTEGER_PROMOTION_BADNESS;
2624 /* >>> !! else fall through !! <<< */
2625 case TYPE_CODE_CHAR:
2626 /* Deal with signed, unsigned, and plain chars for C++ and
2627 with int cases falling through from previous case. */
2628 if (TYPE_NOSIGN (parm))
2630 if (TYPE_NOSIGN (arg))
2631 return EXACT_MATCH_BADNESS;
2633 return INTEGER_CONVERSION_BADNESS;
2635 else if (TYPE_UNSIGNED (parm))
2637 if (TYPE_UNSIGNED (arg))
2638 return EXACT_MATCH_BADNESS;
2640 return INTEGER_PROMOTION_BADNESS;
2642 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2643 return EXACT_MATCH_BADNESS;
2645 return INTEGER_CONVERSION_BADNESS;
2647 return INCOMPATIBLE_TYPE_BADNESS;
2650 case TYPE_CODE_RANGE:
2651 switch (TYPE_CODE (arg))
2654 case TYPE_CODE_CHAR:
2655 case TYPE_CODE_RANGE:
2656 case TYPE_CODE_BOOL:
2657 case TYPE_CODE_ENUM:
2658 return INTEGER_CONVERSION_BADNESS;
2660 return INT_FLOAT_CONVERSION_BADNESS;
2662 return INCOMPATIBLE_TYPE_BADNESS;
2665 case TYPE_CODE_BOOL:
2666 switch (TYPE_CODE (arg))
2669 case TYPE_CODE_CHAR:
2670 case TYPE_CODE_RANGE:
2671 case TYPE_CODE_ENUM:
2673 return INCOMPATIBLE_TYPE_BADNESS;
2675 return BOOL_PTR_CONVERSION_BADNESS;
2676 case TYPE_CODE_BOOL:
2677 return EXACT_MATCH_BADNESS;
2679 return INCOMPATIBLE_TYPE_BADNESS;
2683 switch (TYPE_CODE (arg))
2686 if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2687 return FLOAT_PROMOTION_BADNESS;
2688 else if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2689 return EXACT_MATCH_BADNESS;
2691 return FLOAT_CONVERSION_BADNESS;
2693 case TYPE_CODE_BOOL:
2694 case TYPE_CODE_ENUM:
2695 case TYPE_CODE_RANGE:
2696 case TYPE_CODE_CHAR:
2697 return INT_FLOAT_CONVERSION_BADNESS;
2699 return INCOMPATIBLE_TYPE_BADNESS;
2702 case TYPE_CODE_COMPLEX:
2703 switch (TYPE_CODE (arg))
2704 { /* Strictly not needed for C++, but... */
2706 return FLOAT_PROMOTION_BADNESS;
2707 case TYPE_CODE_COMPLEX:
2708 return EXACT_MATCH_BADNESS;
2710 return INCOMPATIBLE_TYPE_BADNESS;
2713 case TYPE_CODE_STRUCT:
2714 /* currently same as TYPE_CODE_CLASS. */
2715 switch (TYPE_CODE (arg))
2717 case TYPE_CODE_STRUCT:
2718 /* Check for derivation */
2719 rank.subrank = distance_to_ancestor (parm, arg, 0);
2720 if (rank.subrank >= 0)
2721 return sum_ranks (BASE_CONVERSION_BADNESS, rank);
2722 /* else fall through */
2724 return INCOMPATIBLE_TYPE_BADNESS;
2727 case TYPE_CODE_UNION:
2728 switch (TYPE_CODE (arg))
2730 case TYPE_CODE_UNION:
2732 return INCOMPATIBLE_TYPE_BADNESS;
2735 case TYPE_CODE_MEMBERPTR:
2736 switch (TYPE_CODE (arg))
2739 return INCOMPATIBLE_TYPE_BADNESS;
2742 case TYPE_CODE_METHOD:
2743 switch (TYPE_CODE (arg))
2747 return INCOMPATIBLE_TYPE_BADNESS;
2751 switch (TYPE_CODE (arg))
2755 return INCOMPATIBLE_TYPE_BADNESS;
2760 switch (TYPE_CODE (arg))
2764 return rank_one_type (TYPE_FIELD_TYPE (parm, 0),
2765 TYPE_FIELD_TYPE (arg, 0), NULL);
2767 return INCOMPATIBLE_TYPE_BADNESS;
2770 case TYPE_CODE_VOID:
2772 return INCOMPATIBLE_TYPE_BADNESS;
2773 } /* switch (TYPE_CODE (arg)) */
2777 /* End of functions for overload resolution. */
2780 print_bit_vector (B_TYPE *bits, int nbits)
2784 for (bitno = 0; bitno < nbits; bitno++)
2786 if ((bitno % 8) == 0)
2788 puts_filtered (" ");
2790 if (B_TST (bits, bitno))
2791 printf_filtered (("1"));
2793 printf_filtered (("0"));
2797 /* Note the first arg should be the "this" pointer, we may not want to
2798 include it since we may get into a infinitely recursive
2802 print_arg_types (struct field *args, int nargs, int spaces)
2808 for (i = 0; i < nargs; i++)
2809 recursive_dump_type (args[i].type, spaces + 2);
2814 field_is_static (struct field *f)
2816 /* "static" fields are the fields whose location is not relative
2817 to the address of the enclosing struct. It would be nice to
2818 have a dedicated flag that would be set for static fields when
2819 the type is being created. But in practice, checking the field
2820 loc_kind should give us an accurate answer. */
2821 return (FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSNAME
2822 || FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSADDR);
2826 dump_fn_fieldlists (struct type *type, int spaces)
2832 printfi_filtered (spaces, "fn_fieldlists ");
2833 gdb_print_host_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
2834 printf_filtered ("\n");
2835 for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
2837 f = TYPE_FN_FIELDLIST1 (type, method_idx);
2838 printfi_filtered (spaces + 2, "[%d] name '%s' (",
2840 TYPE_FN_FIELDLIST_NAME (type, method_idx));
2841 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
2843 printf_filtered (_(") length %d\n"),
2844 TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
2845 for (overload_idx = 0;
2846 overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
2849 printfi_filtered (spaces + 4, "[%d] physname '%s' (",
2851 TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
2852 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
2854 printf_filtered (")\n");
2855 printfi_filtered (spaces + 8, "type ");
2856 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx),
2858 printf_filtered ("\n");
2860 recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
2863 printfi_filtered (spaces + 8, "args ");
2864 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx),
2866 printf_filtered ("\n");
2868 print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx),
2869 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f,
2872 printfi_filtered (spaces + 8, "fcontext ");
2873 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
2875 printf_filtered ("\n");
2877 printfi_filtered (spaces + 8, "is_const %d\n",
2878 TYPE_FN_FIELD_CONST (f, overload_idx));
2879 printfi_filtered (spaces + 8, "is_volatile %d\n",
2880 TYPE_FN_FIELD_VOLATILE (f, overload_idx));
2881 printfi_filtered (spaces + 8, "is_private %d\n",
2882 TYPE_FN_FIELD_PRIVATE (f, overload_idx));
2883 printfi_filtered (spaces + 8, "is_protected %d\n",
2884 TYPE_FN_FIELD_PROTECTED (f, overload_idx));
2885 printfi_filtered (spaces + 8, "is_stub %d\n",
2886 TYPE_FN_FIELD_STUB (f, overload_idx));
2887 printfi_filtered (spaces + 8, "voffset %u\n",
2888 TYPE_FN_FIELD_VOFFSET (f, overload_idx));
2894 print_cplus_stuff (struct type *type, int spaces)
2896 printfi_filtered (spaces, "n_baseclasses %d\n",
2897 TYPE_N_BASECLASSES (type));
2898 printfi_filtered (spaces, "nfn_fields %d\n",
2899 TYPE_NFN_FIELDS (type));
2900 printfi_filtered (spaces, "nfn_fields_total %d\n",
2901 TYPE_NFN_FIELDS_TOTAL (type));
2902 if (TYPE_N_BASECLASSES (type) > 0)
2904 printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
2905 TYPE_N_BASECLASSES (type));
2906 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type),
2908 printf_filtered (")");
2910 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
2911 TYPE_N_BASECLASSES (type));
2912 puts_filtered ("\n");
2914 if (TYPE_NFIELDS (type) > 0)
2916 if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
2918 printfi_filtered (spaces,
2919 "private_field_bits (%d bits at *",
2920 TYPE_NFIELDS (type));
2921 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type),
2923 printf_filtered (")");
2924 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
2925 TYPE_NFIELDS (type));
2926 puts_filtered ("\n");
2928 if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
2930 printfi_filtered (spaces,
2931 "protected_field_bits (%d bits at *",
2932 TYPE_NFIELDS (type));
2933 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type),
2935 printf_filtered (")");
2936 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
2937 TYPE_NFIELDS (type));
2938 puts_filtered ("\n");
2941 if (TYPE_NFN_FIELDS (type) > 0)
2943 dump_fn_fieldlists (type, spaces);
2947 /* Print the contents of the TYPE's type_specific union, assuming that
2948 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
2951 print_gnat_stuff (struct type *type, int spaces)
2953 struct type *descriptive_type = TYPE_DESCRIPTIVE_TYPE (type);
2955 recursive_dump_type (descriptive_type, spaces + 2);
2958 static struct obstack dont_print_type_obstack;
2961 recursive_dump_type (struct type *type, int spaces)
2966 obstack_begin (&dont_print_type_obstack, 0);
2968 if (TYPE_NFIELDS (type) > 0
2969 || (HAVE_CPLUS_STRUCT (type) && TYPE_NFN_FIELDS (type) > 0))
2971 struct type **first_dont_print
2972 = (struct type **) obstack_base (&dont_print_type_obstack);
2974 int i = (struct type **)
2975 obstack_next_free (&dont_print_type_obstack) - first_dont_print;
2979 if (type == first_dont_print[i])
2981 printfi_filtered (spaces, "type node ");
2982 gdb_print_host_address (type, gdb_stdout);
2983 printf_filtered (_(" <same as already seen type>\n"));
2988 obstack_ptr_grow (&dont_print_type_obstack, type);
2991 printfi_filtered (spaces, "type node ");
2992 gdb_print_host_address (type, gdb_stdout);
2993 printf_filtered ("\n");
2994 printfi_filtered (spaces, "name '%s' (",
2995 TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
2996 gdb_print_host_address (TYPE_NAME (type), gdb_stdout);
2997 printf_filtered (")\n");
2998 printfi_filtered (spaces, "tagname '%s' (",
2999 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : "<NULL>");
3000 gdb_print_host_address (TYPE_TAG_NAME (type), gdb_stdout);
3001 printf_filtered (")\n");
3002 printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
3003 switch (TYPE_CODE (type))
3005 case TYPE_CODE_UNDEF:
3006 printf_filtered ("(TYPE_CODE_UNDEF)");
3009 printf_filtered ("(TYPE_CODE_PTR)");
3011 case TYPE_CODE_ARRAY:
3012 printf_filtered ("(TYPE_CODE_ARRAY)");
3014 case TYPE_CODE_STRUCT:
3015 printf_filtered ("(TYPE_CODE_STRUCT)");
3017 case TYPE_CODE_UNION:
3018 printf_filtered ("(TYPE_CODE_UNION)");
3020 case TYPE_CODE_ENUM:
3021 printf_filtered ("(TYPE_CODE_ENUM)");
3023 case TYPE_CODE_FLAGS:
3024 printf_filtered ("(TYPE_CODE_FLAGS)");
3026 case TYPE_CODE_FUNC:
3027 printf_filtered ("(TYPE_CODE_FUNC)");
3030 printf_filtered ("(TYPE_CODE_INT)");
3033 printf_filtered ("(TYPE_CODE_FLT)");
3035 case TYPE_CODE_VOID:
3036 printf_filtered ("(TYPE_CODE_VOID)");
3039 printf_filtered ("(TYPE_CODE_SET)");
3041 case TYPE_CODE_RANGE:
3042 printf_filtered ("(TYPE_CODE_RANGE)");
3044 case TYPE_CODE_STRING:
3045 printf_filtered ("(TYPE_CODE_STRING)");
3047 case TYPE_CODE_BITSTRING:
3048 printf_filtered ("(TYPE_CODE_BITSTRING)");
3050 case TYPE_CODE_ERROR:
3051 printf_filtered ("(TYPE_CODE_ERROR)");
3053 case TYPE_CODE_MEMBERPTR:
3054 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
3056 case TYPE_CODE_METHODPTR:
3057 printf_filtered ("(TYPE_CODE_METHODPTR)");
3059 case TYPE_CODE_METHOD:
3060 printf_filtered ("(TYPE_CODE_METHOD)");
3063 printf_filtered ("(TYPE_CODE_REF)");
3065 case TYPE_CODE_CHAR:
3066 printf_filtered ("(TYPE_CODE_CHAR)");
3068 case TYPE_CODE_BOOL:
3069 printf_filtered ("(TYPE_CODE_BOOL)");
3071 case TYPE_CODE_COMPLEX:
3072 printf_filtered ("(TYPE_CODE_COMPLEX)");
3074 case TYPE_CODE_TYPEDEF:
3075 printf_filtered ("(TYPE_CODE_TYPEDEF)");
3077 case TYPE_CODE_NAMESPACE:
3078 printf_filtered ("(TYPE_CODE_NAMESPACE)");
3081 printf_filtered ("(UNKNOWN TYPE CODE)");
3084 puts_filtered ("\n");
3085 printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
3086 if (TYPE_OBJFILE_OWNED (type))
3088 printfi_filtered (spaces, "objfile ");
3089 gdb_print_host_address (TYPE_OWNER (type).objfile, gdb_stdout);
3093 printfi_filtered (spaces, "gdbarch ");
3094 gdb_print_host_address (TYPE_OWNER (type).gdbarch, gdb_stdout);
3096 printf_filtered ("\n");
3097 printfi_filtered (spaces, "target_type ");
3098 gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout);
3099 printf_filtered ("\n");
3100 if (TYPE_TARGET_TYPE (type) != NULL)
3102 recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
3104 printfi_filtered (spaces, "pointer_type ");
3105 gdb_print_host_address (TYPE_POINTER_TYPE (type), gdb_stdout);
3106 printf_filtered ("\n");
3107 printfi_filtered (spaces, "reference_type ");
3108 gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
3109 printf_filtered ("\n");
3110 printfi_filtered (spaces, "type_chain ");
3111 gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);
3112 printf_filtered ("\n");
3113 printfi_filtered (spaces, "instance_flags 0x%x",
3114 TYPE_INSTANCE_FLAGS (type));
3115 if (TYPE_CONST (type))
3117 puts_filtered (" TYPE_FLAG_CONST");
3119 if (TYPE_VOLATILE (type))
3121 puts_filtered (" TYPE_FLAG_VOLATILE");
3123 if (TYPE_CODE_SPACE (type))
3125 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3127 if (TYPE_DATA_SPACE (type))
3129 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3131 if (TYPE_ADDRESS_CLASS_1 (type))
3133 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3135 if (TYPE_ADDRESS_CLASS_2 (type))
3137 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3139 puts_filtered ("\n");
3141 printfi_filtered (spaces, "flags");
3142 if (TYPE_UNSIGNED (type))
3144 puts_filtered (" TYPE_FLAG_UNSIGNED");
3146 if (TYPE_NOSIGN (type))
3148 puts_filtered (" TYPE_FLAG_NOSIGN");
3150 if (TYPE_STUB (type))
3152 puts_filtered (" TYPE_FLAG_STUB");
3154 if (TYPE_TARGET_STUB (type))
3156 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3158 if (TYPE_STATIC (type))
3160 puts_filtered (" TYPE_FLAG_STATIC");
3162 if (TYPE_PROTOTYPED (type))
3164 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3166 if (TYPE_INCOMPLETE (type))
3168 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3170 if (TYPE_VARARGS (type))
3172 puts_filtered (" TYPE_FLAG_VARARGS");
3174 /* This is used for things like AltiVec registers on ppc. Gcc emits
3175 an attribute for the array type, which tells whether or not we
3176 have a vector, instead of a regular array. */
3177 if (TYPE_VECTOR (type))
3179 puts_filtered (" TYPE_FLAG_VECTOR");
3181 if (TYPE_FIXED_INSTANCE (type))
3183 puts_filtered (" TYPE_FIXED_INSTANCE");
3185 if (TYPE_STUB_SUPPORTED (type))
3187 puts_filtered (" TYPE_STUB_SUPPORTED");
3189 if (TYPE_NOTTEXT (type))
3191 puts_filtered (" TYPE_NOTTEXT");
3193 puts_filtered ("\n");
3194 printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
3195 gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
3196 puts_filtered ("\n");
3197 for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
3199 printfi_filtered (spaces + 2,
3200 "[%d] bitpos %d bitsize %d type ",
3201 idx, TYPE_FIELD_BITPOS (type, idx),
3202 TYPE_FIELD_BITSIZE (type, idx));
3203 gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
3204 printf_filtered (" name '%s' (",
3205 TYPE_FIELD_NAME (type, idx) != NULL
3206 ? TYPE_FIELD_NAME (type, idx)
3208 gdb_print_host_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
3209 printf_filtered (")\n");
3210 if (TYPE_FIELD_TYPE (type, idx) != NULL)
3212 recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
3215 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
3217 printfi_filtered (spaces, "low %s%s high %s%s\n",
3218 plongest (TYPE_LOW_BOUND (type)),
3219 TYPE_LOW_BOUND_UNDEFINED (type) ? " (undefined)" : "",
3220 plongest (TYPE_HIGH_BOUND (type)),
3221 TYPE_HIGH_BOUND_UNDEFINED (type)
3222 ? " (undefined)" : "");
3224 printfi_filtered (spaces, "vptr_basetype ");
3225 gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
3226 puts_filtered ("\n");
3227 if (TYPE_VPTR_BASETYPE (type) != NULL)
3229 recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
3231 printfi_filtered (spaces, "vptr_fieldno %d\n",
3232 TYPE_VPTR_FIELDNO (type));
3234 switch (TYPE_SPECIFIC_FIELD (type))
3236 case TYPE_SPECIFIC_CPLUS_STUFF:
3237 printfi_filtered (spaces, "cplus_stuff ");
3238 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type),
3240 puts_filtered ("\n");
3241 print_cplus_stuff (type, spaces);
3244 case TYPE_SPECIFIC_GNAT_STUFF:
3245 printfi_filtered (spaces, "gnat_stuff ");
3246 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type), gdb_stdout);
3247 puts_filtered ("\n");
3248 print_gnat_stuff (type, spaces);
3251 case TYPE_SPECIFIC_FLOATFORMAT:
3252 printfi_filtered (spaces, "floatformat ");
3253 if (TYPE_FLOATFORMAT (type) == NULL)
3254 puts_filtered ("(null)");
3257 puts_filtered ("{ ");
3258 if (TYPE_FLOATFORMAT (type)[0] == NULL
3259 || TYPE_FLOATFORMAT (type)[0]->name == NULL)
3260 puts_filtered ("(null)");
3262 puts_filtered (TYPE_FLOATFORMAT (type)[0]->name);
3264 puts_filtered (", ");
3265 if (TYPE_FLOATFORMAT (type)[1] == NULL
3266 || TYPE_FLOATFORMAT (type)[1]->name == NULL)
3267 puts_filtered ("(null)");
3269 puts_filtered (TYPE_FLOATFORMAT (type)[1]->name);
3271 puts_filtered (" }");
3273 puts_filtered ("\n");
3276 case TYPE_SPECIFIC_FUNC:
3277 printfi_filtered (spaces, "calling_convention %d\n",
3278 TYPE_CALLING_CONVENTION (type));
3279 /* tail_call_list is not printed. */
3284 obstack_free (&dont_print_type_obstack, NULL);
3287 /* Trivial helpers for the libiberty hash table, for mapping one
3292 struct type *old, *new;
3296 type_pair_hash (const void *item)
3298 const struct type_pair *pair = item;
3300 return htab_hash_pointer (pair->old);
3304 type_pair_eq (const void *item_lhs, const void *item_rhs)
3306 const struct type_pair *lhs = item_lhs, *rhs = item_rhs;
3308 return lhs->old == rhs->old;
3311 /* Allocate the hash table used by copy_type_recursive to walk
3312 types without duplicates. We use OBJFILE's obstack, because
3313 OBJFILE is about to be deleted. */
3316 create_copied_types_hash (struct objfile *objfile)
3318 return htab_create_alloc_ex (1, type_pair_hash, type_pair_eq,
3319 NULL, &objfile->objfile_obstack,
3320 hashtab_obstack_allocate,
3321 dummy_obstack_deallocate);
3324 /* Recursively copy (deep copy) TYPE, if it is associated with
3325 OBJFILE. Return a new type allocated using malloc, a saved type if
3326 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
3327 not associated with OBJFILE. */
3330 copy_type_recursive (struct objfile *objfile,
3332 htab_t copied_types)
3334 struct type_pair *stored, pair;
3336 struct type *new_type;
3338 if (! TYPE_OBJFILE_OWNED (type))
3341 /* This type shouldn't be pointing to any types in other objfiles;
3342 if it did, the type might disappear unexpectedly. */
3343 gdb_assert (TYPE_OBJFILE (type) == objfile);
3346 slot = htab_find_slot (copied_types, &pair, INSERT);
3348 return ((struct type_pair *) *slot)->new;
3350 new_type = alloc_type_arch (get_type_arch (type));
3352 /* We must add the new type to the hash table immediately, in case
3353 we encounter this type again during a recursive call below. */
3355 = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair));
3357 stored->new = new_type;
3360 /* Copy the common fields of types. For the main type, we simply
3361 copy the entire thing and then update specific fields as needed. */
3362 *TYPE_MAIN_TYPE (new_type) = *TYPE_MAIN_TYPE (type);
3363 TYPE_OBJFILE_OWNED (new_type) = 0;
3364 TYPE_OWNER (new_type).gdbarch = get_type_arch (type);
3366 if (TYPE_NAME (type))
3367 TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type));
3368 if (TYPE_TAG_NAME (type))
3369 TYPE_TAG_NAME (new_type) = xstrdup (TYPE_TAG_NAME (type));
3371 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
3372 TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
3374 /* Copy the fields. */
3375 if (TYPE_NFIELDS (type))
3379 nfields = TYPE_NFIELDS (type);
3380 TYPE_FIELDS (new_type) = XCALLOC (nfields, struct field);
3381 for (i = 0; i < nfields; i++)
3383 TYPE_FIELD_ARTIFICIAL (new_type, i) =
3384 TYPE_FIELD_ARTIFICIAL (type, i);
3385 TYPE_FIELD_BITSIZE (new_type, i) = TYPE_FIELD_BITSIZE (type, i);
3386 if (TYPE_FIELD_TYPE (type, i))
3387 TYPE_FIELD_TYPE (new_type, i)
3388 = copy_type_recursive (objfile, TYPE_FIELD_TYPE (type, i),
3390 if (TYPE_FIELD_NAME (type, i))
3391 TYPE_FIELD_NAME (new_type, i) =
3392 xstrdup (TYPE_FIELD_NAME (type, i));
3393 switch (TYPE_FIELD_LOC_KIND (type, i))
3395 case FIELD_LOC_KIND_BITPOS:
3396 SET_FIELD_BITPOS (TYPE_FIELD (new_type, i),
3397 TYPE_FIELD_BITPOS (type, i));
3399 case FIELD_LOC_KIND_PHYSADDR:
3400 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i),
3401 TYPE_FIELD_STATIC_PHYSADDR (type, i));
3403 case FIELD_LOC_KIND_PHYSNAME:
3404 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i),
3405 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type,
3409 internal_error (__FILE__, __LINE__,
3410 _("Unexpected type field location kind: %d"),
3411 TYPE_FIELD_LOC_KIND (type, i));
3416 /* For range types, copy the bounds information. */
3417 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
3419 TYPE_RANGE_DATA (new_type) = xmalloc (sizeof (struct range_bounds));
3420 *TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type);
3423 /* Copy pointers to other types. */
3424 if (TYPE_TARGET_TYPE (type))
3425 TYPE_TARGET_TYPE (new_type) =
3426 copy_type_recursive (objfile,
3427 TYPE_TARGET_TYPE (type),
3429 if (TYPE_VPTR_BASETYPE (type))
3430 TYPE_VPTR_BASETYPE (new_type) =
3431 copy_type_recursive (objfile,
3432 TYPE_VPTR_BASETYPE (type),
3434 /* Maybe copy the type_specific bits.
3436 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3437 base classes and methods. There's no fundamental reason why we
3438 can't, but at the moment it is not needed. */
3440 if (TYPE_CODE (type) == TYPE_CODE_FLT)
3441 TYPE_FLOATFORMAT (new_type) = TYPE_FLOATFORMAT (type);
3442 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
3443 || TYPE_CODE (type) == TYPE_CODE_UNION
3444 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
3445 INIT_CPLUS_SPECIFIC (new_type);
3450 /* Make a copy of the given TYPE, except that the pointer & reference
3451 types are not preserved.
3453 This function assumes that the given type has an associated objfile.
3454 This objfile is used to allocate the new type. */
3457 copy_type (const struct type *type)
3459 struct type *new_type;
3461 gdb_assert (TYPE_OBJFILE_OWNED (type));
3463 new_type = alloc_type_copy (type);
3464 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
3465 TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
3466 memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type),
3467 sizeof (struct main_type));
3473 /* Helper functions to initialize architecture-specific types. */
3475 /* Allocate a type structure associated with GDBARCH and set its
3476 CODE, LENGTH, and NAME fields. */
3478 arch_type (struct gdbarch *gdbarch,
3479 enum type_code code, int length, char *name)
3483 type = alloc_type_arch (gdbarch);
3484 TYPE_CODE (type) = code;
3485 TYPE_LENGTH (type) = length;
3488 TYPE_NAME (type) = xstrdup (name);
3493 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
3494 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3495 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3497 arch_integer_type (struct gdbarch *gdbarch,
3498 int bit, int unsigned_p, char *name)
3502 t = arch_type (gdbarch, TYPE_CODE_INT, bit / TARGET_CHAR_BIT, name);
3504 TYPE_UNSIGNED (t) = 1;
3505 if (name && strcmp (name, "char") == 0)
3506 TYPE_NOSIGN (t) = 1;
3511 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
3512 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3513 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3515 arch_character_type (struct gdbarch *gdbarch,
3516 int bit, int unsigned_p, char *name)
3520 t = arch_type (gdbarch, TYPE_CODE_CHAR, bit / TARGET_CHAR_BIT, name);
3522 TYPE_UNSIGNED (t) = 1;
3527 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
3528 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3529 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3531 arch_boolean_type (struct gdbarch *gdbarch,
3532 int bit, int unsigned_p, char *name)
3536 t = arch_type (gdbarch, TYPE_CODE_BOOL, bit / TARGET_CHAR_BIT, name);
3538 TYPE_UNSIGNED (t) = 1;
3543 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
3544 BIT is the type size in bits; if BIT equals -1, the size is
3545 determined by the floatformat. NAME is the type name. Set the
3546 TYPE_FLOATFORMAT from FLOATFORMATS. */
3548 arch_float_type (struct gdbarch *gdbarch,
3549 int bit, char *name, const struct floatformat **floatformats)
3555 gdb_assert (floatformats != NULL);
3556 gdb_assert (floatformats[0] != NULL && floatformats[1] != NULL);
3557 bit = floatformats[0]->totalsize;
3559 gdb_assert (bit >= 0);
3561 t = arch_type (gdbarch, TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, name);
3562 TYPE_FLOATFORMAT (t) = floatformats;
3566 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
3567 NAME is the type name. TARGET_TYPE is the component float type. */
3569 arch_complex_type (struct gdbarch *gdbarch,
3570 char *name, struct type *target_type)
3574 t = arch_type (gdbarch, TYPE_CODE_COMPLEX,
3575 2 * TYPE_LENGTH (target_type), name);
3576 TYPE_TARGET_TYPE (t) = target_type;
3580 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
3581 NAME is the type name. LENGTH is the size of the flag word in bytes. */
3583 arch_flags_type (struct gdbarch *gdbarch, char *name, int length)
3585 int nfields = length * TARGET_CHAR_BIT;
3588 type = arch_type (gdbarch, TYPE_CODE_FLAGS, length, name);
3589 TYPE_UNSIGNED (type) = 1;
3590 TYPE_NFIELDS (type) = nfields;
3591 TYPE_FIELDS (type) = TYPE_ZALLOC (type, nfields * sizeof (struct field));
3596 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
3597 position BITPOS is called NAME. */
3599 append_flags_type_flag (struct type *type, int bitpos, char *name)
3601 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS);
3602 gdb_assert (bitpos < TYPE_NFIELDS (type));
3603 gdb_assert (bitpos >= 0);
3607 TYPE_FIELD_NAME (type, bitpos) = xstrdup (name);
3608 TYPE_FIELD_BITPOS (type, bitpos) = bitpos;
3612 /* Don't show this field to the user. */
3613 TYPE_FIELD_BITPOS (type, bitpos) = -1;
3617 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
3618 specified by CODE) associated with GDBARCH. NAME is the type name. */
3620 arch_composite_type (struct gdbarch *gdbarch, char *name, enum type_code code)
3624 gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION);
3625 t = arch_type (gdbarch, code, 0, NULL);
3626 TYPE_TAG_NAME (t) = name;
3627 INIT_CPLUS_SPECIFIC (t);
3631 /* Add new field with name NAME and type FIELD to composite type T.
3632 Do not set the field's position or adjust the type's length;
3633 the caller should do so. Return the new field. */
3635 append_composite_type_field_raw (struct type *t, char *name,
3640 TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
3641 TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t),
3642 sizeof (struct field) * TYPE_NFIELDS (t));
3643 f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
3644 memset (f, 0, sizeof f[0]);
3645 FIELD_TYPE (f[0]) = field;
3646 FIELD_NAME (f[0]) = name;
3650 /* Add new field with name NAME and type FIELD to composite type T.
3651 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
3653 append_composite_type_field_aligned (struct type *t, char *name,
3654 struct type *field, int alignment)
3656 struct field *f = append_composite_type_field_raw (t, name, field);
3658 if (TYPE_CODE (t) == TYPE_CODE_UNION)
3660 if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
3661 TYPE_LENGTH (t) = TYPE_LENGTH (field);
3663 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
3665 TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
3666 if (TYPE_NFIELDS (t) > 1)
3668 FIELD_BITPOS (f[0]) = (FIELD_BITPOS (f[-1])
3669 + (TYPE_LENGTH (FIELD_TYPE (f[-1]))
3670 * TARGET_CHAR_BIT));
3676 alignment *= TARGET_CHAR_BIT;
3677 left = FIELD_BITPOS (f[0]) % alignment;
3681 FIELD_BITPOS (f[0]) += (alignment - left);
3682 TYPE_LENGTH (t) += (alignment - left) / TARGET_CHAR_BIT;
3689 /* Add new field with name NAME and type FIELD to composite type T. */
3691 append_composite_type_field (struct type *t, char *name,
3694 append_composite_type_field_aligned (t, name, field, 0);
3698 static struct gdbarch_data *gdbtypes_data;
3700 const struct builtin_type *
3701 builtin_type (struct gdbarch *gdbarch)
3703 return gdbarch_data (gdbarch, gdbtypes_data);
3707 gdbtypes_post_init (struct gdbarch *gdbarch)
3709 struct builtin_type *builtin_type
3710 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type);
3713 builtin_type->builtin_void
3714 = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
3715 builtin_type->builtin_char
3716 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3717 !gdbarch_char_signed (gdbarch), "char");
3718 builtin_type->builtin_signed_char
3719 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3721 builtin_type->builtin_unsigned_char
3722 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3723 1, "unsigned char");
3724 builtin_type->builtin_short
3725 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
3727 builtin_type->builtin_unsigned_short
3728 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
3729 1, "unsigned short");
3730 builtin_type->builtin_int
3731 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
3733 builtin_type->builtin_unsigned_int
3734 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
3736 builtin_type->builtin_long
3737 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
3739 builtin_type->builtin_unsigned_long
3740 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
3741 1, "unsigned long");
3742 builtin_type->builtin_long_long
3743 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
3745 builtin_type->builtin_unsigned_long_long
3746 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
3747 1, "unsigned long long");
3748 builtin_type->builtin_float
3749 = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
3750 "float", gdbarch_float_format (gdbarch));
3751 builtin_type->builtin_double
3752 = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
3753 "double", gdbarch_double_format (gdbarch));
3754 builtin_type->builtin_long_double
3755 = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
3756 "long double", gdbarch_long_double_format (gdbarch));
3757 builtin_type->builtin_complex
3758 = arch_complex_type (gdbarch, "complex",
3759 builtin_type->builtin_float);
3760 builtin_type->builtin_double_complex
3761 = arch_complex_type (gdbarch, "double complex",
3762 builtin_type->builtin_double);
3763 builtin_type->builtin_string
3764 = arch_type (gdbarch, TYPE_CODE_STRING, 1, "string");
3765 builtin_type->builtin_bool
3766 = arch_type (gdbarch, TYPE_CODE_BOOL, 1, "bool");
3768 /* The following three are about decimal floating point types, which
3769 are 32-bits, 64-bits and 128-bits respectively. */
3770 builtin_type->builtin_decfloat
3771 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 32 / 8, "_Decimal32");
3772 builtin_type->builtin_decdouble
3773 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 64 / 8, "_Decimal64");
3774 builtin_type->builtin_declong
3775 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 128 / 8, "_Decimal128");
3777 /* "True" character types. */
3778 builtin_type->builtin_true_char
3779 = arch_character_type (gdbarch, TARGET_CHAR_BIT, 0, "true character");
3780 builtin_type->builtin_true_unsigned_char
3781 = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "true character");
3783 /* Fixed-size integer types. */
3784 builtin_type->builtin_int0
3785 = arch_integer_type (gdbarch, 0, 0, "int0_t");
3786 builtin_type->builtin_int8
3787 = arch_integer_type (gdbarch, 8, 0, "int8_t");
3788 builtin_type->builtin_uint8
3789 = arch_integer_type (gdbarch, 8, 1, "uint8_t");
3790 builtin_type->builtin_int16
3791 = arch_integer_type (gdbarch, 16, 0, "int16_t");
3792 builtin_type->builtin_uint16
3793 = arch_integer_type (gdbarch, 16, 1, "uint16_t");
3794 builtin_type->builtin_int32
3795 = arch_integer_type (gdbarch, 32, 0, "int32_t");
3796 builtin_type->builtin_uint32
3797 = arch_integer_type (gdbarch, 32, 1, "uint32_t");
3798 builtin_type->builtin_int64
3799 = arch_integer_type (gdbarch, 64, 0, "int64_t");
3800 builtin_type->builtin_uint64
3801 = arch_integer_type (gdbarch, 64, 1, "uint64_t");
3802 builtin_type->builtin_int128
3803 = arch_integer_type (gdbarch, 128, 0, "int128_t");
3804 builtin_type->builtin_uint128
3805 = arch_integer_type (gdbarch, 128, 1, "uint128_t");
3806 TYPE_INSTANCE_FLAGS (builtin_type->builtin_int8) |=
3807 TYPE_INSTANCE_FLAG_NOTTEXT;
3808 TYPE_INSTANCE_FLAGS (builtin_type->builtin_uint8) |=
3809 TYPE_INSTANCE_FLAG_NOTTEXT;
3811 /* Wide character types. */
3812 builtin_type->builtin_char16
3813 = arch_integer_type (gdbarch, 16, 0, "char16_t");
3814 builtin_type->builtin_char32
3815 = arch_integer_type (gdbarch, 32, 0, "char32_t");
3818 /* Default data/code pointer types. */
3819 builtin_type->builtin_data_ptr
3820 = lookup_pointer_type (builtin_type->builtin_void);
3821 builtin_type->builtin_func_ptr
3822 = lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
3823 builtin_type->builtin_func_func
3824 = lookup_function_type (builtin_type->builtin_func_ptr);
3826 /* This type represents a GDB internal function. */
3827 builtin_type->internal_fn
3828 = arch_type (gdbarch, TYPE_CODE_INTERNAL_FUNCTION, 0,
3829 "<internal function>");
3831 return builtin_type;
3835 /* This set of objfile-based types is intended to be used by symbol
3836 readers as basic types. */
3838 static const struct objfile_data *objfile_type_data;
3840 const struct objfile_type *
3841 objfile_type (struct objfile *objfile)
3843 struct gdbarch *gdbarch;
3844 struct objfile_type *objfile_type
3845 = objfile_data (objfile, objfile_type_data);
3848 return objfile_type;
3850 objfile_type = OBSTACK_CALLOC (&objfile->objfile_obstack,
3851 1, struct objfile_type);
3853 /* Use the objfile architecture to determine basic type properties. */
3854 gdbarch = get_objfile_arch (objfile);
3857 objfile_type->builtin_void
3858 = init_type (TYPE_CODE_VOID, 1,
3862 objfile_type->builtin_char
3863 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3865 | (gdbarch_char_signed (gdbarch) ? 0 : TYPE_FLAG_UNSIGNED)),
3867 objfile_type->builtin_signed_char
3868 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3870 "signed char", objfile);
3871 objfile_type->builtin_unsigned_char
3872 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3874 "unsigned char", objfile);
3875 objfile_type->builtin_short
3876 = init_type (TYPE_CODE_INT,
3877 gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
3878 0, "short", objfile);
3879 objfile_type->builtin_unsigned_short
3880 = init_type (TYPE_CODE_INT,
3881 gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
3882 TYPE_FLAG_UNSIGNED, "unsigned short", objfile);
3883 objfile_type->builtin_int
3884 = init_type (TYPE_CODE_INT,
3885 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
3887 objfile_type->builtin_unsigned_int
3888 = init_type (TYPE_CODE_INT,
3889 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
3890 TYPE_FLAG_UNSIGNED, "unsigned int", objfile);
3891 objfile_type->builtin_long
3892 = init_type (TYPE_CODE_INT,
3893 gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
3894 0, "long", objfile);
3895 objfile_type->builtin_unsigned_long
3896 = init_type (TYPE_CODE_INT,
3897 gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
3898 TYPE_FLAG_UNSIGNED, "unsigned long", objfile);
3899 objfile_type->builtin_long_long
3900 = init_type (TYPE_CODE_INT,
3901 gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
3902 0, "long long", objfile);
3903 objfile_type->builtin_unsigned_long_long
3904 = init_type (TYPE_CODE_INT,
3905 gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
3906 TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
3908 objfile_type->builtin_float
3909 = init_type (TYPE_CODE_FLT,
3910 gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT,
3911 0, "float", objfile);
3912 TYPE_FLOATFORMAT (objfile_type->builtin_float)
3913 = gdbarch_float_format (gdbarch);
3914 objfile_type->builtin_double
3915 = init_type (TYPE_CODE_FLT,
3916 gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT,
3917 0, "double", objfile);
3918 TYPE_FLOATFORMAT (objfile_type->builtin_double)
3919 = gdbarch_double_format (gdbarch);
3920 objfile_type->builtin_long_double
3921 = init_type (TYPE_CODE_FLT,
3922 gdbarch_long_double_bit (gdbarch) / TARGET_CHAR_BIT,
3923 0, "long double", objfile);
3924 TYPE_FLOATFORMAT (objfile_type->builtin_long_double)
3925 = gdbarch_long_double_format (gdbarch);
3927 /* This type represents a type that was unrecognized in symbol read-in. */
3928 objfile_type->builtin_error
3929 = init_type (TYPE_CODE_ERROR, 0, 0, "<unknown type>", objfile);
3931 /* The following set of types is used for symbols with no
3932 debug information. */
3933 objfile_type->nodebug_text_symbol
3934 = init_type (TYPE_CODE_FUNC, 1, 0,
3935 "<text variable, no debug info>", objfile);
3936 TYPE_TARGET_TYPE (objfile_type->nodebug_text_symbol)
3937 = objfile_type->builtin_int;
3938 objfile_type->nodebug_text_gnu_ifunc_symbol
3939 = init_type (TYPE_CODE_FUNC, 1, TYPE_FLAG_GNU_IFUNC,
3940 "<text gnu-indirect-function variable, no debug info>",
3942 TYPE_TARGET_TYPE (objfile_type->nodebug_text_gnu_ifunc_symbol)
3943 = objfile_type->nodebug_text_symbol;
3944 objfile_type->nodebug_got_plt_symbol
3945 = init_type (TYPE_CODE_PTR, gdbarch_addr_bit (gdbarch) / 8, 0,
3946 "<text from jump slot in .got.plt, no debug info>",
3948 TYPE_TARGET_TYPE (objfile_type->nodebug_got_plt_symbol)
3949 = objfile_type->nodebug_text_symbol;
3950 objfile_type->nodebug_data_symbol
3951 = init_type (TYPE_CODE_INT,
3952 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
3953 "<data variable, no debug info>", objfile);
3954 objfile_type->nodebug_unknown_symbol
3955 = init_type (TYPE_CODE_INT, 1, 0,
3956 "<variable (not text or data), no debug info>", objfile);
3957 objfile_type->nodebug_tls_symbol
3958 = init_type (TYPE_CODE_INT,
3959 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
3960 "<thread local variable, no debug info>", objfile);
3962 /* NOTE: on some targets, addresses and pointers are not necessarily
3963 the same --- for example, on the D10V, pointers are 16 bits long,
3964 but addresses are 32 bits long. See doc/gdbint.texinfo,
3965 ``Pointers Are Not Always Addresses''.
3968 - gdb's `struct type' always describes the target's
3970 - gdb's `struct value' objects should always hold values in
3972 - gdb's CORE_ADDR values are addresses in the unified virtual
3973 address space that the assembler and linker work with. Thus,
3974 since target_read_memory takes a CORE_ADDR as an argument, it
3975 can access any memory on the target, even if the processor has
3976 separate code and data address spaces.
3979 - If v is a value holding a D10V code pointer, its contents are
3980 in target form: a big-endian address left-shifted two bits.
3981 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3982 sizeof (void *) == 2 on the target.
3984 In this context, objfile_type->builtin_core_addr is a bit odd:
3985 it's a target type for a value the target will never see. It's
3986 only used to hold the values of (typeless) linker symbols, which
3987 are indeed in the unified virtual address space. */
3989 objfile_type->builtin_core_addr
3990 = init_type (TYPE_CODE_INT,
3991 gdbarch_addr_bit (gdbarch) / 8,
3992 TYPE_FLAG_UNSIGNED, "__CORE_ADDR", objfile);
3994 set_objfile_data (objfile, objfile_type_data, objfile_type);
3995 return objfile_type;
3999 extern void _initialize_gdbtypes (void);
4001 _initialize_gdbtypes (void)
4003 gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
4004 objfile_type_data = register_objfile_data ();
4006 add_setshow_zinteger_cmd ("overload", no_class, &overload_debug,
4007 _("Set debugging of C++ overloading."),
4008 _("Show debugging of C++ overloading."),
4009 _("When enabled, ranking of the "
4010 "functions is displayed."),
4012 show_overload_debug,
4013 &setdebuglist, &showdebuglist);
4015 /* Add user knob for controlling resolution of opaque types. */
4016 add_setshow_boolean_cmd ("opaque-type-resolution", class_support,
4017 &opaque_type_resolution,
4018 _("Set resolution of opaque struct/class/union"
4019 " types (if set before loading symbols)."),
4020 _("Show resolution of opaque struct/class/union"
4021 " types (if set before loading symbols)."),
4023 show_opaque_type_resolution,
4024 &setlist, &showlist);