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
3626 if (TYPE_IS_REFERENCE (arg
))
3627 return (sum_ranks (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
),
3628 REFERENCE_CONVERSION_BADNESS
));
3629 if (TYPE_IS_REFERENCE (parm
))
3630 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
),
3631 REFERENCE_CONVERSION_BADNESS
));
3633 /* Debugging only. */
3634 fprintf_filtered (gdb_stderr
,
3635 "------ Arg is %s [%d], parm is %s [%d]\n",
3636 TYPE_NAME (arg
), TYPE_CODE (arg
),
3637 TYPE_NAME (parm
), TYPE_CODE (parm
));
3639 /* x -> y means arg of type x being supplied for parameter of type y. */
3641 switch (TYPE_CODE (parm
))
3644 switch (TYPE_CODE (arg
))
3648 /* Allowed pointer conversions are:
3649 (a) pointer to void-pointer conversion. */
3650 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
3651 return VOID_PTR_CONVERSION_BADNESS
;
3653 /* (b) pointer to ancestor-pointer conversion. */
3654 rank
.subrank
= distance_to_ancestor (TYPE_TARGET_TYPE (parm
),
3655 TYPE_TARGET_TYPE (arg
),
3657 if (rank
.subrank
>= 0)
3658 return sum_ranks (BASE_PTR_CONVERSION_BADNESS
, rank
);
3660 return INCOMPATIBLE_TYPE_BADNESS
;
3661 case TYPE_CODE_ARRAY
:
3662 if (types_equal (TYPE_TARGET_TYPE (parm
),
3663 TYPE_TARGET_TYPE (arg
)))
3664 return EXACT_MATCH_BADNESS
;
3665 return INCOMPATIBLE_TYPE_BADNESS
;
3666 case TYPE_CODE_FUNC
:
3667 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
);
3669 if (value
!= NULL
&& TYPE_CODE (value_type (value
)) == TYPE_CODE_INT
)
3671 if (value_as_long (value
) == 0)
3673 /* Null pointer conversion: allow it to be cast to a pointer.
3674 [4.10.1 of C++ standard draft n3290] */
3675 return NULL_POINTER_CONVERSION_BADNESS
;
3679 /* If type checking is disabled, allow the conversion. */
3680 if (!strict_type_checking
)
3681 return NS_INTEGER_POINTER_CONVERSION_BADNESS
;
3685 case TYPE_CODE_ENUM
:
3686 case TYPE_CODE_FLAGS
:
3687 case TYPE_CODE_CHAR
:
3688 case TYPE_CODE_RANGE
:
3689 case TYPE_CODE_BOOL
:
3691 return INCOMPATIBLE_TYPE_BADNESS
;
3693 case TYPE_CODE_ARRAY
:
3694 switch (TYPE_CODE (arg
))
3697 case TYPE_CODE_ARRAY
:
3698 return rank_one_type (TYPE_TARGET_TYPE (parm
),
3699 TYPE_TARGET_TYPE (arg
), NULL
);
3701 return INCOMPATIBLE_TYPE_BADNESS
;
3703 case TYPE_CODE_FUNC
:
3704 switch (TYPE_CODE (arg
))
3706 case TYPE_CODE_PTR
: /* funcptr -> func */
3707 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
);
3709 return INCOMPATIBLE_TYPE_BADNESS
;
3712 switch (TYPE_CODE (arg
))
3715 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
3717 /* Deal with signed, unsigned, and plain chars and
3718 signed and unsigned ints. */
3719 if (TYPE_NOSIGN (parm
))
3721 /* This case only for character types. */
3722 if (TYPE_NOSIGN (arg
))
3723 return EXACT_MATCH_BADNESS
; /* plain char -> plain char */
3724 else /* signed/unsigned char -> plain char */
3725 return INTEGER_CONVERSION_BADNESS
;
3727 else if (TYPE_UNSIGNED (parm
))
3729 if (TYPE_UNSIGNED (arg
))
3731 /* unsigned int -> unsigned int, or
3732 unsigned long -> unsigned long */
3733 if (integer_types_same_name_p (TYPE_NAME (parm
),
3735 return EXACT_MATCH_BADNESS
;
3736 else if (integer_types_same_name_p (TYPE_NAME (arg
),
3738 && integer_types_same_name_p (TYPE_NAME (parm
),
3740 /* unsigned int -> unsigned long */
3741 return INTEGER_PROMOTION_BADNESS
;
3743 /* unsigned long -> unsigned int */
3744 return INTEGER_CONVERSION_BADNESS
;
3748 if (integer_types_same_name_p (TYPE_NAME (arg
),
3750 && integer_types_same_name_p (TYPE_NAME (parm
),
3752 /* signed long -> unsigned int */
3753 return INTEGER_CONVERSION_BADNESS
;
3755 /* signed int/long -> unsigned int/long */
3756 return INTEGER_CONVERSION_BADNESS
;
3759 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
3761 if (integer_types_same_name_p (TYPE_NAME (parm
),
3763 return EXACT_MATCH_BADNESS
;
3764 else if (integer_types_same_name_p (TYPE_NAME (arg
),
3766 && integer_types_same_name_p (TYPE_NAME (parm
),
3768 return INTEGER_PROMOTION_BADNESS
;
3770 return INTEGER_CONVERSION_BADNESS
;
3773 return INTEGER_CONVERSION_BADNESS
;
3775 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
3776 return INTEGER_PROMOTION_BADNESS
;
3778 return INTEGER_CONVERSION_BADNESS
;
3779 case TYPE_CODE_ENUM
:
3780 case TYPE_CODE_FLAGS
:
3781 case TYPE_CODE_CHAR
:
3782 case TYPE_CODE_RANGE
:
3783 case TYPE_CODE_BOOL
:
3784 if (TYPE_DECLARED_CLASS (arg
))
3785 return INCOMPATIBLE_TYPE_BADNESS
;
3786 return INTEGER_PROMOTION_BADNESS
;
3788 return INT_FLOAT_CONVERSION_BADNESS
;
3790 return NS_POINTER_CONVERSION_BADNESS
;
3792 return INCOMPATIBLE_TYPE_BADNESS
;
3795 case TYPE_CODE_ENUM
:
3796 switch (TYPE_CODE (arg
))
3799 case TYPE_CODE_CHAR
:
3800 case TYPE_CODE_RANGE
:
3801 case TYPE_CODE_BOOL
:
3802 case TYPE_CODE_ENUM
:
3803 if (TYPE_DECLARED_CLASS (parm
) || TYPE_DECLARED_CLASS (arg
))
3804 return INCOMPATIBLE_TYPE_BADNESS
;
3805 return INTEGER_CONVERSION_BADNESS
;
3807 return INT_FLOAT_CONVERSION_BADNESS
;
3809 return INCOMPATIBLE_TYPE_BADNESS
;
3812 case TYPE_CODE_CHAR
:
3813 switch (TYPE_CODE (arg
))
3815 case TYPE_CODE_RANGE
:
3816 case TYPE_CODE_BOOL
:
3817 case TYPE_CODE_ENUM
:
3818 if (TYPE_DECLARED_CLASS (arg
))
3819 return INCOMPATIBLE_TYPE_BADNESS
;
3820 return INTEGER_CONVERSION_BADNESS
;
3822 return INT_FLOAT_CONVERSION_BADNESS
;
3824 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
3825 return INTEGER_CONVERSION_BADNESS
;
3826 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
3827 return INTEGER_PROMOTION_BADNESS
;
3828 /* >>> !! else fall through !! <<< */
3829 case TYPE_CODE_CHAR
:
3830 /* Deal with signed, unsigned, and plain chars for C++ and
3831 with int cases falling through from previous case. */
3832 if (TYPE_NOSIGN (parm
))
3834 if (TYPE_NOSIGN (arg
))
3835 return EXACT_MATCH_BADNESS
;
3837 return INTEGER_CONVERSION_BADNESS
;
3839 else if (TYPE_UNSIGNED (parm
))
3841 if (TYPE_UNSIGNED (arg
))
3842 return EXACT_MATCH_BADNESS
;
3844 return INTEGER_PROMOTION_BADNESS
;
3846 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
3847 return EXACT_MATCH_BADNESS
;
3849 return INTEGER_CONVERSION_BADNESS
;
3851 return INCOMPATIBLE_TYPE_BADNESS
;
3854 case TYPE_CODE_RANGE
:
3855 switch (TYPE_CODE (arg
))
3858 case TYPE_CODE_CHAR
:
3859 case TYPE_CODE_RANGE
:
3860 case TYPE_CODE_BOOL
:
3861 case TYPE_CODE_ENUM
:
3862 return INTEGER_CONVERSION_BADNESS
;
3864 return INT_FLOAT_CONVERSION_BADNESS
;
3866 return INCOMPATIBLE_TYPE_BADNESS
;
3869 case TYPE_CODE_BOOL
:
3870 switch (TYPE_CODE (arg
))
3872 /* n3290 draft, section 4.12.1 (conv.bool):
3874 "A prvalue of arithmetic, unscoped enumeration, pointer, or
3875 pointer to member type can be converted to a prvalue of type
3876 bool. A zero value, null pointer value, or null member pointer
3877 value is converted to false; any other value is converted to
3878 true. A prvalue of type std::nullptr_t can be converted to a
3879 prvalue of type bool; the resulting value is false." */
3881 case TYPE_CODE_CHAR
:
3882 case TYPE_CODE_ENUM
:
3884 case TYPE_CODE_MEMBERPTR
:
3886 return BOOL_CONVERSION_BADNESS
;
3887 case TYPE_CODE_RANGE
:
3888 return INCOMPATIBLE_TYPE_BADNESS
;
3889 case TYPE_CODE_BOOL
:
3890 return EXACT_MATCH_BADNESS
;
3892 return INCOMPATIBLE_TYPE_BADNESS
;
3896 switch (TYPE_CODE (arg
))
3899 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
3900 return FLOAT_PROMOTION_BADNESS
;
3901 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
3902 return EXACT_MATCH_BADNESS
;
3904 return FLOAT_CONVERSION_BADNESS
;
3906 case TYPE_CODE_BOOL
:
3907 case TYPE_CODE_ENUM
:
3908 case TYPE_CODE_RANGE
:
3909 case TYPE_CODE_CHAR
:
3910 return INT_FLOAT_CONVERSION_BADNESS
;
3912 return INCOMPATIBLE_TYPE_BADNESS
;
3915 case TYPE_CODE_COMPLEX
:
3916 switch (TYPE_CODE (arg
))
3917 { /* Strictly not needed for C++, but... */
3919 return FLOAT_PROMOTION_BADNESS
;
3920 case TYPE_CODE_COMPLEX
:
3921 return EXACT_MATCH_BADNESS
;
3923 return INCOMPATIBLE_TYPE_BADNESS
;
3926 case TYPE_CODE_STRUCT
:
3927 switch (TYPE_CODE (arg
))
3929 case TYPE_CODE_STRUCT
:
3930 /* Check for derivation */
3931 rank
.subrank
= distance_to_ancestor (parm
, arg
, 0);
3932 if (rank
.subrank
>= 0)
3933 return sum_ranks (BASE_CONVERSION_BADNESS
, rank
);
3934 /* else fall through */
3936 return INCOMPATIBLE_TYPE_BADNESS
;
3939 case TYPE_CODE_UNION
:
3940 switch (TYPE_CODE (arg
))
3942 case TYPE_CODE_UNION
:
3944 return INCOMPATIBLE_TYPE_BADNESS
;
3947 case TYPE_CODE_MEMBERPTR
:
3948 switch (TYPE_CODE (arg
))
3951 return INCOMPATIBLE_TYPE_BADNESS
;
3954 case TYPE_CODE_METHOD
:
3955 switch (TYPE_CODE (arg
))
3959 return INCOMPATIBLE_TYPE_BADNESS
;
3963 switch (TYPE_CODE (arg
))
3967 return INCOMPATIBLE_TYPE_BADNESS
;
3972 switch (TYPE_CODE (arg
))
3976 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0),
3977 TYPE_FIELD_TYPE (arg
, 0), NULL
);
3979 return INCOMPATIBLE_TYPE_BADNESS
;
3982 case TYPE_CODE_VOID
:
3984 return INCOMPATIBLE_TYPE_BADNESS
;
3985 } /* switch (TYPE_CODE (arg)) */
3988 /* End of functions for overload resolution. */
3990 /* Routines to pretty-print types. */
3993 print_bit_vector (B_TYPE
*bits
, int nbits
)
3997 for (bitno
= 0; bitno
< nbits
; bitno
++)
3999 if ((bitno
% 8) == 0)
4001 puts_filtered (" ");
4003 if (B_TST (bits
, bitno
))
4004 printf_filtered (("1"));
4006 printf_filtered (("0"));
4010 /* Note the first arg should be the "this" pointer, we may not want to
4011 include it since we may get into a infinitely recursive
4015 print_args (struct field
*args
, int nargs
, int spaces
)
4021 for (i
= 0; i
< nargs
; i
++)
4023 printfi_filtered (spaces
, "[%d] name '%s'\n", i
,
4024 args
[i
].name
!= NULL
? args
[i
].name
: "<NULL>");
4025 recursive_dump_type (args
[i
].type
, spaces
+ 2);
4031 field_is_static (struct field
*f
)
4033 /* "static" fields are the fields whose location is not relative
4034 to the address of the enclosing struct. It would be nice to
4035 have a dedicated flag that would be set for static fields when
4036 the type is being created. But in practice, checking the field
4037 loc_kind should give us an accurate answer. */
4038 return (FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSNAME
4039 || FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSADDR
);
4043 dump_fn_fieldlists (struct type
*type
, int spaces
)
4049 printfi_filtered (spaces
, "fn_fieldlists ");
4050 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
4051 printf_filtered ("\n");
4052 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
4054 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
4055 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
4057 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
4058 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
4060 printf_filtered (_(") length %d\n"),
4061 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
4062 for (overload_idx
= 0;
4063 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
4066 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
4068 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
4069 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
4071 printf_filtered (")\n");
4072 printfi_filtered (spaces
+ 8, "type ");
4073 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
4075 printf_filtered ("\n");
4077 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
4080 printfi_filtered (spaces
+ 8, "args ");
4081 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
4083 printf_filtered ("\n");
4084 print_args (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
4085 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
, overload_idx
)),
4087 printfi_filtered (spaces
+ 8, "fcontext ");
4088 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
4090 printf_filtered ("\n");
4092 printfi_filtered (spaces
+ 8, "is_const %d\n",
4093 TYPE_FN_FIELD_CONST (f
, overload_idx
));
4094 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
4095 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
4096 printfi_filtered (spaces
+ 8, "is_private %d\n",
4097 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
4098 printfi_filtered (spaces
+ 8, "is_protected %d\n",
4099 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
4100 printfi_filtered (spaces
+ 8, "is_stub %d\n",
4101 TYPE_FN_FIELD_STUB (f
, overload_idx
));
4102 printfi_filtered (spaces
+ 8, "voffset %u\n",
4103 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
4109 print_cplus_stuff (struct type
*type
, int spaces
)
4111 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
4112 printfi_filtered (spaces
, "vptr_basetype ");
4113 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
4114 puts_filtered ("\n");
4115 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
4116 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
4118 printfi_filtered (spaces
, "n_baseclasses %d\n",
4119 TYPE_N_BASECLASSES (type
));
4120 printfi_filtered (spaces
, "nfn_fields %d\n",
4121 TYPE_NFN_FIELDS (type
));
4122 if (TYPE_N_BASECLASSES (type
) > 0)
4124 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
4125 TYPE_N_BASECLASSES (type
));
4126 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
4128 printf_filtered (")");
4130 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
4131 TYPE_N_BASECLASSES (type
));
4132 puts_filtered ("\n");
4134 if (TYPE_NFIELDS (type
) > 0)
4136 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
4138 printfi_filtered (spaces
,
4139 "private_field_bits (%d bits at *",
4140 TYPE_NFIELDS (type
));
4141 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
4143 printf_filtered (")");
4144 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
4145 TYPE_NFIELDS (type
));
4146 puts_filtered ("\n");
4148 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
4150 printfi_filtered (spaces
,
4151 "protected_field_bits (%d bits at *",
4152 TYPE_NFIELDS (type
));
4153 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
4155 printf_filtered (")");
4156 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
4157 TYPE_NFIELDS (type
));
4158 puts_filtered ("\n");
4161 if (TYPE_NFN_FIELDS (type
) > 0)
4163 dump_fn_fieldlists (type
, spaces
);
4167 /* Print the contents of the TYPE's type_specific union, assuming that
4168 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
4171 print_gnat_stuff (struct type
*type
, int spaces
)
4173 struct type
*descriptive_type
= TYPE_DESCRIPTIVE_TYPE (type
);
4175 if (descriptive_type
== NULL
)
4176 printfi_filtered (spaces
+ 2, "no descriptive type\n");
4179 printfi_filtered (spaces
+ 2, "descriptive type\n");
4180 recursive_dump_type (descriptive_type
, spaces
+ 4);
4184 static struct obstack dont_print_type_obstack
;
4187 recursive_dump_type (struct type
*type
, int spaces
)
4192 obstack_begin (&dont_print_type_obstack
, 0);
4194 if (TYPE_NFIELDS (type
) > 0
4195 || (HAVE_CPLUS_STRUCT (type
) && TYPE_NFN_FIELDS (type
) > 0))
4197 struct type
**first_dont_print
4198 = (struct type
**) obstack_base (&dont_print_type_obstack
);
4200 int i
= (struct type
**)
4201 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
4205 if (type
== first_dont_print
[i
])
4207 printfi_filtered (spaces
, "type node ");
4208 gdb_print_host_address (type
, gdb_stdout
);
4209 printf_filtered (_(" <same as already seen type>\n"));
4214 obstack_ptr_grow (&dont_print_type_obstack
, type
);
4217 printfi_filtered (spaces
, "type node ");
4218 gdb_print_host_address (type
, gdb_stdout
);
4219 printf_filtered ("\n");
4220 printfi_filtered (spaces
, "name '%s' (",
4221 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
4222 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
4223 printf_filtered (")\n");
4224 printfi_filtered (spaces
, "tagname '%s' (",
4225 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
4226 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
4227 printf_filtered (")\n");
4228 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
4229 switch (TYPE_CODE (type
))
4231 case TYPE_CODE_UNDEF
:
4232 printf_filtered ("(TYPE_CODE_UNDEF)");
4235 printf_filtered ("(TYPE_CODE_PTR)");
4237 case TYPE_CODE_ARRAY
:
4238 printf_filtered ("(TYPE_CODE_ARRAY)");
4240 case TYPE_CODE_STRUCT
:
4241 printf_filtered ("(TYPE_CODE_STRUCT)");
4243 case TYPE_CODE_UNION
:
4244 printf_filtered ("(TYPE_CODE_UNION)");
4246 case TYPE_CODE_ENUM
:
4247 printf_filtered ("(TYPE_CODE_ENUM)");
4249 case TYPE_CODE_FLAGS
:
4250 printf_filtered ("(TYPE_CODE_FLAGS)");
4252 case TYPE_CODE_FUNC
:
4253 printf_filtered ("(TYPE_CODE_FUNC)");
4256 printf_filtered ("(TYPE_CODE_INT)");
4259 printf_filtered ("(TYPE_CODE_FLT)");
4261 case TYPE_CODE_VOID
:
4262 printf_filtered ("(TYPE_CODE_VOID)");
4265 printf_filtered ("(TYPE_CODE_SET)");
4267 case TYPE_CODE_RANGE
:
4268 printf_filtered ("(TYPE_CODE_RANGE)");
4270 case TYPE_CODE_STRING
:
4271 printf_filtered ("(TYPE_CODE_STRING)");
4273 case TYPE_CODE_ERROR
:
4274 printf_filtered ("(TYPE_CODE_ERROR)");
4276 case TYPE_CODE_MEMBERPTR
:
4277 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
4279 case TYPE_CODE_METHODPTR
:
4280 printf_filtered ("(TYPE_CODE_METHODPTR)");
4282 case TYPE_CODE_METHOD
:
4283 printf_filtered ("(TYPE_CODE_METHOD)");
4286 printf_filtered ("(TYPE_CODE_REF)");
4288 case TYPE_CODE_CHAR
:
4289 printf_filtered ("(TYPE_CODE_CHAR)");
4291 case TYPE_CODE_BOOL
:
4292 printf_filtered ("(TYPE_CODE_BOOL)");
4294 case TYPE_CODE_COMPLEX
:
4295 printf_filtered ("(TYPE_CODE_COMPLEX)");
4297 case TYPE_CODE_TYPEDEF
:
4298 printf_filtered ("(TYPE_CODE_TYPEDEF)");
4300 case TYPE_CODE_NAMESPACE
:
4301 printf_filtered ("(TYPE_CODE_NAMESPACE)");
4304 printf_filtered ("(UNKNOWN TYPE CODE)");
4307 puts_filtered ("\n");
4308 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
4309 if (TYPE_OBJFILE_OWNED (type
))
4311 printfi_filtered (spaces
, "objfile ");
4312 gdb_print_host_address (TYPE_OWNER (type
).objfile
, gdb_stdout
);
4316 printfi_filtered (spaces
, "gdbarch ");
4317 gdb_print_host_address (TYPE_OWNER (type
).gdbarch
, gdb_stdout
);
4319 printf_filtered ("\n");
4320 printfi_filtered (spaces
, "target_type ");
4321 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
4322 printf_filtered ("\n");
4323 if (TYPE_TARGET_TYPE (type
) != NULL
)
4325 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
4327 printfi_filtered (spaces
, "pointer_type ");
4328 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
4329 printf_filtered ("\n");
4330 printfi_filtered (spaces
, "reference_type ");
4331 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
4332 printf_filtered ("\n");
4333 printfi_filtered (spaces
, "type_chain ");
4334 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
4335 printf_filtered ("\n");
4336 printfi_filtered (spaces
, "instance_flags 0x%x",
4337 TYPE_INSTANCE_FLAGS (type
));
4338 if (TYPE_CONST (type
))
4340 puts_filtered (" TYPE_CONST");
4342 if (TYPE_VOLATILE (type
))
4344 puts_filtered (" TYPE_VOLATILE");
4346 if (TYPE_CODE_SPACE (type
))
4348 puts_filtered (" TYPE_CODE_SPACE");
4350 if (TYPE_DATA_SPACE (type
))
4352 puts_filtered (" TYPE_DATA_SPACE");
4354 if (TYPE_ADDRESS_CLASS_1 (type
))
4356 puts_filtered (" TYPE_ADDRESS_CLASS_1");
4358 if (TYPE_ADDRESS_CLASS_2 (type
))
4360 puts_filtered (" TYPE_ADDRESS_CLASS_2");
4362 if (TYPE_RESTRICT (type
))
4364 puts_filtered (" TYPE_RESTRICT");
4366 if (TYPE_ATOMIC (type
))
4368 puts_filtered (" TYPE_ATOMIC");
4370 puts_filtered ("\n");
4372 printfi_filtered (spaces
, "flags");
4373 if (TYPE_UNSIGNED (type
))
4375 puts_filtered (" TYPE_UNSIGNED");
4377 if (TYPE_NOSIGN (type
))
4379 puts_filtered (" TYPE_NOSIGN");
4381 if (TYPE_STUB (type
))
4383 puts_filtered (" TYPE_STUB");
4385 if (TYPE_TARGET_STUB (type
))
4387 puts_filtered (" TYPE_TARGET_STUB");
4389 if (TYPE_STATIC (type
))
4391 puts_filtered (" TYPE_STATIC");
4393 if (TYPE_PROTOTYPED (type
))
4395 puts_filtered (" TYPE_PROTOTYPED");
4397 if (TYPE_INCOMPLETE (type
))
4399 puts_filtered (" TYPE_INCOMPLETE");
4401 if (TYPE_VARARGS (type
))
4403 puts_filtered (" TYPE_VARARGS");
4405 /* This is used for things like AltiVec registers on ppc. Gcc emits
4406 an attribute for the array type, which tells whether or not we
4407 have a vector, instead of a regular array. */
4408 if (TYPE_VECTOR (type
))
4410 puts_filtered (" TYPE_VECTOR");
4412 if (TYPE_FIXED_INSTANCE (type
))
4414 puts_filtered (" TYPE_FIXED_INSTANCE");
4416 if (TYPE_STUB_SUPPORTED (type
))
4418 puts_filtered (" TYPE_STUB_SUPPORTED");
4420 if (TYPE_NOTTEXT (type
))
4422 puts_filtered (" TYPE_NOTTEXT");
4424 puts_filtered ("\n");
4425 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
4426 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
4427 puts_filtered ("\n");
4428 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
4430 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
4431 printfi_filtered (spaces
+ 2,
4432 "[%d] enumval %s type ",
4433 idx
, plongest (TYPE_FIELD_ENUMVAL (type
, idx
)));
4435 printfi_filtered (spaces
+ 2,
4436 "[%d] bitpos %s bitsize %d type ",
4437 idx
, plongest (TYPE_FIELD_BITPOS (type
, idx
)),
4438 TYPE_FIELD_BITSIZE (type
, idx
));
4439 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
4440 printf_filtered (" name '%s' (",
4441 TYPE_FIELD_NAME (type
, idx
) != NULL
4442 ? TYPE_FIELD_NAME (type
, idx
)
4444 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
4445 printf_filtered (")\n");
4446 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
4448 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
4451 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
4453 printfi_filtered (spaces
, "low %s%s high %s%s\n",
4454 plongest (TYPE_LOW_BOUND (type
)),
4455 TYPE_LOW_BOUND_UNDEFINED (type
) ? " (undefined)" : "",
4456 plongest (TYPE_HIGH_BOUND (type
)),
4457 TYPE_HIGH_BOUND_UNDEFINED (type
)
4458 ? " (undefined)" : "");
4461 switch (TYPE_SPECIFIC_FIELD (type
))
4463 case TYPE_SPECIFIC_CPLUS_STUFF
:
4464 printfi_filtered (spaces
, "cplus_stuff ");
4465 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
),
4467 puts_filtered ("\n");
4468 print_cplus_stuff (type
, spaces
);
4471 case TYPE_SPECIFIC_GNAT_STUFF
:
4472 printfi_filtered (spaces
, "gnat_stuff ");
4473 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type
), gdb_stdout
);
4474 puts_filtered ("\n");
4475 print_gnat_stuff (type
, spaces
);
4478 case TYPE_SPECIFIC_FLOATFORMAT
:
4479 printfi_filtered (spaces
, "floatformat ");
4480 if (TYPE_FLOATFORMAT (type
) == NULL
)
4481 puts_filtered ("(null)");
4484 puts_filtered ("{ ");
4485 if (TYPE_FLOATFORMAT (type
)[0] == NULL
4486 || TYPE_FLOATFORMAT (type
)[0]->name
== NULL
)
4487 puts_filtered ("(null)");
4489 puts_filtered (TYPE_FLOATFORMAT (type
)[0]->name
);
4491 puts_filtered (", ");
4492 if (TYPE_FLOATFORMAT (type
)[1] == NULL
4493 || TYPE_FLOATFORMAT (type
)[1]->name
== NULL
)
4494 puts_filtered ("(null)");
4496 puts_filtered (TYPE_FLOATFORMAT (type
)[1]->name
);
4498 puts_filtered (" }");
4500 puts_filtered ("\n");
4503 case TYPE_SPECIFIC_FUNC
:
4504 printfi_filtered (spaces
, "calling_convention %d\n",
4505 TYPE_CALLING_CONVENTION (type
));
4506 /* tail_call_list is not printed. */
4509 case TYPE_SPECIFIC_SELF_TYPE
:
4510 printfi_filtered (spaces
, "self_type ");
4511 gdb_print_host_address (TYPE_SELF_TYPE (type
), gdb_stdout
);
4512 puts_filtered ("\n");
4517 obstack_free (&dont_print_type_obstack
, NULL
);
4520 /* Trivial helpers for the libiberty hash table, for mapping one
4525 struct type
*old
, *newobj
;
4529 type_pair_hash (const void *item
)
4531 const struct type_pair
*pair
= (const struct type_pair
*) item
;
4533 return htab_hash_pointer (pair
->old
);
4537 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
4539 const struct type_pair
*lhs
= (const struct type_pair
*) item_lhs
;
4540 const struct type_pair
*rhs
= (const struct type_pair
*) item_rhs
;
4542 return lhs
->old
== rhs
->old
;
4545 /* Allocate the hash table used by copy_type_recursive to walk
4546 types without duplicates. We use OBJFILE's obstack, because
4547 OBJFILE is about to be deleted. */
4550 create_copied_types_hash (struct objfile
*objfile
)
4552 return htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
4553 NULL
, &objfile
->objfile_obstack
,
4554 hashtab_obstack_allocate
,
4555 dummy_obstack_deallocate
);
4558 /* Recursively copy (deep copy) a dynamic attribute list of a type. */
4560 static struct dynamic_prop_list
*
4561 copy_dynamic_prop_list (struct obstack
*objfile_obstack
,
4562 struct dynamic_prop_list
*list
)
4564 struct dynamic_prop_list
*copy
= list
;
4565 struct dynamic_prop_list
**node_ptr
= ©
;
4567 while (*node_ptr
!= NULL
)
4569 struct dynamic_prop_list
*node_copy
;
4571 node_copy
= ((struct dynamic_prop_list
*)
4572 obstack_copy (objfile_obstack
, *node_ptr
,
4573 sizeof (struct dynamic_prop_list
)));
4574 node_copy
->prop
= (*node_ptr
)->prop
;
4575 *node_ptr
= node_copy
;
4577 node_ptr
= &node_copy
->next
;
4583 /* Recursively copy (deep copy) TYPE, if it is associated with
4584 OBJFILE. Return a new type owned by the gdbarch associated with the type, a
4585 saved type if we have already visited TYPE (using COPIED_TYPES), or TYPE if
4586 it is not associated with OBJFILE. */
4589 copy_type_recursive (struct objfile
*objfile
,
4591 htab_t copied_types
)
4593 struct type_pair
*stored
, pair
;
4595 struct type
*new_type
;
4597 if (! TYPE_OBJFILE_OWNED (type
))
4600 /* This type shouldn't be pointing to any types in other objfiles;
4601 if it did, the type might disappear unexpectedly. */
4602 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
4605 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
4607 return ((struct type_pair
*) *slot
)->newobj
;
4609 new_type
= alloc_type_arch (get_type_arch (type
));
4611 /* We must add the new type to the hash table immediately, in case
4612 we encounter this type again during a recursive call below. */
4613 stored
= XOBNEW (&objfile
->objfile_obstack
, struct type_pair
);
4615 stored
->newobj
= new_type
;
4618 /* Copy the common fields of types. For the main type, we simply
4619 copy the entire thing and then update specific fields as needed. */
4620 *TYPE_MAIN_TYPE (new_type
) = *TYPE_MAIN_TYPE (type
);
4621 TYPE_OBJFILE_OWNED (new_type
) = 0;
4622 TYPE_OWNER (new_type
).gdbarch
= get_type_arch (type
);
4624 if (TYPE_NAME (type
))
4625 TYPE_NAME (new_type
) = xstrdup (TYPE_NAME (type
));
4626 if (TYPE_TAG_NAME (type
))
4627 TYPE_TAG_NAME (new_type
) = xstrdup (TYPE_TAG_NAME (type
));
4629 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
4630 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
4632 /* Copy the fields. */
4633 if (TYPE_NFIELDS (type
))
4637 nfields
= TYPE_NFIELDS (type
);
4638 TYPE_FIELDS (new_type
) = XCNEWVEC (struct field
, nfields
);
4639 for (i
= 0; i
< nfields
; i
++)
4641 TYPE_FIELD_ARTIFICIAL (new_type
, i
) =
4642 TYPE_FIELD_ARTIFICIAL (type
, i
);
4643 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
4644 if (TYPE_FIELD_TYPE (type
, i
))
4645 TYPE_FIELD_TYPE (new_type
, i
)
4646 = copy_type_recursive (objfile
, TYPE_FIELD_TYPE (type
, i
),
4648 if (TYPE_FIELD_NAME (type
, i
))
4649 TYPE_FIELD_NAME (new_type
, i
) =
4650 xstrdup (TYPE_FIELD_NAME (type
, i
));
4651 switch (TYPE_FIELD_LOC_KIND (type
, i
))
4653 case FIELD_LOC_KIND_BITPOS
:
4654 SET_FIELD_BITPOS (TYPE_FIELD (new_type
, i
),
4655 TYPE_FIELD_BITPOS (type
, i
));
4657 case FIELD_LOC_KIND_ENUMVAL
:
4658 SET_FIELD_ENUMVAL (TYPE_FIELD (new_type
, i
),
4659 TYPE_FIELD_ENUMVAL (type
, i
));
4661 case FIELD_LOC_KIND_PHYSADDR
:
4662 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type
, i
),
4663 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
4665 case FIELD_LOC_KIND_PHYSNAME
:
4666 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type
, i
),
4667 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
,
4671 internal_error (__FILE__
, __LINE__
,
4672 _("Unexpected type field location kind: %d"),
4673 TYPE_FIELD_LOC_KIND (type
, i
));
4678 /* For range types, copy the bounds information. */
4679 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
4681 TYPE_RANGE_DATA (new_type
) = XNEW (struct range_bounds
);
4682 *TYPE_RANGE_DATA (new_type
) = *TYPE_RANGE_DATA (type
);
4685 if (TYPE_DYN_PROP_LIST (type
) != NULL
)
4686 TYPE_DYN_PROP_LIST (new_type
)
4687 = copy_dynamic_prop_list (&objfile
->objfile_obstack
,
4688 TYPE_DYN_PROP_LIST (type
));
4691 /* Copy pointers to other types. */
4692 if (TYPE_TARGET_TYPE (type
))
4693 TYPE_TARGET_TYPE (new_type
) =
4694 copy_type_recursive (objfile
,
4695 TYPE_TARGET_TYPE (type
),
4698 /* Maybe copy the type_specific bits.
4700 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
4701 base classes and methods. There's no fundamental reason why we
4702 can't, but at the moment it is not needed. */
4704 switch (TYPE_SPECIFIC_FIELD (type
))
4706 case TYPE_SPECIFIC_NONE
:
4708 case TYPE_SPECIFIC_FUNC
:
4709 INIT_FUNC_SPECIFIC (new_type
);
4710 TYPE_CALLING_CONVENTION (new_type
) = TYPE_CALLING_CONVENTION (type
);
4711 TYPE_NO_RETURN (new_type
) = TYPE_NO_RETURN (type
);
4712 TYPE_TAIL_CALL_LIST (new_type
) = NULL
;
4714 case TYPE_SPECIFIC_FLOATFORMAT
:
4715 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
4717 case TYPE_SPECIFIC_CPLUS_STUFF
:
4718 INIT_CPLUS_SPECIFIC (new_type
);
4720 case TYPE_SPECIFIC_GNAT_STUFF
:
4721 INIT_GNAT_SPECIFIC (new_type
);
4723 case TYPE_SPECIFIC_SELF_TYPE
:
4724 set_type_self_type (new_type
,
4725 copy_type_recursive (objfile
, TYPE_SELF_TYPE (type
),
4729 gdb_assert_not_reached ("bad type_specific_kind");
4735 /* Make a copy of the given TYPE, except that the pointer & reference
4736 types are not preserved.
4738 This function assumes that the given type has an associated objfile.
4739 This objfile is used to allocate the new type. */
4742 copy_type (const struct type
*type
)
4744 struct type
*new_type
;
4746 gdb_assert (TYPE_OBJFILE_OWNED (type
));
4748 new_type
= alloc_type_copy (type
);
4749 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
4750 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
4751 memcpy (TYPE_MAIN_TYPE (new_type
), TYPE_MAIN_TYPE (type
),
4752 sizeof (struct main_type
));
4753 if (TYPE_DYN_PROP_LIST (type
) != NULL
)
4754 TYPE_DYN_PROP_LIST (new_type
)
4755 = copy_dynamic_prop_list (&TYPE_OBJFILE (type
) -> objfile_obstack
,
4756 TYPE_DYN_PROP_LIST (type
));
4761 /* Helper functions to initialize architecture-specific types. */
4763 /* Allocate a type structure associated with GDBARCH and set its
4764 CODE, LENGTH, and NAME fields. */
4767 arch_type (struct gdbarch
*gdbarch
,
4768 enum type_code code
, int length
, const char *name
)
4772 type
= alloc_type_arch (gdbarch
);
4773 set_type_code (type
, code
);
4774 TYPE_LENGTH (type
) = length
;
4777 TYPE_NAME (type
) = gdbarch_obstack_strdup (gdbarch
, name
);
4782 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
4783 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
4784 the type's TYPE_UNSIGNED flag. NAME is the type name. */
4787 arch_integer_type (struct gdbarch
*gdbarch
,
4788 int bit
, int unsigned_p
, const char *name
)
4792 t
= arch_type (gdbarch
, TYPE_CODE_INT
, bit
/ TARGET_CHAR_BIT
, name
);
4794 TYPE_UNSIGNED (t
) = 1;
4799 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
4800 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
4801 the type's TYPE_UNSIGNED flag. NAME is the type name. */
4804 arch_character_type (struct gdbarch
*gdbarch
,
4805 int bit
, int unsigned_p
, const char *name
)
4809 t
= arch_type (gdbarch
, TYPE_CODE_CHAR
, bit
/ TARGET_CHAR_BIT
, name
);
4811 TYPE_UNSIGNED (t
) = 1;
4816 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
4817 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
4818 the type's TYPE_UNSIGNED flag. NAME is the type name. */
4821 arch_boolean_type (struct gdbarch
*gdbarch
,
4822 int bit
, int unsigned_p
, const char *name
)
4826 t
= arch_type (gdbarch
, TYPE_CODE_BOOL
, bit
/ TARGET_CHAR_BIT
, name
);
4828 TYPE_UNSIGNED (t
) = 1;
4833 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
4834 BIT is the type size in bits; if BIT equals -1, the size is
4835 determined by the floatformat. NAME is the type name. Set the
4836 TYPE_FLOATFORMAT from FLOATFORMATS. */
4839 arch_float_type (struct gdbarch
*gdbarch
,
4840 int bit
, const char *name
,
4841 const struct floatformat
**floatformats
)
4845 bit
= verify_floatformat (bit
, floatformats
);
4846 t
= arch_type (gdbarch
, TYPE_CODE_FLT
, bit
/ TARGET_CHAR_BIT
, name
);
4847 TYPE_FLOATFORMAT (t
) = floatformats
;
4852 /* Allocate a TYPE_CODE_DECFLOAT type structure associated with GDBARCH.
4853 BIT is the type size in bits. NAME is the type name. */
4856 arch_decfloat_type (struct gdbarch
*gdbarch
, int bit
, const char *name
)
4860 t
= arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, bit
/ TARGET_CHAR_BIT
, name
);
4864 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
4865 NAME is the type name. TARGET_TYPE is the component float type. */
4868 arch_complex_type (struct gdbarch
*gdbarch
,
4869 const char *name
, struct type
*target_type
)
4873 t
= arch_type (gdbarch
, TYPE_CODE_COMPLEX
,
4874 2 * TYPE_LENGTH (target_type
), name
);
4875 TYPE_TARGET_TYPE (t
) = target_type
;
4879 /* Allocate a TYPE_CODE_PTR type structure associated with GDBARCH.
4880 BIT is the pointer type size in bits. NAME is the type name.
4881 TARGET_TYPE is the pointer target type. Always sets the pointer type's
4882 TYPE_UNSIGNED flag. */
4885 arch_pointer_type (struct gdbarch
*gdbarch
,
4886 int bit
, const char *name
, struct type
*target_type
)
4890 t
= arch_type (gdbarch
, TYPE_CODE_PTR
, bit
/ TARGET_CHAR_BIT
, name
);
4891 TYPE_TARGET_TYPE (t
) = target_type
;
4892 TYPE_UNSIGNED (t
) = 1;
4896 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
4897 NAME is the type name. LENGTH is the size of the flag word in bytes. */
4900 arch_flags_type (struct gdbarch
*gdbarch
, const char *name
, int length
)
4902 int max_nfields
= length
* TARGET_CHAR_BIT
;
4905 type
= arch_type (gdbarch
, TYPE_CODE_FLAGS
, length
, name
);
4906 TYPE_UNSIGNED (type
) = 1;
4907 TYPE_NFIELDS (type
) = 0;
4908 /* Pre-allocate enough space assuming every field is one bit. */
4910 = (struct field
*) TYPE_ZALLOC (type
, max_nfields
* sizeof (struct field
));
4915 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
4916 position BITPOS is called NAME. Pass NAME as "" for fields that
4917 should not be printed. */
4920 append_flags_type_field (struct type
*type
, int start_bitpos
, int nr_bits
,
4921 struct type
*field_type
, const char *name
)
4923 int type_bitsize
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
4924 int field_nr
= TYPE_NFIELDS (type
);
4926 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLAGS
);
4927 gdb_assert (TYPE_NFIELDS (type
) + 1 <= type_bitsize
);
4928 gdb_assert (start_bitpos
>= 0 && start_bitpos
< type_bitsize
);
4929 gdb_assert (nr_bits
>= 1 && nr_bits
<= type_bitsize
);
4930 gdb_assert (name
!= NULL
);
4932 TYPE_FIELD_NAME (type
, field_nr
) = xstrdup (name
);
4933 TYPE_FIELD_TYPE (type
, field_nr
) = field_type
;
4934 SET_FIELD_BITPOS (TYPE_FIELD (type
, field_nr
), start_bitpos
);
4935 TYPE_FIELD_BITSIZE (type
, field_nr
) = nr_bits
;
4936 ++TYPE_NFIELDS (type
);
4939 /* Special version of append_flags_type_field to add a flag field.
4940 Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
4941 position BITPOS is called NAME. */
4944 append_flags_type_flag (struct type
*type
, int bitpos
, const char *name
)
4946 struct gdbarch
*gdbarch
= get_type_arch (type
);
4948 append_flags_type_field (type
, bitpos
, 1,
4949 builtin_type (gdbarch
)->builtin_bool
,
4953 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
4954 specified by CODE) associated with GDBARCH. NAME is the type name. */
4957 arch_composite_type (struct gdbarch
*gdbarch
, const char *name
,
4958 enum type_code code
)
4962 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
4963 t
= arch_type (gdbarch
, code
, 0, NULL
);
4964 TYPE_TAG_NAME (t
) = name
;
4965 INIT_CPLUS_SPECIFIC (t
);
4969 /* Add new field with name NAME and type FIELD to composite type T.
4970 Do not set the field's position or adjust the type's length;
4971 the caller should do so. Return the new field. */
4974 append_composite_type_field_raw (struct type
*t
, const char *name
,
4979 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
4980 TYPE_FIELDS (t
) = XRESIZEVEC (struct field
, TYPE_FIELDS (t
),
4982 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
4983 memset (f
, 0, sizeof f
[0]);
4984 FIELD_TYPE (f
[0]) = field
;
4985 FIELD_NAME (f
[0]) = name
;
4989 /* Add new field with name NAME and type FIELD to composite type T.
4990 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
4993 append_composite_type_field_aligned (struct type
*t
, const char *name
,
4994 struct type
*field
, int alignment
)
4996 struct field
*f
= append_composite_type_field_raw (t
, name
, field
);
4998 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
5000 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
5001 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
5003 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
5005 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
5006 if (TYPE_NFIELDS (t
) > 1)
5008 SET_FIELD_BITPOS (f
[0],
5009 (FIELD_BITPOS (f
[-1])
5010 + (TYPE_LENGTH (FIELD_TYPE (f
[-1]))
5011 * TARGET_CHAR_BIT
)));
5017 alignment
*= TARGET_CHAR_BIT
;
5018 left
= FIELD_BITPOS (f
[0]) % alignment
;
5022 SET_FIELD_BITPOS (f
[0], FIELD_BITPOS (f
[0]) + (alignment
- left
));
5023 TYPE_LENGTH (t
) += (alignment
- left
) / TARGET_CHAR_BIT
;
5030 /* Add new field with name NAME and type FIELD to composite type T. */
5033 append_composite_type_field (struct type
*t
, const char *name
,
5036 append_composite_type_field_aligned (t
, name
, field
, 0);
5039 static struct gdbarch_data
*gdbtypes_data
;
5041 const struct builtin_type
*
5042 builtin_type (struct gdbarch
*gdbarch
)
5044 return (const struct builtin_type
*) gdbarch_data (gdbarch
, gdbtypes_data
);
5048 gdbtypes_post_init (struct gdbarch
*gdbarch
)
5050 struct builtin_type
*builtin_type
5051 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
5054 builtin_type
->builtin_void
5055 = arch_type (gdbarch
, TYPE_CODE_VOID
, 1, "void");
5056 builtin_type
->builtin_char
5057 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
5058 !gdbarch_char_signed (gdbarch
), "char");
5059 TYPE_NOSIGN (builtin_type
->builtin_char
) = 1;
5060 builtin_type
->builtin_signed_char
5061 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
5063 builtin_type
->builtin_unsigned_char
5064 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
5065 1, "unsigned char");
5066 builtin_type
->builtin_short
5067 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
5069 builtin_type
->builtin_unsigned_short
5070 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
5071 1, "unsigned short");
5072 builtin_type
->builtin_int
5073 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
5075 builtin_type
->builtin_unsigned_int
5076 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
5078 builtin_type
->builtin_long
5079 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
5081 builtin_type
->builtin_unsigned_long
5082 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
5083 1, "unsigned long");
5084 builtin_type
->builtin_long_long
5085 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
5087 builtin_type
->builtin_unsigned_long_long
5088 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
5089 1, "unsigned long long");
5090 builtin_type
->builtin_float
5091 = arch_float_type (gdbarch
, gdbarch_float_bit (gdbarch
),
5092 "float", gdbarch_float_format (gdbarch
));
5093 builtin_type
->builtin_double
5094 = arch_float_type (gdbarch
, gdbarch_double_bit (gdbarch
),
5095 "double", gdbarch_double_format (gdbarch
));
5096 builtin_type
->builtin_long_double
5097 = arch_float_type (gdbarch
, gdbarch_long_double_bit (gdbarch
),
5098 "long double", gdbarch_long_double_format (gdbarch
));
5099 builtin_type
->builtin_complex
5100 = arch_complex_type (gdbarch
, "complex",
5101 builtin_type
->builtin_float
);
5102 builtin_type
->builtin_double_complex
5103 = arch_complex_type (gdbarch
, "double complex",
5104 builtin_type
->builtin_double
);
5105 builtin_type
->builtin_string
5106 = arch_type (gdbarch
, TYPE_CODE_STRING
, 1, "string");
5107 builtin_type
->builtin_bool
5108 = arch_type (gdbarch
, TYPE_CODE_BOOL
, 1, "bool");
5110 /* The following three are about decimal floating point types, which
5111 are 32-bits, 64-bits and 128-bits respectively. */
5112 builtin_type
->builtin_decfloat
5113 = arch_decfloat_type (gdbarch
, 32, "_Decimal32");
5114 builtin_type
->builtin_decdouble
5115 = arch_decfloat_type (gdbarch
, 64, "_Decimal64");
5116 builtin_type
->builtin_declong
5117 = arch_decfloat_type (gdbarch
, 128, "_Decimal128");
5119 /* "True" character types. */
5120 builtin_type
->builtin_true_char
5121 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 0, "true character");
5122 builtin_type
->builtin_true_unsigned_char
5123 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 1, "true character");
5125 /* Fixed-size integer types. */
5126 builtin_type
->builtin_int0
5127 = arch_integer_type (gdbarch
, 0, 0, "int0_t");
5128 builtin_type
->builtin_int8
5129 = arch_integer_type (gdbarch
, 8, 0, "int8_t");
5130 builtin_type
->builtin_uint8
5131 = arch_integer_type (gdbarch
, 8, 1, "uint8_t");
5132 builtin_type
->builtin_int16
5133 = arch_integer_type (gdbarch
, 16, 0, "int16_t");
5134 builtin_type
->builtin_uint16
5135 = arch_integer_type (gdbarch
, 16, 1, "uint16_t");
5136 builtin_type
->builtin_int32
5137 = arch_integer_type (gdbarch
, 32, 0, "int32_t");
5138 builtin_type
->builtin_uint32
5139 = arch_integer_type (gdbarch
, 32, 1, "uint32_t");
5140 builtin_type
->builtin_int64
5141 = arch_integer_type (gdbarch
, 64, 0, "int64_t");
5142 builtin_type
->builtin_uint64
5143 = arch_integer_type (gdbarch
, 64, 1, "uint64_t");
5144 builtin_type
->builtin_int128
5145 = arch_integer_type (gdbarch
, 128, 0, "int128_t");
5146 builtin_type
->builtin_uint128
5147 = arch_integer_type (gdbarch
, 128, 1, "uint128_t");
5148 TYPE_INSTANCE_FLAGS (builtin_type
->builtin_int8
) |=
5149 TYPE_INSTANCE_FLAG_NOTTEXT
;
5150 TYPE_INSTANCE_FLAGS (builtin_type
->builtin_uint8
) |=
5151 TYPE_INSTANCE_FLAG_NOTTEXT
;
5153 /* Wide character types. */
5154 builtin_type
->builtin_char16
5155 = arch_integer_type (gdbarch
, 16, 0, "char16_t");
5156 builtin_type
->builtin_char32
5157 = arch_integer_type (gdbarch
, 32, 0, "char32_t");
5160 /* Default data/code pointer types. */
5161 builtin_type
->builtin_data_ptr
5162 = lookup_pointer_type (builtin_type
->builtin_void
);
5163 builtin_type
->builtin_func_ptr
5164 = lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
5165 builtin_type
->builtin_func_func
5166 = lookup_function_type (builtin_type
->builtin_func_ptr
);
5168 /* This type represents a GDB internal function. */
5169 builtin_type
->internal_fn
5170 = arch_type (gdbarch
, TYPE_CODE_INTERNAL_FUNCTION
, 0,
5171 "<internal function>");
5173 /* This type represents an xmethod. */
5174 builtin_type
->xmethod
5175 = arch_type (gdbarch
, TYPE_CODE_XMETHOD
, 0, "<xmethod>");
5177 return builtin_type
;
5180 /* This set of objfile-based types is intended to be used by symbol
5181 readers as basic types. */
5183 static const struct objfile_data
*objfile_type_data
;
5185 const struct objfile_type
*
5186 objfile_type (struct objfile
*objfile
)
5188 struct gdbarch
*gdbarch
;
5189 struct objfile_type
*objfile_type
5190 = (struct objfile_type
*) objfile_data (objfile
, objfile_type_data
);
5193 return objfile_type
;
5195 objfile_type
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
5196 1, struct objfile_type
);
5198 /* Use the objfile architecture to determine basic type properties. */
5199 gdbarch
= get_objfile_arch (objfile
);
5202 objfile_type
->builtin_void
5203 = init_type (objfile
, TYPE_CODE_VOID
, 1, "void");
5204 objfile_type
->builtin_char
5205 = init_integer_type (objfile
, TARGET_CHAR_BIT
,
5206 !gdbarch_char_signed (gdbarch
), "char");
5207 TYPE_NOSIGN (objfile_type
->builtin_char
) = 1;
5208 objfile_type
->builtin_signed_char
5209 = init_integer_type (objfile
, TARGET_CHAR_BIT
,
5211 objfile_type
->builtin_unsigned_char
5212 = init_integer_type (objfile
, TARGET_CHAR_BIT
,
5213 1, "unsigned char");
5214 objfile_type
->builtin_short
5215 = init_integer_type (objfile
, gdbarch_short_bit (gdbarch
),
5217 objfile_type
->builtin_unsigned_short
5218 = init_integer_type (objfile
, gdbarch_short_bit (gdbarch
),
5219 1, "unsigned short");
5220 objfile_type
->builtin_int
5221 = init_integer_type (objfile
, gdbarch_int_bit (gdbarch
),
5223 objfile_type
->builtin_unsigned_int
5224 = init_integer_type (objfile
, gdbarch_int_bit (gdbarch
),
5226 objfile_type
->builtin_long
5227 = init_integer_type (objfile
, gdbarch_long_bit (gdbarch
),
5229 objfile_type
->builtin_unsigned_long
5230 = init_integer_type (objfile
, gdbarch_long_bit (gdbarch
),
5231 1, "unsigned long");
5232 objfile_type
->builtin_long_long
5233 = init_integer_type (objfile
, gdbarch_long_long_bit (gdbarch
),
5235 objfile_type
->builtin_unsigned_long_long
5236 = init_integer_type (objfile
, gdbarch_long_long_bit (gdbarch
),
5237 1, "unsigned long long");
5238 objfile_type
->builtin_float
5239 = init_float_type (objfile
, gdbarch_float_bit (gdbarch
),
5240 "float", gdbarch_float_format (gdbarch
));
5241 objfile_type
->builtin_double
5242 = init_float_type (objfile
, gdbarch_double_bit (gdbarch
),
5243 "double", gdbarch_double_format (gdbarch
));
5244 objfile_type
->builtin_long_double
5245 = init_float_type (objfile
, gdbarch_long_double_bit (gdbarch
),
5246 "long double", gdbarch_long_double_format (gdbarch
));
5248 /* This type represents a type that was unrecognized in symbol read-in. */
5249 objfile_type
->builtin_error
5250 = init_type (objfile
, TYPE_CODE_ERROR
, 0, "<unknown type>");
5252 /* The following set of types is used for symbols with no
5253 debug information. */
5254 objfile_type
->nodebug_text_symbol
5255 = init_type (objfile
, TYPE_CODE_FUNC
, 1,
5256 "<text variable, no debug info>");
5257 TYPE_TARGET_TYPE (objfile_type
->nodebug_text_symbol
)
5258 = objfile_type
->builtin_int
;
5259 objfile_type
->nodebug_text_gnu_ifunc_symbol
5260 = init_type (objfile
, TYPE_CODE_FUNC
, 1,
5261 "<text gnu-indirect-function variable, no debug info>");
5262 TYPE_TARGET_TYPE (objfile_type
->nodebug_text_gnu_ifunc_symbol
)
5263 = objfile_type
->nodebug_text_symbol
;
5264 TYPE_GNU_IFUNC (objfile_type
->nodebug_text_gnu_ifunc_symbol
) = 1;
5265 objfile_type
->nodebug_got_plt_symbol
5266 = init_pointer_type (objfile
, gdbarch_addr_bit (gdbarch
),
5267 "<text from jump slot in .got.plt, no debug info>",
5268 objfile_type
->nodebug_text_symbol
);
5269 objfile_type
->nodebug_data_symbol
5270 = init_integer_type (objfile
, gdbarch_int_bit (gdbarch
), 0,
5271 "<data variable, no debug info>");
5272 objfile_type
->nodebug_unknown_symbol
5273 = init_integer_type (objfile
, TARGET_CHAR_BIT
, 0,
5274 "<variable (not text or data), no debug info>");
5275 objfile_type
->nodebug_tls_symbol
5276 = init_integer_type (objfile
, gdbarch_int_bit (gdbarch
), 0,
5277 "<thread local variable, no debug info>");
5279 /* NOTE: on some targets, addresses and pointers are not necessarily
5283 - gdb's `struct type' always describes the target's
5285 - gdb's `struct value' objects should always hold values in
5287 - gdb's CORE_ADDR values are addresses in the unified virtual
5288 address space that the assembler and linker work with. Thus,
5289 since target_read_memory takes a CORE_ADDR as an argument, it
5290 can access any memory on the target, even if the processor has
5291 separate code and data address spaces.
5293 In this context, objfile_type->builtin_core_addr is a bit odd:
5294 it's a target type for a value the target will never see. It's
5295 only used to hold the values of (typeless) linker symbols, which
5296 are indeed in the unified virtual address space. */
5298 objfile_type
->builtin_core_addr
5299 = init_integer_type (objfile
, gdbarch_addr_bit (gdbarch
), 1,
5302 set_objfile_data (objfile
, objfile_type_data
, objfile_type
);
5303 return objfile_type
;
5306 extern initialize_file_ftype _initialize_gdbtypes
;
5309 _initialize_gdbtypes (void)
5311 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
5312 objfile_type_data
= register_objfile_data ();
5314 add_setshow_zuinteger_cmd ("overload", no_class
, &overload_debug
,
5315 _("Set debugging of C++ overloading."),
5316 _("Show debugging of C++ overloading."),
5317 _("When enabled, ranking of the "
5318 "functions is displayed."),
5320 show_overload_debug
,
5321 &setdebuglist
, &showdebuglist
);
5323 /* Add user knob for controlling resolution of opaque types. */
5324 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
5325 &opaque_type_resolution
,
5326 _("Set resolution of opaque struct/class/union"
5327 " types (if set before loading symbols)."),
5328 _("Show resolution of opaque struct/class/union"
5329 " types (if set before loading symbols)."),
5331 show_opaque_type_resolution
,
5332 &setlist
, &showlist
);
5334 /* Add an option to permit non-strict type checking. */
5335 add_setshow_boolean_cmd ("type", class_support
,
5336 &strict_type_checking
,
5337 _("Set strict type checking."),
5338 _("Show strict type checking."),
5340 show_strict_type_checking
,
5341 &setchecklist
, &showchecklist
);