1 /* Support routines for manipulating internal types for GDB.
3 Copyright (C) 1992-2017 Free Software Foundation, Inc.
5 Contributed by Cygnus Support, using pieces from other GDB modules.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
28 #include "expression.h"
33 #include "complaints.h"
37 #include "cp-support.h"
39 #include "dwarf2loc.h"
42 /* Initialize BADNESS constants. */
44 const struct rank LENGTH_MISMATCH_BADNESS = {100,0};
46 const struct rank TOO_FEW_PARAMS_BADNESS = {100,0};
47 const struct rank INCOMPATIBLE_TYPE_BADNESS = {100,0};
49 const struct rank EXACT_MATCH_BADNESS = {0,0};
51 const struct rank INTEGER_PROMOTION_BADNESS = {1,0};
52 const struct rank FLOAT_PROMOTION_BADNESS = {1,0};
53 const struct rank BASE_PTR_CONVERSION_BADNESS = {1,0};
54 const struct rank INTEGER_CONVERSION_BADNESS = {2,0};
55 const struct rank FLOAT_CONVERSION_BADNESS = {2,0};
56 const struct rank INT_FLOAT_CONVERSION_BADNESS = {2,0};
57 const struct rank VOID_PTR_CONVERSION_BADNESS = {2,0};
58 const struct rank BOOL_CONVERSION_BADNESS = {3,0};
59 const struct rank BASE_CONVERSION_BADNESS = {2,0};
60 const struct rank REFERENCE_CONVERSION_BADNESS = {2,0};
61 const struct rank NULL_POINTER_CONVERSION_BADNESS = {2,0};
62 const struct rank NS_POINTER_CONVERSION_BADNESS = {10,0};
63 const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS = {3,0};
65 /* Floatformat pairs. */
66 const struct floatformat *floatformats_ieee_half[BFD_ENDIAN_UNKNOWN] = {
67 &floatformat_ieee_half_big,
68 &floatformat_ieee_half_little
70 const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN] = {
71 &floatformat_ieee_single_big,
72 &floatformat_ieee_single_little
74 const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN] = {
75 &floatformat_ieee_double_big,
76 &floatformat_ieee_double_little
78 const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN] = {
79 &floatformat_ieee_double_big,
80 &floatformat_ieee_double_littlebyte_bigword
82 const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN] = {
83 &floatformat_i387_ext,
86 const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN] = {
87 &floatformat_m68881_ext,
88 &floatformat_m68881_ext
90 const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN] = {
91 &floatformat_arm_ext_big,
92 &floatformat_arm_ext_littlebyte_bigword
94 const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN] = {
95 &floatformat_ia64_spill_big,
96 &floatformat_ia64_spill_little
98 const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN] = {
99 &floatformat_ia64_quad_big,
100 &floatformat_ia64_quad_little
102 const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN] = {
106 const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN] = {
110 const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN] = {
111 &floatformat_ibm_long_double_big,
112 &floatformat_ibm_long_double_little
115 /* Should opaque types be resolved? */
117 static int opaque_type_resolution = 1;
119 /* A flag to enable printing of debugging information of C++
122 unsigned int overload_debug = 0;
124 /* A flag to enable strict type checking. */
126 static int strict_type_checking = 1;
128 /* A function to show whether opaque types are resolved. */
131 show_opaque_type_resolution (struct ui_file *file, int from_tty,
132 struct cmd_list_element *c,
135 fprintf_filtered (file, _("Resolution of opaque struct/class/union types "
136 "(if set before loading symbols) is %s.\n"),
140 /* A function to show whether C++ overload debugging is enabled. */
143 show_overload_debug (struct ui_file *file, int from_tty,
144 struct cmd_list_element *c, const char *value)
146 fprintf_filtered (file, _("Debugging of C++ overloading is %s.\n"),
150 /* A function to show the status of strict type checking. */
153 show_strict_type_checking (struct ui_file *file, int from_tty,
154 struct cmd_list_element *c, const char *value)
156 fprintf_filtered (file, _("Strict type checking is %s.\n"), value);
160 /* Allocate a new OBJFILE-associated type structure and fill it
161 with some defaults. Space for the type structure is allocated
162 on the objfile's objfile_obstack. */
165 alloc_type (struct objfile *objfile)
169 gdb_assert (objfile != NULL);
171 /* Alloc the structure and start off with all fields zeroed. */
172 type = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct type);
173 TYPE_MAIN_TYPE (type) = OBSTACK_ZALLOC (&objfile->objfile_obstack,
175 OBJSTAT (objfile, n_types++);
177 TYPE_OBJFILE_OWNED (type) = 1;
178 TYPE_OWNER (type).objfile = objfile;
180 /* Initialize the fields that might not be zero. */
182 TYPE_CODE (type) = TYPE_CODE_UNDEF;
183 TYPE_CHAIN (type) = type; /* Chain back to itself. */
188 /* Allocate a new GDBARCH-associated type structure and fill it
189 with some defaults. Space for the type structure is allocated
190 on the obstack associated with GDBARCH. */
193 alloc_type_arch (struct gdbarch *gdbarch)
197 gdb_assert (gdbarch != NULL);
199 /* Alloc the structure and start off with all fields zeroed. */
201 type = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct type);
202 TYPE_MAIN_TYPE (type) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct main_type);
204 TYPE_OBJFILE_OWNED (type) = 0;
205 TYPE_OWNER (type).gdbarch = gdbarch;
207 /* Initialize the fields that might not be zero. */
209 TYPE_CODE (type) = TYPE_CODE_UNDEF;
210 TYPE_CHAIN (type) = type; /* Chain back to itself. */
215 /* If TYPE is objfile-associated, allocate a new type structure
216 associated with the same objfile. If TYPE is gdbarch-associated,
217 allocate a new type structure associated with the same gdbarch. */
220 alloc_type_copy (const struct type *type)
222 if (TYPE_OBJFILE_OWNED (type))
223 return alloc_type (TYPE_OWNER (type).objfile);
225 return alloc_type_arch (TYPE_OWNER (type).gdbarch);
228 /* If TYPE is gdbarch-associated, return that architecture.
229 If TYPE is objfile-associated, return that objfile's architecture. */
232 get_type_arch (const struct type *type)
234 if (TYPE_OBJFILE_OWNED (type))
235 return get_objfile_arch (TYPE_OWNER (type).objfile);
237 return TYPE_OWNER (type).gdbarch;
240 /* See gdbtypes.h. */
243 get_target_type (struct type *type)
247 type = TYPE_TARGET_TYPE (type);
249 type = check_typedef (type);
255 /* See gdbtypes.h. */
258 type_length_units (struct type *type)
260 struct gdbarch *arch = get_type_arch (type);
261 int unit_size = gdbarch_addressable_memory_unit_size (arch);
263 return TYPE_LENGTH (type) / unit_size;
266 /* Alloc a new type instance structure, fill it with some defaults,
267 and point it at OLDTYPE. Allocate the new type instance from the
268 same place as OLDTYPE. */
271 alloc_type_instance (struct type *oldtype)
275 /* Allocate the structure. */
277 if (! TYPE_OBJFILE_OWNED (oldtype))
278 type = XCNEW (struct type);
280 type = OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype)->objfile_obstack,
283 TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype);
285 TYPE_CHAIN (type) = type; /* Chain back to itself for now. */
290 /* Clear all remnants of the previous type at TYPE, in preparation for
291 replacing it with something else. Preserve owner information. */
294 smash_type (struct type *type)
296 int objfile_owned = TYPE_OBJFILE_OWNED (type);
297 union type_owner owner = TYPE_OWNER (type);
299 memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
301 /* Restore owner information. */
302 TYPE_OBJFILE_OWNED (type) = objfile_owned;
303 TYPE_OWNER (type) = owner;
305 /* For now, delete the rings. */
306 TYPE_CHAIN (type) = type;
308 /* For now, leave the pointer/reference types alone. */
311 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
312 to a pointer to memory where the pointer type should be stored.
313 If *TYPEPTR is zero, update it to point to the pointer type we return.
314 We allocate new memory if needed. */
317 make_pointer_type (struct type *type, struct type **typeptr)
319 struct type *ntype; /* New type */
322 ntype = TYPE_POINTER_TYPE (type);
327 return ntype; /* Don't care about alloc,
328 and have new type. */
329 else if (*typeptr == 0)
331 *typeptr = ntype; /* Tracking alloc, and have new type. */
336 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
338 ntype = alloc_type_copy (type);
342 else /* We have storage, but need to reset it. */
345 chain = TYPE_CHAIN (ntype);
347 TYPE_CHAIN (ntype) = chain;
350 TYPE_TARGET_TYPE (ntype) = type;
351 TYPE_POINTER_TYPE (type) = ntype;
353 /* FIXME! Assumes the machine has only one representation for pointers! */
356 = gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
357 TYPE_CODE (ntype) = TYPE_CODE_PTR;
359 /* Mark pointers as unsigned. The target converts between pointers
360 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
361 gdbarch_address_to_pointer. */
362 TYPE_UNSIGNED (ntype) = 1;
364 /* Update the length of all the other variants of this type. */
365 chain = TYPE_CHAIN (ntype);
366 while (chain != ntype)
368 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
369 chain = TYPE_CHAIN (chain);
375 /* Given a type TYPE, return a type of pointers to that type.
376 May need to construct such a type if this is the first use. */
379 lookup_pointer_type (struct type *type)
381 return make_pointer_type (type, (struct type **) 0);
384 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
385 points to a pointer to memory where the reference type should be
386 stored. If *TYPEPTR is zero, update it to point to the reference
387 type we return. We allocate new memory if needed. REFCODE denotes
388 the kind of reference type to lookup (lvalue or rvalue reference). */
391 make_reference_type (struct type *type, struct type **typeptr,
392 enum type_code refcode)
394 struct type *ntype; /* New type */
395 struct type **reftype;
398 gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
400 ntype = (refcode == TYPE_CODE_REF ? TYPE_REFERENCE_TYPE (type)
401 : TYPE_RVALUE_REFERENCE_TYPE (type));
406 return ntype; /* Don't care about alloc,
407 and have new type. */
408 else if (*typeptr == 0)
410 *typeptr = ntype; /* Tracking alloc, and have new type. */
415 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
417 ntype = alloc_type_copy (type);
421 else /* We have storage, but need to reset it. */
424 chain = TYPE_CHAIN (ntype);
426 TYPE_CHAIN (ntype) = chain;
429 TYPE_TARGET_TYPE (ntype) = type;
430 reftype = (refcode == TYPE_CODE_REF ? &TYPE_REFERENCE_TYPE (type)
431 : &TYPE_RVALUE_REFERENCE_TYPE (type));
435 /* FIXME! Assume the machine has only one representation for
436 references, and that it matches the (only) representation for
439 TYPE_LENGTH (ntype) =
440 gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
441 TYPE_CODE (ntype) = refcode;
445 /* Update the length of all the other variants of this type. */
446 chain = TYPE_CHAIN (ntype);
447 while (chain != ntype)
449 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
450 chain = TYPE_CHAIN (chain);
456 /* Same as above, but caller doesn't care about memory allocation
460 lookup_reference_type (struct type *type, enum type_code refcode)
462 return make_reference_type (type, (struct type **) 0, refcode);
465 /* Lookup the lvalue reference type for the type TYPE. */
468 lookup_lvalue_reference_type (struct type *type)
470 return lookup_reference_type (type, TYPE_CODE_REF);
473 /* Lookup the rvalue reference type for the type TYPE. */
476 lookup_rvalue_reference_type (struct type *type)
478 return lookup_reference_type (type, TYPE_CODE_RVALUE_REF);
481 /* Lookup a function type that returns type TYPE. TYPEPTR, if
482 nonzero, points to a pointer to memory where the function type
483 should be stored. If *TYPEPTR is zero, update it to point to the
484 function type we return. We allocate new memory if needed. */
487 make_function_type (struct type *type, struct type **typeptr)
489 struct type *ntype; /* New type */
491 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
493 ntype = alloc_type_copy (type);
497 else /* We have storage, but need to reset it. */
503 TYPE_TARGET_TYPE (ntype) = type;
505 TYPE_LENGTH (ntype) = 1;
506 TYPE_CODE (ntype) = TYPE_CODE_FUNC;
508 INIT_FUNC_SPECIFIC (ntype);
513 /* Given a type TYPE, return a type of functions that return that type.
514 May need to construct such a type if this is the first use. */
517 lookup_function_type (struct type *type)
519 return make_function_type (type, (struct type **) 0);
522 /* Given a type TYPE and argument types, return the appropriate
523 function type. If the final type in PARAM_TYPES is NULL, make a
527 lookup_function_type_with_arguments (struct type *type,
529 struct type **param_types)
531 struct type *fn = make_function_type (type, (struct type **) 0);
536 if (param_types[nparams - 1] == NULL)
539 TYPE_VARARGS (fn) = 1;
541 else if (TYPE_CODE (check_typedef (param_types[nparams - 1]))
545 /* Caller should have ensured this. */
546 gdb_assert (nparams == 0);
547 TYPE_PROTOTYPED (fn) = 1;
551 TYPE_NFIELDS (fn) = nparams;
553 = (struct field *) TYPE_ZALLOC (fn, nparams * sizeof (struct field));
554 for (i = 0; i < nparams; ++i)
555 TYPE_FIELD_TYPE (fn, i) = param_types[i];
560 /* Identify address space identifier by name --
561 return the integer flag defined in gdbtypes.h. */
564 address_space_name_to_int (struct gdbarch *gdbarch, char *space_identifier)
568 /* Check for known address space delimiters. */
569 if (!strcmp (space_identifier, "code"))
570 return TYPE_INSTANCE_FLAG_CODE_SPACE;
571 else if (!strcmp (space_identifier, "data"))
572 return TYPE_INSTANCE_FLAG_DATA_SPACE;
573 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch)
574 && gdbarch_address_class_name_to_type_flags (gdbarch,
579 error (_("Unknown address space specifier: \"%s\""), space_identifier);
582 /* Identify address space identifier by integer flag as defined in
583 gdbtypes.h -- return the string version of the adress space name. */
586 address_space_int_to_name (struct gdbarch *gdbarch, int space_flag)
588 if (space_flag & TYPE_INSTANCE_FLAG_CODE_SPACE)
590 else if (space_flag & TYPE_INSTANCE_FLAG_DATA_SPACE)
592 else if ((space_flag & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
593 && gdbarch_address_class_type_flags_to_name_p (gdbarch))
594 return gdbarch_address_class_type_flags_to_name (gdbarch, space_flag);
599 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
601 If STORAGE is non-NULL, create the new type instance there.
602 STORAGE must be in the same obstack as TYPE. */
605 make_qualified_type (struct type *type, int new_flags,
606 struct type *storage)
613 if (TYPE_INSTANCE_FLAGS (ntype) == new_flags)
615 ntype = TYPE_CHAIN (ntype);
617 while (ntype != type);
619 /* Create a new type instance. */
621 ntype = alloc_type_instance (type);
624 /* If STORAGE was provided, it had better be in the same objfile
625 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
626 if one objfile is freed and the other kept, we'd have
627 dangling pointers. */
628 gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage));
631 TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type);
632 TYPE_CHAIN (ntype) = ntype;
635 /* Pointers or references to the original type are not relevant to
637 TYPE_POINTER_TYPE (ntype) = (struct type *) 0;
638 TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0;
640 /* Chain the new qualified type to the old type. */
641 TYPE_CHAIN (ntype) = TYPE_CHAIN (type);
642 TYPE_CHAIN (type) = ntype;
644 /* Now set the instance flags and return the new type. */
645 TYPE_INSTANCE_FLAGS (ntype) = new_flags;
647 /* Set length of new type to that of the original type. */
648 TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
653 /* Make an address-space-delimited variant of a type -- a type that
654 is identical to the one supplied except that it has an address
655 space attribute attached to it (such as "code" or "data").
657 The space attributes "code" and "data" are for Harvard
658 architectures. The address space attributes are for architectures
659 which have alternately sized pointers or pointers with alternate
663 make_type_with_address_space (struct type *type, int space_flag)
665 int new_flags = ((TYPE_INSTANCE_FLAGS (type)
666 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
667 | TYPE_INSTANCE_FLAG_DATA_SPACE
668 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL))
671 return make_qualified_type (type, new_flags, NULL);
674 /* Make a "c-v" variant of a type -- a type that is identical to the
675 one supplied except that it may have const or volatile attributes
676 CNST is a flag for setting the const attribute
677 VOLTL is a flag for setting the volatile attribute
678 TYPE is the base type whose variant we are creating.
680 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
681 storage to hold the new qualified type; *TYPEPTR and TYPE must be
682 in the same objfile. Otherwise, allocate fresh memory for the new
683 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
684 new type we construct. */
687 make_cv_type (int cnst, int voltl,
689 struct type **typeptr)
691 struct type *ntype; /* New type */
693 int new_flags = (TYPE_INSTANCE_FLAGS (type)
694 & ~(TYPE_INSTANCE_FLAG_CONST
695 | TYPE_INSTANCE_FLAG_VOLATILE));
698 new_flags |= TYPE_INSTANCE_FLAG_CONST;
701 new_flags |= TYPE_INSTANCE_FLAG_VOLATILE;
703 if (typeptr && *typeptr != NULL)
705 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
706 a C-V variant chain that threads across objfiles: if one
707 objfile gets freed, then the other has a broken C-V chain.
709 This code used to try to copy over the main type from TYPE to
710 *TYPEPTR if they were in different objfiles, but that's
711 wrong, too: TYPE may have a field list or member function
712 lists, which refer to types of their own, etc. etc. The
713 whole shebang would need to be copied over recursively; you
714 can't have inter-objfile pointers. The only thing to do is
715 to leave stub types as stub types, and look them up afresh by
716 name each time you encounter them. */
717 gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type));
720 ntype = make_qualified_type (type, new_flags,
721 typeptr ? *typeptr : NULL);
729 /* Make a 'restrict'-qualified version of TYPE. */
732 make_restrict_type (struct type *type)
734 return make_qualified_type (type,
735 (TYPE_INSTANCE_FLAGS (type)
736 | TYPE_INSTANCE_FLAG_RESTRICT),
740 /* Make a type without const, volatile, or restrict. */
743 make_unqualified_type (struct type *type)
745 return make_qualified_type (type,
746 (TYPE_INSTANCE_FLAGS (type)
747 & ~(TYPE_INSTANCE_FLAG_CONST
748 | TYPE_INSTANCE_FLAG_VOLATILE
749 | TYPE_INSTANCE_FLAG_RESTRICT)),
753 /* Make a '_Atomic'-qualified version of TYPE. */
756 make_atomic_type (struct type *type)
758 return make_qualified_type (type,
759 (TYPE_INSTANCE_FLAGS (type)
760 | TYPE_INSTANCE_FLAG_ATOMIC),
764 /* Replace the contents of ntype with the type *type. This changes the
765 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
766 the changes are propogated to all types in the TYPE_CHAIN.
768 In order to build recursive types, it's inevitable that we'll need
769 to update types in place --- but this sort of indiscriminate
770 smashing is ugly, and needs to be replaced with something more
771 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
772 clear if more steps are needed. */
775 replace_type (struct type *ntype, struct type *type)
779 /* These two types had better be in the same objfile. Otherwise,
780 the assignment of one type's main type structure to the other
781 will produce a type with references to objects (names; field
782 lists; etc.) allocated on an objfile other than its own. */
783 gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (type));
785 *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
787 /* The type length is not a part of the main type. Update it for
788 each type on the variant chain. */
792 /* Assert that this element of the chain has no address-class bits
793 set in its flags. Such type variants might have type lengths
794 which are supposed to be different from the non-address-class
795 variants. This assertion shouldn't ever be triggered because
796 symbol readers which do construct address-class variants don't
797 call replace_type(). */
798 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0);
800 TYPE_LENGTH (chain) = TYPE_LENGTH (type);
801 chain = TYPE_CHAIN (chain);
803 while (ntype != chain);
805 /* Assert that the two types have equivalent instance qualifiers.
806 This should be true for at least all of our debug readers. */
807 gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type));
810 /* Implement direct support for MEMBER_TYPE in GNU C++.
811 May need to construct such a type if this is the first use.
812 The TYPE is the type of the member. The DOMAIN is the type
813 of the aggregate that the member belongs to. */
816 lookup_memberptr_type (struct type *type, struct type *domain)
820 mtype = alloc_type_copy (type);
821 smash_to_memberptr_type (mtype, domain, type);
825 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
828 lookup_methodptr_type (struct type *to_type)
832 mtype = alloc_type_copy (to_type);
833 smash_to_methodptr_type (mtype, to_type);
837 /* Allocate a stub method whose return type is TYPE. This apparently
838 happens for speed of symbol reading, since parsing out the
839 arguments to the method is cpu-intensive, the way we are doing it.
840 So, we will fill in arguments later. This always returns a fresh
844 allocate_stub_method (struct type *type)
848 mtype = alloc_type_copy (type);
849 TYPE_CODE (mtype) = TYPE_CODE_METHOD;
850 TYPE_LENGTH (mtype) = 1;
851 TYPE_STUB (mtype) = 1;
852 TYPE_TARGET_TYPE (mtype) = type;
853 /* TYPE_SELF_TYPE (mtype) = unknown yet */
857 /* Create a range type with a dynamic range from LOW_BOUND to
858 HIGH_BOUND, inclusive. See create_range_type for further details. */
861 create_range_type (struct type *result_type, struct type *index_type,
862 const struct dynamic_prop *low_bound,
863 const struct dynamic_prop *high_bound)
865 if (result_type == NULL)
866 result_type = alloc_type_copy (index_type);
867 TYPE_CODE (result_type) = TYPE_CODE_RANGE;
868 TYPE_TARGET_TYPE (result_type) = index_type;
869 if (TYPE_STUB (index_type))
870 TYPE_TARGET_STUB (result_type) = 1;
872 TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
874 TYPE_RANGE_DATA (result_type) = (struct range_bounds *)
875 TYPE_ZALLOC (result_type, sizeof (struct range_bounds));
876 TYPE_RANGE_DATA (result_type)->low = *low_bound;
877 TYPE_RANGE_DATA (result_type)->high = *high_bound;
879 if (low_bound->kind == PROP_CONST && low_bound->data.const_val >= 0)
880 TYPE_UNSIGNED (result_type) = 1;
882 /* Ada allows the declaration of range types whose upper bound is
883 less than the lower bound, so checking the lower bound is not
884 enough. Make sure we do not mark a range type whose upper bound
885 is negative as unsigned. */
886 if (high_bound->kind == PROP_CONST && high_bound->data.const_val < 0)
887 TYPE_UNSIGNED (result_type) = 0;
892 /* Create a range type using either a blank type supplied in
893 RESULT_TYPE, or creating a new type, inheriting the objfile from
896 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
897 to HIGH_BOUND, inclusive.
899 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
900 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
903 create_static_range_type (struct type *result_type, struct type *index_type,
904 LONGEST low_bound, LONGEST high_bound)
906 struct dynamic_prop low, high;
908 low.kind = PROP_CONST;
909 low.data.const_val = low_bound;
911 high.kind = PROP_CONST;
912 high.data.const_val = high_bound;
914 result_type = create_range_type (result_type, index_type, &low, &high);
919 /* Predicate tests whether BOUNDS are static. Returns 1 if all bounds values
920 are static, otherwise returns 0. */
923 has_static_range (const struct range_bounds *bounds)
925 return (bounds->low.kind == PROP_CONST
926 && bounds->high.kind == PROP_CONST);
930 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
931 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
932 bounds will fit in LONGEST), or -1 otherwise. */
935 get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
937 type = check_typedef (type);
938 switch (TYPE_CODE (type))
940 case TYPE_CODE_RANGE:
941 *lowp = TYPE_LOW_BOUND (type);
942 *highp = TYPE_HIGH_BOUND (type);
945 if (TYPE_NFIELDS (type) > 0)
947 /* The enums may not be sorted by value, so search all
951 *lowp = *highp = TYPE_FIELD_ENUMVAL (type, 0);
952 for (i = 0; i < TYPE_NFIELDS (type); i++)
954 if (TYPE_FIELD_ENUMVAL (type, i) < *lowp)
955 *lowp = TYPE_FIELD_ENUMVAL (type, i);
956 if (TYPE_FIELD_ENUMVAL (type, i) > *highp)
957 *highp = TYPE_FIELD_ENUMVAL (type, i);
960 /* Set unsigned indicator if warranted. */
963 TYPE_UNSIGNED (type) = 1;
977 if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */
979 if (!TYPE_UNSIGNED (type))
981 *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
985 /* ... fall through for unsigned ints ... */
988 /* This round-about calculation is to avoid shifting by
989 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
990 if TYPE_LENGTH (type) == sizeof (LONGEST). */
991 *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
992 *highp = (*highp - 1) | *highp;
999 /* Assuming TYPE is a simple, non-empty array type, compute its upper
1000 and lower bound. Save the low bound into LOW_BOUND if not NULL.
1001 Save the high bound into HIGH_BOUND if not NULL.
1003 Return 1 if the operation was successful. Return zero otherwise,
1004 in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
1006 We now simply use get_discrete_bounds call to get the values
1007 of the low and high bounds.
1008 get_discrete_bounds can return three values:
1009 1, meaning that index is a range,
1010 0, meaning that index is a discrete type,
1011 or -1 for failure. */
1014 get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound)
1016 struct type *index = TYPE_INDEX_TYPE (type);
1024 res = get_discrete_bounds (index, &low, &high);
1028 /* Check if the array bounds are undefined. */
1030 && ((low_bound && TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type))
1031 || (high_bound && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))))
1043 /* Assuming that TYPE is a discrete type and VAL is a valid integer
1044 representation of a value of this type, save the corresponding
1045 position number in POS.
1047 Its differs from VAL only in the case of enumeration types. In
1048 this case, the position number of the value of the first listed
1049 enumeration literal is zero; the position number of the value of
1050 each subsequent enumeration literal is one more than that of its
1051 predecessor in the list.
1053 Return 1 if the operation was successful. Return zero otherwise,
1054 in which case the value of POS is unmodified.
1058 discrete_position (struct type *type, LONGEST val, LONGEST *pos)
1060 if (TYPE_CODE (type) == TYPE_CODE_ENUM)
1064 for (i = 0; i < TYPE_NFIELDS (type); i += 1)
1066 if (val == TYPE_FIELD_ENUMVAL (type, i))
1072 /* Invalid enumeration value. */
1082 /* Create an array type using either a blank type supplied in
1083 RESULT_TYPE, or creating a new type, inheriting the objfile from
1086 Elements will be of type ELEMENT_TYPE, the indices will be of type
1089 If BIT_STRIDE is not zero, build a packed array type whose element
1090 size is BIT_STRIDE. Otherwise, ignore this parameter.
1092 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1093 sure it is TYPE_CODE_UNDEF before we bash it into an array
1097 create_array_type_with_stride (struct type *result_type,
1098 struct type *element_type,
1099 struct type *range_type,
1100 unsigned int bit_stride)
1102 if (result_type == NULL)
1103 result_type = alloc_type_copy (range_type);
1105 TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
1106 TYPE_TARGET_TYPE (result_type) = element_type;
1107 if (has_static_range (TYPE_RANGE_DATA (range_type))
1108 && (!type_not_associated (result_type)
1109 && !type_not_allocated (result_type)))
1111 LONGEST low_bound, high_bound;
1113 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
1114 low_bound = high_bound = 0;
1115 element_type = check_typedef (element_type);
1116 /* Be careful when setting the array length. Ada arrays can be
1117 empty arrays with the high_bound being smaller than the low_bound.
1118 In such cases, the array length should be zero. */
1119 if (high_bound < low_bound)
1120 TYPE_LENGTH (result_type) = 0;
1121 else if (bit_stride > 0)
1122 TYPE_LENGTH (result_type) =
1123 (bit_stride * (high_bound - low_bound + 1) + 7) / 8;
1125 TYPE_LENGTH (result_type) =
1126 TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
1130 /* This type is dynamic and its length needs to be computed
1131 on demand. In the meantime, avoid leaving the TYPE_LENGTH
1132 undefined by setting it to zero. Although we are not expected
1133 to trust TYPE_LENGTH in this case, setting the size to zero
1134 allows us to avoid allocating objects of random sizes in case
1135 we accidently do. */
1136 TYPE_LENGTH (result_type) = 0;
1139 TYPE_NFIELDS (result_type) = 1;
1140 TYPE_FIELDS (result_type) =
1141 (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
1142 TYPE_INDEX_TYPE (result_type) = range_type;
1144 TYPE_FIELD_BITSIZE (result_type, 0) = bit_stride;
1146 /* TYPE_TARGET_STUB will take care of zero length arrays. */
1147 if (TYPE_LENGTH (result_type) == 0)
1148 TYPE_TARGET_STUB (result_type) = 1;
1153 /* Same as create_array_type_with_stride but with no bit_stride
1154 (BIT_STRIDE = 0), thus building an unpacked array. */
1157 create_array_type (struct type *result_type,
1158 struct type *element_type,
1159 struct type *range_type)
1161 return create_array_type_with_stride (result_type, element_type,
1166 lookup_array_range_type (struct type *element_type,
1167 LONGEST low_bound, LONGEST high_bound)
1169 struct gdbarch *gdbarch = get_type_arch (element_type);
1170 struct type *index_type = builtin_type (gdbarch)->builtin_int;
1171 struct type *range_type
1172 = create_static_range_type (NULL, index_type, low_bound, high_bound);
1174 return create_array_type (NULL, element_type, range_type);
1177 /* Create a string type using either a blank type supplied in
1178 RESULT_TYPE, or creating a new type. String types are similar
1179 enough to array of char types that we can use create_array_type to
1180 build the basic type and then bash it into a string type.
1182 For fixed length strings, the range type contains 0 as the lower
1183 bound and the length of the string minus one as the upper bound.
1185 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1186 sure it is TYPE_CODE_UNDEF before we bash it into a string
1190 create_string_type (struct type *result_type,
1191 struct type *string_char_type,
1192 struct type *range_type)
1194 result_type = create_array_type (result_type,
1197 TYPE_CODE (result_type) = TYPE_CODE_STRING;
1202 lookup_string_range_type (struct type *string_char_type,
1203 LONGEST low_bound, LONGEST high_bound)
1205 struct type *result_type;
1207 result_type = lookup_array_range_type (string_char_type,
1208 low_bound, high_bound);
1209 TYPE_CODE (result_type) = TYPE_CODE_STRING;
1214 create_set_type (struct type *result_type, struct type *domain_type)
1216 if (result_type == NULL)
1217 result_type = alloc_type_copy (domain_type);
1219 TYPE_CODE (result_type) = TYPE_CODE_SET;
1220 TYPE_NFIELDS (result_type) = 1;
1221 TYPE_FIELDS (result_type)
1222 = (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
1224 if (!TYPE_STUB (domain_type))
1226 LONGEST low_bound, high_bound, bit_length;
1228 if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
1229 low_bound = high_bound = 0;
1230 bit_length = high_bound - low_bound + 1;
1231 TYPE_LENGTH (result_type)
1232 = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
1234 TYPE_UNSIGNED (result_type) = 1;
1236 TYPE_FIELD_TYPE (result_type, 0) = domain_type;
1241 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
1242 and any array types nested inside it. */
1245 make_vector_type (struct type *array_type)
1247 struct type *inner_array, *elt_type;
1250 /* Find the innermost array type, in case the array is
1251 multi-dimensional. */
1252 inner_array = array_type;
1253 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
1254 inner_array = TYPE_TARGET_TYPE (inner_array);
1256 elt_type = TYPE_TARGET_TYPE (inner_array);
1257 if (TYPE_CODE (elt_type) == TYPE_CODE_INT)
1259 flags = TYPE_INSTANCE_FLAGS (elt_type) | TYPE_INSTANCE_FLAG_NOTTEXT;
1260 elt_type = make_qualified_type (elt_type, flags, NULL);
1261 TYPE_TARGET_TYPE (inner_array) = elt_type;
1264 TYPE_VECTOR (array_type) = 1;
1268 init_vector_type (struct type *elt_type, int n)
1270 struct type *array_type;
1272 array_type = lookup_array_range_type (elt_type, 0, n - 1);
1273 make_vector_type (array_type);
1277 /* Internal routine called by TYPE_SELF_TYPE to return the type that TYPE
1278 belongs to. In c++ this is the class of "this", but TYPE_THIS_TYPE is too
1279 confusing. "self" is a common enough replacement for "this".
1280 TYPE must be one of TYPE_CODE_METHODPTR, TYPE_CODE_MEMBERPTR, or
1281 TYPE_CODE_METHOD. */
1284 internal_type_self_type (struct type *type)
1286 switch (TYPE_CODE (type))
1288 case TYPE_CODE_METHODPTR:
1289 case TYPE_CODE_MEMBERPTR:
1290 if (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_NONE)
1292 gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_SELF_TYPE);
1293 return TYPE_MAIN_TYPE (type)->type_specific.self_type;
1294 case TYPE_CODE_METHOD:
1295 if (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_NONE)
1297 gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_FUNC);
1298 return TYPE_MAIN_TYPE (type)->type_specific.func_stuff->self_type;
1300 gdb_assert_not_reached ("bad type");
1304 /* Set the type of the class that TYPE belongs to.
1305 In c++ this is the class of "this".
1306 TYPE must be one of TYPE_CODE_METHODPTR, TYPE_CODE_MEMBERPTR, or
1307 TYPE_CODE_METHOD. */
1310 set_type_self_type (struct type *type, struct type *self_type)
1312 switch (TYPE_CODE (type))
1314 case TYPE_CODE_METHODPTR:
1315 case TYPE_CODE_MEMBERPTR:
1316 if (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_NONE)
1317 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_SELF_TYPE;
1318 gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_SELF_TYPE);
1319 TYPE_MAIN_TYPE (type)->type_specific.self_type = self_type;
1321 case TYPE_CODE_METHOD:
1322 if (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_NONE)
1323 INIT_FUNC_SPECIFIC (type);
1324 gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_FUNC);
1325 TYPE_MAIN_TYPE (type)->type_specific.func_stuff->self_type = self_type;
1328 gdb_assert_not_reached ("bad type");
1332 /* Smash TYPE to be a type of pointers to members of SELF_TYPE with type
1333 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1334 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1335 TYPE doesn't include the offset (that's the value of the MEMBER
1336 itself), but does include the structure type into which it points
1339 When "smashing" the type, we preserve the objfile that the old type
1340 pointed to, since we aren't changing where the type is actually
1344 smash_to_memberptr_type (struct type *type, struct type *self_type,
1345 struct type *to_type)
1348 TYPE_CODE (type) = TYPE_CODE_MEMBERPTR;
1349 TYPE_TARGET_TYPE (type) = to_type;
1350 set_type_self_type (type, self_type);
1351 /* Assume that a data member pointer is the same size as a normal
1354 = gdbarch_ptr_bit (get_type_arch (to_type)) / TARGET_CHAR_BIT;
1357 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1359 When "smashing" the type, we preserve the objfile that the old type
1360 pointed to, since we aren't changing where the type is actually
1364 smash_to_methodptr_type (struct type *type, struct type *to_type)
1367 TYPE_CODE (type) = TYPE_CODE_METHODPTR;
1368 TYPE_TARGET_TYPE (type) = to_type;
1369 set_type_self_type (type, TYPE_SELF_TYPE (to_type));
1370 TYPE_LENGTH (type) = cplus_method_ptr_size (to_type);
1373 /* Smash TYPE to be a type of method of SELF_TYPE with type TO_TYPE.
1374 METHOD just means `function that gets an extra "this" argument'.
1376 When "smashing" the type, we preserve the objfile that the old type
1377 pointed to, since we aren't changing where the type is actually
1381 smash_to_method_type (struct type *type, struct type *self_type,
1382 struct type *to_type, struct field *args,
1383 int nargs, int varargs)
1386 TYPE_CODE (type) = TYPE_CODE_METHOD;
1387 TYPE_TARGET_TYPE (type) = to_type;
1388 set_type_self_type (type, self_type);
1389 TYPE_FIELDS (type) = args;
1390 TYPE_NFIELDS (type) = nargs;
1392 TYPE_VARARGS (type) = 1;
1393 TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
1396 /* Return a typename for a struct/union/enum type without "struct ",
1397 "union ", or "enum ". If the type has a NULL name, return NULL. */
1400 type_name_no_tag (const struct type *type)
1402 if (TYPE_TAG_NAME (type) != NULL)
1403 return TYPE_TAG_NAME (type);
1405 /* Is there code which expects this to return the name if there is
1406 no tag name? My guess is that this is mainly used for C++ in
1407 cases where the two will always be the same. */
1408 return TYPE_NAME (type);
1411 /* A wrapper of type_name_no_tag which calls error if the type is anonymous.
1412 Since GCC PR debug/47510 DWARF provides associated information to detect the
1413 anonymous class linkage name from its typedef.
1415 Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
1419 type_name_no_tag_or_error (struct type *type)
1421 struct type *saved_type = type;
1423 struct objfile *objfile;
1425 type = check_typedef (type);
1427 name = type_name_no_tag (type);
1431 name = type_name_no_tag (saved_type);
1432 objfile = TYPE_OBJFILE (saved_type);
1433 error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
1434 name ? name : "<anonymous>",
1435 objfile ? objfile_name (objfile) : "<arch>");
1438 /* Lookup a typedef or primitive type named NAME, visible in lexical
1439 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1440 suitably defined. */
1443 lookup_typename (const struct language_defn *language,
1444 struct gdbarch *gdbarch, const char *name,
1445 const struct block *block, int noerr)
1449 sym = lookup_symbol_in_language (name, block, VAR_DOMAIN,
1450 language->la_language, NULL).symbol;
1451 if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1452 return SYMBOL_TYPE (sym);
1456 error (_("No type named %s."), name);
1460 lookup_unsigned_typename (const struct language_defn *language,
1461 struct gdbarch *gdbarch, const char *name)
1463 char *uns = (char *) alloca (strlen (name) + 10);
1465 strcpy (uns, "unsigned ");
1466 strcpy (uns + 9, name);
1467 return lookup_typename (language, gdbarch, uns, (struct block *) NULL, 0);
1471 lookup_signed_typename (const struct language_defn *language,
1472 struct gdbarch *gdbarch, const char *name)
1475 char *uns = (char *) alloca (strlen (name) + 8);
1477 strcpy (uns, "signed ");
1478 strcpy (uns + 7, name);
1479 t = lookup_typename (language, gdbarch, uns, (struct block *) NULL, 1);
1480 /* If we don't find "signed FOO" just try again with plain "FOO". */
1483 return lookup_typename (language, gdbarch, name, (struct block *) NULL, 0);
1486 /* Lookup a structure type named "struct NAME",
1487 visible in lexical block BLOCK. */
1490 lookup_struct (const char *name, const struct block *block)
1494 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
1498 error (_("No struct type named %s."), name);
1500 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1502 error (_("This context has class, union or enum %s, not a struct."),
1505 return (SYMBOL_TYPE (sym));
1508 /* Lookup a union type named "union NAME",
1509 visible in lexical block BLOCK. */
1512 lookup_union (const char *name, const struct block *block)
1517 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
1520 error (_("No union type named %s."), name);
1522 t = SYMBOL_TYPE (sym);
1524 if (TYPE_CODE (t) == TYPE_CODE_UNION)
1527 /* If we get here, it's not a union. */
1528 error (_("This context has class, struct or enum %s, not a union."),
1532 /* Lookup an enum type named "enum NAME",
1533 visible in lexical block BLOCK. */
1536 lookup_enum (const char *name, const struct block *block)
1540 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
1543 error (_("No enum type named %s."), name);
1545 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
1547 error (_("This context has class, struct or union %s, not an enum."),
1550 return (SYMBOL_TYPE (sym));
1553 /* Lookup a template type named "template NAME<TYPE>",
1554 visible in lexical block BLOCK. */
1557 lookup_template_type (char *name, struct type *type,
1558 const struct block *block)
1561 char *nam = (char *)
1562 alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4);
1566 strcat (nam, TYPE_NAME (type));
1567 strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
1569 sym = lookup_symbol (nam, block, VAR_DOMAIN, 0).symbol;
1573 error (_("No template type named %s."), name);
1575 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1577 error (_("This context has class, union or enum %s, not a struct."),
1580 return (SYMBOL_TYPE (sym));
1583 /* Given a type TYPE, lookup the type of the component of type named
1586 TYPE can be either a struct or union, or a pointer or reference to
1587 a struct or union. If it is a pointer or reference, its target
1588 type is automatically used. Thus '.' and '->' are interchangable,
1589 as specified for the definitions of the expression element types
1590 STRUCTOP_STRUCT and STRUCTOP_PTR.
1592 If NOERR is nonzero, return zero if NAME is not suitably defined.
1593 If NAME is the name of a baseclass type, return that type. */
1596 lookup_struct_elt_type (struct type *type, const char *name, int noerr)
1602 type = check_typedef (type);
1603 if (TYPE_CODE (type) != TYPE_CODE_PTR
1604 && TYPE_CODE (type) != TYPE_CODE_REF)
1606 type = TYPE_TARGET_TYPE (type);
1609 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1610 && TYPE_CODE (type) != TYPE_CODE_UNION)
1612 std::string type_name = type_to_string (type);
1613 error (_("Type %s is not a structure or union type."),
1614 type_name.c_str ());
1618 /* FIXME: This change put in by Michael seems incorrect for the case
1619 where the structure tag name is the same as the member name.
1620 I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
1621 foo; } bell;" Disabled by fnf. */
1625 type_name = type_name_no_tag (type);
1626 if (type_name != NULL && strcmp (type_name, name) == 0)
1631 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1633 const char *t_field_name = TYPE_FIELD_NAME (type, i);
1635 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1637 return TYPE_FIELD_TYPE (type, i);
1639 else if (!t_field_name || *t_field_name == '\0')
1641 struct type *subtype
1642 = lookup_struct_elt_type (TYPE_FIELD_TYPE (type, i), name, 1);
1644 if (subtype != NULL)
1649 /* OK, it's not in this class. Recursively check the baseclasses. */
1650 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1654 t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 1);
1666 std::string type_name = type_to_string (type);
1667 error (_("Type %s has no component named %s."), type_name.c_str (), name);
1670 /* Store in *MAX the largest number representable by unsigned integer type
1674 get_unsigned_type_max (struct type *type, ULONGEST *max)
1678 type = check_typedef (type);
1679 gdb_assert (TYPE_CODE (type) == TYPE_CODE_INT && TYPE_UNSIGNED (type));
1680 gdb_assert (TYPE_LENGTH (type) <= sizeof (ULONGEST));
1682 /* Written this way to avoid overflow. */
1683 n = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
1684 *max = ((((ULONGEST) 1 << (n - 1)) - 1) << 1) | 1;
1687 /* Store in *MIN, *MAX the smallest and largest numbers representable by
1688 signed integer type TYPE. */
1691 get_signed_type_minmax (struct type *type, LONGEST *min, LONGEST *max)
1695 type = check_typedef (type);
1696 gdb_assert (TYPE_CODE (type) == TYPE_CODE_INT && !TYPE_UNSIGNED (type));
1697 gdb_assert (TYPE_LENGTH (type) <= sizeof (LONGEST));
1699 n = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
1700 *min = -((ULONGEST) 1 << (n - 1));
1701 *max = ((ULONGEST) 1 << (n - 1)) - 1;
1704 /* Internal routine called by TYPE_VPTR_FIELDNO to return the value of
1705 cplus_stuff.vptr_fieldno.
1707 cplus_stuff is initialized to cplus_struct_default which does not
1708 set vptr_fieldno to -1 for portability reasons (IWBN to use C99
1709 designated initializers). We cope with that here. */
1712 internal_type_vptr_fieldno (struct type *type)
1714 type = check_typedef (type);
1715 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
1716 || TYPE_CODE (type) == TYPE_CODE_UNION);
1717 if (!HAVE_CPLUS_STRUCT (type))
1719 return TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_fieldno;
1722 /* Set the value of cplus_stuff.vptr_fieldno. */
1725 set_type_vptr_fieldno (struct type *type, int fieldno)
1727 type = check_typedef (type);
1728 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
1729 || TYPE_CODE (type) == TYPE_CODE_UNION);
1730 if (!HAVE_CPLUS_STRUCT (type))
1731 ALLOCATE_CPLUS_STRUCT_TYPE (type);
1732 TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_fieldno = fieldno;
1735 /* Internal routine called by TYPE_VPTR_BASETYPE to return the value of
1736 cplus_stuff.vptr_basetype. */
1739 internal_type_vptr_basetype (struct type *type)
1741 type = check_typedef (type);
1742 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
1743 || TYPE_CODE (type) == TYPE_CODE_UNION);
1744 gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_CPLUS_STUFF);
1745 return TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_basetype;
1748 /* Set the value of cplus_stuff.vptr_basetype. */
1751 set_type_vptr_basetype (struct type *type, struct type *basetype)
1753 type = check_typedef (type);
1754 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
1755 || TYPE_CODE (type) == TYPE_CODE_UNION);
1756 if (!HAVE_CPLUS_STRUCT (type))
1757 ALLOCATE_CPLUS_STRUCT_TYPE (type);
1758 TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_basetype = basetype;
1761 /* Lookup the vptr basetype/fieldno values for TYPE.
1762 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1763 vptr_fieldno. Also, if found and basetype is from the same objfile,
1765 If not found, return -1 and ignore BASETYPEP.
1766 Callers should be aware that in some cases (for example,
1767 the type or one of its baseclasses is a stub type and we are
1768 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1769 this function will not be able to find the
1770 virtual function table pointer, and vptr_fieldno will remain -1 and
1771 vptr_basetype will remain NULL or incomplete. */
1774 get_vptr_fieldno (struct type *type, struct type **basetypep)
1776 type = check_typedef (type);
1778 if (TYPE_VPTR_FIELDNO (type) < 0)
1782 /* We must start at zero in case the first (and only) baseclass
1783 is virtual (and hence we cannot share the table pointer). */
1784 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1786 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
1788 struct type *basetype;
1790 fieldno = get_vptr_fieldno (baseclass, &basetype);
1793 /* If the type comes from a different objfile we can't cache
1794 it, it may have a different lifetime. PR 2384 */
1795 if (TYPE_OBJFILE (type) == TYPE_OBJFILE (basetype))
1797 set_type_vptr_fieldno (type, fieldno);
1798 set_type_vptr_basetype (type, basetype);
1801 *basetypep = basetype;
1812 *basetypep = TYPE_VPTR_BASETYPE (type);
1813 return TYPE_VPTR_FIELDNO (type);
1818 stub_noname_complaint (void)
1820 complaint (&symfile_complaints, _("stub type has NULL name"));
1823 /* Worker for is_dynamic_type. */
1826 is_dynamic_type_internal (struct type *type, int top_level)
1828 type = check_typedef (type);
1830 /* We only want to recognize references at the outermost level. */
1831 if (top_level && TYPE_CODE (type) == TYPE_CODE_REF)
1832 type = check_typedef (TYPE_TARGET_TYPE (type));
1834 /* Types that have a dynamic TYPE_DATA_LOCATION are considered
1835 dynamic, even if the type itself is statically defined.
1836 From a user's point of view, this may appear counter-intuitive;
1837 but it makes sense in this context, because the point is to determine
1838 whether any part of the type needs to be resolved before it can
1840 if (TYPE_DATA_LOCATION (type) != NULL
1841 && (TYPE_DATA_LOCATION_KIND (type) == PROP_LOCEXPR
1842 || TYPE_DATA_LOCATION_KIND (type) == PROP_LOCLIST))
1845 if (TYPE_ASSOCIATED_PROP (type))
1848 if (TYPE_ALLOCATED_PROP (type))
1851 switch (TYPE_CODE (type))
1853 case TYPE_CODE_RANGE:
1855 /* A range type is obviously dynamic if it has at least one
1856 dynamic bound. But also consider the range type to be
1857 dynamic when its subtype is dynamic, even if the bounds
1858 of the range type are static. It allows us to assume that
1859 the subtype of a static range type is also static. */
1860 return (!has_static_range (TYPE_RANGE_DATA (type))
1861 || is_dynamic_type_internal (TYPE_TARGET_TYPE (type), 0));
1864 case TYPE_CODE_ARRAY:
1866 gdb_assert (TYPE_NFIELDS (type) == 1);
1868 /* The array is dynamic if either the bounds are dynamic,
1869 or the elements it contains have a dynamic contents. */
1870 if (is_dynamic_type_internal (TYPE_INDEX_TYPE (type), 0))
1872 return is_dynamic_type_internal (TYPE_TARGET_TYPE (type), 0);
1875 case TYPE_CODE_STRUCT:
1876 case TYPE_CODE_UNION:
1880 for (i = 0; i < TYPE_NFIELDS (type); ++i)
1881 if (!field_is_static (&TYPE_FIELD (type, i))
1882 && is_dynamic_type_internal (TYPE_FIELD_TYPE (type, i), 0))
1891 /* See gdbtypes.h. */
1894 is_dynamic_type (struct type *type)
1896 return is_dynamic_type_internal (type, 1);
1899 static struct type *resolve_dynamic_type_internal
1900 (struct type *type, struct property_addr_info *addr_stack, int top_level);
1902 /* Given a dynamic range type (dyn_range_type) and a stack of
1903 struct property_addr_info elements, return a static version
1906 static struct type *
1907 resolve_dynamic_range (struct type *dyn_range_type,
1908 struct property_addr_info *addr_stack)
1911 struct type *static_range_type, *static_target_type;
1912 const struct dynamic_prop *prop;
1913 struct dynamic_prop low_bound, high_bound;
1915 gdb_assert (TYPE_CODE (dyn_range_type) == TYPE_CODE_RANGE);
1917 prop = &TYPE_RANGE_DATA (dyn_range_type)->low;
1918 if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
1920 low_bound.kind = PROP_CONST;
1921 low_bound.data.const_val = value;
1925 low_bound.kind = PROP_UNDEFINED;
1926 low_bound.data.const_val = 0;
1929 prop = &TYPE_RANGE_DATA (dyn_range_type)->high;
1930 if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
1932 high_bound.kind = PROP_CONST;
1933 high_bound.data.const_val = value;
1935 if (TYPE_RANGE_DATA (dyn_range_type)->flag_upper_bound_is_count)
1936 high_bound.data.const_val
1937 = low_bound.data.const_val + high_bound.data.const_val - 1;
1941 high_bound.kind = PROP_UNDEFINED;
1942 high_bound.data.const_val = 0;
1946 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (dyn_range_type),
1948 static_range_type = create_range_type (copy_type (dyn_range_type),
1950 &low_bound, &high_bound);
1951 TYPE_RANGE_DATA (static_range_type)->flag_bound_evaluated = 1;
1952 return static_range_type;
1955 /* Resolves dynamic bound values of an array type TYPE to static ones.
1956 ADDR_STACK is a stack of struct property_addr_info to be used
1957 if needed during the dynamic resolution. */
1959 static struct type *
1960 resolve_dynamic_array (struct type *type,
1961 struct property_addr_info *addr_stack)
1964 struct type *elt_type;
1965 struct type *range_type;
1966 struct type *ary_dim;
1967 struct dynamic_prop *prop;
1969 gdb_assert (TYPE_CODE (type) == TYPE_CODE_ARRAY);
1971 type = copy_type (type);
1974 range_type = check_typedef (TYPE_INDEX_TYPE (elt_type));
1975 range_type = resolve_dynamic_range (range_type, addr_stack);
1977 /* Resolve allocated/associated here before creating a new array type, which
1978 will update the length of the array accordingly. */
1979 prop = TYPE_ALLOCATED_PROP (type);
1980 if (prop != NULL && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
1982 TYPE_DYN_PROP_ADDR (prop) = value;
1983 TYPE_DYN_PROP_KIND (prop) = PROP_CONST;
1985 prop = TYPE_ASSOCIATED_PROP (type);
1986 if (prop != NULL && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
1988 TYPE_DYN_PROP_ADDR (prop) = value;
1989 TYPE_DYN_PROP_KIND (prop) = PROP_CONST;
1992 ary_dim = check_typedef (TYPE_TARGET_TYPE (elt_type));
1994 if (ary_dim != NULL && TYPE_CODE (ary_dim) == TYPE_CODE_ARRAY)
1995 elt_type = resolve_dynamic_array (ary_dim, addr_stack);
1997 elt_type = TYPE_TARGET_TYPE (type);
1999 return create_array_type_with_stride (type, elt_type, range_type,
2000 TYPE_FIELD_BITSIZE (type, 0));
2003 /* Resolve dynamic bounds of members of the union TYPE to static
2004 bounds. ADDR_STACK is a stack of struct property_addr_info
2005 to be used if needed during the dynamic resolution. */
2007 static struct type *
2008 resolve_dynamic_union (struct type *type,
2009 struct property_addr_info *addr_stack)
2011 struct type *resolved_type;
2013 unsigned int max_len = 0;
2015 gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
2017 resolved_type = copy_type (type);
2018 TYPE_FIELDS (resolved_type)
2019 = (struct field *) TYPE_ALLOC (resolved_type,
2020 TYPE_NFIELDS (resolved_type)
2021 * sizeof (struct field));
2022 memcpy (TYPE_FIELDS (resolved_type),
2024 TYPE_NFIELDS (resolved_type) * sizeof (struct field));
2025 for (i = 0; i < TYPE_NFIELDS (resolved_type); ++i)
2029 if (field_is_static (&TYPE_FIELD (type, i)))
2032 t = resolve_dynamic_type_internal (TYPE_FIELD_TYPE (resolved_type, i),
2034 TYPE_FIELD_TYPE (resolved_type, i) = t;
2035 if (TYPE_LENGTH (t) > max_len)
2036 max_len = TYPE_LENGTH (t);
2039 TYPE_LENGTH (resolved_type) = max_len;
2040 return resolved_type;
2043 /* Resolve dynamic bounds of members of the struct TYPE to static
2044 bounds. ADDR_STACK is a stack of struct property_addr_info to
2045 be used if needed during the dynamic resolution. */
2047 static struct type *
2048 resolve_dynamic_struct (struct type *type,
2049 struct property_addr_info *addr_stack)
2051 struct type *resolved_type;
2053 unsigned resolved_type_bit_length = 0;
2055 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT);
2056 gdb_assert (TYPE_NFIELDS (type) > 0);
2058 resolved_type = copy_type (type);
2059 TYPE_FIELDS (resolved_type)
2060 = (struct field *) TYPE_ALLOC (resolved_type,
2061 TYPE_NFIELDS (resolved_type)
2062 * sizeof (struct field));
2063 memcpy (TYPE_FIELDS (resolved_type),
2065 TYPE_NFIELDS (resolved_type) * sizeof (struct field));
2066 for (i = 0; i < TYPE_NFIELDS (resolved_type); ++i)
2068 unsigned new_bit_length;
2069 struct property_addr_info pinfo;
2071 if (field_is_static (&TYPE_FIELD (type, i)))
2074 /* As we know this field is not a static field, the field's
2075 field_loc_kind should be FIELD_LOC_KIND_BITPOS. Verify
2076 this is the case, but only trigger a simple error rather
2077 than an internal error if that fails. While failing
2078 that verification indicates a bug in our code, the error
2079 is not severe enough to suggest to the user he stops
2080 his debugging session because of it. */
2081 if (TYPE_FIELD_LOC_KIND (type, i) != FIELD_LOC_KIND_BITPOS)
2082 error (_("Cannot determine struct field location"
2083 " (invalid location kind)"));
2085 pinfo.type = check_typedef (TYPE_FIELD_TYPE (type, i));
2086 pinfo.valaddr = addr_stack->valaddr;
2089 + (TYPE_FIELD_BITPOS (resolved_type, i) / TARGET_CHAR_BIT));
2090 pinfo.next = addr_stack;
2092 TYPE_FIELD_TYPE (resolved_type, i)
2093 = resolve_dynamic_type_internal (TYPE_FIELD_TYPE (resolved_type, i),
2095 gdb_assert (TYPE_FIELD_LOC_KIND (resolved_type, i)
2096 == FIELD_LOC_KIND_BITPOS);
2098 new_bit_length = TYPE_FIELD_BITPOS (resolved_type, i);
2099 if (TYPE_FIELD_BITSIZE (resolved_type, i) != 0)
2100 new_bit_length += TYPE_FIELD_BITSIZE (resolved_type, i);
2102 new_bit_length += (TYPE_LENGTH (TYPE_FIELD_TYPE (resolved_type, i))
2105 /* Normally, we would use the position and size of the last field
2106 to determine the size of the enclosing structure. But GCC seems
2107 to be encoding the position of some fields incorrectly when
2108 the struct contains a dynamic field that is not placed last.
2109 So we compute the struct size based on the field that has
2110 the highest position + size - probably the best we can do. */
2111 if (new_bit_length > resolved_type_bit_length)
2112 resolved_type_bit_length = new_bit_length;
2115 /* The length of a type won't change for fortran, but it does for C and Ada.
2116 For fortran the size of dynamic fields might change over time but not the
2117 type length of the structure. If we adapt it, we run into problems
2118 when calculating the element offset for arrays of structs. */
2119 if (current_language->la_language != language_fortran)
2120 TYPE_LENGTH (resolved_type)
2121 = (resolved_type_bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
2123 /* The Ada language uses this field as a cache for static fixed types: reset
2124 it as RESOLVED_TYPE must have its own static fixed type. */
2125 TYPE_TARGET_TYPE (resolved_type) = NULL;
2127 return resolved_type;
2130 /* Worker for resolved_dynamic_type. */
2132 static struct type *
2133 resolve_dynamic_type_internal (struct type *type,
2134 struct property_addr_info *addr_stack,
2137 struct type *real_type = check_typedef (type);
2138 struct type *resolved_type = type;
2139 struct dynamic_prop *prop;
2142 if (!is_dynamic_type_internal (real_type, top_level))
2145 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
2147 resolved_type = copy_type (type);
2148 TYPE_TARGET_TYPE (resolved_type)
2149 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type), addr_stack,
2154 /* Before trying to resolve TYPE, make sure it is not a stub. */
2157 switch (TYPE_CODE (type))
2161 struct property_addr_info pinfo;
2163 pinfo.type = check_typedef (TYPE_TARGET_TYPE (type));
2164 pinfo.valaddr = NULL;
2165 if (addr_stack->valaddr != NULL)
2166 pinfo.addr = extract_typed_address (addr_stack->valaddr, type);
2168 pinfo.addr = read_memory_typed_address (addr_stack->addr, type);
2169 pinfo.next = addr_stack;
2171 resolved_type = copy_type (type);
2172 TYPE_TARGET_TYPE (resolved_type)
2173 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type),
2178 case TYPE_CODE_ARRAY:
2179 resolved_type = resolve_dynamic_array (type, addr_stack);
2182 case TYPE_CODE_RANGE:
2183 resolved_type = resolve_dynamic_range (type, addr_stack);
2186 case TYPE_CODE_UNION:
2187 resolved_type = resolve_dynamic_union (type, addr_stack);
2190 case TYPE_CODE_STRUCT:
2191 resolved_type = resolve_dynamic_struct (type, addr_stack);
2196 /* Resolve data_location attribute. */
2197 prop = TYPE_DATA_LOCATION (resolved_type);
2199 && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
2201 TYPE_DYN_PROP_ADDR (prop) = value;
2202 TYPE_DYN_PROP_KIND (prop) = PROP_CONST;
2205 return resolved_type;
2208 /* See gdbtypes.h */
2211 resolve_dynamic_type (struct type *type, const gdb_byte *valaddr,
2214 struct property_addr_info pinfo
2215 = {check_typedef (type), valaddr, addr, NULL};
2217 return resolve_dynamic_type_internal (type, &pinfo, 1);
2220 /* See gdbtypes.h */
2222 struct dynamic_prop *
2223 get_dyn_prop (enum dynamic_prop_node_kind prop_kind, const struct type *type)
2225 struct dynamic_prop_list *node = TYPE_DYN_PROP_LIST (type);
2227 while (node != NULL)
2229 if (node->prop_kind == prop_kind)
2236 /* See gdbtypes.h */
2239 add_dyn_prop (enum dynamic_prop_node_kind prop_kind, struct dynamic_prop prop,
2240 struct type *type, struct objfile *objfile)
2242 struct dynamic_prop_list *temp;
2244 gdb_assert (TYPE_OBJFILE_OWNED (type));
2246 temp = XOBNEW (&objfile->objfile_obstack, struct dynamic_prop_list);
2247 temp->prop_kind = prop_kind;
2249 temp->next = TYPE_DYN_PROP_LIST (type);
2251 TYPE_DYN_PROP_LIST (type) = temp;
2254 /* Remove dynamic property from TYPE in case it exists. */
2257 remove_dyn_prop (enum dynamic_prop_node_kind prop_kind,
2260 struct dynamic_prop_list *prev_node, *curr_node;
2262 curr_node = TYPE_DYN_PROP_LIST (type);
2265 while (NULL != curr_node)
2267 if (curr_node->prop_kind == prop_kind)
2269 /* Update the linked list but don't free anything.
2270 The property was allocated on objstack and it is not known
2271 if we are on top of it. Nevertheless, everything is released
2272 when the complete objstack is freed. */
2273 if (NULL == prev_node)
2274 TYPE_DYN_PROP_LIST (type) = curr_node->next;
2276 prev_node->next = curr_node->next;
2281 prev_node = curr_node;
2282 curr_node = curr_node->next;
2286 /* Find the real type of TYPE. This function returns the real type,
2287 after removing all layers of typedefs, and completing opaque or stub
2288 types. Completion changes the TYPE argument, but stripping of
2291 Instance flags (e.g. const/volatile) are preserved as typedefs are
2292 stripped. If necessary a new qualified form of the underlying type
2295 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
2296 not been computed and we're either in the middle of reading symbols, or
2297 there was no name for the typedef in the debug info.
2299 NOTE: Lookup of opaque types can throw errors for invalid symbol files.
2300 QUITs in the symbol reading code can also throw.
2301 Thus this function can throw an exception.
2303 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
2306 If this is a stubbed struct (i.e. declared as struct foo *), see if
2307 we can find a full definition in some other file. If so, copy this
2308 definition, so we can use it in future. There used to be a comment
2309 (but not any code) that if we don't find a full definition, we'd
2310 set a flag so we don't spend time in the future checking the same
2311 type. That would be a mistake, though--we might load in more
2312 symbols which contain a full definition for the type. */
2315 check_typedef (struct type *type)
2317 struct type *orig_type = type;
2318 /* While we're removing typedefs, we don't want to lose qualifiers.
2319 E.g., const/volatile. */
2320 int instance_flags = TYPE_INSTANCE_FLAGS (type);
2324 while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
2326 if (!TYPE_TARGET_TYPE (type))
2331 /* It is dangerous to call lookup_symbol if we are currently
2332 reading a symtab. Infinite recursion is one danger. */
2333 if (currently_reading_symtab)
2334 return make_qualified_type (type, instance_flags, NULL);
2336 name = type_name_no_tag (type);
2337 /* FIXME: shouldn't we separately check the TYPE_NAME and
2338 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
2339 VAR_DOMAIN as appropriate? (this code was written before
2340 TYPE_NAME and TYPE_TAG_NAME were separate). */
2343 stub_noname_complaint ();
2344 return make_qualified_type (type, instance_flags, NULL);
2346 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol;
2348 TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
2349 else /* TYPE_CODE_UNDEF */
2350 TYPE_TARGET_TYPE (type) = alloc_type_arch (get_type_arch (type));
2352 type = TYPE_TARGET_TYPE (type);
2354 /* Preserve the instance flags as we traverse down the typedef chain.
2356 Handling address spaces/classes is nasty, what do we do if there's a
2358 E.g., what if an outer typedef marks the type as class_1 and an inner
2359 typedef marks the type as class_2?
2360 This is the wrong place to do such error checking. We leave it to
2361 the code that created the typedef in the first place to flag the
2362 error. We just pick the outer address space (akin to letting the
2363 outer cast in a chain of casting win), instead of assuming
2364 "it can't happen". */
2366 const int ALL_SPACES = (TYPE_INSTANCE_FLAG_CODE_SPACE
2367 | TYPE_INSTANCE_FLAG_DATA_SPACE);
2368 const int ALL_CLASSES = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL;
2369 int new_instance_flags = TYPE_INSTANCE_FLAGS (type);
2371 /* Treat code vs data spaces and address classes separately. */
2372 if ((instance_flags & ALL_SPACES) != 0)
2373 new_instance_flags &= ~ALL_SPACES;
2374 if ((instance_flags & ALL_CLASSES) != 0)
2375 new_instance_flags &= ~ALL_CLASSES;
2377 instance_flags |= new_instance_flags;
2381 /* If this is a struct/class/union with no fields, then check
2382 whether a full definition exists somewhere else. This is for
2383 systems where a type definition with no fields is issued for such
2384 types, instead of identifying them as stub types in the first
2387 if (TYPE_IS_OPAQUE (type)
2388 && opaque_type_resolution
2389 && !currently_reading_symtab)
2391 const char *name = type_name_no_tag (type);
2392 struct type *newtype;
2396 stub_noname_complaint ();
2397 return make_qualified_type (type, instance_flags, NULL);
2399 newtype = lookup_transparent_type (name);
2403 /* If the resolved type and the stub are in the same
2404 objfile, then replace the stub type with the real deal.
2405 But if they're in separate objfiles, leave the stub
2406 alone; we'll just look up the transparent type every time
2407 we call check_typedef. We can't create pointers between
2408 types allocated to different objfiles, since they may
2409 have different lifetimes. Trying to copy NEWTYPE over to
2410 TYPE's objfile is pointless, too, since you'll have to
2411 move over any other types NEWTYPE refers to, which could
2412 be an unbounded amount of stuff. */
2413 if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type))
2414 type = make_qualified_type (newtype,
2415 TYPE_INSTANCE_FLAGS (type),
2421 /* Otherwise, rely on the stub flag being set for opaque/stubbed
2423 else if (TYPE_STUB (type) && !currently_reading_symtab)
2425 const char *name = type_name_no_tag (type);
2426 /* FIXME: shouldn't we separately check the TYPE_NAME and the
2427 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
2428 as appropriate? (this code was written before TYPE_NAME and
2429 TYPE_TAG_NAME were separate). */
2434 stub_noname_complaint ();
2435 return make_qualified_type (type, instance_flags, NULL);
2437 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol;
2440 /* Same as above for opaque types, we can replace the stub
2441 with the complete type only if they are in the same
2443 if (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type))
2444 type = make_qualified_type (SYMBOL_TYPE (sym),
2445 TYPE_INSTANCE_FLAGS (type),
2448 type = SYMBOL_TYPE (sym);
2452 if (TYPE_TARGET_STUB (type))
2454 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
2456 if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type))
2458 /* Nothing we can do. */
2460 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
2462 TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
2463 TYPE_TARGET_STUB (type) = 0;
2467 type = make_qualified_type (type, instance_flags, NULL);
2469 /* Cache TYPE_LENGTH for future use. */
2470 TYPE_LENGTH (orig_type) = TYPE_LENGTH (type);
2475 /* Parse a type expression in the string [P..P+LENGTH). If an error
2476 occurs, silently return a void type. */
2478 static struct type *
2479 safe_parse_type (struct gdbarch *gdbarch, char *p, int length)
2481 struct ui_file *saved_gdb_stderr;
2482 struct type *type = NULL; /* Initialize to keep gcc happy. */
2484 /* Suppress error messages. */
2485 saved_gdb_stderr = gdb_stderr;
2486 gdb_stderr = &null_stream;
2488 /* Call parse_and_eval_type() without fear of longjmp()s. */
2491 type = parse_and_eval_type (p, length);
2493 CATCH (except, RETURN_MASK_ERROR)
2495 type = builtin_type (gdbarch)->builtin_void;
2499 /* Stop suppressing error messages. */
2500 gdb_stderr = saved_gdb_stderr;
2505 /* Ugly hack to convert method stubs into method types.
2507 He ain't kiddin'. This demangles the name of the method into a
2508 string including argument types, parses out each argument type,
2509 generates a string casting a zero to that type, evaluates the
2510 string, and stuffs the resulting type into an argtype vector!!!
2511 Then it knows the type of the whole function (including argument
2512 types for overloading), which info used to be in the stab's but was
2513 removed to hack back the space required for them. */
2516 check_stub_method (struct type *type, int method_id, int signature_id)
2518 struct gdbarch *gdbarch = get_type_arch (type);
2520 char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
2521 char *demangled_name = gdb_demangle (mangled_name,
2522 DMGL_PARAMS | DMGL_ANSI);
2523 char *argtypetext, *p;
2524 int depth = 0, argcount = 1;
2525 struct field *argtypes;
2528 /* Make sure we got back a function string that we can use. */
2530 p = strchr (demangled_name, '(');
2534 if (demangled_name == NULL || p == NULL)
2535 error (_("Internal: Cannot demangle mangled name `%s'."),
2538 /* Now, read in the parameters that define this type. */
2543 if (*p == '(' || *p == '<')
2547 else if (*p == ')' || *p == '>')
2551 else if (*p == ',' && depth == 0)
2559 /* If we read one argument and it was ``void'', don't count it. */
2560 if (startswith (argtypetext, "(void)"))
2563 /* We need one extra slot, for the THIS pointer. */
2565 argtypes = (struct field *)
2566 TYPE_ALLOC (type, (argcount + 1) * sizeof (struct field));
2569 /* Add THIS pointer for non-static methods. */
2570 f = TYPE_FN_FIELDLIST1 (type, method_id);
2571 if (TYPE_FN_FIELD_STATIC_P (f, signature_id))
2575 argtypes[0].type = lookup_pointer_type (type);
2579 if (*p != ')') /* () means no args, skip while. */
2584 if (depth <= 0 && (*p == ',' || *p == ')'))
2586 /* Avoid parsing of ellipsis, they will be handled below.
2587 Also avoid ``void'' as above. */
2588 if (strncmp (argtypetext, "...", p - argtypetext) != 0
2589 && strncmp (argtypetext, "void", p - argtypetext) != 0)
2591 argtypes[argcount].type =
2592 safe_parse_type (gdbarch, argtypetext, p - argtypetext);
2595 argtypetext = p + 1;
2598 if (*p == '(' || *p == '<')
2602 else if (*p == ')' || *p == '>')
2611 TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name;
2613 /* Now update the old "stub" type into a real type. */
2614 mtype = TYPE_FN_FIELD_TYPE (f, signature_id);
2615 /* MTYPE may currently be a function (TYPE_CODE_FUNC).
2616 We want a method (TYPE_CODE_METHOD). */
2617 smash_to_method_type (mtype, type, TYPE_TARGET_TYPE (mtype),
2618 argtypes, argcount, p[-2] == '.');
2619 TYPE_STUB (mtype) = 0;
2620 TYPE_FN_FIELD_STUB (f, signature_id) = 0;
2622 xfree (demangled_name);
2625 /* This is the external interface to check_stub_method, above. This
2626 function unstubs all of the signatures for TYPE's METHOD_ID method
2627 name. After calling this function TYPE_FN_FIELD_STUB will be
2628 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
2631 This function unfortunately can not die until stabs do. */
2634 check_stub_method_group (struct type *type, int method_id)
2636 int len = TYPE_FN_FIELDLIST_LENGTH (type, method_id);
2637 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
2638 int j, found_stub = 0;
2640 for (j = 0; j < len; j++)
2641 if (TYPE_FN_FIELD_STUB (f, j))
2644 check_stub_method (type, method_id, j);
2647 /* GNU v3 methods with incorrect names were corrected when we read
2648 in type information, because it was cheaper to do it then. The
2649 only GNU v2 methods with incorrect method names are operators and
2650 destructors; destructors were also corrected when we read in type
2653 Therefore the only thing we need to handle here are v2 operator
2655 if (found_stub && !startswith (TYPE_FN_FIELD_PHYSNAME (f, 0), "_Z"))
2658 char dem_opname[256];
2660 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
2662 dem_opname, DMGL_ANSI);
2664 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
2668 TYPE_FN_FIELDLIST_NAME (type, method_id) = xstrdup (dem_opname);
2672 /* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */
2673 const struct cplus_struct_type cplus_struct_default = { };
2676 allocate_cplus_struct_type (struct type *type)
2678 if (HAVE_CPLUS_STRUCT (type))
2679 /* Structure was already allocated. Nothing more to do. */
2682 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CPLUS_STUFF;
2683 TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
2684 TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
2685 *(TYPE_RAW_CPLUS_SPECIFIC (type)) = cplus_struct_default;
2686 set_type_vptr_fieldno (type, -1);
2689 const struct gnat_aux_type gnat_aux_default =
2692 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
2693 and allocate the associated gnat-specific data. The gnat-specific
2694 data is also initialized to gnat_aux_default. */
2697 allocate_gnat_aux_type (struct type *type)
2699 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_GNAT_STUFF;
2700 TYPE_GNAT_SPECIFIC (type) = (struct gnat_aux_type *)
2701 TYPE_ALLOC (type, sizeof (struct gnat_aux_type));
2702 *(TYPE_GNAT_SPECIFIC (type)) = gnat_aux_default;
2705 /* Helper function to initialize a newly allocated type. Set type code
2706 to CODE and initialize the type-specific fields accordingly. */
2709 set_type_code (struct type *type, enum type_code code)
2711 TYPE_CODE (type) = code;
2715 case TYPE_CODE_STRUCT:
2716 case TYPE_CODE_UNION:
2717 case TYPE_CODE_NAMESPACE:
2718 INIT_CPLUS_SPECIFIC (type);
2721 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FLOATFORMAT;
2723 case TYPE_CODE_FUNC:
2724 INIT_FUNC_SPECIFIC (type);
2729 /* Helper function to verify floating-point format and size.
2730 BIT is the type size in bits; if BIT equals -1, the size is
2731 determined by the floatformat. Returns size to be used. */
2734 verify_floatformat (int bit, const struct floatformat **floatformats)
2736 gdb_assert (floatformats != NULL);
2737 gdb_assert (floatformats[0] != NULL && floatformats[1] != NULL);
2740 bit = floatformats[0]->totalsize;
2741 gdb_assert (bit >= 0);
2743 size_t len = bit / TARGET_CHAR_BIT;
2744 gdb_assert (len >= floatformat_totalsize_bytes (floatformats[0]));
2745 gdb_assert (len >= floatformat_totalsize_bytes (floatformats[1]));
2750 /* Helper function to initialize the standard scalar types.
2752 If NAME is non-NULL, then it is used to initialize the type name.
2753 Note that NAME is not copied; it is required to have a lifetime at
2754 least as long as OBJFILE. */
2757 init_type (struct objfile *objfile, enum type_code code, int length,
2762 type = alloc_type (objfile);
2763 set_type_code (type, code);
2764 TYPE_LENGTH (type) = length;
2765 TYPE_NAME (type) = name;
2770 /* Allocate a TYPE_CODE_INT type structure associated with OBJFILE.
2771 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
2772 the type's TYPE_UNSIGNED flag. NAME is the type name. */
2775 init_integer_type (struct objfile *objfile,
2776 int bit, int unsigned_p, const char *name)
2780 t = init_type (objfile, TYPE_CODE_INT, bit / TARGET_CHAR_BIT, name);
2782 TYPE_UNSIGNED (t) = 1;
2787 /* Allocate a TYPE_CODE_CHAR type structure associated with OBJFILE.
2788 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
2789 the type's TYPE_UNSIGNED flag. NAME is the type name. */
2792 init_character_type (struct objfile *objfile,
2793 int bit, int unsigned_p, const char *name)
2797 t = init_type (objfile, TYPE_CODE_CHAR, bit / TARGET_CHAR_BIT, name);
2799 TYPE_UNSIGNED (t) = 1;
2804 /* Allocate a TYPE_CODE_BOOL type structure associated with OBJFILE.
2805 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
2806 the type's TYPE_UNSIGNED flag. NAME is the type name. */
2809 init_boolean_type (struct objfile *objfile,
2810 int bit, int unsigned_p, const char *name)
2814 t = init_type (objfile, TYPE_CODE_BOOL, bit / TARGET_CHAR_BIT, name);
2816 TYPE_UNSIGNED (t) = 1;
2821 /* Allocate a TYPE_CODE_FLT type structure associated with OBJFILE.
2822 BIT is the type size in bits; if BIT equals -1, the size is
2823 determined by the floatformat. NAME is the type name. Set the
2824 TYPE_FLOATFORMAT from FLOATFORMATS. */
2827 init_float_type (struct objfile *objfile,
2828 int bit, const char *name,
2829 const struct floatformat **floatformats)
2833 bit = verify_floatformat (bit, floatformats);
2834 t = init_type (objfile, TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, name);
2835 TYPE_FLOATFORMAT (t) = floatformats;
2840 /* Allocate a TYPE_CODE_DECFLOAT type structure associated with OBJFILE.
2841 BIT is the type size in bits. NAME is the type name. */
2844 init_decfloat_type (struct objfile *objfile, int bit, const char *name)
2848 t = init_type (objfile, TYPE_CODE_DECFLOAT, bit / TARGET_CHAR_BIT, name);
2852 /* Allocate a TYPE_CODE_COMPLEX type structure associated with OBJFILE.
2853 NAME is the type name. TARGET_TYPE is the component float type. */
2856 init_complex_type (struct objfile *objfile,
2857 const char *name, struct type *target_type)
2861 t = init_type (objfile, TYPE_CODE_COMPLEX,
2862 2 * TYPE_LENGTH (target_type), name);
2863 TYPE_TARGET_TYPE (t) = target_type;
2867 /* Allocate a TYPE_CODE_PTR type structure associated with OBJFILE.
2868 BIT is the pointer type size in bits. NAME is the type name.
2869 TARGET_TYPE is the pointer target type. Always sets the pointer type's
2870 TYPE_UNSIGNED flag. */
2873 init_pointer_type (struct objfile *objfile,
2874 int bit, const char *name, struct type *target_type)
2878 t = init_type (objfile, TYPE_CODE_PTR, bit / TARGET_CHAR_BIT, name);
2879 TYPE_TARGET_TYPE (t) = target_type;
2880 TYPE_UNSIGNED (t) = 1;
2885 /* Queries on types. */
2888 can_dereference (struct type *t)
2890 /* FIXME: Should we return true for references as well as
2892 t = check_typedef (t);
2895 && TYPE_CODE (t) == TYPE_CODE_PTR
2896 && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
2900 is_integral_type (struct type *t)
2902 t = check_typedef (t);
2905 && ((TYPE_CODE (t) == TYPE_CODE_INT)
2906 || (TYPE_CODE (t) == TYPE_CODE_ENUM)
2907 || (TYPE_CODE (t) == TYPE_CODE_FLAGS)
2908 || (TYPE_CODE (t) == TYPE_CODE_CHAR)
2909 || (TYPE_CODE (t) == TYPE_CODE_RANGE)
2910 || (TYPE_CODE (t) == TYPE_CODE_BOOL)));
2913 /* Return true if TYPE is scalar. */
2916 is_scalar_type (struct type *type)
2918 type = check_typedef (type);
2920 switch (TYPE_CODE (type))
2922 case TYPE_CODE_ARRAY:
2923 case TYPE_CODE_STRUCT:
2924 case TYPE_CODE_UNION:
2926 case TYPE_CODE_STRING:
2933 /* Return true if T is scalar, or a composite type which in practice has
2934 the memory layout of a scalar type. E.g., an array or struct with only
2935 one scalar element inside it, or a union with only scalar elements. */
2938 is_scalar_type_recursive (struct type *t)
2940 t = check_typedef (t);
2942 if (is_scalar_type (t))
2944 /* Are we dealing with an array or string of known dimensions? */
2945 else if ((TYPE_CODE (t) == TYPE_CODE_ARRAY
2946 || TYPE_CODE (t) == TYPE_CODE_STRING) && TYPE_NFIELDS (t) == 1
2947 && TYPE_CODE (TYPE_INDEX_TYPE (t)) == TYPE_CODE_RANGE)
2949 LONGEST low_bound, high_bound;
2950 struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t));
2952 get_discrete_bounds (TYPE_INDEX_TYPE (t), &low_bound, &high_bound);
2954 return high_bound == low_bound && is_scalar_type_recursive (elt_type);
2956 /* Are we dealing with a struct with one element? */
2957 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT && TYPE_NFIELDS (t) == 1)
2958 return is_scalar_type_recursive (TYPE_FIELD_TYPE (t, 0));
2959 else if (TYPE_CODE (t) == TYPE_CODE_UNION)
2961 int i, n = TYPE_NFIELDS (t);
2963 /* If all elements of the union are scalar, then the union is scalar. */
2964 for (i = 0; i < n; i++)
2965 if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t, i)))
2974 /* Return true is T is a class or a union. False otherwise. */
2977 class_or_union_p (const struct type *t)
2979 return (TYPE_CODE (t) == TYPE_CODE_STRUCT
2980 || TYPE_CODE (t) == TYPE_CODE_UNION);
2983 /* A helper function which returns true if types A and B represent the
2984 "same" class type. This is true if the types have the same main
2985 type, or the same name. */
2988 class_types_same_p (const struct type *a, const struct type *b)
2990 return (TYPE_MAIN_TYPE (a) == TYPE_MAIN_TYPE (b)
2991 || (TYPE_NAME (a) && TYPE_NAME (b)
2992 && !strcmp (TYPE_NAME (a), TYPE_NAME (b))));
2995 /* If BASE is an ancestor of DCLASS return the distance between them.
2996 otherwise return -1;
3000 class B: public A {};
3001 class C: public B {};
3004 distance_to_ancestor (A, A, 0) = 0
3005 distance_to_ancestor (A, B, 0) = 1
3006 distance_to_ancestor (A, C, 0) = 2
3007 distance_to_ancestor (A, D, 0) = 3
3009 If PUBLIC is 1 then only public ancestors are considered,
3010 and the function returns the distance only if BASE is a public ancestor
3014 distance_to_ancestor (A, D, 1) = -1. */
3017 distance_to_ancestor (struct type *base, struct type *dclass, int is_public)
3022 base = check_typedef (base);
3023 dclass = check_typedef (dclass);
3025 if (class_types_same_p (base, dclass))
3028 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
3030 if (is_public && ! BASETYPE_VIA_PUBLIC (dclass, i))
3033 d = distance_to_ancestor (base, TYPE_BASECLASS (dclass, i), is_public);
3041 /* Check whether BASE is an ancestor or base class or DCLASS
3042 Return 1 if so, and 0 if not.
3043 Note: If BASE and DCLASS are of the same type, this function
3044 will return 1. So for some class A, is_ancestor (A, A) will
3048 is_ancestor (struct type *base, struct type *dclass)
3050 return distance_to_ancestor (base, dclass, 0) >= 0;
3053 /* Like is_ancestor, but only returns true when BASE is a public
3054 ancestor of DCLASS. */
3057 is_public_ancestor (struct type *base, struct type *dclass)
3059 return distance_to_ancestor (base, dclass, 1) >= 0;
3062 /* A helper function for is_unique_ancestor. */
3065 is_unique_ancestor_worker (struct type *base, struct type *dclass,
3067 const gdb_byte *valaddr, int embedded_offset,
3068 CORE_ADDR address, struct value *val)
3072 base = check_typedef (base);
3073 dclass = check_typedef (dclass);
3075 for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i)
3080 iter = check_typedef (TYPE_BASECLASS (dclass, i));
3082 this_offset = baseclass_offset (dclass, i, valaddr, embedded_offset,
3085 if (class_types_same_p (base, iter))
3087 /* If this is the first subclass, set *OFFSET and set count
3088 to 1. Otherwise, if this is at the same offset as
3089 previous instances, do nothing. Otherwise, increment
3093 *offset = this_offset;
3096 else if (this_offset == *offset)
3104 count += is_unique_ancestor_worker (base, iter, offset,
3106 embedded_offset + this_offset,
3113 /* Like is_ancestor, but only returns true if BASE is a unique base
3114 class of the type of VAL. */
3117 is_unique_ancestor (struct type *base, struct value *val)
3121 return is_unique_ancestor_worker (base, value_type (val), &offset,
3122 value_contents_for_printing (val),
3123 value_embedded_offset (val),
3124 value_address (val), val) == 1;
3128 /* Overload resolution. */
3130 /* Return the sum of the rank of A with the rank of B. */
3133 sum_ranks (struct rank a, struct rank b)
3136 c.rank = a.rank + b.rank;
3137 c.subrank = a.subrank + b.subrank;
3141 /* Compare rank A and B and return:
3143 1 if a is better than b
3144 -1 if b is better than a. */
3147 compare_ranks (struct rank a, struct rank b)
3149 if (a.rank == b.rank)
3151 if (a.subrank == b.subrank)
3153 if (a.subrank < b.subrank)
3155 if (a.subrank > b.subrank)
3159 if (a.rank < b.rank)
3162 /* a.rank > b.rank */
3166 /* Functions for overload resolution begin here. */
3168 /* Compare two badness vectors A and B and return the result.
3169 0 => A and B are identical
3170 1 => A and B are incomparable
3171 2 => A is better than B
3172 3 => A is worse than B */
3175 compare_badness (struct badness_vector *a, struct badness_vector *b)
3179 short found_pos = 0; /* any positives in c? */
3180 short found_neg = 0; /* any negatives in c? */
3182 /* differing lengths => incomparable */
3183 if (a->length != b->length)
3186 /* Subtract b from a */
3187 for (i = 0; i < a->length; i++)
3189 tmp = compare_ranks (b->rank[i], a->rank[i]);
3199 return 1; /* incomparable */
3201 return 3; /* A > B */
3207 return 2; /* A < B */
3209 return 0; /* A == B */
3213 /* Rank a function by comparing its parameter types (PARMS, length
3214 NPARMS), to the types of an argument list (ARGS, length NARGS).
3215 Return a pointer to a badness vector. This has NARGS + 1
3218 struct badness_vector *
3219 rank_function (struct type **parms, int nparms,
3220 struct value **args, int nargs)
3223 struct badness_vector *bv = XNEW (struct badness_vector);
3224 int min_len = nparms < nargs ? nparms : nargs;
3226 bv->length = nargs + 1; /* add 1 for the length-match rank. */
3227 bv->rank = XNEWVEC (struct rank, nargs + 1);
3229 /* First compare the lengths of the supplied lists.
3230 If there is a mismatch, set it to a high value. */
3232 /* pai/1997-06-03 FIXME: when we have debug info about default
3233 arguments and ellipsis parameter lists, we should consider those
3234 and rank the length-match more finely. */
3236 LENGTH_MATCH (bv) = (nargs != nparms)
3237 ? LENGTH_MISMATCH_BADNESS
3238 : EXACT_MATCH_BADNESS;
3240 /* Now rank all the parameters of the candidate function. */
3241 for (i = 1; i <= min_len; i++)
3242 bv->rank[i] = rank_one_type (parms[i - 1], value_type (args[i - 1]),
3245 /* If more arguments than parameters, add dummy entries. */
3246 for (i = min_len + 1; i <= nargs; i++)
3247 bv->rank[i] = TOO_FEW_PARAMS_BADNESS;
3252 /* Compare the names of two integer types, assuming that any sign
3253 qualifiers have been checked already. We do it this way because
3254 there may be an "int" in the name of one of the types. */
3257 integer_types_same_name_p (const char *first, const char *second)
3259 int first_p, second_p;
3261 /* If both are shorts, return 1; if neither is a short, keep
3263 first_p = (strstr (first, "short") != NULL);
3264 second_p = (strstr (second, "short") != NULL);
3265 if (first_p && second_p)
3267 if (first_p || second_p)
3270 /* Likewise for long. */
3271 first_p = (strstr (first, "long") != NULL);
3272 second_p = (strstr (second, "long") != NULL);
3273 if (first_p && second_p)
3275 if (first_p || second_p)
3278 /* Likewise for char. */
3279 first_p = (strstr (first, "char") != NULL);
3280 second_p = (strstr (second, "char") != NULL);
3281 if (first_p && second_p)
3283 if (first_p || second_p)
3286 /* They must both be ints. */
3290 /* Compares type A to type B returns 1 if the represent the same type
3294 types_equal (struct type *a, struct type *b)
3296 /* Identical type pointers. */
3297 /* However, this still doesn't catch all cases of same type for b
3298 and a. The reason is that builtin types are different from
3299 the same ones constructed from the object. */
3303 /* Resolve typedefs */
3304 if (TYPE_CODE (a) == TYPE_CODE_TYPEDEF)
3305 a = check_typedef (a);
3306 if (TYPE_CODE (b) == TYPE_CODE_TYPEDEF)
3307 b = check_typedef (b);
3309 /* If after resolving typedefs a and b are not of the same type
3310 code then they are not equal. */
3311 if (TYPE_CODE (a) != TYPE_CODE (b))
3314 /* If a and b are both pointers types or both reference types then
3315 they are equal of the same type iff the objects they refer to are
3316 of the same type. */
3317 if (TYPE_CODE (a) == TYPE_CODE_PTR
3318 || TYPE_CODE (a) == TYPE_CODE_REF)
3319 return types_equal (TYPE_TARGET_TYPE (a),
3320 TYPE_TARGET_TYPE (b));
3322 /* Well, damnit, if the names are exactly the same, I'll say they
3323 are exactly the same. This happens when we generate method
3324 stubs. The types won't point to the same address, but they
3325 really are the same. */
3327 if (TYPE_NAME (a) && TYPE_NAME (b)
3328 && strcmp (TYPE_NAME (a), TYPE_NAME (b)) == 0)
3331 /* Check if identical after resolving typedefs. */
3335 /* Two function types are equal if their argument and return types
3337 if (TYPE_CODE (a) == TYPE_CODE_FUNC)
3341 if (TYPE_NFIELDS (a) != TYPE_NFIELDS (b))
3344 if (!types_equal (TYPE_TARGET_TYPE (a), TYPE_TARGET_TYPE (b)))
3347 for (i = 0; i < TYPE_NFIELDS (a); ++i)
3348 if (!types_equal (TYPE_FIELD_TYPE (a, i), TYPE_FIELD_TYPE (b, i)))
3357 /* Deep comparison of types. */
3359 /* An entry in the type-equality bcache. */
3361 typedef struct type_equality_entry
3363 struct type *type1, *type2;
3364 } type_equality_entry_d;
3366 DEF_VEC_O (type_equality_entry_d);
3368 /* A helper function to compare two strings. Returns 1 if they are
3369 the same, 0 otherwise. Handles NULLs properly. */
3372 compare_maybe_null_strings (const char *s, const char *t)
3374 if (s == NULL && t != NULL)
3376 else if (s != NULL && t == NULL)
3378 else if (s == NULL && t== NULL)
3380 return strcmp (s, t) == 0;
3383 /* A helper function for check_types_worklist that checks two types for
3384 "deep" equality. Returns non-zero if the types are considered the
3385 same, zero otherwise. */
3388 check_types_equal (struct type *type1, struct type *type2,
3389 VEC (type_equality_entry_d) **worklist)
3391 type1 = check_typedef (type1);
3392 type2 = check_typedef (type2);
3397 if (TYPE_CODE (type1) != TYPE_CODE (type2)
3398 || TYPE_LENGTH (type1) != TYPE_LENGTH (type2)
3399 || TYPE_UNSIGNED (type1) != TYPE_UNSIGNED (type2)
3400 || TYPE_NOSIGN (type1) != TYPE_NOSIGN (type2)
3401 || TYPE_VARARGS (type1) != TYPE_VARARGS (type2)
3402 || TYPE_VECTOR (type1) != TYPE_VECTOR (type2)
3403 || TYPE_NOTTEXT (type1) != TYPE_NOTTEXT (type2)
3404 || TYPE_INSTANCE_FLAGS (type1) != TYPE_INSTANCE_FLAGS (type2)
3405 || TYPE_NFIELDS (type1) != TYPE_NFIELDS (type2))
3408 if (!compare_maybe_null_strings (TYPE_TAG_NAME (type1),
3409 TYPE_TAG_NAME (type2)))
3411 if (!compare_maybe_null_strings (TYPE_NAME (type1), TYPE_NAME (type2)))
3414 if (TYPE_CODE (type1) == TYPE_CODE_RANGE)
3416 if (memcmp (TYPE_RANGE_DATA (type1), TYPE_RANGE_DATA (type2),
3417 sizeof (*TYPE_RANGE_DATA (type1))) != 0)
3424 for (i = 0; i < TYPE_NFIELDS (type1); ++i)
3426 const struct field *field1 = &TYPE_FIELD (type1, i);
3427 const struct field *field2 = &TYPE_FIELD (type2, i);
3428 struct type_equality_entry entry;
3430 if (FIELD_ARTIFICIAL (*field1) != FIELD_ARTIFICIAL (*field2)
3431 || FIELD_BITSIZE (*field1) != FIELD_BITSIZE (*field2)
3432 || FIELD_LOC_KIND (*field1) != FIELD_LOC_KIND (*field2))
3434 if (!compare_maybe_null_strings (FIELD_NAME (*field1),
3435 FIELD_NAME (*field2)))
3437 switch (FIELD_LOC_KIND (*field1))
3439 case FIELD_LOC_KIND_BITPOS:
3440 if (FIELD_BITPOS (*field1) != FIELD_BITPOS (*field2))
3443 case FIELD_LOC_KIND_ENUMVAL:
3444 if (FIELD_ENUMVAL (*field1) != FIELD_ENUMVAL (*field2))
3447 case FIELD_LOC_KIND_PHYSADDR:
3448 if (FIELD_STATIC_PHYSADDR (*field1)
3449 != FIELD_STATIC_PHYSADDR (*field2))
3452 case FIELD_LOC_KIND_PHYSNAME:
3453 if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1),
3454 FIELD_STATIC_PHYSNAME (*field2)))
3457 case FIELD_LOC_KIND_DWARF_BLOCK:
3459 struct dwarf2_locexpr_baton *block1, *block2;
3461 block1 = FIELD_DWARF_BLOCK (*field1);
3462 block2 = FIELD_DWARF_BLOCK (*field2);
3463 if (block1->per_cu != block2->per_cu
3464 || block1->size != block2->size
3465 || memcmp (block1->data, block2->data, block1->size) != 0)
3470 internal_error (__FILE__, __LINE__, _("Unsupported field kind "
3471 "%d by check_types_equal"),
3472 FIELD_LOC_KIND (*field1));
3475 entry.type1 = FIELD_TYPE (*field1);
3476 entry.type2 = FIELD_TYPE (*field2);
3477 VEC_safe_push (type_equality_entry_d, *worklist, &entry);
3481 if (TYPE_TARGET_TYPE (type1) != NULL)
3483 struct type_equality_entry entry;
3485 if (TYPE_TARGET_TYPE (type2) == NULL)
3488 entry.type1 = TYPE_TARGET_TYPE (type1);
3489 entry.type2 = TYPE_TARGET_TYPE (type2);
3490 VEC_safe_push (type_equality_entry_d, *worklist, &entry);
3492 else if (TYPE_TARGET_TYPE (type2) != NULL)
3498 /* Check types on a worklist for equality. Returns zero if any pair
3499 is not equal, non-zero if they are all considered equal. */
3502 check_types_worklist (VEC (type_equality_entry_d) **worklist,
3503 struct bcache *cache)
3505 while (!VEC_empty (type_equality_entry_d, *worklist))
3507 struct type_equality_entry entry;
3510 entry = *VEC_last (type_equality_entry_d, *worklist);
3511 VEC_pop (type_equality_entry_d, *worklist);
3513 /* If the type pair has already been visited, we know it is
3515 bcache_full (&entry, sizeof (entry), cache, &added);
3519 if (check_types_equal (entry.type1, entry.type2, worklist) == 0)
3526 /* Return non-zero if types TYPE1 and TYPE2 are equal, as determined by a
3527 "deep comparison". Otherwise return zero. */
3530 types_deeply_equal (struct type *type1, struct type *type2)
3532 struct gdb_exception except = exception_none;
3534 struct bcache *cache;
3535 VEC (type_equality_entry_d) *worklist = NULL;
3536 struct type_equality_entry entry;
3538 gdb_assert (type1 != NULL && type2 != NULL);
3540 /* Early exit for the simple case. */
3544 cache = bcache_xmalloc (NULL, NULL);
3546 entry.type1 = type1;
3547 entry.type2 = type2;
3548 VEC_safe_push (type_equality_entry_d, worklist, &entry);
3550 /* check_types_worklist calls several nested helper functions, some
3551 of which can raise a GDB exception, so we just check and rethrow
3552 here. If there is a GDB exception, a comparison is not capable
3553 (or trusted), so exit. */
3556 result = check_types_worklist (&worklist, cache);
3558 CATCH (ex, RETURN_MASK_ALL)
3564 bcache_xfree (cache);
3565 VEC_free (type_equality_entry_d, worklist);
3567 /* Rethrow if there was a problem. */
3568 if (except.reason < 0)
3569 throw_exception (except);
3574 /* Allocated status of type TYPE. Return zero if type TYPE is allocated.
3575 Otherwise return one. */
3578 type_not_allocated (const struct type *type)
3580 struct dynamic_prop *prop = TYPE_ALLOCATED_PROP (type);
3582 return (prop && TYPE_DYN_PROP_KIND (prop) == PROP_CONST
3583 && !TYPE_DYN_PROP_ADDR (prop));
3586 /* Associated status of type TYPE. Return zero if type TYPE is associated.
3587 Otherwise return one. */
3590 type_not_associated (const struct type *type)
3592 struct dynamic_prop *prop = TYPE_ASSOCIATED_PROP (type);
3594 return (prop && TYPE_DYN_PROP_KIND (prop) == PROP_CONST
3595 && !TYPE_DYN_PROP_ADDR (prop));
3598 /* Compare one type (PARM) for compatibility with another (ARG).
3599 * PARM is intended to be the parameter type of a function; and
3600 * ARG is the supplied argument's type. This function tests if
3601 * the latter can be converted to the former.
3602 * VALUE is the argument's value or NULL if none (or called recursively)
3604 * Return 0 if they are identical types;
3605 * Otherwise, return an integer which corresponds to how compatible
3606 * PARM is to ARG. The higher the return value, the worse the match.
3607 * Generally the "bad" conversions are all uniformly assigned a 100. */
3610 rank_one_type (struct type *parm, struct type *arg, struct value *value)
3612 struct rank rank = {0,0};
3614 if (types_equal (parm, arg))
3615 return EXACT_MATCH_BADNESS;
3617 /* Resolve typedefs */
3618 if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF)
3619 parm = check_typedef (parm);
3620 if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
3621 arg = check_typedef (arg);
3623 /* See through references, since we can almost make non-references
3625 if (TYPE_CODE (arg) == TYPE_CODE_REF)
3626 return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL),
3627 REFERENCE_CONVERSION_BADNESS));
3628 if (TYPE_CODE (parm) == TYPE_CODE_REF)
3629 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL),
3630 REFERENCE_CONVERSION_BADNESS));
3632 /* Debugging only. */
3633 fprintf_filtered (gdb_stderr,
3634 "------ Arg is %s [%d], parm is %s [%d]\n",
3635 TYPE_NAME (arg), TYPE_CODE (arg),
3636 TYPE_NAME (parm), TYPE_CODE (parm));
3638 /* x -> y means arg of type x being supplied for parameter of type y. */
3640 switch (TYPE_CODE (parm))
3643 switch (TYPE_CODE (arg))
3647 /* Allowed pointer conversions are:
3648 (a) pointer to void-pointer conversion. */
3649 if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID)
3650 return VOID_PTR_CONVERSION_BADNESS;
3652 /* (b) pointer to ancestor-pointer conversion. */
3653 rank.subrank = distance_to_ancestor (TYPE_TARGET_TYPE (parm),
3654 TYPE_TARGET_TYPE (arg),
3656 if (rank.subrank >= 0)
3657 return sum_ranks (BASE_PTR_CONVERSION_BADNESS, rank);
3659 return INCOMPATIBLE_TYPE_BADNESS;
3660 case TYPE_CODE_ARRAY:
3661 if (types_equal (TYPE_TARGET_TYPE (parm),
3662 TYPE_TARGET_TYPE (arg)))
3663 return EXACT_MATCH_BADNESS;
3664 return INCOMPATIBLE_TYPE_BADNESS;
3665 case TYPE_CODE_FUNC:
3666 return rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL);
3668 if (value != NULL && TYPE_CODE (value_type (value)) == TYPE_CODE_INT)
3670 if (value_as_long (value) == 0)
3672 /* Null pointer conversion: allow it to be cast to a pointer.
3673 [4.10.1 of C++ standard draft n3290] */
3674 return NULL_POINTER_CONVERSION_BADNESS;
3678 /* If type checking is disabled, allow the conversion. */
3679 if (!strict_type_checking)
3680 return NS_INTEGER_POINTER_CONVERSION_BADNESS;
3684 case TYPE_CODE_ENUM:
3685 case TYPE_CODE_FLAGS:
3686 case TYPE_CODE_CHAR:
3687 case TYPE_CODE_RANGE:
3688 case TYPE_CODE_BOOL:
3690 return INCOMPATIBLE_TYPE_BADNESS;
3692 case TYPE_CODE_ARRAY:
3693 switch (TYPE_CODE (arg))
3696 case TYPE_CODE_ARRAY:
3697 return rank_one_type (TYPE_TARGET_TYPE (parm),
3698 TYPE_TARGET_TYPE (arg), NULL);
3700 return INCOMPATIBLE_TYPE_BADNESS;
3702 case TYPE_CODE_FUNC:
3703 switch (TYPE_CODE (arg))
3705 case TYPE_CODE_PTR: /* funcptr -> func */
3706 return rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL);
3708 return INCOMPATIBLE_TYPE_BADNESS;
3711 switch (TYPE_CODE (arg))
3714 if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
3716 /* Deal with signed, unsigned, and plain chars and
3717 signed and unsigned ints. */
3718 if (TYPE_NOSIGN (parm))
3720 /* This case only for character types. */
3721 if (TYPE_NOSIGN (arg))
3722 return EXACT_MATCH_BADNESS; /* plain char -> plain char */
3723 else /* signed/unsigned char -> plain char */
3724 return INTEGER_CONVERSION_BADNESS;
3726 else if (TYPE_UNSIGNED (parm))
3728 if (TYPE_UNSIGNED (arg))
3730 /* unsigned int -> unsigned int, or
3731 unsigned long -> unsigned long */
3732 if (integer_types_same_name_p (TYPE_NAME (parm),
3734 return EXACT_MATCH_BADNESS;
3735 else if (integer_types_same_name_p (TYPE_NAME (arg),
3737 && integer_types_same_name_p (TYPE_NAME (parm),
3739 /* unsigned int -> unsigned long */
3740 return INTEGER_PROMOTION_BADNESS;
3742 /* unsigned long -> unsigned int */
3743 return INTEGER_CONVERSION_BADNESS;
3747 if (integer_types_same_name_p (TYPE_NAME (arg),
3749 && integer_types_same_name_p (TYPE_NAME (parm),
3751 /* signed long -> unsigned int */
3752 return INTEGER_CONVERSION_BADNESS;
3754 /* signed int/long -> unsigned int/long */
3755 return INTEGER_CONVERSION_BADNESS;
3758 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
3760 if (integer_types_same_name_p (TYPE_NAME (parm),
3762 return EXACT_MATCH_BADNESS;
3763 else if (integer_types_same_name_p (TYPE_NAME (arg),
3765 && integer_types_same_name_p (TYPE_NAME (parm),
3767 return INTEGER_PROMOTION_BADNESS;
3769 return INTEGER_CONVERSION_BADNESS;
3772 return INTEGER_CONVERSION_BADNESS;
3774 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
3775 return INTEGER_PROMOTION_BADNESS;
3777 return INTEGER_CONVERSION_BADNESS;
3778 case TYPE_CODE_ENUM:
3779 case TYPE_CODE_FLAGS:
3780 case TYPE_CODE_CHAR:
3781 case TYPE_CODE_RANGE:
3782 case TYPE_CODE_BOOL:
3783 if (TYPE_DECLARED_CLASS (arg))
3784 return INCOMPATIBLE_TYPE_BADNESS;
3785 return INTEGER_PROMOTION_BADNESS;
3787 return INT_FLOAT_CONVERSION_BADNESS;
3789 return NS_POINTER_CONVERSION_BADNESS;
3791 return INCOMPATIBLE_TYPE_BADNESS;
3794 case TYPE_CODE_ENUM:
3795 switch (TYPE_CODE (arg))
3798 case TYPE_CODE_CHAR:
3799 case TYPE_CODE_RANGE:
3800 case TYPE_CODE_BOOL:
3801 case TYPE_CODE_ENUM:
3802 if (TYPE_DECLARED_CLASS (parm) || TYPE_DECLARED_CLASS (arg))
3803 return INCOMPATIBLE_TYPE_BADNESS;
3804 return INTEGER_CONVERSION_BADNESS;
3806 return INT_FLOAT_CONVERSION_BADNESS;
3808 return INCOMPATIBLE_TYPE_BADNESS;
3811 case TYPE_CODE_CHAR:
3812 switch (TYPE_CODE (arg))
3814 case TYPE_CODE_RANGE:
3815 case TYPE_CODE_BOOL:
3816 case TYPE_CODE_ENUM:
3817 if (TYPE_DECLARED_CLASS (arg))
3818 return INCOMPATIBLE_TYPE_BADNESS;
3819 return INTEGER_CONVERSION_BADNESS;
3821 return INT_FLOAT_CONVERSION_BADNESS;
3823 if (TYPE_LENGTH (arg) > TYPE_LENGTH (parm))
3824 return INTEGER_CONVERSION_BADNESS;
3825 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
3826 return INTEGER_PROMOTION_BADNESS;
3827 /* >>> !! else fall through !! <<< */
3828 case TYPE_CODE_CHAR:
3829 /* Deal with signed, unsigned, and plain chars for C++ and
3830 with int cases falling through from previous case. */
3831 if (TYPE_NOSIGN (parm))
3833 if (TYPE_NOSIGN (arg))
3834 return EXACT_MATCH_BADNESS;
3836 return INTEGER_CONVERSION_BADNESS;
3838 else if (TYPE_UNSIGNED (parm))
3840 if (TYPE_UNSIGNED (arg))
3841 return EXACT_MATCH_BADNESS;
3843 return INTEGER_PROMOTION_BADNESS;
3845 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
3846 return EXACT_MATCH_BADNESS;
3848 return INTEGER_CONVERSION_BADNESS;
3850 return INCOMPATIBLE_TYPE_BADNESS;
3853 case TYPE_CODE_RANGE:
3854 switch (TYPE_CODE (arg))
3857 case TYPE_CODE_CHAR:
3858 case TYPE_CODE_RANGE:
3859 case TYPE_CODE_BOOL:
3860 case TYPE_CODE_ENUM:
3861 return INTEGER_CONVERSION_BADNESS;
3863 return INT_FLOAT_CONVERSION_BADNESS;
3865 return INCOMPATIBLE_TYPE_BADNESS;
3868 case TYPE_CODE_BOOL:
3869 switch (TYPE_CODE (arg))
3871 /* n3290 draft, section 4.12.1 (conv.bool):
3873 "A prvalue of arithmetic, unscoped enumeration, pointer, or
3874 pointer to member type can be converted to a prvalue of type
3875 bool. A zero value, null pointer value, or null member pointer
3876 value is converted to false; any other value is converted to
3877 true. A prvalue of type std::nullptr_t can be converted to a
3878 prvalue of type bool; the resulting value is false." */
3880 case TYPE_CODE_CHAR:
3881 case TYPE_CODE_ENUM:
3883 case TYPE_CODE_MEMBERPTR:
3885 return BOOL_CONVERSION_BADNESS;
3886 case TYPE_CODE_RANGE:
3887 return INCOMPATIBLE_TYPE_BADNESS;
3888 case TYPE_CODE_BOOL:
3889 return EXACT_MATCH_BADNESS;
3891 return INCOMPATIBLE_TYPE_BADNESS;
3895 switch (TYPE_CODE (arg))
3898 if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
3899 return FLOAT_PROMOTION_BADNESS;
3900 else if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
3901 return EXACT_MATCH_BADNESS;
3903 return FLOAT_CONVERSION_BADNESS;
3905 case TYPE_CODE_BOOL:
3906 case TYPE_CODE_ENUM:
3907 case TYPE_CODE_RANGE:
3908 case TYPE_CODE_CHAR:
3909 return INT_FLOAT_CONVERSION_BADNESS;
3911 return INCOMPATIBLE_TYPE_BADNESS;
3914 case TYPE_CODE_COMPLEX:
3915 switch (TYPE_CODE (arg))
3916 { /* Strictly not needed for C++, but... */
3918 return FLOAT_PROMOTION_BADNESS;
3919 case TYPE_CODE_COMPLEX:
3920 return EXACT_MATCH_BADNESS;
3922 return INCOMPATIBLE_TYPE_BADNESS;
3925 case TYPE_CODE_STRUCT:
3926 switch (TYPE_CODE (arg))
3928 case TYPE_CODE_STRUCT:
3929 /* Check for derivation */
3930 rank.subrank = distance_to_ancestor (parm, arg, 0);
3931 if (rank.subrank >= 0)
3932 return sum_ranks (BASE_CONVERSION_BADNESS, rank);
3933 /* else fall through */
3935 return INCOMPATIBLE_TYPE_BADNESS;
3938 case TYPE_CODE_UNION:
3939 switch (TYPE_CODE (arg))
3941 case TYPE_CODE_UNION:
3943 return INCOMPATIBLE_TYPE_BADNESS;
3946 case TYPE_CODE_MEMBERPTR:
3947 switch (TYPE_CODE (arg))
3950 return INCOMPATIBLE_TYPE_BADNESS;
3953 case TYPE_CODE_METHOD:
3954 switch (TYPE_CODE (arg))
3958 return INCOMPATIBLE_TYPE_BADNESS;
3962 switch (TYPE_CODE (arg))
3966 return INCOMPATIBLE_TYPE_BADNESS;
3971 switch (TYPE_CODE (arg))
3975 return rank_one_type (TYPE_FIELD_TYPE (parm, 0),
3976 TYPE_FIELD_TYPE (arg, 0), NULL);
3978 return INCOMPATIBLE_TYPE_BADNESS;
3981 case TYPE_CODE_VOID:
3983 return INCOMPATIBLE_TYPE_BADNESS;
3984 } /* switch (TYPE_CODE (arg)) */
3987 /* End of functions for overload resolution. */
3989 /* Routines to pretty-print types. */
3992 print_bit_vector (B_TYPE *bits, int nbits)
3996 for (bitno = 0; bitno < nbits; bitno++)
3998 if ((bitno % 8) == 0)
4000 puts_filtered (" ");
4002 if (B_TST (bits, bitno))
4003 printf_filtered (("1"));
4005 printf_filtered (("0"));
4009 /* Note the first arg should be the "this" pointer, we may not want to
4010 include it since we may get into a infinitely recursive
4014 print_args (struct field *args, int nargs, int spaces)
4020 for (i = 0; i < nargs; i++)
4022 printfi_filtered (spaces, "[%d] name '%s'\n", i,
4023 args[i].name != NULL ? args[i].name : "<NULL>");
4024 recursive_dump_type (args[i].type, spaces + 2);
4030 field_is_static (struct field *f)
4032 /* "static" fields are the fields whose location is not relative
4033 to the address of the enclosing struct. It would be nice to
4034 have a dedicated flag that would be set for static fields when
4035 the type is being created. But in practice, checking the field
4036 loc_kind should give us an accurate answer. */
4037 return (FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSNAME
4038 || FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSADDR);
4042 dump_fn_fieldlists (struct type *type, int spaces)
4048 printfi_filtered (spaces, "fn_fieldlists ");
4049 gdb_print_host_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
4050 printf_filtered ("\n");
4051 for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
4053 f = TYPE_FN_FIELDLIST1 (type, method_idx);
4054 printfi_filtered (spaces + 2, "[%d] name '%s' (",
4056 TYPE_FN_FIELDLIST_NAME (type, method_idx));
4057 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
4059 printf_filtered (_(") length %d\n"),
4060 TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
4061 for (overload_idx = 0;
4062 overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
4065 printfi_filtered (spaces + 4, "[%d] physname '%s' (",
4067 TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
4068 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
4070 printf_filtered (")\n");
4071 printfi_filtered (spaces + 8, "type ");
4072 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx),
4074 printf_filtered ("\n");
4076 recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
4079 printfi_filtered (spaces + 8, "args ");
4080 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx),
4082 printf_filtered ("\n");
4083 print_args (TYPE_FN_FIELD_ARGS (f, overload_idx),
4084 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, overload_idx)),
4086 printfi_filtered (spaces + 8, "fcontext ");
4087 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
4089 printf_filtered ("\n");
4091 printfi_filtered (spaces + 8, "is_const %d\n",
4092 TYPE_FN_FIELD_CONST (f, overload_idx));
4093 printfi_filtered (spaces + 8, "is_volatile %d\n",
4094 TYPE_FN_FIELD_VOLATILE (f, overload_idx));
4095 printfi_filtered (spaces + 8, "is_private %d\n",
4096 TYPE_FN_FIELD_PRIVATE (f, overload_idx));
4097 printfi_filtered (spaces + 8, "is_protected %d\n",
4098 TYPE_FN_FIELD_PROTECTED (f, overload_idx));
4099 printfi_filtered (spaces + 8, "is_stub %d\n",
4100 TYPE_FN_FIELD_STUB (f, overload_idx));
4101 printfi_filtered (spaces + 8, "voffset %u\n",
4102 TYPE_FN_FIELD_VOFFSET (f, overload_idx));
4108 print_cplus_stuff (struct type *type, int spaces)
4110 printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type));
4111 printfi_filtered (spaces, "vptr_basetype ");
4112 gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
4113 puts_filtered ("\n");
4114 if (TYPE_VPTR_BASETYPE (type) != NULL)
4115 recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
4117 printfi_filtered (spaces, "n_baseclasses %d\n",
4118 TYPE_N_BASECLASSES (type));
4119 printfi_filtered (spaces, "nfn_fields %d\n",
4120 TYPE_NFN_FIELDS (type));
4121 if (TYPE_N_BASECLASSES (type) > 0)
4123 printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
4124 TYPE_N_BASECLASSES (type));
4125 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type),
4127 printf_filtered (")");
4129 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
4130 TYPE_N_BASECLASSES (type));
4131 puts_filtered ("\n");
4133 if (TYPE_NFIELDS (type) > 0)
4135 if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
4137 printfi_filtered (spaces,
4138 "private_field_bits (%d bits at *",
4139 TYPE_NFIELDS (type));
4140 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type),
4142 printf_filtered (")");
4143 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
4144 TYPE_NFIELDS (type));
4145 puts_filtered ("\n");
4147 if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
4149 printfi_filtered (spaces,
4150 "protected_field_bits (%d bits at *",
4151 TYPE_NFIELDS (type));
4152 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type),
4154 printf_filtered (")");
4155 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
4156 TYPE_NFIELDS (type));
4157 puts_filtered ("\n");
4160 if (TYPE_NFN_FIELDS (type) > 0)
4162 dump_fn_fieldlists (type, spaces);
4166 /* Print the contents of the TYPE's type_specific union, assuming that
4167 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
4170 print_gnat_stuff (struct type *type, int spaces)
4172 struct type *descriptive_type = TYPE_DESCRIPTIVE_TYPE (type);
4174 if (descriptive_type == NULL)
4175 printfi_filtered (spaces + 2, "no descriptive type\n");
4178 printfi_filtered (spaces + 2, "descriptive type\n");
4179 recursive_dump_type (descriptive_type, spaces + 4);
4183 static struct obstack dont_print_type_obstack;
4186 recursive_dump_type (struct type *type, int spaces)
4191 obstack_begin (&dont_print_type_obstack, 0);
4193 if (TYPE_NFIELDS (type) > 0
4194 || (HAVE_CPLUS_STRUCT (type) && TYPE_NFN_FIELDS (type) > 0))
4196 struct type **first_dont_print
4197 = (struct type **) obstack_base (&dont_print_type_obstack);
4199 int i = (struct type **)
4200 obstack_next_free (&dont_print_type_obstack) - first_dont_print;
4204 if (type == first_dont_print[i])
4206 printfi_filtered (spaces, "type node ");
4207 gdb_print_host_address (type, gdb_stdout);
4208 printf_filtered (_(" <same as already seen type>\n"));
4213 obstack_ptr_grow (&dont_print_type_obstack, type);
4216 printfi_filtered (spaces, "type node ");
4217 gdb_print_host_address (type, gdb_stdout);
4218 printf_filtered ("\n");
4219 printfi_filtered (spaces, "name '%s' (",
4220 TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
4221 gdb_print_host_address (TYPE_NAME (type), gdb_stdout);
4222 printf_filtered (")\n");
4223 printfi_filtered (spaces, "tagname '%s' (",
4224 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : "<NULL>");
4225 gdb_print_host_address (TYPE_TAG_NAME (type), gdb_stdout);
4226 printf_filtered (")\n");
4227 printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
4228 switch (TYPE_CODE (type))
4230 case TYPE_CODE_UNDEF:
4231 printf_filtered ("(TYPE_CODE_UNDEF)");
4234 printf_filtered ("(TYPE_CODE_PTR)");
4236 case TYPE_CODE_ARRAY:
4237 printf_filtered ("(TYPE_CODE_ARRAY)");
4239 case TYPE_CODE_STRUCT:
4240 printf_filtered ("(TYPE_CODE_STRUCT)");
4242 case TYPE_CODE_UNION:
4243 printf_filtered ("(TYPE_CODE_UNION)");
4245 case TYPE_CODE_ENUM:
4246 printf_filtered ("(TYPE_CODE_ENUM)");
4248 case TYPE_CODE_FLAGS:
4249 printf_filtered ("(TYPE_CODE_FLAGS)");
4251 case TYPE_CODE_FUNC:
4252 printf_filtered ("(TYPE_CODE_FUNC)");
4255 printf_filtered ("(TYPE_CODE_INT)");
4258 printf_filtered ("(TYPE_CODE_FLT)");
4260 case TYPE_CODE_VOID:
4261 printf_filtered ("(TYPE_CODE_VOID)");
4264 printf_filtered ("(TYPE_CODE_SET)");
4266 case TYPE_CODE_RANGE:
4267 printf_filtered ("(TYPE_CODE_RANGE)");
4269 case TYPE_CODE_STRING:
4270 printf_filtered ("(TYPE_CODE_STRING)");
4272 case TYPE_CODE_ERROR:
4273 printf_filtered ("(TYPE_CODE_ERROR)");
4275 case TYPE_CODE_MEMBERPTR:
4276 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
4278 case TYPE_CODE_METHODPTR:
4279 printf_filtered ("(TYPE_CODE_METHODPTR)");
4281 case TYPE_CODE_METHOD:
4282 printf_filtered ("(TYPE_CODE_METHOD)");
4285 printf_filtered ("(TYPE_CODE_REF)");
4287 case TYPE_CODE_CHAR:
4288 printf_filtered ("(TYPE_CODE_CHAR)");
4290 case TYPE_CODE_BOOL:
4291 printf_filtered ("(TYPE_CODE_BOOL)");
4293 case TYPE_CODE_COMPLEX:
4294 printf_filtered ("(TYPE_CODE_COMPLEX)");
4296 case TYPE_CODE_TYPEDEF:
4297 printf_filtered ("(TYPE_CODE_TYPEDEF)");
4299 case TYPE_CODE_NAMESPACE:
4300 printf_filtered ("(TYPE_CODE_NAMESPACE)");
4303 printf_filtered ("(UNKNOWN TYPE CODE)");
4306 puts_filtered ("\n");
4307 printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
4308 if (TYPE_OBJFILE_OWNED (type))
4310 printfi_filtered (spaces, "objfile ");
4311 gdb_print_host_address (TYPE_OWNER (type).objfile, gdb_stdout);
4315 printfi_filtered (spaces, "gdbarch ");
4316 gdb_print_host_address (TYPE_OWNER (type).gdbarch, gdb_stdout);
4318 printf_filtered ("\n");
4319 printfi_filtered (spaces, "target_type ");
4320 gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout);
4321 printf_filtered ("\n");
4322 if (TYPE_TARGET_TYPE (type) != NULL)
4324 recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
4326 printfi_filtered (spaces, "pointer_type ");
4327 gdb_print_host_address (TYPE_POINTER_TYPE (type), gdb_stdout);
4328 printf_filtered ("\n");
4329 printfi_filtered (spaces, "reference_type ");
4330 gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
4331 printf_filtered ("\n");
4332 printfi_filtered (spaces, "type_chain ");
4333 gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);
4334 printf_filtered ("\n");
4335 printfi_filtered (spaces, "instance_flags 0x%x",
4336 TYPE_INSTANCE_FLAGS (type));
4337 if (TYPE_CONST (type))
4339 puts_filtered (" TYPE_CONST");
4341 if (TYPE_VOLATILE (type))
4343 puts_filtered (" TYPE_VOLATILE");
4345 if (TYPE_CODE_SPACE (type))
4347 puts_filtered (" TYPE_CODE_SPACE");
4349 if (TYPE_DATA_SPACE (type))
4351 puts_filtered (" TYPE_DATA_SPACE");
4353 if (TYPE_ADDRESS_CLASS_1 (type))
4355 puts_filtered (" TYPE_ADDRESS_CLASS_1");
4357 if (TYPE_ADDRESS_CLASS_2 (type))
4359 puts_filtered (" TYPE_ADDRESS_CLASS_2");
4361 if (TYPE_RESTRICT (type))
4363 puts_filtered (" TYPE_RESTRICT");
4365 if (TYPE_ATOMIC (type))
4367 puts_filtered (" TYPE_ATOMIC");
4369 puts_filtered ("\n");
4371 printfi_filtered (spaces, "flags");
4372 if (TYPE_UNSIGNED (type))
4374 puts_filtered (" TYPE_UNSIGNED");
4376 if (TYPE_NOSIGN (type))
4378 puts_filtered (" TYPE_NOSIGN");
4380 if (TYPE_STUB (type))
4382 puts_filtered (" TYPE_STUB");
4384 if (TYPE_TARGET_STUB (type))
4386 puts_filtered (" TYPE_TARGET_STUB");
4388 if (TYPE_STATIC (type))
4390 puts_filtered (" TYPE_STATIC");
4392 if (TYPE_PROTOTYPED (type))
4394 puts_filtered (" TYPE_PROTOTYPED");
4396 if (TYPE_INCOMPLETE (type))
4398 puts_filtered (" TYPE_INCOMPLETE");
4400 if (TYPE_VARARGS (type))
4402 puts_filtered (" TYPE_VARARGS");
4404 /* This is used for things like AltiVec registers on ppc. Gcc emits
4405 an attribute for the array type, which tells whether or not we
4406 have a vector, instead of a regular array. */
4407 if (TYPE_VECTOR (type))
4409 puts_filtered (" TYPE_VECTOR");
4411 if (TYPE_FIXED_INSTANCE (type))
4413 puts_filtered (" TYPE_FIXED_INSTANCE");
4415 if (TYPE_STUB_SUPPORTED (type))
4417 puts_filtered (" TYPE_STUB_SUPPORTED");
4419 if (TYPE_NOTTEXT (type))
4421 puts_filtered (" TYPE_NOTTEXT");
4423 puts_filtered ("\n");
4424 printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
4425 gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
4426 puts_filtered ("\n");
4427 for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
4429 if (TYPE_CODE (type) == TYPE_CODE_ENUM)
4430 printfi_filtered (spaces + 2,
4431 "[%d] enumval %s type ",
4432 idx, plongest (TYPE_FIELD_ENUMVAL (type, idx)));
4434 printfi_filtered (spaces + 2,
4435 "[%d] bitpos %s bitsize %d type ",
4436 idx, plongest (TYPE_FIELD_BITPOS (type, idx)),
4437 TYPE_FIELD_BITSIZE (type, idx));
4438 gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
4439 printf_filtered (" name '%s' (",
4440 TYPE_FIELD_NAME (type, idx) != NULL
4441 ? TYPE_FIELD_NAME (type, idx)
4443 gdb_print_host_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
4444 printf_filtered (")\n");
4445 if (TYPE_FIELD_TYPE (type, idx) != NULL)
4447 recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
4450 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
4452 printfi_filtered (spaces, "low %s%s high %s%s\n",
4453 plongest (TYPE_LOW_BOUND (type)),
4454 TYPE_LOW_BOUND_UNDEFINED (type) ? " (undefined)" : "",
4455 plongest (TYPE_HIGH_BOUND (type)),
4456 TYPE_HIGH_BOUND_UNDEFINED (type)
4457 ? " (undefined)" : "");
4460 switch (TYPE_SPECIFIC_FIELD (type))
4462 case TYPE_SPECIFIC_CPLUS_STUFF:
4463 printfi_filtered (spaces, "cplus_stuff ");
4464 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type),
4466 puts_filtered ("\n");
4467 print_cplus_stuff (type, spaces);
4470 case TYPE_SPECIFIC_GNAT_STUFF:
4471 printfi_filtered (spaces, "gnat_stuff ");
4472 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type), gdb_stdout);
4473 puts_filtered ("\n");
4474 print_gnat_stuff (type, spaces);
4477 case TYPE_SPECIFIC_FLOATFORMAT:
4478 printfi_filtered (spaces, "floatformat ");
4479 if (TYPE_FLOATFORMAT (type) == NULL)
4480 puts_filtered ("(null)");
4483 puts_filtered ("{ ");
4484 if (TYPE_FLOATFORMAT (type)[0] == NULL
4485 || TYPE_FLOATFORMAT (type)[0]->name == NULL)
4486 puts_filtered ("(null)");
4488 puts_filtered (TYPE_FLOATFORMAT (type)[0]->name);
4490 puts_filtered (", ");
4491 if (TYPE_FLOATFORMAT (type)[1] == NULL
4492 || TYPE_FLOATFORMAT (type)[1]->name == NULL)
4493 puts_filtered ("(null)");
4495 puts_filtered (TYPE_FLOATFORMAT (type)[1]->name);
4497 puts_filtered (" }");
4499 puts_filtered ("\n");
4502 case TYPE_SPECIFIC_FUNC:
4503 printfi_filtered (spaces, "calling_convention %d\n",
4504 TYPE_CALLING_CONVENTION (type));
4505 /* tail_call_list is not printed. */
4508 case TYPE_SPECIFIC_SELF_TYPE:
4509 printfi_filtered (spaces, "self_type ");
4510 gdb_print_host_address (TYPE_SELF_TYPE (type), gdb_stdout);
4511 puts_filtered ("\n");
4516 obstack_free (&dont_print_type_obstack, NULL);
4519 /* Trivial helpers for the libiberty hash table, for mapping one
4524 struct type *old, *newobj;
4528 type_pair_hash (const void *item)
4530 const struct type_pair *pair = (const struct type_pair *) item;
4532 return htab_hash_pointer (pair->old);
4536 type_pair_eq (const void *item_lhs, const void *item_rhs)
4538 const struct type_pair *lhs = (const struct type_pair *) item_lhs;
4539 const struct type_pair *rhs = (const struct type_pair *) item_rhs;
4541 return lhs->old == rhs->old;
4544 /* Allocate the hash table used by copy_type_recursive to walk
4545 types without duplicates. We use OBJFILE's obstack, because
4546 OBJFILE is about to be deleted. */
4549 create_copied_types_hash (struct objfile *objfile)
4551 return htab_create_alloc_ex (1, type_pair_hash, type_pair_eq,
4552 NULL, &objfile->objfile_obstack,
4553 hashtab_obstack_allocate,
4554 dummy_obstack_deallocate);
4557 /* Recursively copy (deep copy) a dynamic attribute list of a type. */
4559 static struct dynamic_prop_list *
4560 copy_dynamic_prop_list (struct obstack *objfile_obstack,
4561 struct dynamic_prop_list *list)
4563 struct dynamic_prop_list *copy = list;
4564 struct dynamic_prop_list **node_ptr = ©
4566 while (*node_ptr != NULL)
4568 struct dynamic_prop_list *node_copy;
4570 node_copy = ((struct dynamic_prop_list *)
4571 obstack_copy (objfile_obstack, *node_ptr,
4572 sizeof (struct dynamic_prop_list)));
4573 node_copy->prop = (*node_ptr)->prop;
4574 *node_ptr = node_copy;
4576 node_ptr = &node_copy->next;
4582 /* Recursively copy (deep copy) TYPE, if it is associated with
4583 OBJFILE. Return a new type owned by the gdbarch associated with the type, a
4584 saved type if we have already visited TYPE (using COPIED_TYPES), or TYPE if
4585 it is not associated with OBJFILE. */
4588 copy_type_recursive (struct objfile *objfile,
4590 htab_t copied_types)
4592 struct type_pair *stored, pair;
4594 struct type *new_type;
4596 if (! TYPE_OBJFILE_OWNED (type))
4599 /* This type shouldn't be pointing to any types in other objfiles;
4600 if it did, the type might disappear unexpectedly. */
4601 gdb_assert (TYPE_OBJFILE (type) == objfile);
4604 slot = htab_find_slot (copied_types, &pair, INSERT);
4606 return ((struct type_pair *) *slot)->newobj;
4608 new_type = alloc_type_arch (get_type_arch (type));
4610 /* We must add the new type to the hash table immediately, in case
4611 we encounter this type again during a recursive call below. */
4612 stored = XOBNEW (&objfile->objfile_obstack, struct type_pair);
4614 stored->newobj = new_type;
4617 /* Copy the common fields of types. For the main type, we simply
4618 copy the entire thing and then update specific fields as needed. */
4619 *TYPE_MAIN_TYPE (new_type) = *TYPE_MAIN_TYPE (type);
4620 TYPE_OBJFILE_OWNED (new_type) = 0;
4621 TYPE_OWNER (new_type).gdbarch = get_type_arch (type);
4623 if (TYPE_NAME (type))
4624 TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type));
4625 if (TYPE_TAG_NAME (type))
4626 TYPE_TAG_NAME (new_type) = xstrdup (TYPE_TAG_NAME (type));
4628 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
4629 TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
4631 /* Copy the fields. */
4632 if (TYPE_NFIELDS (type))
4636 nfields = TYPE_NFIELDS (type);
4637 TYPE_FIELDS (new_type) = XCNEWVEC (struct field, nfields);
4638 for (i = 0; i < nfields; i++)
4640 TYPE_FIELD_ARTIFICIAL (new_type, i) =
4641 TYPE_FIELD_ARTIFICIAL (type, i);
4642 TYPE_FIELD_BITSIZE (new_type, i) = TYPE_FIELD_BITSIZE (type, i);
4643 if (TYPE_FIELD_TYPE (type, i))
4644 TYPE_FIELD_TYPE (new_type, i)
4645 = copy_type_recursive (objfile, TYPE_FIELD_TYPE (type, i),
4647 if (TYPE_FIELD_NAME (type, i))
4648 TYPE_FIELD_NAME (new_type, i) =
4649 xstrdup (TYPE_FIELD_NAME (type, i));
4650 switch (TYPE_FIELD_LOC_KIND (type, i))
4652 case FIELD_LOC_KIND_BITPOS:
4653 SET_FIELD_BITPOS (TYPE_FIELD (new_type, i),
4654 TYPE_FIELD_BITPOS (type, i));
4656 case FIELD_LOC_KIND_ENUMVAL:
4657 SET_FIELD_ENUMVAL (TYPE_FIELD (new_type, i),
4658 TYPE_FIELD_ENUMVAL (type, i));
4660 case FIELD_LOC_KIND_PHYSADDR:
4661 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i),
4662 TYPE_FIELD_STATIC_PHYSADDR (type, i));
4664 case FIELD_LOC_KIND_PHYSNAME:
4665 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i),
4666 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type,
4670 internal_error (__FILE__, __LINE__,
4671 _("Unexpected type field location kind: %d"),
4672 TYPE_FIELD_LOC_KIND (type, i));
4677 /* For range types, copy the bounds information. */
4678 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
4680 TYPE_RANGE_DATA (new_type) = XNEW (struct range_bounds);
4681 *TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type);
4684 if (TYPE_DYN_PROP_LIST (type) != NULL)
4685 TYPE_DYN_PROP_LIST (new_type)
4686 = copy_dynamic_prop_list (&objfile->objfile_obstack,
4687 TYPE_DYN_PROP_LIST (type));
4690 /* Copy pointers to other types. */
4691 if (TYPE_TARGET_TYPE (type))
4692 TYPE_TARGET_TYPE (new_type) =
4693 copy_type_recursive (objfile,
4694 TYPE_TARGET_TYPE (type),
4697 /* Maybe copy the type_specific bits.
4699 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
4700 base classes and methods. There's no fundamental reason why we
4701 can't, but at the moment it is not needed. */
4703 switch (TYPE_SPECIFIC_FIELD (type))
4705 case TYPE_SPECIFIC_NONE:
4707 case TYPE_SPECIFIC_FUNC:
4708 INIT_FUNC_SPECIFIC (new_type);
4709 TYPE_CALLING_CONVENTION (new_type) = TYPE_CALLING_CONVENTION (type);
4710 TYPE_NO_RETURN (new_type) = TYPE_NO_RETURN (type);
4711 TYPE_TAIL_CALL_LIST (new_type) = NULL;
4713 case TYPE_SPECIFIC_FLOATFORMAT:
4714 TYPE_FLOATFORMAT (new_type) = TYPE_FLOATFORMAT (type);
4716 case TYPE_SPECIFIC_CPLUS_STUFF:
4717 INIT_CPLUS_SPECIFIC (new_type);
4719 case TYPE_SPECIFIC_GNAT_STUFF:
4720 INIT_GNAT_SPECIFIC (new_type);
4722 case TYPE_SPECIFIC_SELF_TYPE:
4723 set_type_self_type (new_type,
4724 copy_type_recursive (objfile, TYPE_SELF_TYPE (type),
4728 gdb_assert_not_reached ("bad type_specific_kind");
4734 /* Make a copy of the given TYPE, except that the pointer & reference
4735 types are not preserved.
4737 This function assumes that the given type has an associated objfile.
4738 This objfile is used to allocate the new type. */
4741 copy_type (const struct type *type)
4743 struct type *new_type;
4745 gdb_assert (TYPE_OBJFILE_OWNED (type));
4747 new_type = alloc_type_copy (type);
4748 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
4749 TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
4750 memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type),
4751 sizeof (struct main_type));
4752 if (TYPE_DYN_PROP_LIST (type) != NULL)
4753 TYPE_DYN_PROP_LIST (new_type)
4754 = copy_dynamic_prop_list (&TYPE_OBJFILE (type) -> objfile_obstack,
4755 TYPE_DYN_PROP_LIST (type));
4760 /* Helper functions to initialize architecture-specific types. */
4762 /* Allocate a type structure associated with GDBARCH and set its
4763 CODE, LENGTH, and NAME fields. */
4766 arch_type (struct gdbarch *gdbarch,
4767 enum type_code code, int length, const char *name)
4771 type = alloc_type_arch (gdbarch);
4772 set_type_code (type, code);
4773 TYPE_LENGTH (type) = length;
4776 TYPE_NAME (type) = gdbarch_obstack_strdup (gdbarch, name);
4781 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
4782 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
4783 the type's TYPE_UNSIGNED flag. NAME is the type name. */
4786 arch_integer_type (struct gdbarch *gdbarch,
4787 int bit, int unsigned_p, const char *name)
4791 t = arch_type (gdbarch, TYPE_CODE_INT, bit / TARGET_CHAR_BIT, name);
4793 TYPE_UNSIGNED (t) = 1;
4798 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
4799 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
4800 the type's TYPE_UNSIGNED flag. NAME is the type name. */
4803 arch_character_type (struct gdbarch *gdbarch,
4804 int bit, int unsigned_p, const char *name)
4808 t = arch_type (gdbarch, TYPE_CODE_CHAR, bit / TARGET_CHAR_BIT, name);
4810 TYPE_UNSIGNED (t) = 1;
4815 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
4816 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
4817 the type's TYPE_UNSIGNED flag. NAME is the type name. */
4820 arch_boolean_type (struct gdbarch *gdbarch,
4821 int bit, int unsigned_p, const char *name)
4825 t = arch_type (gdbarch, TYPE_CODE_BOOL, bit / TARGET_CHAR_BIT, name);
4827 TYPE_UNSIGNED (t) = 1;
4832 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
4833 BIT is the type size in bits; if BIT equals -1, the size is
4834 determined by the floatformat. NAME is the type name. Set the
4835 TYPE_FLOATFORMAT from FLOATFORMATS. */
4838 arch_float_type (struct gdbarch *gdbarch,
4839 int bit, const char *name,
4840 const struct floatformat **floatformats)
4844 bit = verify_floatformat (bit, floatformats);
4845 t = arch_type (gdbarch, TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, name);
4846 TYPE_FLOATFORMAT (t) = floatformats;
4851 /* Allocate a TYPE_CODE_DECFLOAT type structure associated with GDBARCH.
4852 BIT is the type size in bits. NAME is the type name. */
4855 arch_decfloat_type (struct gdbarch *gdbarch, int bit, const char *name)
4859 t = arch_type (gdbarch, TYPE_CODE_DECFLOAT, bit / TARGET_CHAR_BIT, name);
4863 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
4864 NAME is the type name. TARGET_TYPE is the component float type. */
4867 arch_complex_type (struct gdbarch *gdbarch,
4868 const char *name, struct type *target_type)
4872 t = arch_type (gdbarch, TYPE_CODE_COMPLEX,
4873 2 * TYPE_LENGTH (target_type), name);
4874 TYPE_TARGET_TYPE (t) = target_type;
4878 /* Allocate a TYPE_CODE_PTR type structure associated with GDBARCH.
4879 BIT is the pointer type size in bits. NAME is the type name.
4880 TARGET_TYPE is the pointer target type. Always sets the pointer type's
4881 TYPE_UNSIGNED flag. */
4884 arch_pointer_type (struct gdbarch *gdbarch,
4885 int bit, const char *name, struct type *target_type)
4889 t = arch_type (gdbarch, TYPE_CODE_PTR, bit / TARGET_CHAR_BIT, name);
4890 TYPE_TARGET_TYPE (t) = target_type;
4891 TYPE_UNSIGNED (t) = 1;
4895 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
4896 NAME is the type name. LENGTH is the size of the flag word in bytes. */
4899 arch_flags_type (struct gdbarch *gdbarch, const char *name, int length)
4901 int max_nfields = length * TARGET_CHAR_BIT;
4904 type = arch_type (gdbarch, TYPE_CODE_FLAGS, length, name);
4905 TYPE_UNSIGNED (type) = 1;
4906 TYPE_NFIELDS (type) = 0;
4907 /* Pre-allocate enough space assuming every field is one bit. */
4909 = (struct field *) TYPE_ZALLOC (type, max_nfields * sizeof (struct field));
4914 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
4915 position BITPOS is called NAME. Pass NAME as "" for fields that
4916 should not be printed. */
4919 append_flags_type_field (struct type *type, int start_bitpos, int nr_bits,
4920 struct type *field_type, const char *name)
4922 int type_bitsize = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
4923 int field_nr = TYPE_NFIELDS (type);
4925 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS);
4926 gdb_assert (TYPE_NFIELDS (type) + 1 <= type_bitsize);
4927 gdb_assert (start_bitpos >= 0 && start_bitpos < type_bitsize);
4928 gdb_assert (nr_bits >= 1 && nr_bits <= type_bitsize);
4929 gdb_assert (name != NULL);
4931 TYPE_FIELD_NAME (type, field_nr) = xstrdup (name);
4932 TYPE_FIELD_TYPE (type, field_nr) = field_type;
4933 SET_FIELD_BITPOS (TYPE_FIELD (type, field_nr), start_bitpos);
4934 TYPE_FIELD_BITSIZE (type, field_nr) = nr_bits;
4935 ++TYPE_NFIELDS (type);
4938 /* Special version of append_flags_type_field to add a flag field.
4939 Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
4940 position BITPOS is called NAME. */
4943 append_flags_type_flag (struct type *type, int bitpos, const char *name)
4945 struct gdbarch *gdbarch = get_type_arch (type);
4947 append_flags_type_field (type, bitpos, 1,
4948 builtin_type (gdbarch)->builtin_bool,
4952 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
4953 specified by CODE) associated with GDBARCH. NAME is the type name. */
4956 arch_composite_type (struct gdbarch *gdbarch, const char *name,
4957 enum type_code code)
4961 gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION);
4962 t = arch_type (gdbarch, code, 0, NULL);
4963 TYPE_TAG_NAME (t) = name;
4964 INIT_CPLUS_SPECIFIC (t);
4968 /* Add new field with name NAME and type FIELD to composite type T.
4969 Do not set the field's position or adjust the type's length;
4970 the caller should do so. Return the new field. */
4973 append_composite_type_field_raw (struct type *t, const char *name,
4978 TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
4979 TYPE_FIELDS (t) = XRESIZEVEC (struct field, TYPE_FIELDS (t),
4981 f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
4982 memset (f, 0, sizeof f[0]);
4983 FIELD_TYPE (f[0]) = field;
4984 FIELD_NAME (f[0]) = name;
4988 /* Add new field with name NAME and type FIELD to composite type T.
4989 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
4992 append_composite_type_field_aligned (struct type *t, const char *name,
4993 struct type *field, int alignment)
4995 struct field *f = append_composite_type_field_raw (t, name, field);
4997 if (TYPE_CODE (t) == TYPE_CODE_UNION)
4999 if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
5000 TYPE_LENGTH (t) = TYPE_LENGTH (field);
5002 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
5004 TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
5005 if (TYPE_NFIELDS (t) > 1)
5007 SET_FIELD_BITPOS (f[0],
5008 (FIELD_BITPOS (f[-1])
5009 + (TYPE_LENGTH (FIELD_TYPE (f[-1]))
5010 * TARGET_CHAR_BIT)));
5016 alignment *= TARGET_CHAR_BIT;
5017 left = FIELD_BITPOS (f[0]) % alignment;
5021 SET_FIELD_BITPOS (f[0], FIELD_BITPOS (f[0]) + (alignment - left));
5022 TYPE_LENGTH (t) += (alignment - left) / TARGET_CHAR_BIT;
5029 /* Add new field with name NAME and type FIELD to composite type T. */
5032 append_composite_type_field (struct type *t, const char *name,
5035 append_composite_type_field_aligned (t, name, field, 0);
5038 static struct gdbarch_data *gdbtypes_data;
5040 const struct builtin_type *
5041 builtin_type (struct gdbarch *gdbarch)
5043 return (const struct builtin_type *) gdbarch_data (gdbarch, gdbtypes_data);
5047 gdbtypes_post_init (struct gdbarch *gdbarch)
5049 struct builtin_type *builtin_type
5050 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type);
5053 builtin_type->builtin_void
5054 = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
5055 builtin_type->builtin_char
5056 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
5057 !gdbarch_char_signed (gdbarch), "char");
5058 TYPE_NOSIGN (builtin_type->builtin_char) = 1;
5059 builtin_type->builtin_signed_char
5060 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
5062 builtin_type->builtin_unsigned_char
5063 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
5064 1, "unsigned char");
5065 builtin_type->builtin_short
5066 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
5068 builtin_type->builtin_unsigned_short
5069 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
5070 1, "unsigned short");
5071 builtin_type->builtin_int
5072 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
5074 builtin_type->builtin_unsigned_int
5075 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
5077 builtin_type->builtin_long
5078 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
5080 builtin_type->builtin_unsigned_long
5081 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
5082 1, "unsigned long");
5083 builtin_type->builtin_long_long
5084 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
5086 builtin_type->builtin_unsigned_long_long
5087 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
5088 1, "unsigned long long");
5089 builtin_type->builtin_float
5090 = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
5091 "float", gdbarch_float_format (gdbarch));
5092 builtin_type->builtin_double
5093 = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
5094 "double", gdbarch_double_format (gdbarch));
5095 builtin_type->builtin_long_double
5096 = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
5097 "long double", gdbarch_long_double_format (gdbarch));
5098 builtin_type->builtin_complex
5099 = arch_complex_type (gdbarch, "complex",
5100 builtin_type->builtin_float);
5101 builtin_type->builtin_double_complex
5102 = arch_complex_type (gdbarch, "double complex",
5103 builtin_type->builtin_double);
5104 builtin_type->builtin_string
5105 = arch_type (gdbarch, TYPE_CODE_STRING, 1, "string");
5106 builtin_type->builtin_bool
5107 = arch_type (gdbarch, TYPE_CODE_BOOL, 1, "bool");
5109 /* The following three are about decimal floating point types, which
5110 are 32-bits, 64-bits and 128-bits respectively. */
5111 builtin_type->builtin_decfloat
5112 = arch_decfloat_type (gdbarch, 32, "_Decimal32");
5113 builtin_type->builtin_decdouble
5114 = arch_decfloat_type (gdbarch, 64, "_Decimal64");
5115 builtin_type->builtin_declong
5116 = arch_decfloat_type (gdbarch, 128, "_Decimal128");
5118 /* "True" character types. */
5119 builtin_type->builtin_true_char
5120 = arch_character_type (gdbarch, TARGET_CHAR_BIT, 0, "true character");
5121 builtin_type->builtin_true_unsigned_char
5122 = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "true character");
5124 /* Fixed-size integer types. */
5125 builtin_type->builtin_int0
5126 = arch_integer_type (gdbarch, 0, 0, "int0_t");
5127 builtin_type->builtin_int8
5128 = arch_integer_type (gdbarch, 8, 0, "int8_t");
5129 builtin_type->builtin_uint8
5130 = arch_integer_type (gdbarch, 8, 1, "uint8_t");
5131 builtin_type->builtin_int16
5132 = arch_integer_type (gdbarch, 16, 0, "int16_t");
5133 builtin_type->builtin_uint16
5134 = arch_integer_type (gdbarch, 16, 1, "uint16_t");
5135 builtin_type->builtin_int32
5136 = arch_integer_type (gdbarch, 32, 0, "int32_t");
5137 builtin_type->builtin_uint32
5138 = arch_integer_type (gdbarch, 32, 1, "uint32_t");
5139 builtin_type->builtin_int64
5140 = arch_integer_type (gdbarch, 64, 0, "int64_t");
5141 builtin_type->builtin_uint64
5142 = arch_integer_type (gdbarch, 64, 1, "uint64_t");
5143 builtin_type->builtin_int128
5144 = arch_integer_type (gdbarch, 128, 0, "int128_t");
5145 builtin_type->builtin_uint128
5146 = arch_integer_type (gdbarch, 128, 1, "uint128_t");
5147 TYPE_INSTANCE_FLAGS (builtin_type->builtin_int8) |=
5148 TYPE_INSTANCE_FLAG_NOTTEXT;
5149 TYPE_INSTANCE_FLAGS (builtin_type->builtin_uint8) |=
5150 TYPE_INSTANCE_FLAG_NOTTEXT;
5152 /* Wide character types. */
5153 builtin_type->builtin_char16
5154 = arch_integer_type (gdbarch, 16, 0, "char16_t");
5155 builtin_type->builtin_char32
5156 = arch_integer_type (gdbarch, 32, 0, "char32_t");
5159 /* Default data/code pointer types. */
5160 builtin_type->builtin_data_ptr
5161 = lookup_pointer_type (builtin_type->builtin_void);
5162 builtin_type->builtin_func_ptr
5163 = lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
5164 builtin_type->builtin_func_func
5165 = lookup_function_type (builtin_type->builtin_func_ptr);
5167 /* This type represents a GDB internal function. */
5168 builtin_type->internal_fn
5169 = arch_type (gdbarch, TYPE_CODE_INTERNAL_FUNCTION, 0,
5170 "<internal function>");
5172 /* This type represents an xmethod. */
5173 builtin_type->xmethod
5174 = arch_type (gdbarch, TYPE_CODE_XMETHOD, 0, "<xmethod>");
5176 return builtin_type;
5179 /* This set of objfile-based types is intended to be used by symbol
5180 readers as basic types. */
5182 static const struct objfile_data *objfile_type_data;
5184 const struct objfile_type *
5185 objfile_type (struct objfile *objfile)
5187 struct gdbarch *gdbarch;
5188 struct objfile_type *objfile_type
5189 = (struct objfile_type *) objfile_data (objfile, objfile_type_data);
5192 return objfile_type;
5194 objfile_type = OBSTACK_CALLOC (&objfile->objfile_obstack,
5195 1, struct objfile_type);
5197 /* Use the objfile architecture to determine basic type properties. */
5198 gdbarch = get_objfile_arch (objfile);
5201 objfile_type->builtin_void
5202 = init_type (objfile, TYPE_CODE_VOID, 1, "void");
5203 objfile_type->builtin_char
5204 = init_integer_type (objfile, TARGET_CHAR_BIT,
5205 !gdbarch_char_signed (gdbarch), "char");
5206 TYPE_NOSIGN (objfile_type->builtin_char) = 1;
5207 objfile_type->builtin_signed_char
5208 = init_integer_type (objfile, TARGET_CHAR_BIT,
5210 objfile_type->builtin_unsigned_char
5211 = init_integer_type (objfile, TARGET_CHAR_BIT,
5212 1, "unsigned char");
5213 objfile_type->builtin_short
5214 = init_integer_type (objfile, gdbarch_short_bit (gdbarch),
5216 objfile_type->builtin_unsigned_short
5217 = init_integer_type (objfile, gdbarch_short_bit (gdbarch),
5218 1, "unsigned short");
5219 objfile_type->builtin_int
5220 = init_integer_type (objfile, gdbarch_int_bit (gdbarch),
5222 objfile_type->builtin_unsigned_int
5223 = init_integer_type (objfile, gdbarch_int_bit (gdbarch),
5225 objfile_type->builtin_long
5226 = init_integer_type (objfile, gdbarch_long_bit (gdbarch),
5228 objfile_type->builtin_unsigned_long
5229 = init_integer_type (objfile, gdbarch_long_bit (gdbarch),
5230 1, "unsigned long");
5231 objfile_type->builtin_long_long
5232 = init_integer_type (objfile, gdbarch_long_long_bit (gdbarch),
5234 objfile_type->builtin_unsigned_long_long
5235 = init_integer_type (objfile, gdbarch_long_long_bit (gdbarch),
5236 1, "unsigned long long");
5237 objfile_type->builtin_float
5238 = init_float_type (objfile, gdbarch_float_bit (gdbarch),
5239 "float", gdbarch_float_format (gdbarch));
5240 objfile_type->builtin_double
5241 = init_float_type (objfile, gdbarch_double_bit (gdbarch),
5242 "double", gdbarch_double_format (gdbarch));
5243 objfile_type->builtin_long_double
5244 = init_float_type (objfile, gdbarch_long_double_bit (gdbarch),
5245 "long double", gdbarch_long_double_format (gdbarch));
5247 /* This type represents a type that was unrecognized in symbol read-in. */
5248 objfile_type->builtin_error
5249 = init_type (objfile, TYPE_CODE_ERROR, 0, "<unknown type>");
5251 /* The following set of types is used for symbols with no
5252 debug information. */
5253 objfile_type->nodebug_text_symbol
5254 = init_type (objfile, TYPE_CODE_FUNC, 1,
5255 "<text variable, no debug info>");
5256 TYPE_TARGET_TYPE (objfile_type->nodebug_text_symbol)
5257 = objfile_type->builtin_int;
5258 objfile_type->nodebug_text_gnu_ifunc_symbol
5259 = init_type (objfile, TYPE_CODE_FUNC, 1,
5260 "<text gnu-indirect-function variable, no debug info>");
5261 TYPE_TARGET_TYPE (objfile_type->nodebug_text_gnu_ifunc_symbol)
5262 = objfile_type->nodebug_text_symbol;
5263 TYPE_GNU_IFUNC (objfile_type->nodebug_text_gnu_ifunc_symbol) = 1;
5264 objfile_type->nodebug_got_plt_symbol
5265 = init_pointer_type (objfile, gdbarch_addr_bit (gdbarch),
5266 "<text from jump slot in .got.plt, no debug info>",
5267 objfile_type->nodebug_text_symbol);
5268 objfile_type->nodebug_data_symbol
5269 = init_integer_type (objfile, gdbarch_int_bit (gdbarch), 0,
5270 "<data variable, no debug info>");
5271 objfile_type->nodebug_unknown_symbol
5272 = init_integer_type (objfile, TARGET_CHAR_BIT, 0,
5273 "<variable (not text or data), no debug info>");
5274 objfile_type->nodebug_tls_symbol
5275 = init_integer_type (objfile, gdbarch_int_bit (gdbarch), 0,
5276 "<thread local variable, no debug info>");
5278 /* NOTE: on some targets, addresses and pointers are not necessarily
5282 - gdb's `struct type' always describes the target's
5284 - gdb's `struct value' objects should always hold values in
5286 - gdb's CORE_ADDR values are addresses in the unified virtual
5287 address space that the assembler and linker work with. Thus,
5288 since target_read_memory takes a CORE_ADDR as an argument, it
5289 can access any memory on the target, even if the processor has
5290 separate code and data address spaces.
5292 In this context, objfile_type->builtin_core_addr is a bit odd:
5293 it's a target type for a value the target will never see. It's
5294 only used to hold the values of (typeless) linker symbols, which
5295 are indeed in the unified virtual address space. */
5297 objfile_type->builtin_core_addr
5298 = init_integer_type (objfile, gdbarch_addr_bit (gdbarch), 1,
5301 set_objfile_data (objfile, objfile_type_data, objfile_type);
5302 return objfile_type;
5305 extern initialize_file_ftype _initialize_gdbtypes;
5308 _initialize_gdbtypes (void)
5310 gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
5311 objfile_type_data = register_objfile_data ();
5313 add_setshow_zuinteger_cmd ("overload", no_class, &overload_debug,
5314 _("Set debugging of C++ overloading."),
5315 _("Show debugging of C++ overloading."),
5316 _("When enabled, ranking of the "
5317 "functions is displayed."),
5319 show_overload_debug,
5320 &setdebuglist, &showdebuglist);
5322 /* Add user knob for controlling resolution of opaque types. */
5323 add_setshow_boolean_cmd ("opaque-type-resolution", class_support,
5324 &opaque_type_resolution,
5325 _("Set resolution of opaque struct/class/union"
5326 " types (if set before loading symbols)."),
5327 _("Show resolution of opaque struct/class/union"
5328 " types (if set before loading symbols)."),
5330 show_opaque_type_resolution,
5331 &setlist, &showlist);
5333 /* Add an option to permit non-strict type checking. */
5334 add_setshow_boolean_cmd ("type", class_support,
5335 &strict_type_checking,
5336 _("Set strict type checking."),
5337 _("Show strict type checking."),
5339 show_strict_type_checking,
5340 &setchecklist, &showchecklist);