1 /* Support routines for manipulating internal types for GDB.
3 Copyright (C) 1992-2020 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 "dwarf2/loc.h"
41 #include "floatformat.h"
44 #include "gmp-utils.h"
46 /* Initialize BADNESS constants. */
48 const struct rank LENGTH_MISMATCH_BADNESS
= {100,0};
50 const struct rank TOO_FEW_PARAMS_BADNESS
= {100,0};
51 const struct rank INCOMPATIBLE_TYPE_BADNESS
= {100,0};
53 const struct rank EXACT_MATCH_BADNESS
= {0,0};
55 const struct rank INTEGER_PROMOTION_BADNESS
= {1,0};
56 const struct rank FLOAT_PROMOTION_BADNESS
= {1,0};
57 const struct rank BASE_PTR_CONVERSION_BADNESS
= {1,0};
58 const struct rank CV_CONVERSION_BADNESS
= {1, 0};
59 const struct rank INTEGER_CONVERSION_BADNESS
= {2,0};
60 const struct rank FLOAT_CONVERSION_BADNESS
= {2,0};
61 const struct rank INT_FLOAT_CONVERSION_BADNESS
= {2,0};
62 const struct rank VOID_PTR_CONVERSION_BADNESS
= {2,0};
63 const struct rank BOOL_CONVERSION_BADNESS
= {3,0};
64 const struct rank BASE_CONVERSION_BADNESS
= {2,0};
65 const struct rank REFERENCE_CONVERSION_BADNESS
= {2,0};
66 const struct rank REFERENCE_SEE_THROUGH_BADNESS
= {0,1};
67 const struct rank NULL_POINTER_CONVERSION_BADNESS
= {2,0};
68 const struct rank NS_POINTER_CONVERSION_BADNESS
= {10,0};
69 const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS
= {3,0};
71 /* Floatformat pairs. */
72 const struct floatformat
*floatformats_ieee_half
[BFD_ENDIAN_UNKNOWN
] = {
73 &floatformat_ieee_half_big
,
74 &floatformat_ieee_half_little
76 const struct floatformat
*floatformats_ieee_single
[BFD_ENDIAN_UNKNOWN
] = {
77 &floatformat_ieee_single_big
,
78 &floatformat_ieee_single_little
80 const struct floatformat
*floatformats_ieee_double
[BFD_ENDIAN_UNKNOWN
] = {
81 &floatformat_ieee_double_big
,
82 &floatformat_ieee_double_little
84 const struct floatformat
*floatformats_ieee_double_littlebyte_bigword
[BFD_ENDIAN_UNKNOWN
] = {
85 &floatformat_ieee_double_big
,
86 &floatformat_ieee_double_littlebyte_bigword
88 const struct floatformat
*floatformats_i387_ext
[BFD_ENDIAN_UNKNOWN
] = {
89 &floatformat_i387_ext
,
92 const struct floatformat
*floatformats_m68881_ext
[BFD_ENDIAN_UNKNOWN
] = {
93 &floatformat_m68881_ext
,
94 &floatformat_m68881_ext
96 const struct floatformat
*floatformats_arm_ext
[BFD_ENDIAN_UNKNOWN
] = {
97 &floatformat_arm_ext_big
,
98 &floatformat_arm_ext_littlebyte_bigword
100 const struct floatformat
*floatformats_ia64_spill
[BFD_ENDIAN_UNKNOWN
] = {
101 &floatformat_ia64_spill_big
,
102 &floatformat_ia64_spill_little
104 const struct floatformat
*floatformats_ia64_quad
[BFD_ENDIAN_UNKNOWN
] = {
105 &floatformat_ia64_quad_big
,
106 &floatformat_ia64_quad_little
108 const struct floatformat
*floatformats_vax_f
[BFD_ENDIAN_UNKNOWN
] = {
112 const struct floatformat
*floatformats_vax_d
[BFD_ENDIAN_UNKNOWN
] = {
116 const struct floatformat
*floatformats_ibm_long_double
[BFD_ENDIAN_UNKNOWN
] = {
117 &floatformat_ibm_long_double_big
,
118 &floatformat_ibm_long_double_little
120 const struct floatformat
*floatformats_bfloat16
[BFD_ENDIAN_UNKNOWN
] = {
121 &floatformat_bfloat16_big
,
122 &floatformat_bfloat16_little
125 /* Should opaque types be resolved? */
127 static bool opaque_type_resolution
= true;
129 /* See gdbtypes.h. */
131 unsigned int overload_debug
= 0;
133 /* A flag to enable strict type checking. */
135 static bool strict_type_checking
= true;
137 /* A function to show whether opaque types are resolved. */
140 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
141 struct cmd_list_element
*c
,
144 fprintf_filtered (file
, _("Resolution of opaque struct/class/union types "
145 "(if set before loading symbols) is %s.\n"),
149 /* A function to show whether C++ overload debugging is enabled. */
152 show_overload_debug (struct ui_file
*file
, int from_tty
,
153 struct cmd_list_element
*c
, const char *value
)
155 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"),
159 /* A function to show the status of strict type checking. */
162 show_strict_type_checking (struct ui_file
*file
, int from_tty
,
163 struct cmd_list_element
*c
, const char *value
)
165 fprintf_filtered (file
, _("Strict type checking is %s.\n"), value
);
169 /* Allocate a new OBJFILE-associated type structure and fill it
170 with some defaults. Space for the type structure is allocated
171 on the objfile's objfile_obstack. */
174 alloc_type (struct objfile
*objfile
)
178 gdb_assert (objfile
!= NULL
);
180 /* Alloc the structure and start off with all fields zeroed. */
181 type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct type
);
182 TYPE_MAIN_TYPE (type
) = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
184 OBJSTAT (objfile
, n_types
++);
186 TYPE_OBJFILE_OWNED (type
) = 1;
187 TYPE_OWNER (type
).objfile
= objfile
;
189 /* Initialize the fields that might not be zero. */
191 type
->set_code (TYPE_CODE_UNDEF
);
192 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
197 /* Allocate a new GDBARCH-associated type structure and fill it
198 with some defaults. Space for the type structure is allocated
199 on the obstack associated with GDBARCH. */
202 alloc_type_arch (struct gdbarch
*gdbarch
)
206 gdb_assert (gdbarch
!= NULL
);
208 /* Alloc the structure and start off with all fields zeroed. */
210 type
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct type
);
211 TYPE_MAIN_TYPE (type
) = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct main_type
);
213 TYPE_OBJFILE_OWNED (type
) = 0;
214 TYPE_OWNER (type
).gdbarch
= gdbarch
;
216 /* Initialize the fields that might not be zero. */
218 type
->set_code (TYPE_CODE_UNDEF
);
219 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
224 /* If TYPE is objfile-associated, allocate a new type structure
225 associated with the same objfile. If TYPE is gdbarch-associated,
226 allocate a new type structure associated with the same gdbarch. */
229 alloc_type_copy (const struct type
*type
)
231 if (TYPE_OBJFILE_OWNED (type
))
232 return alloc_type (TYPE_OWNER (type
).objfile
);
234 return alloc_type_arch (TYPE_OWNER (type
).gdbarch
);
237 /* If TYPE is gdbarch-associated, return that architecture.
238 If TYPE is objfile-associated, return that objfile's architecture. */
241 get_type_arch (const struct type
*type
)
243 struct gdbarch
*arch
;
245 if (TYPE_OBJFILE_OWNED (type
))
246 arch
= TYPE_OWNER (type
).objfile
->arch ();
248 arch
= TYPE_OWNER (type
).gdbarch
;
250 /* The ARCH can be NULL if TYPE is associated with neither an objfile nor
251 a gdbarch, however, this is very rare, and even then, in most cases
252 that get_type_arch is called, we assume that a non-NULL value is
254 gdb_assert (arch
!= NULL
);
258 /* See gdbtypes.h. */
261 get_target_type (struct type
*type
)
265 type
= TYPE_TARGET_TYPE (type
);
267 type
= check_typedef (type
);
273 /* See gdbtypes.h. */
276 type_length_units (struct type
*type
)
278 struct gdbarch
*arch
= get_type_arch (type
);
279 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
281 return TYPE_LENGTH (type
) / unit_size
;
284 /* Alloc a new type instance structure, fill it with some defaults,
285 and point it at OLDTYPE. Allocate the new type instance from the
286 same place as OLDTYPE. */
289 alloc_type_instance (struct type
*oldtype
)
293 /* Allocate the structure. */
295 if (! TYPE_OBJFILE_OWNED (oldtype
))
296 type
= GDBARCH_OBSTACK_ZALLOC (get_type_arch (oldtype
), struct type
);
298 type
= OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype
)->objfile_obstack
,
301 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
303 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
308 /* Clear all remnants of the previous type at TYPE, in preparation for
309 replacing it with something else. Preserve owner information. */
312 smash_type (struct type
*type
)
314 int objfile_owned
= TYPE_OBJFILE_OWNED (type
);
315 union type_owner owner
= TYPE_OWNER (type
);
317 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
319 /* Restore owner information. */
320 TYPE_OBJFILE_OWNED (type
) = objfile_owned
;
321 TYPE_OWNER (type
) = owner
;
323 /* For now, delete the rings. */
324 TYPE_CHAIN (type
) = type
;
326 /* For now, leave the pointer/reference types alone. */
329 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
330 to a pointer to memory where the pointer type should be stored.
331 If *TYPEPTR is zero, update it to point to the pointer type we return.
332 We allocate new memory if needed. */
335 make_pointer_type (struct type
*type
, struct type
**typeptr
)
337 struct type
*ntype
; /* New type */
340 ntype
= TYPE_POINTER_TYPE (type
);
345 return ntype
; /* Don't care about alloc,
346 and have new type. */
347 else if (*typeptr
== 0)
349 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
354 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
356 ntype
= alloc_type_copy (type
);
360 else /* We have storage, but need to reset it. */
363 chain
= TYPE_CHAIN (ntype
);
365 TYPE_CHAIN (ntype
) = chain
;
368 TYPE_TARGET_TYPE (ntype
) = type
;
369 TYPE_POINTER_TYPE (type
) = ntype
;
371 /* FIXME! Assumes the machine has only one representation for pointers! */
374 = gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
375 ntype
->set_code (TYPE_CODE_PTR
);
377 /* Mark pointers as unsigned. The target converts between pointers
378 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
379 gdbarch_address_to_pointer. */
380 ntype
->set_is_unsigned (true);
382 /* Update the length of all the other variants of this type. */
383 chain
= TYPE_CHAIN (ntype
);
384 while (chain
!= ntype
)
386 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
387 chain
= TYPE_CHAIN (chain
);
393 /* Given a type TYPE, return a type of pointers to that type.
394 May need to construct such a type if this is the first use. */
397 lookup_pointer_type (struct type
*type
)
399 return make_pointer_type (type
, (struct type
**) 0);
402 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
403 points to a pointer to memory where the reference type should be
404 stored. If *TYPEPTR is zero, update it to point to the reference
405 type we return. We allocate new memory if needed. REFCODE denotes
406 the kind of reference type to lookup (lvalue or rvalue reference). */
409 make_reference_type (struct type
*type
, struct type
**typeptr
,
410 enum type_code refcode
)
412 struct type
*ntype
; /* New type */
413 struct type
**reftype
;
416 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
418 ntype
= (refcode
== TYPE_CODE_REF
? TYPE_REFERENCE_TYPE (type
)
419 : TYPE_RVALUE_REFERENCE_TYPE (type
));
424 return ntype
; /* Don't care about alloc,
425 and have new type. */
426 else if (*typeptr
== 0)
428 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
433 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
435 ntype
= alloc_type_copy (type
);
439 else /* We have storage, but need to reset it. */
442 chain
= TYPE_CHAIN (ntype
);
444 TYPE_CHAIN (ntype
) = chain
;
447 TYPE_TARGET_TYPE (ntype
) = type
;
448 reftype
= (refcode
== TYPE_CODE_REF
? &TYPE_REFERENCE_TYPE (type
)
449 : &TYPE_RVALUE_REFERENCE_TYPE (type
));
453 /* FIXME! Assume the machine has only one representation for
454 references, and that it matches the (only) representation for
457 TYPE_LENGTH (ntype
) =
458 gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
459 ntype
->set_code (refcode
);
463 /* Update the length of all the other variants of this type. */
464 chain
= TYPE_CHAIN (ntype
);
465 while (chain
!= ntype
)
467 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
468 chain
= TYPE_CHAIN (chain
);
474 /* Same as above, but caller doesn't care about memory allocation
478 lookup_reference_type (struct type
*type
, enum type_code refcode
)
480 return make_reference_type (type
, (struct type
**) 0, refcode
);
483 /* Lookup the lvalue reference type for the type TYPE. */
486 lookup_lvalue_reference_type (struct type
*type
)
488 return lookup_reference_type (type
, TYPE_CODE_REF
);
491 /* Lookup the rvalue reference type for the type TYPE. */
494 lookup_rvalue_reference_type (struct type
*type
)
496 return lookup_reference_type (type
, TYPE_CODE_RVALUE_REF
);
499 /* Lookup a function type that returns type TYPE. TYPEPTR, if
500 nonzero, points to a pointer to memory where the function type
501 should be stored. If *TYPEPTR is zero, update it to point to the
502 function type we return. We allocate new memory if needed. */
505 make_function_type (struct type
*type
, struct type
**typeptr
)
507 struct type
*ntype
; /* New type */
509 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
511 ntype
= alloc_type_copy (type
);
515 else /* We have storage, but need to reset it. */
521 TYPE_TARGET_TYPE (ntype
) = type
;
523 TYPE_LENGTH (ntype
) = 1;
524 ntype
->set_code (TYPE_CODE_FUNC
);
526 INIT_FUNC_SPECIFIC (ntype
);
531 /* Given a type TYPE, return a type of functions that return that type.
532 May need to construct such a type if this is the first use. */
535 lookup_function_type (struct type
*type
)
537 return make_function_type (type
, (struct type
**) 0);
540 /* Given a type TYPE and argument types, return the appropriate
541 function type. If the final type in PARAM_TYPES is NULL, make a
545 lookup_function_type_with_arguments (struct type
*type
,
547 struct type
**param_types
)
549 struct type
*fn
= make_function_type (type
, (struct type
**) 0);
554 if (param_types
[nparams
- 1] == NULL
)
557 fn
->set_has_varargs (true);
559 else if (check_typedef (param_types
[nparams
- 1])->code ()
563 /* Caller should have ensured this. */
564 gdb_assert (nparams
== 0);
565 fn
->set_is_prototyped (true);
568 fn
->set_is_prototyped (true);
571 fn
->set_num_fields (nparams
);
573 ((struct field
*) TYPE_ZALLOC (fn
, nparams
* sizeof (struct field
)));
574 for (i
= 0; i
< nparams
; ++i
)
575 fn
->field (i
).set_type (param_types
[i
]);
580 /* Identify address space identifier by name -- return a
581 type_instance_flags. */
584 address_space_name_to_type_instance_flags (struct gdbarch
*gdbarch
,
585 const char *space_identifier
)
587 type_instance_flags type_flags
;
589 /* Check for known address space delimiters. */
590 if (!strcmp (space_identifier
, "code"))
591 return TYPE_INSTANCE_FLAG_CODE_SPACE
;
592 else if (!strcmp (space_identifier
, "data"))
593 return TYPE_INSTANCE_FLAG_DATA_SPACE
;
594 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
595 && gdbarch_address_class_name_to_type_flags (gdbarch
,
600 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
603 /* Identify address space identifier by type_instance_flags and return
604 the string version of the adress space name. */
607 address_space_type_instance_flags_to_name (struct gdbarch
*gdbarch
,
608 type_instance_flags space_flag
)
610 if (space_flag
& TYPE_INSTANCE_FLAG_CODE_SPACE
)
612 else if (space_flag
& TYPE_INSTANCE_FLAG_DATA_SPACE
)
614 else if ((space_flag
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
615 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
616 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
621 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
623 If STORAGE is non-NULL, create the new type instance there.
624 STORAGE must be in the same obstack as TYPE. */
627 make_qualified_type (struct type
*type
, type_instance_flags new_flags
,
628 struct type
*storage
)
635 if (ntype
->instance_flags () == new_flags
)
637 ntype
= TYPE_CHAIN (ntype
);
639 while (ntype
!= type
);
641 /* Create a new type instance. */
643 ntype
= alloc_type_instance (type
);
646 /* If STORAGE was provided, it had better be in the same objfile
647 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
648 if one objfile is freed and the other kept, we'd have
649 dangling pointers. */
650 gdb_assert (TYPE_OBJFILE (type
) == TYPE_OBJFILE (storage
));
653 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
654 TYPE_CHAIN (ntype
) = ntype
;
657 /* Pointers or references to the original type are not relevant to
659 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
660 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
662 /* Chain the new qualified type to the old type. */
663 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
664 TYPE_CHAIN (type
) = ntype
;
666 /* Now set the instance flags and return the new type. */
667 ntype
->set_instance_flags (new_flags
);
669 /* Set length of new type to that of the original type. */
670 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
675 /* Make an address-space-delimited variant of a type -- a type that
676 is identical to the one supplied except that it has an address
677 space attribute attached to it (such as "code" or "data").
679 The space attributes "code" and "data" are for Harvard
680 architectures. The address space attributes are for architectures
681 which have alternately sized pointers or pointers with alternate
685 make_type_with_address_space (struct type
*type
,
686 type_instance_flags space_flag
)
688 type_instance_flags new_flags
= ((type
->instance_flags ()
689 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
690 | TYPE_INSTANCE_FLAG_DATA_SPACE
691 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
))
694 return make_qualified_type (type
, new_flags
, NULL
);
697 /* Make a "c-v" variant of a type -- a type that is identical to the
698 one supplied except that it may have const or volatile attributes
699 CNST is a flag for setting the const attribute
700 VOLTL is a flag for setting the volatile attribute
701 TYPE is the base type whose variant we are creating.
703 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
704 storage to hold the new qualified type; *TYPEPTR and TYPE must be
705 in the same objfile. Otherwise, allocate fresh memory for the new
706 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
707 new type we construct. */
710 make_cv_type (int cnst
, int voltl
,
712 struct type
**typeptr
)
714 struct type
*ntype
; /* New type */
716 type_instance_flags new_flags
= (type
->instance_flags ()
717 & ~(TYPE_INSTANCE_FLAG_CONST
718 | TYPE_INSTANCE_FLAG_VOLATILE
));
721 new_flags
|= TYPE_INSTANCE_FLAG_CONST
;
724 new_flags
|= TYPE_INSTANCE_FLAG_VOLATILE
;
726 if (typeptr
&& *typeptr
!= NULL
)
728 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
729 a C-V variant chain that threads across objfiles: if one
730 objfile gets freed, then the other has a broken C-V chain.
732 This code used to try to copy over the main type from TYPE to
733 *TYPEPTR if they were in different objfiles, but that's
734 wrong, too: TYPE may have a field list or member function
735 lists, which refer to types of their own, etc. etc. The
736 whole shebang would need to be copied over recursively; you
737 can't have inter-objfile pointers. The only thing to do is
738 to leave stub types as stub types, and look them up afresh by
739 name each time you encounter them. */
740 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
));
743 ntype
= make_qualified_type (type
, new_flags
,
744 typeptr
? *typeptr
: NULL
);
752 /* Make a 'restrict'-qualified version of TYPE. */
755 make_restrict_type (struct type
*type
)
757 return make_qualified_type (type
,
758 (type
->instance_flags ()
759 | TYPE_INSTANCE_FLAG_RESTRICT
),
763 /* Make a type without const, volatile, or restrict. */
766 make_unqualified_type (struct type
*type
)
768 return make_qualified_type (type
,
769 (type
->instance_flags ()
770 & ~(TYPE_INSTANCE_FLAG_CONST
771 | TYPE_INSTANCE_FLAG_VOLATILE
772 | TYPE_INSTANCE_FLAG_RESTRICT
)),
776 /* Make a '_Atomic'-qualified version of TYPE. */
779 make_atomic_type (struct type
*type
)
781 return make_qualified_type (type
,
782 (type
->instance_flags ()
783 | TYPE_INSTANCE_FLAG_ATOMIC
),
787 /* Replace the contents of ntype with the type *type. This changes the
788 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
789 the changes are propogated to all types in the TYPE_CHAIN.
791 In order to build recursive types, it's inevitable that we'll need
792 to update types in place --- but this sort of indiscriminate
793 smashing is ugly, and needs to be replaced with something more
794 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
795 clear if more steps are needed. */
798 replace_type (struct type
*ntype
, struct type
*type
)
802 /* These two types had better be in the same objfile. Otherwise,
803 the assignment of one type's main type structure to the other
804 will produce a type with references to objects (names; field
805 lists; etc.) allocated on an objfile other than its own. */
806 gdb_assert (TYPE_OBJFILE (ntype
) == TYPE_OBJFILE (type
));
808 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
810 /* The type length is not a part of the main type. Update it for
811 each type on the variant chain. */
815 /* Assert that this element of the chain has no address-class bits
816 set in its flags. Such type variants might have type lengths
817 which are supposed to be different from the non-address-class
818 variants. This assertion shouldn't ever be triggered because
819 symbol readers which do construct address-class variants don't
820 call replace_type(). */
821 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
823 TYPE_LENGTH (chain
) = TYPE_LENGTH (type
);
824 chain
= TYPE_CHAIN (chain
);
826 while (ntype
!= chain
);
828 /* Assert that the two types have equivalent instance qualifiers.
829 This should be true for at least all of our debug readers. */
830 gdb_assert (ntype
->instance_flags () == type
->instance_flags ());
833 /* Implement direct support for MEMBER_TYPE in GNU C++.
834 May need to construct such a type if this is the first use.
835 The TYPE is the type of the member. The DOMAIN is the type
836 of the aggregate that the member belongs to. */
839 lookup_memberptr_type (struct type
*type
, struct type
*domain
)
843 mtype
= alloc_type_copy (type
);
844 smash_to_memberptr_type (mtype
, domain
, type
);
848 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
851 lookup_methodptr_type (struct type
*to_type
)
855 mtype
= alloc_type_copy (to_type
);
856 smash_to_methodptr_type (mtype
, to_type
);
860 /* Allocate a stub method whose return type is TYPE. This apparently
861 happens for speed of symbol reading, since parsing out the
862 arguments to the method is cpu-intensive, the way we are doing it.
863 So, we will fill in arguments later. This always returns a fresh
867 allocate_stub_method (struct type
*type
)
871 mtype
= alloc_type_copy (type
);
872 mtype
->set_code (TYPE_CODE_METHOD
);
873 TYPE_LENGTH (mtype
) = 1;
874 mtype
->set_is_stub (true);
875 TYPE_TARGET_TYPE (mtype
) = type
;
876 /* TYPE_SELF_TYPE (mtype) = unknown yet */
880 /* See gdbtypes.h. */
883 operator== (const dynamic_prop
&l
, const dynamic_prop
&r
)
885 if (l
.kind () != r
.kind ())
893 return l
.const_val () == r
.const_val ();
894 case PROP_ADDR_OFFSET
:
897 return l
.baton () == r
.baton ();
898 case PROP_VARIANT_PARTS
:
899 return l
.variant_parts () == r
.variant_parts ();
901 return l
.original_type () == r
.original_type ();
904 gdb_assert_not_reached ("unhandled dynamic_prop kind");
907 /* See gdbtypes.h. */
910 operator== (const range_bounds
&l
, const range_bounds
&r
)
912 #define FIELD_EQ(FIELD) (l.FIELD == r.FIELD)
914 return (FIELD_EQ (low
)
916 && FIELD_EQ (flag_upper_bound_is_count
)
917 && FIELD_EQ (flag_bound_evaluated
)
923 /* Create a range type with a dynamic range from LOW_BOUND to
924 HIGH_BOUND, inclusive. See create_range_type for further details. */
927 create_range_type (struct type
*result_type
, struct type
*index_type
,
928 const struct dynamic_prop
*low_bound
,
929 const struct dynamic_prop
*high_bound
,
932 /* The INDEX_TYPE should be a type capable of holding the upper and lower
933 bounds, as such a zero sized, or void type makes no sense. */
934 gdb_assert (index_type
->code () != TYPE_CODE_VOID
);
935 gdb_assert (TYPE_LENGTH (index_type
) > 0);
937 if (result_type
== NULL
)
938 result_type
= alloc_type_copy (index_type
);
939 result_type
->set_code (TYPE_CODE_RANGE
);
940 TYPE_TARGET_TYPE (result_type
) = index_type
;
941 if (index_type
->is_stub ())
942 result_type
->set_target_is_stub (true);
944 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
947 = (struct range_bounds
*) TYPE_ZALLOC (result_type
, sizeof (range_bounds
));
948 bounds
->low
= *low_bound
;
949 bounds
->high
= *high_bound
;
951 bounds
->stride
.set_const_val (0);
953 result_type
->set_bounds (bounds
);
955 if (index_type
->code () == TYPE_CODE_FIXED_POINT
)
956 result_type
->set_is_unsigned (index_type
->is_unsigned ());
957 /* Note that the signed-ness of a range type can't simply be copied
958 from the underlying type. Consider a case where the underlying
959 type is 'int', but the range type can hold 0..65535, and where
960 the range is further specified to fit into 16 bits. In this
961 case, if we copy the underlying type's sign, then reading some
962 range values will cause an unwanted sign extension. So, we have
963 some heuristics here instead. */
964 else if (low_bound
->kind () == PROP_CONST
&& low_bound
->const_val () >= 0)
965 result_type
->set_is_unsigned (true);
966 /* Ada allows the declaration of range types whose upper bound is
967 less than the lower bound, so checking the lower bound is not
968 enough. Make sure we do not mark a range type whose upper bound
969 is negative as unsigned. */
970 if (high_bound
->kind () == PROP_CONST
&& high_bound
->const_val () < 0)
971 result_type
->set_is_unsigned (false);
973 result_type
->set_endianity_is_not_default
974 (index_type
->endianity_is_not_default ());
979 /* See gdbtypes.h. */
982 create_range_type_with_stride (struct type
*result_type
,
983 struct type
*index_type
,
984 const struct dynamic_prop
*low_bound
,
985 const struct dynamic_prop
*high_bound
,
987 const struct dynamic_prop
*stride
,
990 result_type
= create_range_type (result_type
, index_type
, low_bound
,
993 gdb_assert (stride
!= nullptr);
994 result_type
->bounds ()->stride
= *stride
;
995 result_type
->bounds ()->flag_is_byte_stride
= byte_stride_p
;
1002 /* Create a range type using either a blank type supplied in
1003 RESULT_TYPE, or creating a new type, inheriting the objfile from
1006 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
1007 to HIGH_BOUND, inclusive.
1009 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1010 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
1013 create_static_range_type (struct type
*result_type
, struct type
*index_type
,
1014 LONGEST low_bound
, LONGEST high_bound
)
1016 struct dynamic_prop low
, high
;
1018 low
.set_const_val (low_bound
);
1019 high
.set_const_val (high_bound
);
1021 result_type
= create_range_type (result_type
, index_type
, &low
, &high
, 0);
1026 /* Predicate tests whether BOUNDS are static. Returns 1 if all bounds values
1027 are static, otherwise returns 0. */
1030 has_static_range (const struct range_bounds
*bounds
)
1032 /* If the range doesn't have a defined stride then its stride field will
1033 be initialized to the constant 0. */
1034 return (bounds
->low
.kind () == PROP_CONST
1035 && bounds
->high
.kind () == PROP_CONST
1036 && bounds
->stride
.kind () == PROP_CONST
);
1039 /* See gdbtypes.h. */
1041 gdb::optional
<LONGEST
>
1042 get_discrete_low_bound (struct type
*type
)
1044 type
= check_typedef (type
);
1045 switch (type
->code ())
1047 case TYPE_CODE_RANGE
:
1049 /* This function only works for ranges with a constant low bound. */
1050 if (type
->bounds ()->low
.kind () != PROP_CONST
)
1053 LONGEST low
= type
->bounds ()->low
.const_val ();
1055 if (TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_ENUM
)
1057 gdb::optional
<LONGEST
> low_pos
1058 = discrete_position (TYPE_TARGET_TYPE (type
), low
);
1060 if (low_pos
.has_value ())
1067 case TYPE_CODE_ENUM
:
1069 if (type
->num_fields () > 0)
1071 /* The enums may not be sorted by value, so search all
1073 LONGEST low
= TYPE_FIELD_ENUMVAL (type
, 0);
1075 for (int i
= 0; i
< type
->num_fields (); i
++)
1077 if (TYPE_FIELD_ENUMVAL (type
, i
) < low
)
1078 low
= TYPE_FIELD_ENUMVAL (type
, i
);
1081 /* Set unsigned indicator if warranted. */
1083 type
->set_is_unsigned (true);
1091 case TYPE_CODE_BOOL
:
1095 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
1098 if (!type
->is_unsigned ())
1099 return -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
1102 case TYPE_CODE_CHAR
:
1110 /* See gdbtypes.h. */
1112 gdb::optional
<LONGEST
>
1113 get_discrete_high_bound (struct type
*type
)
1115 type
= check_typedef (type
);
1116 switch (type
->code ())
1118 case TYPE_CODE_RANGE
:
1120 /* This function only works for ranges with a constant high bound. */
1121 if (type
->bounds ()->high
.kind () != PROP_CONST
)
1124 LONGEST high
= type
->bounds ()->high
.const_val ();
1126 if (TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_ENUM
)
1128 gdb::optional
<LONGEST
> high_pos
1129 = discrete_position (TYPE_TARGET_TYPE (type
), high
);
1131 if (high_pos
.has_value ())
1138 case TYPE_CODE_ENUM
:
1140 if (type
->num_fields () > 0)
1142 /* The enums may not be sorted by value, so search all
1144 LONGEST high
= TYPE_FIELD_ENUMVAL (type
, 0);
1146 for (int i
= 0; i
< type
->num_fields (); i
++)
1148 if (TYPE_FIELD_ENUMVAL (type
, i
) > high
)
1149 high
= TYPE_FIELD_ENUMVAL (type
, i
);
1158 case TYPE_CODE_BOOL
:
1162 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
1165 if (!type
->is_unsigned ())
1167 LONGEST low
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
1172 case TYPE_CODE_CHAR
:
1174 /* This round-about calculation is to avoid shifting by
1175 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
1176 if TYPE_LENGTH (type) == sizeof (LONGEST). */
1177 LONGEST high
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
1178 return (high
- 1) | high
;
1186 /* See gdbtypes.h. */
1189 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
1191 gdb::optional
<LONGEST
> low
= get_discrete_low_bound (type
);
1192 if (!low
.has_value ())
1195 gdb::optional
<LONGEST
> high
= get_discrete_high_bound (type
);
1196 if (!high
.has_value ())
1205 /* See gdbtypes.h */
1208 get_array_bounds (struct type
*type
, LONGEST
*low_bound
, LONGEST
*high_bound
)
1210 struct type
*index
= type
->index_type ();
1217 if (!get_discrete_bounds (index
, &low
, &high
))
1229 /* Assuming that TYPE is a discrete type and VAL is a valid integer
1230 representation of a value of this type, save the corresponding
1231 position number in POS.
1233 Its differs from VAL only in the case of enumeration types. In
1234 this case, the position number of the value of the first listed
1235 enumeration literal is zero; the position number of the value of
1236 each subsequent enumeration literal is one more than that of its
1237 predecessor in the list.
1239 Return 1 if the operation was successful. Return zero otherwise,
1240 in which case the value of POS is unmodified.
1243 gdb::optional
<LONGEST
>
1244 discrete_position (struct type
*type
, LONGEST val
)
1246 if (type
->code () == TYPE_CODE_RANGE
)
1247 type
= TYPE_TARGET_TYPE (type
);
1249 if (type
->code () == TYPE_CODE_ENUM
)
1253 for (i
= 0; i
< type
->num_fields (); i
+= 1)
1255 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
1259 /* Invalid enumeration value. */
1266 /* If the array TYPE has static bounds calculate and update its
1267 size, then return true. Otherwise return false and leave TYPE
1271 update_static_array_size (struct type
*type
)
1273 gdb_assert (type
->code () == TYPE_CODE_ARRAY
);
1275 struct type
*range_type
= type
->index_type ();
1277 if (type
->dyn_prop (DYN_PROP_BYTE_STRIDE
) == nullptr
1278 && has_static_range (range_type
->bounds ())
1279 && (!type_not_associated (type
)
1280 && !type_not_allocated (type
)))
1282 LONGEST low_bound
, high_bound
;
1284 struct type
*element_type
;
1286 /* If the array itself doesn't provide a stride value then take
1287 whatever stride the range provides. Don't update BIT_STRIDE as
1288 we don't want to place the stride value from the range into this
1289 arrays bit size field. */
1290 stride
= TYPE_FIELD_BITSIZE (type
, 0);
1292 stride
= range_type
->bit_stride ();
1294 if (!get_discrete_bounds (range_type
, &low_bound
, &high_bound
))
1295 low_bound
= high_bound
= 0;
1297 element_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1298 /* Be careful when setting the array length. Ada arrays can be
1299 empty arrays with the high_bound being smaller than the low_bound.
1300 In such cases, the array length should be zero. */
1301 if (high_bound
< low_bound
)
1302 TYPE_LENGTH (type
) = 0;
1303 else if (stride
!= 0)
1305 /* Ensure that the type length is always positive, even in the
1306 case where (for example in Fortran) we have a negative
1307 stride. It is possible to have a single element array with a
1308 negative stride in Fortran (this doesn't mean anything
1309 special, it's still just a single element array) so do
1310 consider that case when touching this code. */
1311 LONGEST element_count
= std::abs (high_bound
- low_bound
+ 1);
1313 = ((std::abs (stride
) * element_count
) + 7) / 8;
1316 TYPE_LENGTH (type
) =
1317 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
1319 /* If this array's element is itself an array with a bit stride,
1320 then we want to update this array's bit stride to reflect the
1321 size of the sub-array. Otherwise, we'll end up using the
1322 wrong size when trying to find elements of the outer
1324 if (element_type
->code () == TYPE_CODE_ARRAY
1325 && TYPE_LENGTH (element_type
) != 0
1326 && TYPE_FIELD_BITSIZE (element_type
, 0) != 0
1327 && get_array_bounds (element_type
, &low_bound
, &high_bound
)
1328 && high_bound
>= low_bound
)
1329 TYPE_FIELD_BITSIZE (type
, 0)
1330 = ((high_bound
- low_bound
+ 1)
1331 * TYPE_FIELD_BITSIZE (element_type
, 0));
1339 /* Create an array type using either a blank type supplied in
1340 RESULT_TYPE, or creating a new type, inheriting the objfile from
1343 Elements will be of type ELEMENT_TYPE, the indices will be of type
1346 BYTE_STRIDE_PROP, when not NULL, provides the array's byte stride.
1347 This byte stride property is added to the resulting array type
1348 as a DYN_PROP_BYTE_STRIDE. As a consequence, the BYTE_STRIDE_PROP
1349 argument can only be used to create types that are objfile-owned
1350 (see add_dyn_prop), meaning that either this function must be called
1351 with an objfile-owned RESULT_TYPE, or an objfile-owned RANGE_TYPE.
1353 BIT_STRIDE is taken into account only when BYTE_STRIDE_PROP is NULL.
1354 If BIT_STRIDE is not zero, build a packed array type whose element
1355 size is BIT_STRIDE. Otherwise, ignore this parameter.
1357 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1358 sure it is TYPE_CODE_UNDEF before we bash it into an array
1362 create_array_type_with_stride (struct type
*result_type
,
1363 struct type
*element_type
,
1364 struct type
*range_type
,
1365 struct dynamic_prop
*byte_stride_prop
,
1366 unsigned int bit_stride
)
1368 if (byte_stride_prop
!= NULL
1369 && byte_stride_prop
->kind () == PROP_CONST
)
1371 /* The byte stride is actually not dynamic. Pretend we were
1372 called with bit_stride set instead of byte_stride_prop.
1373 This will give us the same result type, while avoiding
1374 the need to handle this as a special case. */
1375 bit_stride
= byte_stride_prop
->const_val () * 8;
1376 byte_stride_prop
= NULL
;
1379 if (result_type
== NULL
)
1380 result_type
= alloc_type_copy (range_type
);
1382 result_type
->set_code (TYPE_CODE_ARRAY
);
1383 TYPE_TARGET_TYPE (result_type
) = element_type
;
1385 result_type
->set_num_fields (1);
1386 result_type
->set_fields
1387 ((struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
)));
1388 result_type
->set_index_type (range_type
);
1389 if (byte_stride_prop
!= NULL
)
1390 result_type
->add_dyn_prop (DYN_PROP_BYTE_STRIDE
, *byte_stride_prop
);
1391 else if (bit_stride
> 0)
1392 TYPE_FIELD_BITSIZE (result_type
, 0) = bit_stride
;
1394 if (!update_static_array_size (result_type
))
1396 /* This type is dynamic and its length needs to be computed
1397 on demand. In the meantime, avoid leaving the TYPE_LENGTH
1398 undefined by setting it to zero. Although we are not expected
1399 to trust TYPE_LENGTH in this case, setting the size to zero
1400 allows us to avoid allocating objects of random sizes in case
1401 we accidently do. */
1402 TYPE_LENGTH (result_type
) = 0;
1405 /* TYPE_TARGET_STUB will take care of zero length arrays. */
1406 if (TYPE_LENGTH (result_type
) == 0)
1407 result_type
->set_target_is_stub (true);
1412 /* Same as create_array_type_with_stride but with no bit_stride
1413 (BIT_STRIDE = 0), thus building an unpacked array. */
1416 create_array_type (struct type
*result_type
,
1417 struct type
*element_type
,
1418 struct type
*range_type
)
1420 return create_array_type_with_stride (result_type
, element_type
,
1421 range_type
, NULL
, 0);
1425 lookup_array_range_type (struct type
*element_type
,
1426 LONGEST low_bound
, LONGEST high_bound
)
1428 struct type
*index_type
;
1429 struct type
*range_type
;
1431 if (TYPE_OBJFILE_OWNED (element_type
))
1432 index_type
= objfile_type (TYPE_OWNER (element_type
).objfile
)->builtin_int
;
1434 index_type
= builtin_type (get_type_arch (element_type
))->builtin_int
;
1435 range_type
= create_static_range_type (NULL
, index_type
,
1436 low_bound
, high_bound
);
1438 return create_array_type (NULL
, element_type
, range_type
);
1441 /* Create a string type using either a blank type supplied in
1442 RESULT_TYPE, or creating a new type. String types are similar
1443 enough to array of char types that we can use create_array_type to
1444 build the basic type and then bash it into a string type.
1446 For fixed length strings, the range type contains 0 as the lower
1447 bound and the length of the string minus one as the upper bound.
1449 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1450 sure it is TYPE_CODE_UNDEF before we bash it into a string
1454 create_string_type (struct type
*result_type
,
1455 struct type
*string_char_type
,
1456 struct type
*range_type
)
1458 result_type
= create_array_type (result_type
,
1461 result_type
->set_code (TYPE_CODE_STRING
);
1466 lookup_string_range_type (struct type
*string_char_type
,
1467 LONGEST low_bound
, LONGEST high_bound
)
1469 struct type
*result_type
;
1471 result_type
= lookup_array_range_type (string_char_type
,
1472 low_bound
, high_bound
);
1473 result_type
->set_code (TYPE_CODE_STRING
);
1478 create_set_type (struct type
*result_type
, struct type
*domain_type
)
1480 if (result_type
== NULL
)
1481 result_type
= alloc_type_copy (domain_type
);
1483 result_type
->set_code (TYPE_CODE_SET
);
1484 result_type
->set_num_fields (1);
1485 result_type
->set_fields
1486 ((struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
)));
1488 if (!domain_type
->is_stub ())
1490 LONGEST low_bound
, high_bound
, bit_length
;
1492 if (!get_discrete_bounds (domain_type
, &low_bound
, &high_bound
))
1493 low_bound
= high_bound
= 0;
1495 bit_length
= high_bound
- low_bound
+ 1;
1496 TYPE_LENGTH (result_type
)
1497 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
1499 result_type
->set_is_unsigned (true);
1501 result_type
->field (0).set_type (domain_type
);
1506 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
1507 and any array types nested inside it. */
1510 make_vector_type (struct type
*array_type
)
1512 struct type
*inner_array
, *elt_type
;
1514 /* Find the innermost array type, in case the array is
1515 multi-dimensional. */
1516 inner_array
= array_type
;
1517 while (TYPE_TARGET_TYPE (inner_array
)->code () == TYPE_CODE_ARRAY
)
1518 inner_array
= TYPE_TARGET_TYPE (inner_array
);
1520 elt_type
= TYPE_TARGET_TYPE (inner_array
);
1521 if (elt_type
->code () == TYPE_CODE_INT
)
1523 type_instance_flags flags
1524 = elt_type
->instance_flags () | TYPE_INSTANCE_FLAG_NOTTEXT
;
1525 elt_type
= make_qualified_type (elt_type
, flags
, NULL
);
1526 TYPE_TARGET_TYPE (inner_array
) = elt_type
;
1529 array_type
->set_is_vector (true);
1533 init_vector_type (struct type
*elt_type
, int n
)
1535 struct type
*array_type
;
1537 array_type
= lookup_array_range_type (elt_type
, 0, n
- 1);
1538 make_vector_type (array_type
);
1542 /* Internal routine called by TYPE_SELF_TYPE to return the type that TYPE
1543 belongs to. In c++ this is the class of "this", but TYPE_THIS_TYPE is too
1544 confusing. "self" is a common enough replacement for "this".
1545 TYPE must be one of TYPE_CODE_METHODPTR, TYPE_CODE_MEMBERPTR, or
1546 TYPE_CODE_METHOD. */
1549 internal_type_self_type (struct type
*type
)
1551 switch (type
->code ())
1553 case TYPE_CODE_METHODPTR
:
1554 case TYPE_CODE_MEMBERPTR
:
1555 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1557 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_SELF_TYPE
);
1558 return TYPE_MAIN_TYPE (type
)->type_specific
.self_type
;
1559 case TYPE_CODE_METHOD
:
1560 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1562 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
1563 return TYPE_MAIN_TYPE (type
)->type_specific
.func_stuff
->self_type
;
1565 gdb_assert_not_reached ("bad type");
1569 /* Set the type of the class that TYPE belongs to.
1570 In c++ this is the class of "this".
1571 TYPE must be one of TYPE_CODE_METHODPTR, TYPE_CODE_MEMBERPTR, or
1572 TYPE_CODE_METHOD. */
1575 set_type_self_type (struct type
*type
, struct type
*self_type
)
1577 switch (type
->code ())
1579 case TYPE_CODE_METHODPTR
:
1580 case TYPE_CODE_MEMBERPTR
:
1581 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1582 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_SELF_TYPE
;
1583 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_SELF_TYPE
);
1584 TYPE_MAIN_TYPE (type
)->type_specific
.self_type
= self_type
;
1586 case TYPE_CODE_METHOD
:
1587 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1588 INIT_FUNC_SPECIFIC (type
);
1589 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
1590 TYPE_MAIN_TYPE (type
)->type_specific
.func_stuff
->self_type
= self_type
;
1593 gdb_assert_not_reached ("bad type");
1597 /* Smash TYPE to be a type of pointers to members of SELF_TYPE with type
1598 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1599 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1600 TYPE doesn't include the offset (that's the value of the MEMBER
1601 itself), but does include the structure type into which it points
1604 When "smashing" the type, we preserve the objfile that the old type
1605 pointed to, since we aren't changing where the type is actually
1609 smash_to_memberptr_type (struct type
*type
, struct type
*self_type
,
1610 struct type
*to_type
)
1613 type
->set_code (TYPE_CODE_MEMBERPTR
);
1614 TYPE_TARGET_TYPE (type
) = to_type
;
1615 set_type_self_type (type
, self_type
);
1616 /* Assume that a data member pointer is the same size as a normal
1619 = gdbarch_ptr_bit (get_type_arch (to_type
)) / TARGET_CHAR_BIT
;
1622 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1624 When "smashing" the type, we preserve the objfile that the old type
1625 pointed to, since we aren't changing where the type is actually
1629 smash_to_methodptr_type (struct type
*type
, struct type
*to_type
)
1632 type
->set_code (TYPE_CODE_METHODPTR
);
1633 TYPE_TARGET_TYPE (type
) = to_type
;
1634 set_type_self_type (type
, TYPE_SELF_TYPE (to_type
));
1635 TYPE_LENGTH (type
) = cplus_method_ptr_size (to_type
);
1638 /* Smash TYPE to be a type of method of SELF_TYPE with type TO_TYPE.
1639 METHOD just means `function that gets an extra "this" argument'.
1641 When "smashing" the type, we preserve the objfile that the old type
1642 pointed to, since we aren't changing where the type is actually
1646 smash_to_method_type (struct type
*type
, struct type
*self_type
,
1647 struct type
*to_type
, struct field
*args
,
1648 int nargs
, int varargs
)
1651 type
->set_code (TYPE_CODE_METHOD
);
1652 TYPE_TARGET_TYPE (type
) = to_type
;
1653 set_type_self_type (type
, self_type
);
1654 type
->set_fields (args
);
1655 type
->set_num_fields (nargs
);
1657 type
->set_has_varargs (true);
1658 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1661 /* A wrapper of TYPE_NAME which calls error if the type is anonymous.
1662 Since GCC PR debug/47510 DWARF provides associated information to detect the
1663 anonymous class linkage name from its typedef.
1665 Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
1669 type_name_or_error (struct type
*type
)
1671 struct type
*saved_type
= type
;
1673 struct objfile
*objfile
;
1675 type
= check_typedef (type
);
1677 name
= type
->name ();
1681 name
= saved_type
->name ();
1682 objfile
= TYPE_OBJFILE (saved_type
);
1683 error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
1684 name
? name
: "<anonymous>",
1685 objfile
? objfile_name (objfile
) : "<arch>");
1688 /* Lookup a typedef or primitive type named NAME, visible in lexical
1689 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1690 suitably defined. */
1693 lookup_typename (const struct language_defn
*language
,
1695 const struct block
*block
, int noerr
)
1699 sym
= lookup_symbol_in_language (name
, block
, VAR_DOMAIN
,
1700 language
->la_language
, NULL
).symbol
;
1701 if (sym
!= NULL
&& SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
1702 return SYMBOL_TYPE (sym
);
1706 error (_("No type named %s."), name
);
1710 lookup_unsigned_typename (const struct language_defn
*language
,
1713 char *uns
= (char *) alloca (strlen (name
) + 10);
1715 strcpy (uns
, "unsigned ");
1716 strcpy (uns
+ 9, name
);
1717 return lookup_typename (language
, uns
, NULL
, 0);
1721 lookup_signed_typename (const struct language_defn
*language
, const char *name
)
1724 char *uns
= (char *) alloca (strlen (name
) + 8);
1726 strcpy (uns
, "signed ");
1727 strcpy (uns
+ 7, name
);
1728 t
= lookup_typename (language
, uns
, NULL
, 1);
1729 /* If we don't find "signed FOO" just try again with plain "FOO". */
1732 return lookup_typename (language
, name
, NULL
, 0);
1735 /* Lookup a structure type named "struct NAME",
1736 visible in lexical block BLOCK. */
1739 lookup_struct (const char *name
, const struct block
*block
)
1743 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
1747 error (_("No struct type named %s."), name
);
1749 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_STRUCT
)
1751 error (_("This context has class, union or enum %s, not a struct."),
1754 return (SYMBOL_TYPE (sym
));
1757 /* Lookup a union type named "union NAME",
1758 visible in lexical block BLOCK. */
1761 lookup_union (const char *name
, const struct block
*block
)
1766 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
1769 error (_("No union type named %s."), name
);
1771 t
= SYMBOL_TYPE (sym
);
1773 if (t
->code () == TYPE_CODE_UNION
)
1776 /* If we get here, it's not a union. */
1777 error (_("This context has class, struct or enum %s, not a union."),
1781 /* Lookup an enum type named "enum NAME",
1782 visible in lexical block BLOCK. */
1785 lookup_enum (const char *name
, const struct block
*block
)
1789 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
1792 error (_("No enum type named %s."), name
);
1794 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_ENUM
)
1796 error (_("This context has class, struct or union %s, not an enum."),
1799 return (SYMBOL_TYPE (sym
));
1802 /* Lookup a template type named "template NAME<TYPE>",
1803 visible in lexical block BLOCK. */
1806 lookup_template_type (const char *name
, struct type
*type
,
1807 const struct block
*block
)
1810 char *nam
= (char *)
1811 alloca (strlen (name
) + strlen (type
->name ()) + 4);
1815 strcat (nam
, type
->name ());
1816 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1818 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0).symbol
;
1822 error (_("No template type named %s."), name
);
1824 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_STRUCT
)
1826 error (_("This context has class, union or enum %s, not a struct."),
1829 return (SYMBOL_TYPE (sym
));
1832 /* See gdbtypes.h. */
1835 lookup_struct_elt (struct type
*type
, const char *name
, int noerr
)
1841 type
= check_typedef (type
);
1842 if (type
->code () != TYPE_CODE_PTR
1843 && type
->code () != TYPE_CODE_REF
)
1845 type
= TYPE_TARGET_TYPE (type
);
1848 if (type
->code () != TYPE_CODE_STRUCT
1849 && type
->code () != TYPE_CODE_UNION
)
1851 std::string type_name
= type_to_string (type
);
1852 error (_("Type %s is not a structure or union type."),
1853 type_name
.c_str ());
1856 for (i
= type
->num_fields () - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1858 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1860 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1862 return {&type
->field (i
), TYPE_FIELD_BITPOS (type
, i
)};
1864 else if (!t_field_name
|| *t_field_name
== '\0')
1867 = lookup_struct_elt (type
->field (i
).type (), name
, 1);
1868 if (elt
.field
!= NULL
)
1870 elt
.offset
+= TYPE_FIELD_BITPOS (type
, i
);
1876 /* OK, it's not in this class. Recursively check the baseclasses. */
1877 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1879 struct_elt elt
= lookup_struct_elt (TYPE_BASECLASS (type
, i
), name
, 1);
1880 if (elt
.field
!= NULL
)
1885 return {nullptr, 0};
1887 std::string type_name
= type_to_string (type
);
1888 error (_("Type %s has no component named %s."), type_name
.c_str (), name
);
1891 /* See gdbtypes.h. */
1894 lookup_struct_elt_type (struct type
*type
, const char *name
, int noerr
)
1896 struct_elt elt
= lookup_struct_elt (type
, name
, noerr
);
1897 if (elt
.field
!= NULL
)
1898 return elt
.field
->type ();
1903 /* Store in *MAX the largest number representable by unsigned integer type
1907 get_unsigned_type_max (struct type
*type
, ULONGEST
*max
)
1911 type
= check_typedef (type
);
1912 gdb_assert (type
->code () == TYPE_CODE_INT
&& type
->is_unsigned ());
1913 gdb_assert (TYPE_LENGTH (type
) <= sizeof (ULONGEST
));
1915 /* Written this way to avoid overflow. */
1916 n
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
1917 *max
= ((((ULONGEST
) 1 << (n
- 1)) - 1) << 1) | 1;
1920 /* Store in *MIN, *MAX the smallest and largest numbers representable by
1921 signed integer type TYPE. */
1924 get_signed_type_minmax (struct type
*type
, LONGEST
*min
, LONGEST
*max
)
1928 type
= check_typedef (type
);
1929 gdb_assert (type
->code () == TYPE_CODE_INT
&& !type
->is_unsigned ());
1930 gdb_assert (TYPE_LENGTH (type
) <= sizeof (LONGEST
));
1932 n
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
1933 *min
= -((ULONGEST
) 1 << (n
- 1));
1934 *max
= ((ULONGEST
) 1 << (n
- 1)) - 1;
1937 /* Internal routine called by TYPE_VPTR_FIELDNO to return the value of
1938 cplus_stuff.vptr_fieldno.
1940 cplus_stuff is initialized to cplus_struct_default which does not
1941 set vptr_fieldno to -1 for portability reasons (IWBN to use C99
1942 designated initializers). We cope with that here. */
1945 internal_type_vptr_fieldno (struct type
*type
)
1947 type
= check_typedef (type
);
1948 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1949 || type
->code () == TYPE_CODE_UNION
);
1950 if (!HAVE_CPLUS_STRUCT (type
))
1952 return TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_fieldno
;
1955 /* Set the value of cplus_stuff.vptr_fieldno. */
1958 set_type_vptr_fieldno (struct type
*type
, int fieldno
)
1960 type
= check_typedef (type
);
1961 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1962 || type
->code () == TYPE_CODE_UNION
);
1963 if (!HAVE_CPLUS_STRUCT (type
))
1964 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1965 TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_fieldno
= fieldno
;
1968 /* Internal routine called by TYPE_VPTR_BASETYPE to return the value of
1969 cplus_stuff.vptr_basetype. */
1972 internal_type_vptr_basetype (struct type
*type
)
1974 type
= check_typedef (type
);
1975 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1976 || type
->code () == TYPE_CODE_UNION
);
1977 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_CPLUS_STUFF
);
1978 return TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_basetype
;
1981 /* Set the value of cplus_stuff.vptr_basetype. */
1984 set_type_vptr_basetype (struct type
*type
, struct type
*basetype
)
1986 type
= check_typedef (type
);
1987 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1988 || type
->code () == TYPE_CODE_UNION
);
1989 if (!HAVE_CPLUS_STRUCT (type
))
1990 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1991 TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_basetype
= basetype
;
1994 /* Lookup the vptr basetype/fieldno values for TYPE.
1995 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1996 vptr_fieldno. Also, if found and basetype is from the same objfile,
1998 If not found, return -1 and ignore BASETYPEP.
1999 Callers should be aware that in some cases (for example,
2000 the type or one of its baseclasses is a stub type and we are
2001 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
2002 this function will not be able to find the
2003 virtual function table pointer, and vptr_fieldno will remain -1 and
2004 vptr_basetype will remain NULL or incomplete. */
2007 get_vptr_fieldno (struct type
*type
, struct type
**basetypep
)
2009 type
= check_typedef (type
);
2011 if (TYPE_VPTR_FIELDNO (type
) < 0)
2015 /* We must start at zero in case the first (and only) baseclass
2016 is virtual (and hence we cannot share the table pointer). */
2017 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
2019 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
2021 struct type
*basetype
;
2023 fieldno
= get_vptr_fieldno (baseclass
, &basetype
);
2026 /* If the type comes from a different objfile we can't cache
2027 it, it may have a different lifetime. PR 2384 */
2028 if (TYPE_OBJFILE (type
) == TYPE_OBJFILE (basetype
))
2030 set_type_vptr_fieldno (type
, fieldno
);
2031 set_type_vptr_basetype (type
, basetype
);
2034 *basetypep
= basetype
;
2045 *basetypep
= TYPE_VPTR_BASETYPE (type
);
2046 return TYPE_VPTR_FIELDNO (type
);
2051 stub_noname_complaint (void)
2053 complaint (_("stub type has NULL name"));
2056 /* Return nonzero if TYPE has a DYN_PROP_BYTE_STRIDE dynamic property
2057 attached to it, and that property has a non-constant value. */
2060 array_type_has_dynamic_stride (struct type
*type
)
2062 struct dynamic_prop
*prop
= type
->dyn_prop (DYN_PROP_BYTE_STRIDE
);
2064 return (prop
!= NULL
&& prop
->kind () != PROP_CONST
);
2067 /* Worker for is_dynamic_type. */
2070 is_dynamic_type_internal (struct type
*type
, int top_level
)
2072 type
= check_typedef (type
);
2074 /* We only want to recognize references at the outermost level. */
2075 if (top_level
&& type
->code () == TYPE_CODE_REF
)
2076 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2078 /* Types that have a dynamic TYPE_DATA_LOCATION are considered
2079 dynamic, even if the type itself is statically defined.
2080 From a user's point of view, this may appear counter-intuitive;
2081 but it makes sense in this context, because the point is to determine
2082 whether any part of the type needs to be resolved before it can
2084 if (TYPE_DATA_LOCATION (type
) != NULL
2085 && (TYPE_DATA_LOCATION_KIND (type
) == PROP_LOCEXPR
2086 || TYPE_DATA_LOCATION_KIND (type
) == PROP_LOCLIST
))
2089 if (TYPE_ASSOCIATED_PROP (type
))
2092 if (TYPE_ALLOCATED_PROP (type
))
2095 struct dynamic_prop
*prop
= type
->dyn_prop (DYN_PROP_VARIANT_PARTS
);
2096 if (prop
!= nullptr && prop
->kind () != PROP_TYPE
)
2099 if (TYPE_HAS_DYNAMIC_LENGTH (type
))
2102 switch (type
->code ())
2104 case TYPE_CODE_RANGE
:
2106 /* A range type is obviously dynamic if it has at least one
2107 dynamic bound. But also consider the range type to be
2108 dynamic when its subtype is dynamic, even if the bounds
2109 of the range type are static. It allows us to assume that
2110 the subtype of a static range type is also static. */
2111 return (!has_static_range (type
->bounds ())
2112 || is_dynamic_type_internal (TYPE_TARGET_TYPE (type
), 0));
2115 case TYPE_CODE_STRING
:
2116 /* Strings are very much like an array of characters, and can be
2117 treated as one here. */
2118 case TYPE_CODE_ARRAY
:
2120 gdb_assert (type
->num_fields () == 1);
2122 /* The array is dynamic if either the bounds are dynamic... */
2123 if (is_dynamic_type_internal (type
->index_type (), 0))
2125 /* ... or the elements it contains have a dynamic contents... */
2126 if (is_dynamic_type_internal (TYPE_TARGET_TYPE (type
), 0))
2128 /* ... or if it has a dynamic stride... */
2129 if (array_type_has_dynamic_stride (type
))
2134 case TYPE_CODE_STRUCT
:
2135 case TYPE_CODE_UNION
:
2139 bool is_cplus
= HAVE_CPLUS_STRUCT (type
);
2141 for (i
= 0; i
< type
->num_fields (); ++i
)
2143 /* Static fields can be ignored here. */
2144 if (field_is_static (&type
->field (i
)))
2146 /* If the field has dynamic type, then so does TYPE. */
2147 if (is_dynamic_type_internal (type
->field (i
).type (), 0))
2149 /* If the field is at a fixed offset, then it is not
2151 if (TYPE_FIELD_LOC_KIND (type
, i
) != FIELD_LOC_KIND_DWARF_BLOCK
)
2153 /* Do not consider C++ virtual base types to be dynamic
2154 due to the field's offset being dynamic; these are
2155 handled via other means. */
2156 if (is_cplus
&& BASETYPE_VIA_VIRTUAL (type
, i
))
2167 /* See gdbtypes.h. */
2170 is_dynamic_type (struct type
*type
)
2172 return is_dynamic_type_internal (type
, 1);
2175 static struct type
*resolve_dynamic_type_internal
2176 (struct type
*type
, struct property_addr_info
*addr_stack
, int top_level
);
2178 /* Given a dynamic range type (dyn_range_type) and a stack of
2179 struct property_addr_info elements, return a static version
2182 static struct type
*
2183 resolve_dynamic_range (struct type
*dyn_range_type
,
2184 struct property_addr_info
*addr_stack
)
2187 struct type
*static_range_type
, *static_target_type
;
2188 struct dynamic_prop low_bound
, high_bound
, stride
;
2190 gdb_assert (dyn_range_type
->code () == TYPE_CODE_RANGE
);
2192 const struct dynamic_prop
*prop
= &dyn_range_type
->bounds ()->low
;
2193 if (dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2194 low_bound
.set_const_val (value
);
2196 low_bound
.set_undefined ();
2198 prop
= &dyn_range_type
->bounds ()->high
;
2199 if (dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2201 high_bound
.set_const_val (value
);
2203 if (dyn_range_type
->bounds ()->flag_upper_bound_is_count
)
2204 high_bound
.set_const_val
2205 (low_bound
.const_val () + high_bound
.const_val () - 1);
2208 high_bound
.set_undefined ();
2210 bool byte_stride_p
= dyn_range_type
->bounds ()->flag_is_byte_stride
;
2211 prop
= &dyn_range_type
->bounds ()->stride
;
2212 if (dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2214 stride
.set_const_val (value
);
2216 /* If we have a bit stride that is not an exact number of bytes then
2217 I really don't think this is going to work with current GDB, the
2218 array indexing code in GDB seems to be pretty heavily tied to byte
2219 offsets right now. Assuming 8 bits in a byte. */
2220 struct gdbarch
*gdbarch
= get_type_arch (dyn_range_type
);
2221 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
2222 if (!byte_stride_p
&& (value
% (unit_size
* 8)) != 0)
2223 error (_("bit strides that are not a multiple of the byte size "
2224 "are currently not supported"));
2228 stride
.set_undefined ();
2229 byte_stride_p
= true;
2233 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (dyn_range_type
),
2235 LONGEST bias
= dyn_range_type
->bounds ()->bias
;
2236 static_range_type
= create_range_type_with_stride
2237 (copy_type (dyn_range_type
), static_target_type
,
2238 &low_bound
, &high_bound
, bias
, &stride
, byte_stride_p
);
2239 static_range_type
->bounds ()->flag_bound_evaluated
= 1;
2240 return static_range_type
;
2243 /* Resolves dynamic bound values of an array or string type TYPE to static
2244 ones. ADDR_STACK is a stack of struct property_addr_info to be used if
2245 needed during the dynamic resolution. */
2247 static struct type
*
2248 resolve_dynamic_array_or_string (struct type
*type
,
2249 struct property_addr_info
*addr_stack
)
2252 struct type
*elt_type
;
2253 struct type
*range_type
;
2254 struct type
*ary_dim
;
2255 struct dynamic_prop
*prop
;
2256 unsigned int bit_stride
= 0;
2258 /* For dynamic type resolution strings can be treated like arrays of
2260 gdb_assert (type
->code () == TYPE_CODE_ARRAY
2261 || type
->code () == TYPE_CODE_STRING
);
2263 type
= copy_type (type
);
2266 range_type
= check_typedef (elt_type
->index_type ());
2267 range_type
= resolve_dynamic_range (range_type
, addr_stack
);
2269 /* Resolve allocated/associated here before creating a new array type, which
2270 will update the length of the array accordingly. */
2271 prop
= TYPE_ALLOCATED_PROP (type
);
2272 if (prop
!= NULL
&& dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2273 prop
->set_const_val (value
);
2275 prop
= TYPE_ASSOCIATED_PROP (type
);
2276 if (prop
!= NULL
&& dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2277 prop
->set_const_val (value
);
2279 ary_dim
= check_typedef (TYPE_TARGET_TYPE (elt_type
));
2281 if (ary_dim
!= NULL
&& ary_dim
->code () == TYPE_CODE_ARRAY
)
2282 elt_type
= resolve_dynamic_array_or_string (ary_dim
, addr_stack
);
2284 elt_type
= TYPE_TARGET_TYPE (type
);
2286 prop
= type
->dyn_prop (DYN_PROP_BYTE_STRIDE
);
2289 if (dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2291 type
->remove_dyn_prop (DYN_PROP_BYTE_STRIDE
);
2292 bit_stride
= (unsigned int) (value
* 8);
2296 /* Could be a bug in our code, but it could also happen
2297 if the DWARF info is not correct. Issue a warning,
2298 and assume no byte/bit stride (leave bit_stride = 0). */
2299 warning (_("cannot determine array stride for type %s"),
2300 type
->name () ? type
->name () : "<no name>");
2304 bit_stride
= TYPE_FIELD_BITSIZE (type
, 0);
2306 return create_array_type_with_stride (type
, elt_type
, range_type
, NULL
,
2310 /* Resolve dynamic bounds of members of the union TYPE to static
2311 bounds. ADDR_STACK is a stack of struct property_addr_info
2312 to be used if needed during the dynamic resolution. */
2314 static struct type
*
2315 resolve_dynamic_union (struct type
*type
,
2316 struct property_addr_info
*addr_stack
)
2318 struct type
*resolved_type
;
2320 unsigned int max_len
= 0;
2322 gdb_assert (type
->code () == TYPE_CODE_UNION
);
2324 resolved_type
= copy_type (type
);
2325 resolved_type
->set_fields
2327 TYPE_ALLOC (resolved_type
,
2328 resolved_type
->num_fields () * sizeof (struct field
)));
2329 memcpy (resolved_type
->fields (),
2331 resolved_type
->num_fields () * sizeof (struct field
));
2332 for (i
= 0; i
< resolved_type
->num_fields (); ++i
)
2336 if (field_is_static (&type
->field (i
)))
2339 t
= resolve_dynamic_type_internal (resolved_type
->field (i
).type (),
2341 resolved_type
->field (i
).set_type (t
);
2343 struct type
*real_type
= check_typedef (t
);
2344 if (TYPE_LENGTH (real_type
) > max_len
)
2345 max_len
= TYPE_LENGTH (real_type
);
2348 TYPE_LENGTH (resolved_type
) = max_len
;
2349 return resolved_type
;
2352 /* See gdbtypes.h. */
2355 variant::matches (ULONGEST value
, bool is_unsigned
) const
2357 for (const discriminant_range
&range
: discriminants
)
2358 if (range
.contains (value
, is_unsigned
))
2364 compute_variant_fields_inner (struct type
*type
,
2365 struct property_addr_info
*addr_stack
,
2366 const variant_part
&part
,
2367 std::vector
<bool> &flags
);
2369 /* A helper function to determine which variant fields will be active.
2370 This handles both the variant's direct fields, and any variant
2371 parts embedded in this variant. TYPE is the type we're examining.
2372 ADDR_STACK holds information about the concrete object. VARIANT is
2373 the current variant to be handled. FLAGS is where the results are
2374 stored -- this function sets the Nth element in FLAGS if the
2375 corresponding field is enabled. ENABLED is whether this variant is
2379 compute_variant_fields_recurse (struct type
*type
,
2380 struct property_addr_info
*addr_stack
,
2381 const variant
&variant
,
2382 std::vector
<bool> &flags
,
2385 for (int field
= variant
.first_field
; field
< variant
.last_field
; ++field
)
2386 flags
[field
] = enabled
;
2388 for (const variant_part
&new_part
: variant
.parts
)
2391 compute_variant_fields_inner (type
, addr_stack
, new_part
, flags
);
2394 for (const auto &sub_variant
: new_part
.variants
)
2395 compute_variant_fields_recurse (type
, addr_stack
, sub_variant
,
2401 /* A helper function to determine which variant fields will be active.
2402 This evaluates the discriminant, decides which variant (if any) is
2403 active, and then updates FLAGS to reflect which fields should be
2404 available. TYPE is the type we're examining. ADDR_STACK holds
2405 information about the concrete object. VARIANT is the current
2406 variant to be handled. FLAGS is where the results are stored --
2407 this function sets the Nth element in FLAGS if the corresponding
2408 field is enabled. */
2411 compute_variant_fields_inner (struct type
*type
,
2412 struct property_addr_info
*addr_stack
,
2413 const variant_part
&part
,
2414 std::vector
<bool> &flags
)
2416 /* Evaluate the discriminant. */
2417 gdb::optional
<ULONGEST
> discr_value
;
2418 if (part
.discriminant_index
!= -1)
2420 int idx
= part
.discriminant_index
;
2422 if (TYPE_FIELD_LOC_KIND (type
, idx
) != FIELD_LOC_KIND_BITPOS
)
2423 error (_("Cannot determine struct field location"
2424 " (invalid location kind)"));
2426 if (addr_stack
->valaddr
.data () != NULL
)
2427 discr_value
= unpack_field_as_long (type
, addr_stack
->valaddr
.data (),
2431 CORE_ADDR addr
= (addr_stack
->addr
2432 + (TYPE_FIELD_BITPOS (type
, idx
)
2433 / TARGET_CHAR_BIT
));
2435 LONGEST bitsize
= TYPE_FIELD_BITSIZE (type
, idx
);
2436 LONGEST size
= bitsize
/ 8;
2438 size
= TYPE_LENGTH (type
->field (idx
).type ());
2440 gdb_byte bits
[sizeof (ULONGEST
)];
2441 read_memory (addr
, bits
, size
);
2443 LONGEST bitpos
= (TYPE_FIELD_BITPOS (type
, idx
)
2446 discr_value
= unpack_bits_as_long (type
->field (idx
).type (),
2447 bits
, bitpos
, bitsize
);
2451 /* Go through each variant and see which applies. */
2452 const variant
*default_variant
= nullptr;
2453 const variant
*applied_variant
= nullptr;
2454 for (const auto &variant
: part
.variants
)
2456 if (variant
.is_default ())
2457 default_variant
= &variant
;
2458 else if (discr_value
.has_value ()
2459 && variant
.matches (*discr_value
, part
.is_unsigned
))
2461 applied_variant
= &variant
;
2465 if (applied_variant
== nullptr)
2466 applied_variant
= default_variant
;
2468 for (const auto &variant
: part
.variants
)
2469 compute_variant_fields_recurse (type
, addr_stack
, variant
,
2470 flags
, applied_variant
== &variant
);
2473 /* Determine which variant fields are available in TYPE. The enabled
2474 fields are stored in RESOLVED_TYPE. ADDR_STACK holds information
2475 about the concrete object. PARTS describes the top-level variant
2476 parts for this type. */
2479 compute_variant_fields (struct type
*type
,
2480 struct type
*resolved_type
,
2481 struct property_addr_info
*addr_stack
,
2482 const gdb::array_view
<variant_part
> &parts
)
2484 /* Assume all fields are included by default. */
2485 std::vector
<bool> flags (resolved_type
->num_fields (), true);
2487 /* Now disable fields based on the variants that control them. */
2488 for (const auto &part
: parts
)
2489 compute_variant_fields_inner (type
, addr_stack
, part
, flags
);
2491 resolved_type
->set_num_fields
2492 (std::count (flags
.begin (), flags
.end (), true));
2493 resolved_type
->set_fields
2495 TYPE_ALLOC (resolved_type
,
2496 resolved_type
->num_fields () * sizeof (struct field
)));
2499 for (int i
= 0; i
< type
->num_fields (); ++i
)
2504 resolved_type
->field (out
) = type
->field (i
);
2509 /* Resolve dynamic bounds of members of the struct TYPE to static
2510 bounds. ADDR_STACK is a stack of struct property_addr_info to
2511 be used if needed during the dynamic resolution. */
2513 static struct type
*
2514 resolve_dynamic_struct (struct type
*type
,
2515 struct property_addr_info
*addr_stack
)
2517 struct type
*resolved_type
;
2519 unsigned resolved_type_bit_length
= 0;
2521 gdb_assert (type
->code () == TYPE_CODE_STRUCT
);
2522 gdb_assert (type
->num_fields () > 0);
2524 resolved_type
= copy_type (type
);
2526 dynamic_prop
*variant_prop
= resolved_type
->dyn_prop (DYN_PROP_VARIANT_PARTS
);
2527 if (variant_prop
!= nullptr && variant_prop
->kind () == PROP_VARIANT_PARTS
)
2529 compute_variant_fields (type
, resolved_type
, addr_stack
,
2530 *variant_prop
->variant_parts ());
2531 /* We want to leave the property attached, so that the Rust code
2532 can tell whether the type was originally an enum. */
2533 variant_prop
->set_original_type (type
);
2537 resolved_type
->set_fields
2539 TYPE_ALLOC (resolved_type
,
2540 resolved_type
->num_fields () * sizeof (struct field
)));
2541 memcpy (resolved_type
->fields (),
2543 resolved_type
->num_fields () * sizeof (struct field
));
2546 for (i
= 0; i
< resolved_type
->num_fields (); ++i
)
2548 unsigned new_bit_length
;
2549 struct property_addr_info pinfo
;
2551 if (field_is_static (&resolved_type
->field (i
)))
2554 if (TYPE_FIELD_LOC_KIND (resolved_type
, i
) == FIELD_LOC_KIND_DWARF_BLOCK
)
2556 struct dwarf2_property_baton baton
;
2558 = lookup_pointer_type (resolved_type
->field (i
).type ());
2559 baton
.locexpr
= *TYPE_FIELD_DWARF_BLOCK (resolved_type
, i
);
2561 struct dynamic_prop prop
;
2562 prop
.set_locexpr (&baton
);
2565 if (dwarf2_evaluate_property (&prop
, nullptr, addr_stack
, &addr
,
2567 SET_FIELD_BITPOS (resolved_type
->field (i
),
2568 TARGET_CHAR_BIT
* (addr
- addr_stack
->addr
));
2571 /* As we know this field is not a static field, the field's
2572 field_loc_kind should be FIELD_LOC_KIND_BITPOS. Verify
2573 this is the case, but only trigger a simple error rather
2574 than an internal error if that fails. While failing
2575 that verification indicates a bug in our code, the error
2576 is not severe enough to suggest to the user he stops
2577 his debugging session because of it. */
2578 if (TYPE_FIELD_LOC_KIND (resolved_type
, i
) != FIELD_LOC_KIND_BITPOS
)
2579 error (_("Cannot determine struct field location"
2580 " (invalid location kind)"));
2582 pinfo
.type
= check_typedef (resolved_type
->field (i
).type ());
2583 pinfo
.valaddr
= addr_stack
->valaddr
;
2586 + (TYPE_FIELD_BITPOS (resolved_type
, i
) / TARGET_CHAR_BIT
));
2587 pinfo
.next
= addr_stack
;
2589 resolved_type
->field (i
).set_type
2590 (resolve_dynamic_type_internal (resolved_type
->field (i
).type (),
2592 gdb_assert (TYPE_FIELD_LOC_KIND (resolved_type
, i
)
2593 == FIELD_LOC_KIND_BITPOS
);
2595 new_bit_length
= TYPE_FIELD_BITPOS (resolved_type
, i
);
2596 if (TYPE_FIELD_BITSIZE (resolved_type
, i
) != 0)
2597 new_bit_length
+= TYPE_FIELD_BITSIZE (resolved_type
, i
);
2600 struct type
*real_type
2601 = check_typedef (resolved_type
->field (i
).type ());
2603 new_bit_length
+= (TYPE_LENGTH (real_type
) * TARGET_CHAR_BIT
);
2606 /* Normally, we would use the position and size of the last field
2607 to determine the size of the enclosing structure. But GCC seems
2608 to be encoding the position of some fields incorrectly when
2609 the struct contains a dynamic field that is not placed last.
2610 So we compute the struct size based on the field that has
2611 the highest position + size - probably the best we can do. */
2612 if (new_bit_length
> resolved_type_bit_length
)
2613 resolved_type_bit_length
= new_bit_length
;
2616 /* The length of a type won't change for fortran, but it does for C and Ada.
2617 For fortran the size of dynamic fields might change over time but not the
2618 type length of the structure. If we adapt it, we run into problems
2619 when calculating the element offset for arrays of structs. */
2620 if (current_language
->la_language
!= language_fortran
)
2621 TYPE_LENGTH (resolved_type
)
2622 = (resolved_type_bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
2624 /* The Ada language uses this field as a cache for static fixed types: reset
2625 it as RESOLVED_TYPE must have its own static fixed type. */
2626 TYPE_TARGET_TYPE (resolved_type
) = NULL
;
2628 return resolved_type
;
2631 /* Worker for resolved_dynamic_type. */
2633 static struct type
*
2634 resolve_dynamic_type_internal (struct type
*type
,
2635 struct property_addr_info
*addr_stack
,
2638 struct type
*real_type
= check_typedef (type
);
2639 struct type
*resolved_type
= nullptr;
2640 struct dynamic_prop
*prop
;
2643 if (!is_dynamic_type_internal (real_type
, top_level
))
2646 gdb::optional
<CORE_ADDR
> type_length
;
2647 prop
= TYPE_DYNAMIC_LENGTH (type
);
2649 && dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2650 type_length
= value
;
2652 if (type
->code () == TYPE_CODE_TYPEDEF
)
2654 resolved_type
= copy_type (type
);
2655 TYPE_TARGET_TYPE (resolved_type
)
2656 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type
), addr_stack
,
2661 /* Before trying to resolve TYPE, make sure it is not a stub. */
2664 switch (type
->code ())
2668 struct property_addr_info pinfo
;
2670 pinfo
.type
= check_typedef (TYPE_TARGET_TYPE (type
));
2672 if (addr_stack
->valaddr
.data () != NULL
)
2673 pinfo
.addr
= extract_typed_address (addr_stack
->valaddr
.data (),
2676 pinfo
.addr
= read_memory_typed_address (addr_stack
->addr
, type
);
2677 pinfo
.next
= addr_stack
;
2679 resolved_type
= copy_type (type
);
2680 TYPE_TARGET_TYPE (resolved_type
)
2681 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type
),
2686 case TYPE_CODE_STRING
:
2687 /* Strings are very much like an array of characters, and can be
2688 treated as one here. */
2689 case TYPE_CODE_ARRAY
:
2690 resolved_type
= resolve_dynamic_array_or_string (type
, addr_stack
);
2693 case TYPE_CODE_RANGE
:
2694 resolved_type
= resolve_dynamic_range (type
, addr_stack
);
2697 case TYPE_CODE_UNION
:
2698 resolved_type
= resolve_dynamic_union (type
, addr_stack
);
2701 case TYPE_CODE_STRUCT
:
2702 resolved_type
= resolve_dynamic_struct (type
, addr_stack
);
2707 if (resolved_type
== nullptr)
2710 if (type_length
.has_value ())
2712 TYPE_LENGTH (resolved_type
) = *type_length
;
2713 resolved_type
->remove_dyn_prop (DYN_PROP_BYTE_SIZE
);
2716 /* Resolve data_location attribute. */
2717 prop
= TYPE_DATA_LOCATION (resolved_type
);
2719 && dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2721 /* Start of Fortran hack. See comment in f-lang.h for what is going
2723 if (current_language
->la_language
== language_fortran
2724 && resolved_type
->code () == TYPE_CODE_ARRAY
)
2725 value
= fortran_adjust_dynamic_array_base_address_hack (resolved_type
,
2727 /* End of Fortran hack. */
2728 prop
->set_const_val (value
);
2731 return resolved_type
;
2734 /* See gdbtypes.h */
2737 resolve_dynamic_type (struct type
*type
,
2738 gdb::array_view
<const gdb_byte
> valaddr
,
2741 struct property_addr_info pinfo
2742 = {check_typedef (type
), valaddr
, addr
, NULL
};
2744 return resolve_dynamic_type_internal (type
, &pinfo
, 1);
2747 /* See gdbtypes.h */
2750 type::dyn_prop (dynamic_prop_node_kind prop_kind
) const
2752 dynamic_prop_list
*node
= this->main_type
->dyn_prop_list
;
2754 while (node
!= NULL
)
2756 if (node
->prop_kind
== prop_kind
)
2763 /* See gdbtypes.h */
2766 type::add_dyn_prop (dynamic_prop_node_kind prop_kind
, dynamic_prop prop
)
2768 struct dynamic_prop_list
*temp
;
2770 gdb_assert (TYPE_OBJFILE_OWNED (this));
2772 temp
= XOBNEW (&TYPE_OBJFILE (this)->objfile_obstack
,
2773 struct dynamic_prop_list
);
2774 temp
->prop_kind
= prop_kind
;
2776 temp
->next
= this->main_type
->dyn_prop_list
;
2778 this->main_type
->dyn_prop_list
= temp
;
2781 /* See gdbtypes.h. */
2784 type::remove_dyn_prop (dynamic_prop_node_kind kind
)
2786 struct dynamic_prop_list
*prev_node
, *curr_node
;
2788 curr_node
= this->main_type
->dyn_prop_list
;
2791 while (NULL
!= curr_node
)
2793 if (curr_node
->prop_kind
== kind
)
2795 /* Update the linked list but don't free anything.
2796 The property was allocated on objstack and it is not known
2797 if we are on top of it. Nevertheless, everything is released
2798 when the complete objstack is freed. */
2799 if (NULL
== prev_node
)
2800 this->main_type
->dyn_prop_list
= curr_node
->next
;
2802 prev_node
->next
= curr_node
->next
;
2807 prev_node
= curr_node
;
2808 curr_node
= curr_node
->next
;
2812 /* Find the real type of TYPE. This function returns the real type,
2813 after removing all layers of typedefs, and completing opaque or stub
2814 types. Completion changes the TYPE argument, but stripping of
2817 Instance flags (e.g. const/volatile) are preserved as typedefs are
2818 stripped. If necessary a new qualified form of the underlying type
2821 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
2822 not been computed and we're either in the middle of reading symbols, or
2823 there was no name for the typedef in the debug info.
2825 NOTE: Lookup of opaque types can throw errors for invalid symbol files.
2826 QUITs in the symbol reading code can also throw.
2827 Thus this function can throw an exception.
2829 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
2832 If this is a stubbed struct (i.e. declared as struct foo *), see if
2833 we can find a full definition in some other file. If so, copy this
2834 definition, so we can use it in future. There used to be a comment
2835 (but not any code) that if we don't find a full definition, we'd
2836 set a flag so we don't spend time in the future checking the same
2837 type. That would be a mistake, though--we might load in more
2838 symbols which contain a full definition for the type. */
2841 check_typedef (struct type
*type
)
2843 struct type
*orig_type
= type
;
2847 /* While we're removing typedefs, we don't want to lose qualifiers.
2848 E.g., const/volatile. */
2849 type_instance_flags instance_flags
= type
->instance_flags ();
2851 while (type
->code () == TYPE_CODE_TYPEDEF
)
2853 if (!TYPE_TARGET_TYPE (type
))
2858 /* It is dangerous to call lookup_symbol if we are currently
2859 reading a symtab. Infinite recursion is one danger. */
2860 if (currently_reading_symtab
)
2861 return make_qualified_type (type
, instance_flags
, NULL
);
2863 name
= type
->name ();
2864 /* FIXME: shouldn't we look in STRUCT_DOMAIN and/or
2865 VAR_DOMAIN as appropriate? */
2868 stub_noname_complaint ();
2869 return make_qualified_type (type
, instance_flags
, NULL
);
2871 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0).symbol
;
2873 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
2874 else /* TYPE_CODE_UNDEF */
2875 TYPE_TARGET_TYPE (type
) = alloc_type_arch (get_type_arch (type
));
2877 type
= TYPE_TARGET_TYPE (type
);
2879 /* Preserve the instance flags as we traverse down the typedef chain.
2881 Handling address spaces/classes is nasty, what do we do if there's a
2883 E.g., what if an outer typedef marks the type as class_1 and an inner
2884 typedef marks the type as class_2?
2885 This is the wrong place to do such error checking. We leave it to
2886 the code that created the typedef in the first place to flag the
2887 error. We just pick the outer address space (akin to letting the
2888 outer cast in a chain of casting win), instead of assuming
2889 "it can't happen". */
2891 const type_instance_flags ALL_SPACES
2892 = (TYPE_INSTANCE_FLAG_CODE_SPACE
2893 | TYPE_INSTANCE_FLAG_DATA_SPACE
);
2894 const type_instance_flags ALL_CLASSES
2895 = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
;
2897 type_instance_flags new_instance_flags
= type
->instance_flags ();
2899 /* Treat code vs data spaces and address classes separately. */
2900 if ((instance_flags
& ALL_SPACES
) != 0)
2901 new_instance_flags
&= ~ALL_SPACES
;
2902 if ((instance_flags
& ALL_CLASSES
) != 0)
2903 new_instance_flags
&= ~ALL_CLASSES
;
2905 instance_flags
|= new_instance_flags
;
2909 /* If this is a struct/class/union with no fields, then check
2910 whether a full definition exists somewhere else. This is for
2911 systems where a type definition with no fields is issued for such
2912 types, instead of identifying them as stub types in the first
2915 if (TYPE_IS_OPAQUE (type
)
2916 && opaque_type_resolution
2917 && !currently_reading_symtab
)
2919 const char *name
= type
->name ();
2920 struct type
*newtype
;
2924 stub_noname_complaint ();
2925 return make_qualified_type (type
, instance_flags
, NULL
);
2927 newtype
= lookup_transparent_type (name
);
2931 /* If the resolved type and the stub are in the same
2932 objfile, then replace the stub type with the real deal.
2933 But if they're in separate objfiles, leave the stub
2934 alone; we'll just look up the transparent type every time
2935 we call check_typedef. We can't create pointers between
2936 types allocated to different objfiles, since they may
2937 have different lifetimes. Trying to copy NEWTYPE over to
2938 TYPE's objfile is pointless, too, since you'll have to
2939 move over any other types NEWTYPE refers to, which could
2940 be an unbounded amount of stuff. */
2941 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
2942 type
= make_qualified_type (newtype
, type
->instance_flags (), type
);
2947 /* Otherwise, rely on the stub flag being set for opaque/stubbed
2949 else if (type
->is_stub () && !currently_reading_symtab
)
2951 const char *name
= type
->name ();
2952 /* FIXME: shouldn't we look in STRUCT_DOMAIN and/or VAR_DOMAIN
2958 stub_noname_complaint ();
2959 return make_qualified_type (type
, instance_flags
, NULL
);
2961 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0).symbol
;
2964 /* Same as above for opaque types, we can replace the stub
2965 with the complete type only if they are in the same
2967 if (TYPE_OBJFILE (SYMBOL_TYPE (sym
)) == TYPE_OBJFILE (type
))
2968 type
= make_qualified_type (SYMBOL_TYPE (sym
),
2969 type
->instance_flags (), type
);
2971 type
= SYMBOL_TYPE (sym
);
2975 if (type
->target_is_stub ())
2977 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
2979 if (target_type
->is_stub () || target_type
->target_is_stub ())
2981 /* Nothing we can do. */
2983 else if (type
->code () == TYPE_CODE_RANGE
)
2985 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
2986 type
->set_target_is_stub (false);
2988 else if (type
->code () == TYPE_CODE_ARRAY
2989 && update_static_array_size (type
))
2990 type
->set_target_is_stub (false);
2993 type
= make_qualified_type (type
, instance_flags
, NULL
);
2995 /* Cache TYPE_LENGTH for future use. */
2996 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
3001 /* Parse a type expression in the string [P..P+LENGTH). If an error
3002 occurs, silently return a void type. */
3004 static struct type
*
3005 safe_parse_type (struct gdbarch
*gdbarch
, const char *p
, int length
)
3007 struct ui_file
*saved_gdb_stderr
;
3008 struct type
*type
= NULL
; /* Initialize to keep gcc happy. */
3010 /* Suppress error messages. */
3011 saved_gdb_stderr
= gdb_stderr
;
3012 gdb_stderr
= &null_stream
;
3014 /* Call parse_and_eval_type() without fear of longjmp()s. */
3017 type
= parse_and_eval_type (p
, length
);
3019 catch (const gdb_exception_error
&except
)
3021 type
= builtin_type (gdbarch
)->builtin_void
;
3024 /* Stop suppressing error messages. */
3025 gdb_stderr
= saved_gdb_stderr
;
3030 /* Ugly hack to convert method stubs into method types.
3032 He ain't kiddin'. This demangles the name of the method into a
3033 string including argument types, parses out each argument type,
3034 generates a string casting a zero to that type, evaluates the
3035 string, and stuffs the resulting type into an argtype vector!!!
3036 Then it knows the type of the whole function (including argument
3037 types for overloading), which info used to be in the stab's but was
3038 removed to hack back the space required for them. */
3041 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
3043 struct gdbarch
*gdbarch
= get_type_arch (type
);
3045 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
3046 char *demangled_name
= gdb_demangle (mangled_name
,
3047 DMGL_PARAMS
| DMGL_ANSI
);
3048 char *argtypetext
, *p
;
3049 int depth
= 0, argcount
= 1;
3050 struct field
*argtypes
;
3053 /* Make sure we got back a function string that we can use. */
3055 p
= strchr (demangled_name
, '(');
3059 if (demangled_name
== NULL
|| p
== NULL
)
3060 error (_("Internal: Cannot demangle mangled name `%s'."),
3063 /* Now, read in the parameters that define this type. */
3068 if (*p
== '(' || *p
== '<')
3072 else if (*p
== ')' || *p
== '>')
3076 else if (*p
== ',' && depth
== 0)
3084 /* If we read one argument and it was ``void'', don't count it. */
3085 if (startswith (argtypetext
, "(void)"))
3088 /* We need one extra slot, for the THIS pointer. */
3090 argtypes
= (struct field
*)
3091 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
3094 /* Add THIS pointer for non-static methods. */
3095 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
3096 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
3100 argtypes
[0].set_type (lookup_pointer_type (type
));
3104 if (*p
!= ')') /* () means no args, skip while. */
3109 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
3111 /* Avoid parsing of ellipsis, they will be handled below.
3112 Also avoid ``void'' as above. */
3113 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
3114 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
3116 argtypes
[argcount
].set_type
3117 (safe_parse_type (gdbarch
, argtypetext
, p
- argtypetext
));
3120 argtypetext
= p
+ 1;
3123 if (*p
== '(' || *p
== '<')
3127 else if (*p
== ')' || *p
== '>')
3136 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
3138 /* Now update the old "stub" type into a real type. */
3139 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
3140 /* MTYPE may currently be a function (TYPE_CODE_FUNC).
3141 We want a method (TYPE_CODE_METHOD). */
3142 smash_to_method_type (mtype
, type
, TYPE_TARGET_TYPE (mtype
),
3143 argtypes
, argcount
, p
[-2] == '.');
3144 mtype
->set_is_stub (false);
3145 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
3147 xfree (demangled_name
);
3150 /* This is the external interface to check_stub_method, above. This
3151 function unstubs all of the signatures for TYPE's METHOD_ID method
3152 name. After calling this function TYPE_FN_FIELD_STUB will be
3153 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
3156 This function unfortunately can not die until stabs do. */
3159 check_stub_method_group (struct type
*type
, int method_id
)
3161 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
3162 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
3164 for (int j
= 0; j
< len
; j
++)
3166 if (TYPE_FN_FIELD_STUB (f
, j
))
3167 check_stub_method (type
, method_id
, j
);
3171 /* Ensure it is in .rodata (if available) by working around GCC PR 44690. */
3172 const struct cplus_struct_type cplus_struct_default
= { };
3175 allocate_cplus_struct_type (struct type
*type
)
3177 if (HAVE_CPLUS_STRUCT (type
))
3178 /* Structure was already allocated. Nothing more to do. */
3181 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_CPLUS_STUFF
;
3182 TYPE_RAW_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
3183 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
3184 *(TYPE_RAW_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
3185 set_type_vptr_fieldno (type
, -1);
3188 const struct gnat_aux_type gnat_aux_default
=
3191 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
3192 and allocate the associated gnat-specific data. The gnat-specific
3193 data is also initialized to gnat_aux_default. */
3196 allocate_gnat_aux_type (struct type
*type
)
3198 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_GNAT_STUFF
;
3199 TYPE_GNAT_SPECIFIC (type
) = (struct gnat_aux_type
*)
3200 TYPE_ALLOC (type
, sizeof (struct gnat_aux_type
));
3201 *(TYPE_GNAT_SPECIFIC (type
)) = gnat_aux_default
;
3204 /* Helper function to initialize a newly allocated type. Set type code
3205 to CODE and initialize the type-specific fields accordingly. */
3208 set_type_code (struct type
*type
, enum type_code code
)
3210 type
->set_code (code
);
3214 case TYPE_CODE_STRUCT
:
3215 case TYPE_CODE_UNION
:
3216 case TYPE_CODE_NAMESPACE
:
3217 INIT_CPLUS_SPECIFIC (type
);
3220 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_FLOATFORMAT
;
3222 case TYPE_CODE_FUNC
:
3223 INIT_FUNC_SPECIFIC (type
);
3225 case TYPE_CODE_FIXED_POINT
:
3226 INIT_FIXED_POINT_SPECIFIC (type
);
3231 /* Helper function to verify floating-point format and size.
3232 BIT is the type size in bits; if BIT equals -1, the size is
3233 determined by the floatformat. Returns size to be used. */
3236 verify_floatformat (int bit
, const struct floatformat
*floatformat
)
3238 gdb_assert (floatformat
!= NULL
);
3241 bit
= floatformat
->totalsize
;
3243 gdb_assert (bit
>= 0);
3244 gdb_assert (bit
>= floatformat
->totalsize
);
3249 /* Return the floating-point format for a floating-point variable of
3252 const struct floatformat
*
3253 floatformat_from_type (const struct type
*type
)
3255 gdb_assert (type
->code () == TYPE_CODE_FLT
);
3256 gdb_assert (TYPE_FLOATFORMAT (type
));
3257 return TYPE_FLOATFORMAT (type
);
3260 /* Helper function to initialize the standard scalar types.
3262 If NAME is non-NULL, then it is used to initialize the type name.
3263 Note that NAME is not copied; it is required to have a lifetime at
3264 least as long as OBJFILE. */
3267 init_type (struct objfile
*objfile
, enum type_code code
, int bit
,
3272 type
= alloc_type (objfile
);
3273 set_type_code (type
, code
);
3274 gdb_assert ((bit
% TARGET_CHAR_BIT
) == 0);
3275 TYPE_LENGTH (type
) = bit
/ TARGET_CHAR_BIT
;
3276 type
->set_name (name
);
3281 /* Allocate a TYPE_CODE_ERROR type structure associated with OBJFILE,
3282 to use with variables that have no debug info. NAME is the type
3285 static struct type
*
3286 init_nodebug_var_type (struct objfile
*objfile
, const char *name
)
3288 return init_type (objfile
, TYPE_CODE_ERROR
, 0, name
);
3291 /* Allocate a TYPE_CODE_INT type structure associated with OBJFILE.
3292 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3293 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3296 init_integer_type (struct objfile
*objfile
,
3297 int bit
, int unsigned_p
, const char *name
)
3301 t
= init_type (objfile
, TYPE_CODE_INT
, bit
, name
);
3303 t
->set_is_unsigned (true);
3305 TYPE_SPECIFIC_FIELD (t
) = TYPE_SPECIFIC_INT
;
3306 TYPE_MAIN_TYPE (t
)->type_specific
.int_stuff
.bit_size
= bit
;
3307 TYPE_MAIN_TYPE (t
)->type_specific
.int_stuff
.bit_offset
= 0;
3312 /* Allocate a TYPE_CODE_CHAR type structure associated with OBJFILE.
3313 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3314 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3317 init_character_type (struct objfile
*objfile
,
3318 int bit
, int unsigned_p
, const char *name
)
3322 t
= init_type (objfile
, TYPE_CODE_CHAR
, bit
, name
);
3324 t
->set_is_unsigned (true);
3329 /* Allocate a TYPE_CODE_BOOL type structure associated with OBJFILE.
3330 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3331 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3334 init_boolean_type (struct objfile
*objfile
,
3335 int bit
, int unsigned_p
, const char *name
)
3339 t
= init_type (objfile
, TYPE_CODE_BOOL
, bit
, name
);
3341 t
->set_is_unsigned (true);
3343 TYPE_SPECIFIC_FIELD (t
) = TYPE_SPECIFIC_INT
;
3344 TYPE_MAIN_TYPE (t
)->type_specific
.int_stuff
.bit_size
= bit
;
3345 TYPE_MAIN_TYPE (t
)->type_specific
.int_stuff
.bit_offset
= 0;
3350 /* Allocate a TYPE_CODE_FLT type structure associated with OBJFILE.
3351 BIT is the type size in bits; if BIT equals -1, the size is
3352 determined by the floatformat. NAME is the type name. Set the
3353 TYPE_FLOATFORMAT from FLOATFORMATS. BYTE_ORDER is the byte order
3354 to use. If it is BFD_ENDIAN_UNKNOWN (the default), then the byte
3355 order of the objfile's architecture is used. */
3358 init_float_type (struct objfile
*objfile
,
3359 int bit
, const char *name
,
3360 const struct floatformat
**floatformats
,
3361 enum bfd_endian byte_order
)
3363 if (byte_order
== BFD_ENDIAN_UNKNOWN
)
3365 struct gdbarch
*gdbarch
= objfile
->arch ();
3366 byte_order
= gdbarch_byte_order (gdbarch
);
3368 const struct floatformat
*fmt
= floatformats
[byte_order
];
3371 bit
= verify_floatformat (bit
, fmt
);
3372 t
= init_type (objfile
, TYPE_CODE_FLT
, bit
, name
);
3373 TYPE_FLOATFORMAT (t
) = fmt
;
3378 /* Allocate a TYPE_CODE_DECFLOAT type structure associated with OBJFILE.
3379 BIT is the type size in bits. NAME is the type name. */
3382 init_decfloat_type (struct objfile
*objfile
, int bit
, const char *name
)
3386 t
= init_type (objfile
, TYPE_CODE_DECFLOAT
, bit
, name
);
3390 /* Allocate a TYPE_CODE_COMPLEX type structure. NAME is the type
3391 name. TARGET_TYPE is the component type. */
3394 init_complex_type (const char *name
, struct type
*target_type
)
3398 gdb_assert (target_type
->code () == TYPE_CODE_INT
3399 || target_type
->code () == TYPE_CODE_FLT
);
3401 if (TYPE_MAIN_TYPE (target_type
)->flds_bnds
.complex_type
== nullptr)
3403 if (name
== nullptr && target_type
->name () != nullptr)
3406 = (char *) TYPE_ALLOC (target_type
,
3407 strlen (target_type
->name ())
3408 + strlen ("_Complex ") + 1);
3409 strcpy (new_name
, "_Complex ");
3410 strcat (new_name
, target_type
->name ());
3414 t
= alloc_type_copy (target_type
);
3415 set_type_code (t
, TYPE_CODE_COMPLEX
);
3416 TYPE_LENGTH (t
) = 2 * TYPE_LENGTH (target_type
);
3419 TYPE_TARGET_TYPE (t
) = target_type
;
3420 TYPE_MAIN_TYPE (target_type
)->flds_bnds
.complex_type
= t
;
3423 return TYPE_MAIN_TYPE (target_type
)->flds_bnds
.complex_type
;
3426 /* Allocate a TYPE_CODE_PTR type structure associated with OBJFILE.
3427 BIT is the pointer type size in bits. NAME is the type name.
3428 TARGET_TYPE is the pointer target type. Always sets the pointer type's
3429 TYPE_UNSIGNED flag. */
3432 init_pointer_type (struct objfile
*objfile
,
3433 int bit
, const char *name
, struct type
*target_type
)
3437 t
= init_type (objfile
, TYPE_CODE_PTR
, bit
, name
);
3438 TYPE_TARGET_TYPE (t
) = target_type
;
3439 t
->set_is_unsigned (true);
3443 /* Allocate a TYPE_CODE_FIXED_POINT type structure associated with OBJFILE.
3444 BIT is the pointer type size in bits.
3445 UNSIGNED_P should be nonzero if the type is unsigned.
3446 NAME is the type name. */
3449 init_fixed_point_type (struct objfile
*objfile
,
3450 int bit
, int unsigned_p
, const char *name
)
3454 t
= init_type (objfile
, TYPE_CODE_FIXED_POINT
, bit
, name
);
3456 t
->set_is_unsigned (true);
3461 /* See gdbtypes.h. */
3464 type_raw_align (struct type
*type
)
3466 if (type
->align_log2
!= 0)
3467 return 1 << (type
->align_log2
- 1);
3471 /* See gdbtypes.h. */
3474 type_align (struct type
*type
)
3476 /* Check alignment provided in the debug information. */
3477 unsigned raw_align
= type_raw_align (type
);
3481 /* Allow the architecture to provide an alignment. */
3482 struct gdbarch
*arch
= get_type_arch (type
);
3483 ULONGEST align
= gdbarch_type_align (arch
, type
);
3487 switch (type
->code ())
3490 case TYPE_CODE_FUNC
:
3491 case TYPE_CODE_FLAGS
:
3493 case TYPE_CODE_RANGE
:
3495 case TYPE_CODE_ENUM
:
3497 case TYPE_CODE_RVALUE_REF
:
3498 case TYPE_CODE_CHAR
:
3499 case TYPE_CODE_BOOL
:
3500 case TYPE_CODE_DECFLOAT
:
3501 case TYPE_CODE_METHODPTR
:
3502 case TYPE_CODE_MEMBERPTR
:
3503 align
= type_length_units (check_typedef (type
));
3506 case TYPE_CODE_ARRAY
:
3507 case TYPE_CODE_COMPLEX
:
3508 case TYPE_CODE_TYPEDEF
:
3509 align
= type_align (TYPE_TARGET_TYPE (type
));
3512 case TYPE_CODE_STRUCT
:
3513 case TYPE_CODE_UNION
:
3515 int number_of_non_static_fields
= 0;
3516 for (unsigned i
= 0; i
< type
->num_fields (); ++i
)
3518 if (!field_is_static (&type
->field (i
)))
3520 number_of_non_static_fields
++;
3521 ULONGEST f_align
= type_align (type
->field (i
).type ());
3524 /* Don't pretend we know something we don't. */
3528 if (f_align
> align
)
3532 /* A struct with no fields, or with only static fields has an
3534 if (number_of_non_static_fields
== 0)
3540 case TYPE_CODE_STRING
:
3541 /* Not sure what to do here, and these can't appear in C or C++
3545 case TYPE_CODE_VOID
:
3549 case TYPE_CODE_ERROR
:
3550 case TYPE_CODE_METHOD
:
3555 if ((align
& (align
- 1)) != 0)
3557 /* Not a power of 2, so pass. */
3564 /* See gdbtypes.h. */
3567 set_type_align (struct type
*type
, ULONGEST align
)
3569 /* Must be a power of 2. Zero is ok. */
3570 gdb_assert ((align
& (align
- 1)) == 0);
3572 unsigned result
= 0;
3579 if (result
>= (1 << TYPE_ALIGN_BITS
))
3582 type
->align_log2
= result
;
3587 /* Queries on types. */
3590 can_dereference (struct type
*t
)
3592 /* FIXME: Should we return true for references as well as
3594 t
= check_typedef (t
);
3597 && t
->code () == TYPE_CODE_PTR
3598 && TYPE_TARGET_TYPE (t
)->code () != TYPE_CODE_VOID
);
3602 is_integral_type (struct type
*t
)
3604 t
= check_typedef (t
);
3607 && !is_fixed_point_type (t
)
3608 && ((t
->code () == TYPE_CODE_INT
)
3609 || (t
->code () == TYPE_CODE_ENUM
)
3610 || (t
->code () == TYPE_CODE_FLAGS
)
3611 || (t
->code () == TYPE_CODE_CHAR
)
3612 || (t
->code () == TYPE_CODE_RANGE
)
3613 || (t
->code () == TYPE_CODE_BOOL
)));
3617 is_floating_type (struct type
*t
)
3619 t
= check_typedef (t
);
3622 && ((t
->code () == TYPE_CODE_FLT
)
3623 || (t
->code () == TYPE_CODE_DECFLOAT
)));
3626 /* Return true if TYPE is scalar. */
3629 is_scalar_type (struct type
*type
)
3631 type
= check_typedef (type
);
3633 if (is_fixed_point_type (type
))
3634 return 0; /* Implemented as a scalar, but more like a floating point. */
3636 switch (type
->code ())
3638 case TYPE_CODE_ARRAY
:
3639 case TYPE_CODE_STRUCT
:
3640 case TYPE_CODE_UNION
:
3642 case TYPE_CODE_STRING
:
3649 /* Return true if T is scalar, or a composite type which in practice has
3650 the memory layout of a scalar type. E.g., an array or struct with only
3651 one scalar element inside it, or a union with only scalar elements. */
3654 is_scalar_type_recursive (struct type
*t
)
3656 t
= check_typedef (t
);
3658 if (is_scalar_type (t
))
3660 /* Are we dealing with an array or string of known dimensions? */
3661 else if ((t
->code () == TYPE_CODE_ARRAY
3662 || t
->code () == TYPE_CODE_STRING
) && t
->num_fields () == 1
3663 && t
->index_type ()->code () == TYPE_CODE_RANGE
)
3665 LONGEST low_bound
, high_bound
;
3666 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (t
));
3668 get_discrete_bounds (t
->index_type (), &low_bound
, &high_bound
);
3670 return high_bound
== low_bound
&& is_scalar_type_recursive (elt_type
);
3672 /* Are we dealing with a struct with one element? */
3673 else if (t
->code () == TYPE_CODE_STRUCT
&& t
->num_fields () == 1)
3674 return is_scalar_type_recursive (t
->field (0).type ());
3675 else if (t
->code () == TYPE_CODE_UNION
)
3677 int i
, n
= t
->num_fields ();
3679 /* If all elements of the union are scalar, then the union is scalar. */
3680 for (i
= 0; i
< n
; i
++)
3681 if (!is_scalar_type_recursive (t
->field (i
).type ()))
3690 /* Return true is T is a class or a union. False otherwise. */
3693 class_or_union_p (const struct type
*t
)
3695 return (t
->code () == TYPE_CODE_STRUCT
3696 || t
->code () == TYPE_CODE_UNION
);
3699 /* A helper function which returns true if types A and B represent the
3700 "same" class type. This is true if the types have the same main
3701 type, or the same name. */
3704 class_types_same_p (const struct type
*a
, const struct type
*b
)
3706 return (TYPE_MAIN_TYPE (a
) == TYPE_MAIN_TYPE (b
)
3707 || (a
->name () && b
->name ()
3708 && !strcmp (a
->name (), b
->name ())));
3711 /* If BASE is an ancestor of DCLASS return the distance between them.
3712 otherwise return -1;
3716 class B: public A {};
3717 class C: public B {};
3720 distance_to_ancestor (A, A, 0) = 0
3721 distance_to_ancestor (A, B, 0) = 1
3722 distance_to_ancestor (A, C, 0) = 2
3723 distance_to_ancestor (A, D, 0) = 3
3725 If PUBLIC is 1 then only public ancestors are considered,
3726 and the function returns the distance only if BASE is a public ancestor
3730 distance_to_ancestor (A, D, 1) = -1. */
3733 distance_to_ancestor (struct type
*base
, struct type
*dclass
, int is_public
)
3738 base
= check_typedef (base
);
3739 dclass
= check_typedef (dclass
);
3741 if (class_types_same_p (base
, dclass
))
3744 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
3746 if (is_public
&& ! BASETYPE_VIA_PUBLIC (dclass
, i
))
3749 d
= distance_to_ancestor (base
, TYPE_BASECLASS (dclass
, i
), is_public
);
3757 /* Check whether BASE is an ancestor or base class or DCLASS
3758 Return 1 if so, and 0 if not.
3759 Note: If BASE and DCLASS are of the same type, this function
3760 will return 1. So for some class A, is_ancestor (A, A) will
3764 is_ancestor (struct type
*base
, struct type
*dclass
)
3766 return distance_to_ancestor (base
, dclass
, 0) >= 0;
3769 /* Like is_ancestor, but only returns true when BASE is a public
3770 ancestor of DCLASS. */
3773 is_public_ancestor (struct type
*base
, struct type
*dclass
)
3775 return distance_to_ancestor (base
, dclass
, 1) >= 0;
3778 /* A helper function for is_unique_ancestor. */
3781 is_unique_ancestor_worker (struct type
*base
, struct type
*dclass
,
3783 const gdb_byte
*valaddr
, int embedded_offset
,
3784 CORE_ADDR address
, struct value
*val
)
3788 base
= check_typedef (base
);
3789 dclass
= check_typedef (dclass
);
3791 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
) && count
< 2; ++i
)
3796 iter
= check_typedef (TYPE_BASECLASS (dclass
, i
));
3798 this_offset
= baseclass_offset (dclass
, i
, valaddr
, embedded_offset
,
3801 if (class_types_same_p (base
, iter
))
3803 /* If this is the first subclass, set *OFFSET and set count
3804 to 1. Otherwise, if this is at the same offset as
3805 previous instances, do nothing. Otherwise, increment
3809 *offset
= this_offset
;
3812 else if (this_offset
== *offset
)
3820 count
+= is_unique_ancestor_worker (base
, iter
, offset
,
3822 embedded_offset
+ this_offset
,
3829 /* Like is_ancestor, but only returns true if BASE is a unique base
3830 class of the type of VAL. */
3833 is_unique_ancestor (struct type
*base
, struct value
*val
)
3837 return is_unique_ancestor_worker (base
, value_type (val
), &offset
,
3838 value_contents_for_printing (val
),
3839 value_embedded_offset (val
),
3840 value_address (val
), val
) == 1;
3843 /* See gdbtypes.h. */
3846 type_byte_order (const struct type
*type
)
3848 bfd_endian byteorder
= gdbarch_byte_order (get_type_arch (type
));
3849 if (type
->endianity_is_not_default ())
3851 if (byteorder
== BFD_ENDIAN_BIG
)
3852 return BFD_ENDIAN_LITTLE
;
3855 gdb_assert (byteorder
== BFD_ENDIAN_LITTLE
);
3856 return BFD_ENDIAN_BIG
;
3864 /* Overload resolution. */
3866 /* Return the sum of the rank of A with the rank of B. */
3869 sum_ranks (struct rank a
, struct rank b
)
3872 c
.rank
= a
.rank
+ b
.rank
;
3873 c
.subrank
= a
.subrank
+ b
.subrank
;
3877 /* Compare rank A and B and return:
3879 1 if a is better than b
3880 -1 if b is better than a. */
3883 compare_ranks (struct rank a
, struct rank b
)
3885 if (a
.rank
== b
.rank
)
3887 if (a
.subrank
== b
.subrank
)
3889 if (a
.subrank
< b
.subrank
)
3891 if (a
.subrank
> b
.subrank
)
3895 if (a
.rank
< b
.rank
)
3898 /* a.rank > b.rank */
3902 /* Functions for overload resolution begin here. */
3904 /* Compare two badness vectors A and B and return the result.
3905 0 => A and B are identical
3906 1 => A and B are incomparable
3907 2 => A is better than B
3908 3 => A is worse than B */
3911 compare_badness (const badness_vector
&a
, const badness_vector
&b
)
3915 short found_pos
= 0; /* any positives in c? */
3916 short found_neg
= 0; /* any negatives in c? */
3918 /* differing sizes => incomparable */
3919 if (a
.size () != b
.size ())
3922 /* Subtract b from a */
3923 for (i
= 0; i
< a
.size (); i
++)
3925 tmp
= compare_ranks (b
[i
], a
[i
]);
3935 return 1; /* incomparable */
3937 return 3; /* A > B */
3943 return 2; /* A < B */
3945 return 0; /* A == B */
3949 /* Rank a function by comparing its parameter types (PARMS), to the
3950 types of an argument list (ARGS). Return the badness vector. This
3951 has ARGS.size() + 1 entries. */
3954 rank_function (gdb::array_view
<type
*> parms
,
3955 gdb::array_view
<value
*> args
)
3957 /* add 1 for the length-match rank. */
3959 bv
.reserve (1 + args
.size ());
3961 /* First compare the lengths of the supplied lists.
3962 If there is a mismatch, set it to a high value. */
3964 /* pai/1997-06-03 FIXME: when we have debug info about default
3965 arguments and ellipsis parameter lists, we should consider those
3966 and rank the length-match more finely. */
3968 bv
.push_back ((args
.size () != parms
.size ())
3969 ? LENGTH_MISMATCH_BADNESS
3970 : EXACT_MATCH_BADNESS
);
3972 /* Now rank all the parameters of the candidate function. */
3973 size_t min_len
= std::min (parms
.size (), args
.size ());
3975 for (size_t i
= 0; i
< min_len
; i
++)
3976 bv
.push_back (rank_one_type (parms
[i
], value_type (args
[i
]),
3979 /* If more arguments than parameters, add dummy entries. */
3980 for (size_t i
= min_len
; i
< args
.size (); i
++)
3981 bv
.push_back (TOO_FEW_PARAMS_BADNESS
);
3986 /* Compare the names of two integer types, assuming that any sign
3987 qualifiers have been checked already. We do it this way because
3988 there may be an "int" in the name of one of the types. */
3991 integer_types_same_name_p (const char *first
, const char *second
)
3993 int first_p
, second_p
;
3995 /* If both are shorts, return 1; if neither is a short, keep
3997 first_p
= (strstr (first
, "short") != NULL
);
3998 second_p
= (strstr (second
, "short") != NULL
);
3999 if (first_p
&& second_p
)
4001 if (first_p
|| second_p
)
4004 /* Likewise for long. */
4005 first_p
= (strstr (first
, "long") != NULL
);
4006 second_p
= (strstr (second
, "long") != NULL
);
4007 if (first_p
&& second_p
)
4009 if (first_p
|| second_p
)
4012 /* Likewise for char. */
4013 first_p
= (strstr (first
, "char") != NULL
);
4014 second_p
= (strstr (second
, "char") != NULL
);
4015 if (first_p
&& second_p
)
4017 if (first_p
|| second_p
)
4020 /* They must both be ints. */
4024 /* Compares type A to type B. Returns true if they represent the same
4025 type, false otherwise. */
4028 types_equal (struct type
*a
, struct type
*b
)
4030 /* Identical type pointers. */
4031 /* However, this still doesn't catch all cases of same type for b
4032 and a. The reason is that builtin types are different from
4033 the same ones constructed from the object. */
4037 /* Resolve typedefs */
4038 if (a
->code () == TYPE_CODE_TYPEDEF
)
4039 a
= check_typedef (a
);
4040 if (b
->code () == TYPE_CODE_TYPEDEF
)
4041 b
= check_typedef (b
);
4043 /* If after resolving typedefs a and b are not of the same type
4044 code then they are not equal. */
4045 if (a
->code () != b
->code ())
4048 /* If a and b are both pointers types or both reference types then
4049 they are equal of the same type iff the objects they refer to are
4050 of the same type. */
4051 if (a
->code () == TYPE_CODE_PTR
4052 || a
->code () == TYPE_CODE_REF
)
4053 return types_equal (TYPE_TARGET_TYPE (a
),
4054 TYPE_TARGET_TYPE (b
));
4056 /* Well, damnit, if the names are exactly the same, I'll say they
4057 are exactly the same. This happens when we generate method
4058 stubs. The types won't point to the same address, but they
4059 really are the same. */
4061 if (a
->name () && b
->name ()
4062 && strcmp (a
->name (), b
->name ()) == 0)
4065 /* Check if identical after resolving typedefs. */
4069 /* Two function types are equal if their argument and return types
4071 if (a
->code () == TYPE_CODE_FUNC
)
4075 if (a
->num_fields () != b
->num_fields ())
4078 if (!types_equal (TYPE_TARGET_TYPE (a
), TYPE_TARGET_TYPE (b
)))
4081 for (i
= 0; i
< a
->num_fields (); ++i
)
4082 if (!types_equal (a
->field (i
).type (), b
->field (i
).type ()))
4091 /* Deep comparison of types. */
4093 /* An entry in the type-equality bcache. */
4095 struct type_equality_entry
4097 type_equality_entry (struct type
*t1
, struct type
*t2
)
4103 struct type
*type1
, *type2
;
4106 /* A helper function to compare two strings. Returns true if they are
4107 the same, false otherwise. Handles NULLs properly. */
4110 compare_maybe_null_strings (const char *s
, const char *t
)
4112 if (s
== NULL
|| t
== NULL
)
4114 return strcmp (s
, t
) == 0;
4117 /* A helper function for check_types_worklist that checks two types for
4118 "deep" equality. Returns true if the types are considered the
4119 same, false otherwise. */
4122 check_types_equal (struct type
*type1
, struct type
*type2
,
4123 std::vector
<type_equality_entry
> *worklist
)
4125 type1
= check_typedef (type1
);
4126 type2
= check_typedef (type2
);
4131 if (type1
->code () != type2
->code ()
4132 || TYPE_LENGTH (type1
) != TYPE_LENGTH (type2
)
4133 || type1
->is_unsigned () != type2
->is_unsigned ()
4134 || type1
->has_no_signedness () != type2
->has_no_signedness ()
4135 || type1
->endianity_is_not_default () != type2
->endianity_is_not_default ()
4136 || type1
->has_varargs () != type2
->has_varargs ()
4137 || type1
->is_vector () != type2
->is_vector ()
4138 || TYPE_NOTTEXT (type1
) != TYPE_NOTTEXT (type2
)
4139 || type1
->instance_flags () != type2
->instance_flags ()
4140 || type1
->num_fields () != type2
->num_fields ())
4143 if (!compare_maybe_null_strings (type1
->name (), type2
->name ()))
4145 if (!compare_maybe_null_strings (type1
->name (), type2
->name ()))
4148 if (type1
->code () == TYPE_CODE_RANGE
)
4150 if (*type1
->bounds () != *type2
->bounds ())
4157 for (i
= 0; i
< type1
->num_fields (); ++i
)
4159 const struct field
*field1
= &type1
->field (i
);
4160 const struct field
*field2
= &type2
->field (i
);
4162 if (FIELD_ARTIFICIAL (*field1
) != FIELD_ARTIFICIAL (*field2
)
4163 || FIELD_BITSIZE (*field1
) != FIELD_BITSIZE (*field2
)
4164 || FIELD_LOC_KIND (*field1
) != FIELD_LOC_KIND (*field2
))
4166 if (!compare_maybe_null_strings (FIELD_NAME (*field1
),
4167 FIELD_NAME (*field2
)))
4169 switch (FIELD_LOC_KIND (*field1
))
4171 case FIELD_LOC_KIND_BITPOS
:
4172 if (FIELD_BITPOS (*field1
) != FIELD_BITPOS (*field2
))
4175 case FIELD_LOC_KIND_ENUMVAL
:
4176 if (FIELD_ENUMVAL (*field1
) != FIELD_ENUMVAL (*field2
))
4179 case FIELD_LOC_KIND_PHYSADDR
:
4180 if (FIELD_STATIC_PHYSADDR (*field1
)
4181 != FIELD_STATIC_PHYSADDR (*field2
))
4184 case FIELD_LOC_KIND_PHYSNAME
:
4185 if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1
),
4186 FIELD_STATIC_PHYSNAME (*field2
)))
4189 case FIELD_LOC_KIND_DWARF_BLOCK
:
4191 struct dwarf2_locexpr_baton
*block1
, *block2
;
4193 block1
= FIELD_DWARF_BLOCK (*field1
);
4194 block2
= FIELD_DWARF_BLOCK (*field2
);
4195 if (block1
->per_cu
!= block2
->per_cu
4196 || block1
->size
!= block2
->size
4197 || memcmp (block1
->data
, block2
->data
, block1
->size
) != 0)
4202 internal_error (__FILE__
, __LINE__
, _("Unsupported field kind "
4203 "%d by check_types_equal"),
4204 FIELD_LOC_KIND (*field1
));
4207 worklist
->emplace_back (field1
->type (), field2
->type ());
4211 if (TYPE_TARGET_TYPE (type1
) != NULL
)
4213 if (TYPE_TARGET_TYPE (type2
) == NULL
)
4216 worklist
->emplace_back (TYPE_TARGET_TYPE (type1
),
4217 TYPE_TARGET_TYPE (type2
));
4219 else if (TYPE_TARGET_TYPE (type2
) != NULL
)
4225 /* Check types on a worklist for equality. Returns false if any pair
4226 is not equal, true if they are all considered equal. */
4229 check_types_worklist (std::vector
<type_equality_entry
> *worklist
,
4232 while (!worklist
->empty ())
4236 struct type_equality_entry entry
= std::move (worklist
->back ());
4237 worklist
->pop_back ();
4239 /* If the type pair has already been visited, we know it is
4241 cache
->insert (&entry
, sizeof (entry
), &added
);
4245 if (!check_types_equal (entry
.type1
, entry
.type2
, worklist
))
4252 /* Return true if types TYPE1 and TYPE2 are equal, as determined by a
4253 "deep comparison". Otherwise return false. */
4256 types_deeply_equal (struct type
*type1
, struct type
*type2
)
4258 std::vector
<type_equality_entry
> worklist
;
4260 gdb_assert (type1
!= NULL
&& type2
!= NULL
);
4262 /* Early exit for the simple case. */
4267 worklist
.emplace_back (type1
, type2
);
4268 return check_types_worklist (&worklist
, &cache
);
4271 /* Allocated status of type TYPE. Return zero if type TYPE is allocated.
4272 Otherwise return one. */
4275 type_not_allocated (const struct type
*type
)
4277 struct dynamic_prop
*prop
= TYPE_ALLOCATED_PROP (type
);
4279 return (prop
!= nullptr && prop
->kind () == PROP_CONST
4280 && prop
->const_val () == 0);
4283 /* Associated status of type TYPE. Return zero if type TYPE is associated.
4284 Otherwise return one. */
4287 type_not_associated (const struct type
*type
)
4289 struct dynamic_prop
*prop
= TYPE_ASSOCIATED_PROP (type
);
4291 return (prop
!= nullptr && prop
->kind () == PROP_CONST
4292 && prop
->const_val () == 0);
4295 /* rank_one_type helper for when PARM's type code is TYPE_CODE_PTR. */
4298 rank_one_type_parm_ptr (struct type
*parm
, struct type
*arg
, struct value
*value
)
4300 struct rank rank
= {0,0};
4302 switch (arg
->code ())
4306 /* Allowed pointer conversions are:
4307 (a) pointer to void-pointer conversion. */
4308 if (TYPE_TARGET_TYPE (parm
)->code () == TYPE_CODE_VOID
)
4309 return VOID_PTR_CONVERSION_BADNESS
;
4311 /* (b) pointer to ancestor-pointer conversion. */
4312 rank
.subrank
= distance_to_ancestor (TYPE_TARGET_TYPE (parm
),
4313 TYPE_TARGET_TYPE (arg
),
4315 if (rank
.subrank
>= 0)
4316 return sum_ranks (BASE_PTR_CONVERSION_BADNESS
, rank
);
4318 return INCOMPATIBLE_TYPE_BADNESS
;
4319 case TYPE_CODE_ARRAY
:
4321 struct type
*t1
= TYPE_TARGET_TYPE (parm
);
4322 struct type
*t2
= TYPE_TARGET_TYPE (arg
);
4324 if (types_equal (t1
, t2
))
4326 /* Make sure they are CV equal. */
4327 if (TYPE_CONST (t1
) != TYPE_CONST (t2
))
4328 rank
.subrank
|= CV_CONVERSION_CONST
;
4329 if (TYPE_VOLATILE (t1
) != TYPE_VOLATILE (t2
))
4330 rank
.subrank
|= CV_CONVERSION_VOLATILE
;
4331 if (rank
.subrank
!= 0)
4332 return sum_ranks (CV_CONVERSION_BADNESS
, rank
);
4333 return EXACT_MATCH_BADNESS
;
4335 return INCOMPATIBLE_TYPE_BADNESS
;
4337 case TYPE_CODE_FUNC
:
4338 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
);
4340 if (value
!= NULL
&& value_type (value
)->code () == TYPE_CODE_INT
)
4342 if (value_as_long (value
) == 0)
4344 /* Null pointer conversion: allow it to be cast to a pointer.
4345 [4.10.1 of C++ standard draft n3290] */
4346 return NULL_POINTER_CONVERSION_BADNESS
;
4350 /* If type checking is disabled, allow the conversion. */
4351 if (!strict_type_checking
)
4352 return NS_INTEGER_POINTER_CONVERSION_BADNESS
;
4356 case TYPE_CODE_ENUM
:
4357 case TYPE_CODE_FLAGS
:
4358 case TYPE_CODE_CHAR
:
4359 case TYPE_CODE_RANGE
:
4360 case TYPE_CODE_BOOL
:
4362 return INCOMPATIBLE_TYPE_BADNESS
;
4366 /* rank_one_type helper for when PARM's type code is TYPE_CODE_ARRAY. */
4369 rank_one_type_parm_array (struct type
*parm
, struct type
*arg
, struct value
*value
)
4371 switch (arg
->code ())
4374 case TYPE_CODE_ARRAY
:
4375 return rank_one_type (TYPE_TARGET_TYPE (parm
),
4376 TYPE_TARGET_TYPE (arg
), NULL
);
4378 return INCOMPATIBLE_TYPE_BADNESS
;
4382 /* rank_one_type helper for when PARM's type code is TYPE_CODE_FUNC. */
4385 rank_one_type_parm_func (struct type
*parm
, struct type
*arg
, struct value
*value
)
4387 switch (arg
->code ())
4389 case TYPE_CODE_PTR
: /* funcptr -> func */
4390 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
);
4392 return INCOMPATIBLE_TYPE_BADNESS
;
4396 /* rank_one_type helper for when PARM's type code is TYPE_CODE_INT. */
4399 rank_one_type_parm_int (struct type
*parm
, struct type
*arg
, struct value
*value
)
4401 switch (arg
->code ())
4404 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
4406 /* Deal with signed, unsigned, and plain chars and
4407 signed and unsigned ints. */
4408 if (parm
->has_no_signedness ())
4410 /* This case only for character types. */
4411 if (arg
->has_no_signedness ())
4412 return EXACT_MATCH_BADNESS
; /* plain char -> plain char */
4413 else /* signed/unsigned char -> plain char */
4414 return INTEGER_CONVERSION_BADNESS
;
4416 else if (parm
->is_unsigned ())
4418 if (arg
->is_unsigned ())
4420 /* unsigned int -> unsigned int, or
4421 unsigned long -> unsigned long */
4422 if (integer_types_same_name_p (parm
->name (),
4424 return EXACT_MATCH_BADNESS
;
4425 else if (integer_types_same_name_p (arg
->name (),
4427 && integer_types_same_name_p (parm
->name (),
4429 /* unsigned int -> unsigned long */
4430 return INTEGER_PROMOTION_BADNESS
;
4432 /* unsigned long -> unsigned int */
4433 return INTEGER_CONVERSION_BADNESS
;
4437 if (integer_types_same_name_p (arg
->name (),
4439 && integer_types_same_name_p (parm
->name (),
4441 /* signed long -> unsigned int */
4442 return INTEGER_CONVERSION_BADNESS
;
4444 /* signed int/long -> unsigned int/long */
4445 return INTEGER_CONVERSION_BADNESS
;
4448 else if (!arg
->has_no_signedness () && !arg
->is_unsigned ())
4450 if (integer_types_same_name_p (parm
->name (),
4452 return EXACT_MATCH_BADNESS
;
4453 else if (integer_types_same_name_p (arg
->name (),
4455 && integer_types_same_name_p (parm
->name (),
4457 return INTEGER_PROMOTION_BADNESS
;
4459 return INTEGER_CONVERSION_BADNESS
;
4462 return INTEGER_CONVERSION_BADNESS
;
4464 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
4465 return INTEGER_PROMOTION_BADNESS
;
4467 return INTEGER_CONVERSION_BADNESS
;
4468 case TYPE_CODE_ENUM
:
4469 case TYPE_CODE_FLAGS
:
4470 case TYPE_CODE_CHAR
:
4471 case TYPE_CODE_RANGE
:
4472 case TYPE_CODE_BOOL
:
4473 if (TYPE_DECLARED_CLASS (arg
))
4474 return INCOMPATIBLE_TYPE_BADNESS
;
4475 return INTEGER_PROMOTION_BADNESS
;
4477 return INT_FLOAT_CONVERSION_BADNESS
;
4479 return NS_POINTER_CONVERSION_BADNESS
;
4481 return INCOMPATIBLE_TYPE_BADNESS
;
4485 /* rank_one_type helper for when PARM's type code is TYPE_CODE_ENUM. */
4488 rank_one_type_parm_enum (struct type
*parm
, struct type
*arg
, struct value
*value
)
4490 switch (arg
->code ())
4493 case TYPE_CODE_CHAR
:
4494 case TYPE_CODE_RANGE
:
4495 case TYPE_CODE_BOOL
:
4496 case TYPE_CODE_ENUM
:
4497 if (TYPE_DECLARED_CLASS (parm
) || TYPE_DECLARED_CLASS (arg
))
4498 return INCOMPATIBLE_TYPE_BADNESS
;
4499 return INTEGER_CONVERSION_BADNESS
;
4501 return INT_FLOAT_CONVERSION_BADNESS
;
4503 return INCOMPATIBLE_TYPE_BADNESS
;
4507 /* rank_one_type helper for when PARM's type code is TYPE_CODE_CHAR. */
4510 rank_one_type_parm_char (struct type
*parm
, struct type
*arg
, struct value
*value
)
4512 switch (arg
->code ())
4514 case TYPE_CODE_RANGE
:
4515 case TYPE_CODE_BOOL
:
4516 case TYPE_CODE_ENUM
:
4517 if (TYPE_DECLARED_CLASS (arg
))
4518 return INCOMPATIBLE_TYPE_BADNESS
;
4519 return INTEGER_CONVERSION_BADNESS
;
4521 return INT_FLOAT_CONVERSION_BADNESS
;
4523 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
4524 return INTEGER_CONVERSION_BADNESS
;
4525 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
4526 return INTEGER_PROMOTION_BADNESS
;
4528 case TYPE_CODE_CHAR
:
4529 /* Deal with signed, unsigned, and plain chars for C++ and
4530 with int cases falling through from previous case. */
4531 if (parm
->has_no_signedness ())
4533 if (arg
->has_no_signedness ())
4534 return EXACT_MATCH_BADNESS
;
4536 return INTEGER_CONVERSION_BADNESS
;
4538 else if (parm
->is_unsigned ())
4540 if (arg
->is_unsigned ())
4541 return EXACT_MATCH_BADNESS
;
4543 return INTEGER_PROMOTION_BADNESS
;
4545 else if (!arg
->has_no_signedness () && !arg
->is_unsigned ())
4546 return EXACT_MATCH_BADNESS
;
4548 return INTEGER_CONVERSION_BADNESS
;
4550 return INCOMPATIBLE_TYPE_BADNESS
;
4554 /* rank_one_type helper for when PARM's type code is TYPE_CODE_RANGE. */
4557 rank_one_type_parm_range (struct type
*parm
, struct type
*arg
, struct value
*value
)
4559 switch (arg
->code ())
4562 case TYPE_CODE_CHAR
:
4563 case TYPE_CODE_RANGE
:
4564 case TYPE_CODE_BOOL
:
4565 case TYPE_CODE_ENUM
:
4566 return INTEGER_CONVERSION_BADNESS
;
4568 return INT_FLOAT_CONVERSION_BADNESS
;
4570 return INCOMPATIBLE_TYPE_BADNESS
;
4574 /* rank_one_type helper for when PARM's type code is TYPE_CODE_BOOL. */
4577 rank_one_type_parm_bool (struct type
*parm
, struct type
*arg
, struct value
*value
)
4579 switch (arg
->code ())
4581 /* n3290 draft, section 4.12.1 (conv.bool):
4583 "A prvalue of arithmetic, unscoped enumeration, pointer, or
4584 pointer to member type can be converted to a prvalue of type
4585 bool. A zero value, null pointer value, or null member pointer
4586 value is converted to false; any other value is converted to
4587 true. A prvalue of type std::nullptr_t can be converted to a
4588 prvalue of type bool; the resulting value is false." */
4590 case TYPE_CODE_CHAR
:
4591 case TYPE_CODE_ENUM
:
4593 case TYPE_CODE_MEMBERPTR
:
4595 return BOOL_CONVERSION_BADNESS
;
4596 case TYPE_CODE_RANGE
:
4597 return INCOMPATIBLE_TYPE_BADNESS
;
4598 case TYPE_CODE_BOOL
:
4599 return EXACT_MATCH_BADNESS
;
4601 return INCOMPATIBLE_TYPE_BADNESS
;
4605 /* rank_one_type helper for when PARM's type code is TYPE_CODE_FLOAT. */
4608 rank_one_type_parm_float (struct type
*parm
, struct type
*arg
, struct value
*value
)
4610 switch (arg
->code ())
4613 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
4614 return FLOAT_PROMOTION_BADNESS
;
4615 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
4616 return EXACT_MATCH_BADNESS
;
4618 return FLOAT_CONVERSION_BADNESS
;
4620 case TYPE_CODE_BOOL
:
4621 case TYPE_CODE_ENUM
:
4622 case TYPE_CODE_RANGE
:
4623 case TYPE_CODE_CHAR
:
4624 return INT_FLOAT_CONVERSION_BADNESS
;
4626 return INCOMPATIBLE_TYPE_BADNESS
;
4630 /* rank_one_type helper for when PARM's type code is TYPE_CODE_COMPLEX. */
4633 rank_one_type_parm_complex (struct type
*parm
, struct type
*arg
, struct value
*value
)
4635 switch (arg
->code ())
4636 { /* Strictly not needed for C++, but... */
4638 return FLOAT_PROMOTION_BADNESS
;
4639 case TYPE_CODE_COMPLEX
:
4640 return EXACT_MATCH_BADNESS
;
4642 return INCOMPATIBLE_TYPE_BADNESS
;
4646 /* rank_one_type helper for when PARM's type code is TYPE_CODE_STRUCT. */
4649 rank_one_type_parm_struct (struct type
*parm
, struct type
*arg
, struct value
*value
)
4651 struct rank rank
= {0, 0};
4653 switch (arg
->code ())
4655 case TYPE_CODE_STRUCT
:
4656 /* Check for derivation */
4657 rank
.subrank
= distance_to_ancestor (parm
, arg
, 0);
4658 if (rank
.subrank
>= 0)
4659 return sum_ranks (BASE_CONVERSION_BADNESS
, rank
);
4662 return INCOMPATIBLE_TYPE_BADNESS
;
4666 /* rank_one_type helper for when PARM's type code is TYPE_CODE_SET. */
4669 rank_one_type_parm_set (struct type
*parm
, struct type
*arg
, struct value
*value
)
4671 switch (arg
->code ())
4675 return rank_one_type (parm
->field (0).type (),
4676 arg
->field (0).type (), NULL
);
4678 return INCOMPATIBLE_TYPE_BADNESS
;
4682 /* Compare one type (PARM) for compatibility with another (ARG).
4683 * PARM is intended to be the parameter type of a function; and
4684 * ARG is the supplied argument's type. This function tests if
4685 * the latter can be converted to the former.
4686 * VALUE is the argument's value or NULL if none (or called recursively)
4688 * Return 0 if they are identical types;
4689 * Otherwise, return an integer which corresponds to how compatible
4690 * PARM is to ARG. The higher the return value, the worse the match.
4691 * Generally the "bad" conversions are all uniformly assigned a 100. */
4694 rank_one_type (struct type
*parm
, struct type
*arg
, struct value
*value
)
4696 struct rank rank
= {0,0};
4698 /* Resolve typedefs */
4699 if (parm
->code () == TYPE_CODE_TYPEDEF
)
4700 parm
= check_typedef (parm
);
4701 if (arg
->code () == TYPE_CODE_TYPEDEF
)
4702 arg
= check_typedef (arg
);
4704 if (TYPE_IS_REFERENCE (parm
) && value
!= NULL
)
4706 if (VALUE_LVAL (value
) == not_lval
)
4708 /* Rvalues should preferably bind to rvalue references or const
4709 lvalue references. */
4710 if (parm
->code () == TYPE_CODE_RVALUE_REF
)
4711 rank
.subrank
= REFERENCE_CONVERSION_RVALUE
;
4712 else if (TYPE_CONST (TYPE_TARGET_TYPE (parm
)))
4713 rank
.subrank
= REFERENCE_CONVERSION_CONST_LVALUE
;
4715 return INCOMPATIBLE_TYPE_BADNESS
;
4716 return sum_ranks (rank
, REFERENCE_CONVERSION_BADNESS
);
4720 /* It's illegal to pass an lvalue as an rvalue. */
4721 if (parm
->code () == TYPE_CODE_RVALUE_REF
)
4722 return INCOMPATIBLE_TYPE_BADNESS
;
4726 if (types_equal (parm
, arg
))
4728 struct type
*t1
= parm
;
4729 struct type
*t2
= arg
;
4731 /* For pointers and references, compare target type. */
4732 if (parm
->code () == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (parm
))
4734 t1
= TYPE_TARGET_TYPE (parm
);
4735 t2
= TYPE_TARGET_TYPE (arg
);
4738 /* Make sure they are CV equal, too. */
4739 if (TYPE_CONST (t1
) != TYPE_CONST (t2
))
4740 rank
.subrank
|= CV_CONVERSION_CONST
;
4741 if (TYPE_VOLATILE (t1
) != TYPE_VOLATILE (t2
))
4742 rank
.subrank
|= CV_CONVERSION_VOLATILE
;
4743 if (rank
.subrank
!= 0)
4744 return sum_ranks (CV_CONVERSION_BADNESS
, rank
);
4745 return EXACT_MATCH_BADNESS
;
4748 /* See through references, since we can almost make non-references
4751 if (TYPE_IS_REFERENCE (arg
))
4752 return (sum_ranks (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
),
4753 REFERENCE_SEE_THROUGH_BADNESS
));
4754 if (TYPE_IS_REFERENCE (parm
))
4755 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
),
4756 REFERENCE_SEE_THROUGH_BADNESS
));
4758 /* Debugging only. */
4759 fprintf_filtered (gdb_stderr
,
4760 "------ Arg is %s [%d], parm is %s [%d]\n",
4761 arg
->name (), arg
->code (),
4762 parm
->name (), parm
->code ());
4764 /* x -> y means arg of type x being supplied for parameter of type y. */
4766 switch (parm
->code ())
4769 return rank_one_type_parm_ptr (parm
, arg
, value
);
4770 case TYPE_CODE_ARRAY
:
4771 return rank_one_type_parm_array (parm
, arg
, value
);
4772 case TYPE_CODE_FUNC
:
4773 return rank_one_type_parm_func (parm
, arg
, value
);
4775 return rank_one_type_parm_int (parm
, arg
, value
);
4776 case TYPE_CODE_ENUM
:
4777 return rank_one_type_parm_enum (parm
, arg
, value
);
4778 case TYPE_CODE_CHAR
:
4779 return rank_one_type_parm_char (parm
, arg
, value
);
4780 case TYPE_CODE_RANGE
:
4781 return rank_one_type_parm_range (parm
, arg
, value
);
4782 case TYPE_CODE_BOOL
:
4783 return rank_one_type_parm_bool (parm
, arg
, value
);
4785 return rank_one_type_parm_float (parm
, arg
, value
);
4786 case TYPE_CODE_COMPLEX
:
4787 return rank_one_type_parm_complex (parm
, arg
, value
);
4788 case TYPE_CODE_STRUCT
:
4789 return rank_one_type_parm_struct (parm
, arg
, value
);
4791 return rank_one_type_parm_set (parm
, arg
, value
);
4793 return INCOMPATIBLE_TYPE_BADNESS
;
4794 } /* switch (arg->code ()) */
4797 /* End of functions for overload resolution. */
4799 /* Routines to pretty-print types. */
4802 print_bit_vector (B_TYPE
*bits
, int nbits
)
4806 for (bitno
= 0; bitno
< nbits
; bitno
++)
4808 if ((bitno
% 8) == 0)
4810 puts_filtered (" ");
4812 if (B_TST (bits
, bitno
))
4813 printf_filtered (("1"));
4815 printf_filtered (("0"));
4819 /* Note the first arg should be the "this" pointer, we may not want to
4820 include it since we may get into a infinitely recursive
4824 print_args (struct field
*args
, int nargs
, int spaces
)
4830 for (i
= 0; i
< nargs
; i
++)
4832 printf_filtered ("%*s[%d] name '%s'\n", spaces
, "", i
,
4833 args
[i
].name
!= NULL
? args
[i
].name
: "<NULL>");
4834 recursive_dump_type (args
[i
].type (), spaces
+ 2);
4840 field_is_static (struct field
*f
)
4842 /* "static" fields are the fields whose location is not relative
4843 to the address of the enclosing struct. It would be nice to
4844 have a dedicated flag that would be set for static fields when
4845 the type is being created. But in practice, checking the field
4846 loc_kind should give us an accurate answer. */
4847 return (FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSNAME
4848 || FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSADDR
);
4852 dump_fn_fieldlists (struct type
*type
, int spaces
)
4858 printf_filtered ("%*sfn_fieldlists ", spaces
, "");
4859 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
4860 printf_filtered ("\n");
4861 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
4863 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
4864 printf_filtered ("%*s[%d] name '%s' (", spaces
+ 2, "",
4866 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
4867 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
4869 printf_filtered (_(") length %d\n"),
4870 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
4871 for (overload_idx
= 0;
4872 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
4875 printf_filtered ("%*s[%d] physname '%s' (",
4876 spaces
+ 4, "", overload_idx
,
4877 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
4878 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
4880 printf_filtered (")\n");
4881 printf_filtered ("%*stype ", spaces
+ 8, "");
4882 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
4884 printf_filtered ("\n");
4886 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
4889 printf_filtered ("%*sargs ", spaces
+ 8, "");
4890 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
4892 printf_filtered ("\n");
4893 print_args (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
4894 TYPE_FN_FIELD_TYPE (f
, overload_idx
)->num_fields (),
4896 printf_filtered ("%*sfcontext ", spaces
+ 8, "");
4897 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
4899 printf_filtered ("\n");
4901 printf_filtered ("%*sis_const %d\n", spaces
+ 8, "",
4902 TYPE_FN_FIELD_CONST (f
, overload_idx
));
4903 printf_filtered ("%*sis_volatile %d\n", spaces
+ 8, "",
4904 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
4905 printf_filtered ("%*sis_private %d\n", spaces
+ 8, "",
4906 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
4907 printf_filtered ("%*sis_protected %d\n", spaces
+ 8, "",
4908 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
4909 printf_filtered ("%*sis_stub %d\n", spaces
+ 8, "",
4910 TYPE_FN_FIELD_STUB (f
, overload_idx
));
4911 printf_filtered ("%*sdefaulted %d\n", spaces
+ 8, "",
4912 TYPE_FN_FIELD_DEFAULTED (f
, overload_idx
));
4913 printf_filtered ("%*sis_deleted %d\n", spaces
+ 8, "",
4914 TYPE_FN_FIELD_DELETED (f
, overload_idx
));
4915 printf_filtered ("%*svoffset %u\n", spaces
+ 8, "",
4916 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
4922 print_cplus_stuff (struct type
*type
, int spaces
)
4924 printf_filtered ("%*svptr_fieldno %d\n", spaces
, "",
4925 TYPE_VPTR_FIELDNO (type
));
4926 printf_filtered ("%*svptr_basetype ", spaces
, "");
4927 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
4928 puts_filtered ("\n");
4929 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
4930 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
4932 printf_filtered ("%*sn_baseclasses %d\n", spaces
, "",
4933 TYPE_N_BASECLASSES (type
));
4934 printf_filtered ("%*snfn_fields %d\n", spaces
, "",
4935 TYPE_NFN_FIELDS (type
));
4936 if (TYPE_N_BASECLASSES (type
) > 0)
4938 printf_filtered ("%*svirtual_field_bits (%d bits at *",
4939 spaces
, "", TYPE_N_BASECLASSES (type
));
4940 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
4942 printf_filtered (")");
4944 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
4945 TYPE_N_BASECLASSES (type
));
4946 puts_filtered ("\n");
4948 if (type
->num_fields () > 0)
4950 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
4952 printf_filtered ("%*sprivate_field_bits (%d bits at *",
4953 spaces
, "", type
->num_fields ());
4954 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
4956 printf_filtered (")");
4957 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
4958 type
->num_fields ());
4959 puts_filtered ("\n");
4961 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
4963 printf_filtered ("%*sprotected_field_bits (%d bits at *",
4964 spaces
, "", type
->num_fields ());
4965 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
4967 printf_filtered (")");
4968 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
4969 type
->num_fields ());
4970 puts_filtered ("\n");
4973 if (TYPE_NFN_FIELDS (type
) > 0)
4975 dump_fn_fieldlists (type
, spaces
);
4978 printf_filtered ("%*scalling_convention %d\n", spaces
, "",
4979 TYPE_CPLUS_CALLING_CONVENTION (type
));
4982 /* Print the contents of the TYPE's type_specific union, assuming that
4983 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
4986 print_gnat_stuff (struct type
*type
, int spaces
)
4988 struct type
*descriptive_type
= TYPE_DESCRIPTIVE_TYPE (type
);
4990 if (descriptive_type
== NULL
)
4991 printf_filtered ("%*sno descriptive type\n", spaces
+ 2, "");
4994 printf_filtered ("%*sdescriptive type\n", spaces
+ 2, "");
4995 recursive_dump_type (descriptive_type
, spaces
+ 4);
4999 /* Print the contents of the TYPE's type_specific union, assuming that
5000 its type-specific kind is TYPE_SPECIFIC_FIXED_POINT. */
5003 print_fixed_point_type_info (struct type
*type
, int spaces
)
5005 printf_filtered ("%*sscaling factor: %s\n", spaces
+ 2, "",
5006 type
->fixed_point_scaling_factor ().str ().c_str ());
5009 static struct obstack dont_print_type_obstack
;
5011 /* Print the dynamic_prop PROP. */
5014 dump_dynamic_prop (dynamic_prop
const& prop
)
5016 switch (prop
.kind ())
5019 printf_filtered ("%s", plongest (prop
.const_val ()));
5021 case PROP_UNDEFINED
:
5022 printf_filtered ("(undefined)");
5026 printf_filtered ("(dynamic)");
5029 gdb_assert_not_reached ("unhandled prop kind");
5035 recursive_dump_type (struct type
*type
, int spaces
)
5040 obstack_begin (&dont_print_type_obstack
, 0);
5042 if (type
->num_fields () > 0
5043 || (HAVE_CPLUS_STRUCT (type
) && TYPE_NFN_FIELDS (type
) > 0))
5045 struct type
**first_dont_print
5046 = (struct type
**) obstack_base (&dont_print_type_obstack
);
5048 int i
= (struct type
**)
5049 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
5053 if (type
== first_dont_print
[i
])
5055 printf_filtered ("%*stype node ", spaces
, "");
5056 gdb_print_host_address (type
, gdb_stdout
);
5057 printf_filtered (_(" <same as already seen type>\n"));
5062 obstack_ptr_grow (&dont_print_type_obstack
, type
);
5065 printf_filtered ("%*stype node ", spaces
, "");
5066 gdb_print_host_address (type
, gdb_stdout
);
5067 printf_filtered ("\n");
5068 printf_filtered ("%*sname '%s' (", spaces
, "",
5069 type
->name () ? type
->name () : "<NULL>");
5070 gdb_print_host_address (type
->name (), gdb_stdout
);
5071 printf_filtered (")\n");
5072 printf_filtered ("%*scode 0x%x ", spaces
, "", type
->code ());
5073 switch (type
->code ())
5075 case TYPE_CODE_UNDEF
:
5076 printf_filtered ("(TYPE_CODE_UNDEF)");
5079 printf_filtered ("(TYPE_CODE_PTR)");
5081 case TYPE_CODE_ARRAY
:
5082 printf_filtered ("(TYPE_CODE_ARRAY)");
5084 case TYPE_CODE_STRUCT
:
5085 printf_filtered ("(TYPE_CODE_STRUCT)");
5087 case TYPE_CODE_UNION
:
5088 printf_filtered ("(TYPE_CODE_UNION)");
5090 case TYPE_CODE_ENUM
:
5091 printf_filtered ("(TYPE_CODE_ENUM)");
5093 case TYPE_CODE_FLAGS
:
5094 printf_filtered ("(TYPE_CODE_FLAGS)");
5096 case TYPE_CODE_FUNC
:
5097 printf_filtered ("(TYPE_CODE_FUNC)");
5100 printf_filtered ("(TYPE_CODE_INT)");
5103 printf_filtered ("(TYPE_CODE_FLT)");
5105 case TYPE_CODE_VOID
:
5106 printf_filtered ("(TYPE_CODE_VOID)");
5109 printf_filtered ("(TYPE_CODE_SET)");
5111 case TYPE_CODE_RANGE
:
5112 printf_filtered ("(TYPE_CODE_RANGE)");
5114 case TYPE_CODE_STRING
:
5115 printf_filtered ("(TYPE_CODE_STRING)");
5117 case TYPE_CODE_ERROR
:
5118 printf_filtered ("(TYPE_CODE_ERROR)");
5120 case TYPE_CODE_MEMBERPTR
:
5121 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
5123 case TYPE_CODE_METHODPTR
:
5124 printf_filtered ("(TYPE_CODE_METHODPTR)");
5126 case TYPE_CODE_METHOD
:
5127 printf_filtered ("(TYPE_CODE_METHOD)");
5130 printf_filtered ("(TYPE_CODE_REF)");
5132 case TYPE_CODE_CHAR
:
5133 printf_filtered ("(TYPE_CODE_CHAR)");
5135 case TYPE_CODE_BOOL
:
5136 printf_filtered ("(TYPE_CODE_BOOL)");
5138 case TYPE_CODE_COMPLEX
:
5139 printf_filtered ("(TYPE_CODE_COMPLEX)");
5141 case TYPE_CODE_TYPEDEF
:
5142 printf_filtered ("(TYPE_CODE_TYPEDEF)");
5144 case TYPE_CODE_NAMESPACE
:
5145 printf_filtered ("(TYPE_CODE_NAMESPACE)");
5147 case TYPE_CODE_FIXED_POINT
:
5148 printf_filtered ("(TYPE_CODE_FIXED_POINT)");
5151 printf_filtered ("(UNKNOWN TYPE CODE)");
5154 puts_filtered ("\n");
5155 printf_filtered ("%*slength %s\n", spaces
, "",
5156 pulongest (TYPE_LENGTH (type
)));
5157 if (TYPE_OBJFILE_OWNED (type
))
5159 printf_filtered ("%*sobjfile ", spaces
, "");
5160 gdb_print_host_address (TYPE_OWNER (type
).objfile
, gdb_stdout
);
5164 printf_filtered ("%*sgdbarch ", spaces
, "");
5165 gdb_print_host_address (TYPE_OWNER (type
).gdbarch
, gdb_stdout
);
5167 printf_filtered ("\n");
5168 printf_filtered ("%*starget_type ", spaces
, "");
5169 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
5170 printf_filtered ("\n");
5171 if (TYPE_TARGET_TYPE (type
) != NULL
)
5173 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
5175 printf_filtered ("%*spointer_type ", spaces
, "");
5176 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
5177 printf_filtered ("\n");
5178 printf_filtered ("%*sreference_type ", spaces
, "");
5179 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
5180 printf_filtered ("\n");
5181 printf_filtered ("%*stype_chain ", spaces
, "");
5182 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
5183 printf_filtered ("\n");
5184 printf_filtered ("%*sinstance_flags 0x%x", spaces
, "",
5185 (unsigned) type
->instance_flags ());
5186 if (TYPE_CONST (type
))
5188 puts_filtered (" TYPE_CONST");
5190 if (TYPE_VOLATILE (type
))
5192 puts_filtered (" TYPE_VOLATILE");
5194 if (TYPE_CODE_SPACE (type
))
5196 puts_filtered (" TYPE_CODE_SPACE");
5198 if (TYPE_DATA_SPACE (type
))
5200 puts_filtered (" TYPE_DATA_SPACE");
5202 if (TYPE_ADDRESS_CLASS_1 (type
))
5204 puts_filtered (" TYPE_ADDRESS_CLASS_1");
5206 if (TYPE_ADDRESS_CLASS_2 (type
))
5208 puts_filtered (" TYPE_ADDRESS_CLASS_2");
5210 if (TYPE_RESTRICT (type
))
5212 puts_filtered (" TYPE_RESTRICT");
5214 if (TYPE_ATOMIC (type
))
5216 puts_filtered (" TYPE_ATOMIC");
5218 puts_filtered ("\n");
5220 printf_filtered ("%*sflags", spaces
, "");
5221 if (type
->is_unsigned ())
5223 puts_filtered (" TYPE_UNSIGNED");
5225 if (type
->has_no_signedness ())
5227 puts_filtered (" TYPE_NOSIGN");
5229 if (type
->endianity_is_not_default ())
5231 puts_filtered (" TYPE_ENDIANITY_NOT_DEFAULT");
5233 if (type
->is_stub ())
5235 puts_filtered (" TYPE_STUB");
5237 if (type
->target_is_stub ())
5239 puts_filtered (" TYPE_TARGET_STUB");
5241 if (type
->is_prototyped ())
5243 puts_filtered (" TYPE_PROTOTYPED");
5245 if (type
->has_varargs ())
5247 puts_filtered (" TYPE_VARARGS");
5249 /* This is used for things like AltiVec registers on ppc. Gcc emits
5250 an attribute for the array type, which tells whether or not we
5251 have a vector, instead of a regular array. */
5252 if (type
->is_vector ())
5254 puts_filtered (" TYPE_VECTOR");
5256 if (type
->is_fixed_instance ())
5258 puts_filtered (" TYPE_FIXED_INSTANCE");
5260 if (type
->stub_is_supported ())
5262 puts_filtered (" TYPE_STUB_SUPPORTED");
5264 if (TYPE_NOTTEXT (type
))
5266 puts_filtered (" TYPE_NOTTEXT");
5268 puts_filtered ("\n");
5269 printf_filtered ("%*snfields %d ", spaces
, "", type
->num_fields ());
5270 gdb_print_host_address (type
->fields (), gdb_stdout
);
5271 puts_filtered ("\n");
5272 for (idx
= 0; idx
< type
->num_fields (); idx
++)
5274 if (type
->code () == TYPE_CODE_ENUM
)
5275 printf_filtered ("%*s[%d] enumval %s type ", spaces
+ 2, "",
5276 idx
, plongest (TYPE_FIELD_ENUMVAL (type
, idx
)));
5278 printf_filtered ("%*s[%d] bitpos %s bitsize %d type ", spaces
+ 2, "",
5279 idx
, plongest (TYPE_FIELD_BITPOS (type
, idx
)),
5280 TYPE_FIELD_BITSIZE (type
, idx
));
5281 gdb_print_host_address (type
->field (idx
).type (), gdb_stdout
);
5282 printf_filtered (" name '%s' (",
5283 TYPE_FIELD_NAME (type
, idx
) != NULL
5284 ? TYPE_FIELD_NAME (type
, idx
)
5286 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
5287 printf_filtered (")\n");
5288 if (type
->field (idx
).type () != NULL
)
5290 recursive_dump_type (type
->field (idx
).type (), spaces
+ 4);
5293 if (type
->code () == TYPE_CODE_RANGE
)
5295 printf_filtered ("%*slow ", spaces
, "");
5296 dump_dynamic_prop (type
->bounds ()->low
);
5297 printf_filtered (" high ");
5298 dump_dynamic_prop (type
->bounds ()->high
);
5299 printf_filtered ("\n");
5302 switch (TYPE_SPECIFIC_FIELD (type
))
5304 case TYPE_SPECIFIC_CPLUS_STUFF
:
5305 printf_filtered ("%*scplus_stuff ", spaces
, "");
5306 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
),
5308 puts_filtered ("\n");
5309 print_cplus_stuff (type
, spaces
);
5312 case TYPE_SPECIFIC_GNAT_STUFF
:
5313 printf_filtered ("%*sgnat_stuff ", spaces
, "");
5314 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type
), gdb_stdout
);
5315 puts_filtered ("\n");
5316 print_gnat_stuff (type
, spaces
);
5319 case TYPE_SPECIFIC_FLOATFORMAT
:
5320 printf_filtered ("%*sfloatformat ", spaces
, "");
5321 if (TYPE_FLOATFORMAT (type
) == NULL
5322 || TYPE_FLOATFORMAT (type
)->name
== NULL
)
5323 puts_filtered ("(null)");
5325 puts_filtered (TYPE_FLOATFORMAT (type
)->name
);
5326 puts_filtered ("\n");
5329 case TYPE_SPECIFIC_FUNC
:
5330 printf_filtered ("%*scalling_convention %d\n", spaces
, "",
5331 TYPE_CALLING_CONVENTION (type
));
5332 /* tail_call_list is not printed. */
5335 case TYPE_SPECIFIC_SELF_TYPE
:
5336 printf_filtered ("%*sself_type ", spaces
, "");
5337 gdb_print_host_address (TYPE_SELF_TYPE (type
), gdb_stdout
);
5338 puts_filtered ("\n");
5341 case TYPE_SPECIFIC_FIXED_POINT
:
5342 printf_filtered ("%*sfixed_point_info ", spaces
, "");
5343 print_fixed_point_type_info (type
, spaces
);
5344 puts_filtered ("\n");
5347 case TYPE_SPECIFIC_INT
:
5348 if (type
->bit_size_differs_p ())
5350 unsigned bit_size
= type
->bit_size ();
5351 unsigned bit_off
= type
->bit_offset ();
5352 printf_filtered ("%*s bit size = %u, bit offset = %u\n", spaces
, "",
5359 obstack_free (&dont_print_type_obstack
, NULL
);
5362 /* Trivial helpers for the libiberty hash table, for mapping one
5365 struct type_pair
: public allocate_on_obstack
5367 type_pair (struct type
*old_
, struct type
*newobj_
)
5368 : old (old_
), newobj (newobj_
)
5371 struct type
* const old
, * const newobj
;
5375 type_pair_hash (const void *item
)
5377 const struct type_pair
*pair
= (const struct type_pair
*) item
;
5379 return htab_hash_pointer (pair
->old
);
5383 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
5385 const struct type_pair
*lhs
= (const struct type_pair
*) item_lhs
;
5386 const struct type_pair
*rhs
= (const struct type_pair
*) item_rhs
;
5388 return lhs
->old
== rhs
->old
;
5391 /* Allocate the hash table used by copy_type_recursive to walk
5392 types without duplicates. We use OBJFILE's obstack, because
5393 OBJFILE is about to be deleted. */
5396 create_copied_types_hash (struct objfile
*objfile
)
5398 return htab_up (htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
5399 NULL
, &objfile
->objfile_obstack
,
5400 hashtab_obstack_allocate
,
5401 dummy_obstack_deallocate
));
5404 /* Recursively copy (deep copy) a dynamic attribute list of a type. */
5406 static struct dynamic_prop_list
*
5407 copy_dynamic_prop_list (struct obstack
*objfile_obstack
,
5408 struct dynamic_prop_list
*list
)
5410 struct dynamic_prop_list
*copy
= list
;
5411 struct dynamic_prop_list
**node_ptr
= ©
;
5413 while (*node_ptr
!= NULL
)
5415 struct dynamic_prop_list
*node_copy
;
5417 node_copy
= ((struct dynamic_prop_list
*)
5418 obstack_copy (objfile_obstack
, *node_ptr
,
5419 sizeof (struct dynamic_prop_list
)));
5420 node_copy
->prop
= (*node_ptr
)->prop
;
5421 *node_ptr
= node_copy
;
5423 node_ptr
= &node_copy
->next
;
5429 /* Recursively copy (deep copy) TYPE, if it is associated with
5430 OBJFILE. Return a new type owned by the gdbarch associated with the type, a
5431 saved type if we have already visited TYPE (using COPIED_TYPES), or TYPE if
5432 it is not associated with OBJFILE. */
5435 copy_type_recursive (struct objfile
*objfile
,
5437 htab_t copied_types
)
5440 struct type
*new_type
;
5442 if (! TYPE_OBJFILE_OWNED (type
))
5445 /* This type shouldn't be pointing to any types in other objfiles;
5446 if it did, the type might disappear unexpectedly. */
5447 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
5449 struct type_pair
pair (type
, nullptr);
5451 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
5453 return ((struct type_pair
*) *slot
)->newobj
;
5455 new_type
= alloc_type_arch (get_type_arch (type
));
5457 /* We must add the new type to the hash table immediately, in case
5458 we encounter this type again during a recursive call below. */
5459 struct type_pair
*stored
5460 = new (&objfile
->objfile_obstack
) struct type_pair (type
, new_type
);
5464 /* Copy the common fields of types. For the main type, we simply
5465 copy the entire thing and then update specific fields as needed. */
5466 *TYPE_MAIN_TYPE (new_type
) = *TYPE_MAIN_TYPE (type
);
5467 TYPE_OBJFILE_OWNED (new_type
) = 0;
5468 TYPE_OWNER (new_type
).gdbarch
= get_type_arch (type
);
5471 new_type
->set_name (xstrdup (type
->name ()));
5473 new_type
->set_instance_flags (type
->instance_flags ());
5474 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
5476 /* Copy the fields. */
5477 if (type
->num_fields ())
5481 nfields
= type
->num_fields ();
5482 new_type
->set_fields
5484 TYPE_ZALLOC (new_type
, nfields
* sizeof (struct field
)));
5486 for (i
= 0; i
< nfields
; i
++)
5488 TYPE_FIELD_ARTIFICIAL (new_type
, i
) =
5489 TYPE_FIELD_ARTIFICIAL (type
, i
);
5490 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
5491 if (type
->field (i
).type ())
5492 new_type
->field (i
).set_type
5493 (copy_type_recursive (objfile
, type
->field (i
).type (),
5495 if (TYPE_FIELD_NAME (type
, i
))
5496 TYPE_FIELD_NAME (new_type
, i
) =
5497 xstrdup (TYPE_FIELD_NAME (type
, i
));
5498 switch (TYPE_FIELD_LOC_KIND (type
, i
))
5500 case FIELD_LOC_KIND_BITPOS
:
5501 SET_FIELD_BITPOS (new_type
->field (i
),
5502 TYPE_FIELD_BITPOS (type
, i
));
5504 case FIELD_LOC_KIND_ENUMVAL
:
5505 SET_FIELD_ENUMVAL (new_type
->field (i
),
5506 TYPE_FIELD_ENUMVAL (type
, i
));
5508 case FIELD_LOC_KIND_PHYSADDR
:
5509 SET_FIELD_PHYSADDR (new_type
->field (i
),
5510 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
5512 case FIELD_LOC_KIND_PHYSNAME
:
5513 SET_FIELD_PHYSNAME (new_type
->field (i
),
5514 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
,
5518 internal_error (__FILE__
, __LINE__
,
5519 _("Unexpected type field location kind: %d"),
5520 TYPE_FIELD_LOC_KIND (type
, i
));
5525 /* For range types, copy the bounds information. */
5526 if (type
->code () == TYPE_CODE_RANGE
)
5528 range_bounds
*bounds
5529 = ((struct range_bounds
*) TYPE_ALLOC
5530 (new_type
, sizeof (struct range_bounds
)));
5532 *bounds
= *type
->bounds ();
5533 new_type
->set_bounds (bounds
);
5536 if (type
->main_type
->dyn_prop_list
!= NULL
)
5537 new_type
->main_type
->dyn_prop_list
5538 = copy_dynamic_prop_list (&objfile
->objfile_obstack
,
5539 type
->main_type
->dyn_prop_list
);
5542 /* Copy pointers to other types. */
5543 if (TYPE_TARGET_TYPE (type
))
5544 TYPE_TARGET_TYPE (new_type
) =
5545 copy_type_recursive (objfile
,
5546 TYPE_TARGET_TYPE (type
),
5549 /* Maybe copy the type_specific bits.
5551 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
5552 base classes and methods. There's no fundamental reason why we
5553 can't, but at the moment it is not needed. */
5555 switch (TYPE_SPECIFIC_FIELD (type
))
5557 case TYPE_SPECIFIC_NONE
:
5559 case TYPE_SPECIFIC_FUNC
:
5560 INIT_FUNC_SPECIFIC (new_type
);
5561 TYPE_CALLING_CONVENTION (new_type
) = TYPE_CALLING_CONVENTION (type
);
5562 TYPE_NO_RETURN (new_type
) = TYPE_NO_RETURN (type
);
5563 TYPE_TAIL_CALL_LIST (new_type
) = NULL
;
5565 case TYPE_SPECIFIC_FLOATFORMAT
:
5566 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
5568 case TYPE_SPECIFIC_CPLUS_STUFF
:
5569 INIT_CPLUS_SPECIFIC (new_type
);
5571 case TYPE_SPECIFIC_GNAT_STUFF
:
5572 INIT_GNAT_SPECIFIC (new_type
);
5574 case TYPE_SPECIFIC_SELF_TYPE
:
5575 set_type_self_type (new_type
,
5576 copy_type_recursive (objfile
, TYPE_SELF_TYPE (type
),
5579 case TYPE_SPECIFIC_FIXED_POINT
:
5580 INIT_FIXED_POINT_SPECIFIC (new_type
);
5581 new_type
->fixed_point_info ().scaling_factor
5582 = type
->fixed_point_info ().scaling_factor
;
5584 case TYPE_SPECIFIC_INT
:
5585 TYPE_SPECIFIC_FIELD (new_type
) = TYPE_SPECIFIC_INT
;
5586 TYPE_MAIN_TYPE (new_type
)->type_specific
.int_stuff
5587 = TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
;
5591 gdb_assert_not_reached ("bad type_specific_kind");
5597 /* Make a copy of the given TYPE, except that the pointer & reference
5598 types are not preserved.
5600 This function assumes that the given type has an associated objfile.
5601 This objfile is used to allocate the new type. */
5604 copy_type (const struct type
*type
)
5606 struct type
*new_type
;
5608 gdb_assert (TYPE_OBJFILE_OWNED (type
));
5610 new_type
= alloc_type_copy (type
);
5611 new_type
->set_instance_flags (type
->instance_flags ());
5612 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
5613 memcpy (TYPE_MAIN_TYPE (new_type
), TYPE_MAIN_TYPE (type
),
5614 sizeof (struct main_type
));
5615 if (type
->main_type
->dyn_prop_list
!= NULL
)
5616 new_type
->main_type
->dyn_prop_list
5617 = copy_dynamic_prop_list (&TYPE_OBJFILE (type
) -> objfile_obstack
,
5618 type
->main_type
->dyn_prop_list
);
5623 /* Helper functions to initialize architecture-specific types. */
5625 /* Allocate a type structure associated with GDBARCH and set its
5626 CODE, LENGTH, and NAME fields. */
5629 arch_type (struct gdbarch
*gdbarch
,
5630 enum type_code code
, int bit
, const char *name
)
5634 type
= alloc_type_arch (gdbarch
);
5635 set_type_code (type
, code
);
5636 gdb_assert ((bit
% TARGET_CHAR_BIT
) == 0);
5637 TYPE_LENGTH (type
) = bit
/ TARGET_CHAR_BIT
;
5640 type
->set_name (gdbarch_obstack_strdup (gdbarch
, name
));
5645 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
5646 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
5647 the type's TYPE_UNSIGNED flag. NAME is the type name. */
5650 arch_integer_type (struct gdbarch
*gdbarch
,
5651 int bit
, int unsigned_p
, const char *name
)
5655 t
= arch_type (gdbarch
, TYPE_CODE_INT
, bit
, name
);
5657 t
->set_is_unsigned (true);
5662 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
5663 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
5664 the type's TYPE_UNSIGNED flag. NAME is the type name. */
5667 arch_character_type (struct gdbarch
*gdbarch
,
5668 int bit
, int unsigned_p
, const char *name
)
5672 t
= arch_type (gdbarch
, TYPE_CODE_CHAR
, bit
, name
);
5674 t
->set_is_unsigned (true);
5679 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
5680 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
5681 the type's TYPE_UNSIGNED flag. NAME is the type name. */
5684 arch_boolean_type (struct gdbarch
*gdbarch
,
5685 int bit
, int unsigned_p
, const char *name
)
5689 t
= arch_type (gdbarch
, TYPE_CODE_BOOL
, bit
, name
);
5691 t
->set_is_unsigned (true);
5696 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
5697 BIT is the type size in bits; if BIT equals -1, the size is
5698 determined by the floatformat. NAME is the type name. Set the
5699 TYPE_FLOATFORMAT from FLOATFORMATS. */
5702 arch_float_type (struct gdbarch
*gdbarch
,
5703 int bit
, const char *name
,
5704 const struct floatformat
**floatformats
)
5706 const struct floatformat
*fmt
= floatformats
[gdbarch_byte_order (gdbarch
)];
5709 bit
= verify_floatformat (bit
, fmt
);
5710 t
= arch_type (gdbarch
, TYPE_CODE_FLT
, bit
, name
);
5711 TYPE_FLOATFORMAT (t
) = fmt
;
5716 /* Allocate a TYPE_CODE_DECFLOAT type structure associated with GDBARCH.
5717 BIT is the type size in bits. NAME is the type name. */
5720 arch_decfloat_type (struct gdbarch
*gdbarch
, int bit
, const char *name
)
5724 t
= arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, bit
, name
);
5728 /* Allocate a TYPE_CODE_PTR type structure associated with GDBARCH.
5729 BIT is the pointer type size in bits. NAME is the type name.
5730 TARGET_TYPE is the pointer target type. Always sets the pointer type's
5731 TYPE_UNSIGNED flag. */
5734 arch_pointer_type (struct gdbarch
*gdbarch
,
5735 int bit
, const char *name
, struct type
*target_type
)
5739 t
= arch_type (gdbarch
, TYPE_CODE_PTR
, bit
, name
);
5740 TYPE_TARGET_TYPE (t
) = target_type
;
5741 t
->set_is_unsigned (true);
5745 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
5746 NAME is the type name. BIT is the size of the flag word in bits. */
5749 arch_flags_type (struct gdbarch
*gdbarch
, const char *name
, int bit
)
5753 type
= arch_type (gdbarch
, TYPE_CODE_FLAGS
, bit
, name
);
5754 type
->set_is_unsigned (true);
5755 type
->set_num_fields (0);
5756 /* Pre-allocate enough space assuming every field is one bit. */
5758 ((struct field
*) TYPE_ZALLOC (type
, bit
* sizeof (struct field
)));
5763 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
5764 position BITPOS is called NAME. Pass NAME as "" for fields that
5765 should not be printed. */
5768 append_flags_type_field (struct type
*type
, int start_bitpos
, int nr_bits
,
5769 struct type
*field_type
, const char *name
)
5771 int type_bitsize
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
5772 int field_nr
= type
->num_fields ();
5774 gdb_assert (type
->code () == TYPE_CODE_FLAGS
);
5775 gdb_assert (type
->num_fields () + 1 <= type_bitsize
);
5776 gdb_assert (start_bitpos
>= 0 && start_bitpos
< type_bitsize
);
5777 gdb_assert (nr_bits
>= 1 && nr_bits
<= type_bitsize
);
5778 gdb_assert (name
!= NULL
);
5780 TYPE_FIELD_NAME (type
, field_nr
) = xstrdup (name
);
5781 type
->field (field_nr
).set_type (field_type
);
5782 SET_FIELD_BITPOS (type
->field (field_nr
), start_bitpos
);
5783 TYPE_FIELD_BITSIZE (type
, field_nr
) = nr_bits
;
5784 type
->set_num_fields (type
->num_fields () + 1);
5787 /* Special version of append_flags_type_field to add a flag field.
5788 Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
5789 position BITPOS is called NAME. */
5792 append_flags_type_flag (struct type
*type
, int bitpos
, const char *name
)
5794 struct gdbarch
*gdbarch
= get_type_arch (type
);
5796 append_flags_type_field (type
, bitpos
, 1,
5797 builtin_type (gdbarch
)->builtin_bool
,
5801 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
5802 specified by CODE) associated with GDBARCH. NAME is the type name. */
5805 arch_composite_type (struct gdbarch
*gdbarch
, const char *name
,
5806 enum type_code code
)
5810 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
5811 t
= arch_type (gdbarch
, code
, 0, NULL
);
5813 INIT_CPLUS_SPECIFIC (t
);
5817 /* Add new field with name NAME and type FIELD to composite type T.
5818 Do not set the field's position or adjust the type's length;
5819 the caller should do so. Return the new field. */
5822 append_composite_type_field_raw (struct type
*t
, const char *name
,
5827 t
->set_num_fields (t
->num_fields () + 1);
5828 t
->set_fields (XRESIZEVEC (struct field
, t
->fields (),
5830 f
= &t
->field (t
->num_fields () - 1);
5831 memset (f
, 0, sizeof f
[0]);
5832 f
[0].set_type (field
);
5833 FIELD_NAME (f
[0]) = name
;
5837 /* Add new field with name NAME and type FIELD to composite type T.
5838 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
5841 append_composite_type_field_aligned (struct type
*t
, const char *name
,
5842 struct type
*field
, int alignment
)
5844 struct field
*f
= append_composite_type_field_raw (t
, name
, field
);
5846 if (t
->code () == TYPE_CODE_UNION
)
5848 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
5849 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
5851 else if (t
->code () == TYPE_CODE_STRUCT
)
5853 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
5854 if (t
->num_fields () > 1)
5856 SET_FIELD_BITPOS (f
[0],
5857 (FIELD_BITPOS (f
[-1])
5858 + (TYPE_LENGTH (f
[-1].type ())
5859 * TARGET_CHAR_BIT
)));
5865 alignment
*= TARGET_CHAR_BIT
;
5866 left
= FIELD_BITPOS (f
[0]) % alignment
;
5870 SET_FIELD_BITPOS (f
[0], FIELD_BITPOS (f
[0]) + (alignment
- left
));
5871 TYPE_LENGTH (t
) += (alignment
- left
) / TARGET_CHAR_BIT
;
5878 /* Add new field with name NAME and type FIELD to composite type T. */
5881 append_composite_type_field (struct type
*t
, const char *name
,
5884 append_composite_type_field_aligned (t
, name
, field
, 0);
5889 /* We manage the lifetimes of fixed_point_type_info objects by
5890 attaching them to the objfile. Currently, these objects are
5891 modified during construction, and GMP does not provide a way to
5892 hash the contents of an mpq_t; so it's a bit of a pain to hash-cons
5893 them. If we did do this, they could be moved to the per-BFD and
5894 shared across objfiles. */
5895 typedef std::vector
<std::unique_ptr
<fixed_point_type_info
>>
5896 fixed_point_type_storage
;
5898 /* Key used for managing the storage of fixed-point type info. */
5899 static const struct objfile_key
<fixed_point_type_storage
>
5900 fixed_point_objfile_key
;
5902 /* See gdbtypes.h. */
5905 allocate_fixed_point_type_info (struct type
*type
)
5907 std::unique_ptr
<fixed_point_type_info
> up (new fixed_point_type_info
);
5908 fixed_point_type_info
*info
;
5910 if (TYPE_OBJFILE_OWNED (type
))
5912 fixed_point_type_storage
*storage
5913 = fixed_point_objfile_key
.get (TYPE_OBJFILE (type
));
5914 if (storage
== nullptr)
5915 storage
= fixed_point_objfile_key
.emplace (TYPE_OBJFILE (type
));
5917 storage
->push_back (std::move (up
));
5921 /* We just leak the memory, because that's what we do generally
5922 for non-objfile-attached types. */
5923 info
= up
.release ();
5926 type
->set_fixed_point_info (info
);
5929 /* See gdbtypes.h. */
5932 is_fixed_point_type (struct type
*type
)
5934 while (check_typedef (type
)->code () == TYPE_CODE_RANGE
)
5935 type
= TYPE_TARGET_TYPE (check_typedef (type
));
5936 type
= check_typedef (type
);
5938 return type
->code () == TYPE_CODE_FIXED_POINT
;
5941 /* See gdbtypes.h. */
5944 type::fixed_point_type_base_type ()
5946 struct type
*type
= this;
5948 while (check_typedef (type
)->code () == TYPE_CODE_RANGE
)
5949 type
= TYPE_TARGET_TYPE (check_typedef (type
));
5950 type
= check_typedef (type
);
5952 gdb_assert (type
->code () == TYPE_CODE_FIXED_POINT
);
5956 /* See gdbtypes.h. */
5959 type::fixed_point_scaling_factor ()
5961 struct type
*type
= this->fixed_point_type_base_type ();
5963 return type
->fixed_point_info ().scaling_factor
;
5968 static struct gdbarch_data
*gdbtypes_data
;
5970 const struct builtin_type
*
5971 builtin_type (struct gdbarch
*gdbarch
)
5973 return (const struct builtin_type
*) gdbarch_data (gdbarch
, gdbtypes_data
);
5977 gdbtypes_post_init (struct gdbarch
*gdbarch
)
5979 struct builtin_type
*builtin_type
5980 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
5983 builtin_type
->builtin_void
5984 = arch_type (gdbarch
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, "void");
5985 builtin_type
->builtin_char
5986 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
5987 !gdbarch_char_signed (gdbarch
), "char");
5988 builtin_type
->builtin_char
->set_has_no_signedness (true);
5989 builtin_type
->builtin_signed_char
5990 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
5992 builtin_type
->builtin_unsigned_char
5993 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
5994 1, "unsigned char");
5995 builtin_type
->builtin_short
5996 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
5998 builtin_type
->builtin_unsigned_short
5999 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
6000 1, "unsigned short");
6001 builtin_type
->builtin_int
6002 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
6004 builtin_type
->builtin_unsigned_int
6005 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
6007 builtin_type
->builtin_long
6008 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
6010 builtin_type
->builtin_unsigned_long
6011 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
6012 1, "unsigned long");
6013 builtin_type
->builtin_long_long
6014 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
6016 builtin_type
->builtin_unsigned_long_long
6017 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
6018 1, "unsigned long long");
6019 builtin_type
->builtin_half
6020 = arch_float_type (gdbarch
, gdbarch_half_bit (gdbarch
),
6021 "half", gdbarch_half_format (gdbarch
));
6022 builtin_type
->builtin_float
6023 = arch_float_type (gdbarch
, gdbarch_float_bit (gdbarch
),
6024 "float", gdbarch_float_format (gdbarch
));
6025 builtin_type
->builtin_bfloat16
6026 = arch_float_type (gdbarch
, gdbarch_bfloat16_bit (gdbarch
),
6027 "bfloat16", gdbarch_bfloat16_format (gdbarch
));
6028 builtin_type
->builtin_double
6029 = arch_float_type (gdbarch
, gdbarch_double_bit (gdbarch
),
6030 "double", gdbarch_double_format (gdbarch
));
6031 builtin_type
->builtin_long_double
6032 = arch_float_type (gdbarch
, gdbarch_long_double_bit (gdbarch
),
6033 "long double", gdbarch_long_double_format (gdbarch
));
6034 builtin_type
->builtin_complex
6035 = init_complex_type ("complex", builtin_type
->builtin_float
);
6036 builtin_type
->builtin_double_complex
6037 = init_complex_type ("double complex", builtin_type
->builtin_double
);
6038 builtin_type
->builtin_string
6039 = arch_type (gdbarch
, TYPE_CODE_STRING
, TARGET_CHAR_BIT
, "string");
6040 builtin_type
->builtin_bool
6041 = arch_type (gdbarch
, TYPE_CODE_BOOL
, TARGET_CHAR_BIT
, "bool");
6043 /* The following three are about decimal floating point types, which
6044 are 32-bits, 64-bits and 128-bits respectively. */
6045 builtin_type
->builtin_decfloat
6046 = arch_decfloat_type (gdbarch
, 32, "_Decimal32");
6047 builtin_type
->builtin_decdouble
6048 = arch_decfloat_type (gdbarch
, 64, "_Decimal64");
6049 builtin_type
->builtin_declong
6050 = arch_decfloat_type (gdbarch
, 128, "_Decimal128");
6052 /* "True" character types. */
6053 builtin_type
->builtin_true_char
6054 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 0, "true character");
6055 builtin_type
->builtin_true_unsigned_char
6056 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 1, "true character");
6058 /* Fixed-size integer types. */
6059 builtin_type
->builtin_int0
6060 = arch_integer_type (gdbarch
, 0, 0, "int0_t");
6061 builtin_type
->builtin_int8
6062 = arch_integer_type (gdbarch
, 8, 0, "int8_t");
6063 builtin_type
->builtin_uint8
6064 = arch_integer_type (gdbarch
, 8, 1, "uint8_t");
6065 builtin_type
->builtin_int16
6066 = arch_integer_type (gdbarch
, 16, 0, "int16_t");
6067 builtin_type
->builtin_uint16
6068 = arch_integer_type (gdbarch
, 16, 1, "uint16_t");
6069 builtin_type
->builtin_int24
6070 = arch_integer_type (gdbarch
, 24, 0, "int24_t");
6071 builtin_type
->builtin_uint24
6072 = arch_integer_type (gdbarch
, 24, 1, "uint24_t");
6073 builtin_type
->builtin_int32
6074 = arch_integer_type (gdbarch
, 32, 0, "int32_t");
6075 builtin_type
->builtin_uint32
6076 = arch_integer_type (gdbarch
, 32, 1, "uint32_t");
6077 builtin_type
->builtin_int64
6078 = arch_integer_type (gdbarch
, 64, 0, "int64_t");
6079 builtin_type
->builtin_uint64
6080 = arch_integer_type (gdbarch
, 64, 1, "uint64_t");
6081 builtin_type
->builtin_int128
6082 = arch_integer_type (gdbarch
, 128, 0, "int128_t");
6083 builtin_type
->builtin_uint128
6084 = arch_integer_type (gdbarch
, 128, 1, "uint128_t");
6086 builtin_type
->builtin_int8
->set_instance_flags
6087 (builtin_type
->builtin_int8
->instance_flags ()
6088 | TYPE_INSTANCE_FLAG_NOTTEXT
);
6090 builtin_type
->builtin_uint8
->set_instance_flags
6091 (builtin_type
->builtin_uint8
->instance_flags ()
6092 | TYPE_INSTANCE_FLAG_NOTTEXT
);
6094 /* Wide character types. */
6095 builtin_type
->builtin_char16
6096 = arch_integer_type (gdbarch
, 16, 1, "char16_t");
6097 builtin_type
->builtin_char32
6098 = arch_integer_type (gdbarch
, 32, 1, "char32_t");
6099 builtin_type
->builtin_wchar
6100 = arch_integer_type (gdbarch
, gdbarch_wchar_bit (gdbarch
),
6101 !gdbarch_wchar_signed (gdbarch
), "wchar_t");
6103 /* Default data/code pointer types. */
6104 builtin_type
->builtin_data_ptr
6105 = lookup_pointer_type (builtin_type
->builtin_void
);
6106 builtin_type
->builtin_func_ptr
6107 = lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
6108 builtin_type
->builtin_func_func
6109 = lookup_function_type (builtin_type
->builtin_func_ptr
);
6111 /* This type represents a GDB internal function. */
6112 builtin_type
->internal_fn
6113 = arch_type (gdbarch
, TYPE_CODE_INTERNAL_FUNCTION
, 0,
6114 "<internal function>");
6116 /* This type represents an xmethod. */
6117 builtin_type
->xmethod
6118 = arch_type (gdbarch
, TYPE_CODE_XMETHOD
, 0, "<xmethod>");
6120 return builtin_type
;
6123 /* This set of objfile-based types is intended to be used by symbol
6124 readers as basic types. */
6126 static const struct objfile_key
<struct objfile_type
,
6127 gdb::noop_deleter
<struct objfile_type
>>
6130 const struct objfile_type
*
6131 objfile_type (struct objfile
*objfile
)
6133 struct gdbarch
*gdbarch
;
6134 struct objfile_type
*objfile_type
= objfile_type_data
.get (objfile
);
6137 return objfile_type
;
6139 objfile_type
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
6140 1, struct objfile_type
);
6142 /* Use the objfile architecture to determine basic type properties. */
6143 gdbarch
= objfile
->arch ();
6146 objfile_type
->builtin_void
6147 = init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, "void");
6148 objfile_type
->builtin_char
6149 = init_integer_type (objfile
, TARGET_CHAR_BIT
,
6150 !gdbarch_char_signed (gdbarch
), "char");
6151 objfile_type
->builtin_char
->set_has_no_signedness (true);
6152 objfile_type
->builtin_signed_char
6153 = init_integer_type (objfile
, TARGET_CHAR_BIT
,
6155 objfile_type
->builtin_unsigned_char
6156 = init_integer_type (objfile
, TARGET_CHAR_BIT
,
6157 1, "unsigned char");
6158 objfile_type
->builtin_short
6159 = init_integer_type (objfile
, gdbarch_short_bit (gdbarch
),
6161 objfile_type
->builtin_unsigned_short
6162 = init_integer_type (objfile
, gdbarch_short_bit (gdbarch
),
6163 1, "unsigned short");
6164 objfile_type
->builtin_int
6165 = init_integer_type (objfile
, gdbarch_int_bit (gdbarch
),
6167 objfile_type
->builtin_unsigned_int
6168 = init_integer_type (objfile
, gdbarch_int_bit (gdbarch
),
6170 objfile_type
->builtin_long
6171 = init_integer_type (objfile
, gdbarch_long_bit (gdbarch
),
6173 objfile_type
->builtin_unsigned_long
6174 = init_integer_type (objfile
, gdbarch_long_bit (gdbarch
),
6175 1, "unsigned long");
6176 objfile_type
->builtin_long_long
6177 = init_integer_type (objfile
, gdbarch_long_long_bit (gdbarch
),
6179 objfile_type
->builtin_unsigned_long_long
6180 = init_integer_type (objfile
, gdbarch_long_long_bit (gdbarch
),
6181 1, "unsigned long long");
6182 objfile_type
->builtin_float
6183 = init_float_type (objfile
, gdbarch_float_bit (gdbarch
),
6184 "float", gdbarch_float_format (gdbarch
));
6185 objfile_type
->builtin_double
6186 = init_float_type (objfile
, gdbarch_double_bit (gdbarch
),
6187 "double", gdbarch_double_format (gdbarch
));
6188 objfile_type
->builtin_long_double
6189 = init_float_type (objfile
, gdbarch_long_double_bit (gdbarch
),
6190 "long double", gdbarch_long_double_format (gdbarch
));
6192 /* This type represents a type that was unrecognized in symbol read-in. */
6193 objfile_type
->builtin_error
6194 = init_type (objfile
, TYPE_CODE_ERROR
, 0, "<unknown type>");
6196 /* The following set of types is used for symbols with no
6197 debug information. */
6198 objfile_type
->nodebug_text_symbol
6199 = init_type (objfile
, TYPE_CODE_FUNC
, TARGET_CHAR_BIT
,
6200 "<text variable, no debug info>");
6202 objfile_type
->nodebug_text_gnu_ifunc_symbol
6203 = init_type (objfile
, TYPE_CODE_FUNC
, TARGET_CHAR_BIT
,
6204 "<text gnu-indirect-function variable, no debug info>");
6205 objfile_type
->nodebug_text_gnu_ifunc_symbol
->set_is_gnu_ifunc (true);
6207 objfile_type
->nodebug_got_plt_symbol
6208 = init_pointer_type (objfile
, gdbarch_addr_bit (gdbarch
),
6209 "<text from jump slot in .got.plt, no debug info>",
6210 objfile_type
->nodebug_text_symbol
);
6211 objfile_type
->nodebug_data_symbol
6212 = init_nodebug_var_type (objfile
, "<data variable, no debug info>");
6213 objfile_type
->nodebug_unknown_symbol
6214 = init_nodebug_var_type (objfile
, "<variable (not text or data), no debug info>");
6215 objfile_type
->nodebug_tls_symbol
6216 = init_nodebug_var_type (objfile
, "<thread local variable, no debug info>");
6218 /* NOTE: on some targets, addresses and pointers are not necessarily
6222 - gdb's `struct type' always describes the target's
6224 - gdb's `struct value' objects should always hold values in
6226 - gdb's CORE_ADDR values are addresses in the unified virtual
6227 address space that the assembler and linker work with. Thus,
6228 since target_read_memory takes a CORE_ADDR as an argument, it
6229 can access any memory on the target, even if the processor has
6230 separate code and data address spaces.
6232 In this context, objfile_type->builtin_core_addr is a bit odd:
6233 it's a target type for a value the target will never see. It's
6234 only used to hold the values of (typeless) linker symbols, which
6235 are indeed in the unified virtual address space. */
6237 objfile_type
->builtin_core_addr
6238 = init_integer_type (objfile
, gdbarch_addr_bit (gdbarch
), 1,
6241 objfile_type_data
.set (objfile
, objfile_type
);
6242 return objfile_type
;
6245 void _initialize_gdbtypes ();
6247 _initialize_gdbtypes ()
6249 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
6251 add_setshow_zuinteger_cmd ("overload", no_class
, &overload_debug
,
6252 _("Set debugging of C++ overloading."),
6253 _("Show debugging of C++ overloading."),
6254 _("When enabled, ranking of the "
6255 "functions is displayed."),
6257 show_overload_debug
,
6258 &setdebuglist
, &showdebuglist
);
6260 /* Add user knob for controlling resolution of opaque types. */
6261 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
6262 &opaque_type_resolution
,
6263 _("Set resolution of opaque struct/class/union"
6264 " types (if set before loading symbols)."),
6265 _("Show resolution of opaque struct/class/union"
6266 " types (if set before loading symbols)."),
6268 show_opaque_type_resolution
,
6269 &setlist
, &showlist
);
6271 /* Add an option to permit non-strict type checking. */
6272 add_setshow_boolean_cmd ("type", class_support
,
6273 &strict_type_checking
,
6274 _("Set strict type checking."),
6275 _("Show strict type checking."),
6277 show_strict_type_checking
,
6278 &setchecklist
, &showchecklist
);