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 gdb::optional
<LONGEST
> high
= get_discrete_high_bound (type
);
1194 if (!low
.has_value () || !high
.has_value ())
1203 /* See gdbtypes.h */
1206 get_array_bounds (struct type
*type
, LONGEST
*low_bound
, LONGEST
*high_bound
)
1208 struct type
*index
= type
->index_type ();
1215 if (!get_discrete_bounds (index
, &low
, &high
))
1227 /* Assuming that TYPE is a discrete type and VAL is a valid integer
1228 representation of a value of this type, save the corresponding
1229 position number in POS.
1231 Its differs from VAL only in the case of enumeration types. In
1232 this case, the position number of the value of the first listed
1233 enumeration literal is zero; the position number of the value of
1234 each subsequent enumeration literal is one more than that of its
1235 predecessor in the list.
1237 Return 1 if the operation was successful. Return zero otherwise,
1238 in which case the value of POS is unmodified.
1241 gdb::optional
<LONGEST
>
1242 discrete_position (struct type
*type
, LONGEST val
)
1244 if (type
->code () == TYPE_CODE_RANGE
)
1245 type
= TYPE_TARGET_TYPE (type
);
1247 if (type
->code () == TYPE_CODE_ENUM
)
1251 for (i
= 0; i
< type
->num_fields (); i
+= 1)
1253 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
1257 /* Invalid enumeration value. */
1264 /* If the array TYPE has static bounds calculate and update its
1265 size, then return true. Otherwise return false and leave TYPE
1269 update_static_array_size (struct type
*type
)
1271 gdb_assert (type
->code () == TYPE_CODE_ARRAY
);
1273 struct type
*range_type
= type
->index_type ();
1275 if (type
->dyn_prop (DYN_PROP_BYTE_STRIDE
) == nullptr
1276 && has_static_range (range_type
->bounds ())
1277 && (!type_not_associated (type
)
1278 && !type_not_allocated (type
)))
1280 LONGEST low_bound
, high_bound
;
1282 struct type
*element_type
;
1284 /* If the array itself doesn't provide a stride value then take
1285 whatever stride the range provides. Don't update BIT_STRIDE as
1286 we don't want to place the stride value from the range into this
1287 arrays bit size field. */
1288 stride
= TYPE_FIELD_BITSIZE (type
, 0);
1290 stride
= range_type
->bit_stride ();
1292 if (!get_discrete_bounds (range_type
, &low_bound
, &high_bound
))
1293 low_bound
= high_bound
= 0;
1295 element_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1296 /* Be careful when setting the array length. Ada arrays can be
1297 empty arrays with the high_bound being smaller than the low_bound.
1298 In such cases, the array length should be zero. */
1299 if (high_bound
< low_bound
)
1300 TYPE_LENGTH (type
) = 0;
1301 else if (stride
!= 0)
1303 /* Ensure that the type length is always positive, even in the
1304 case where (for example in Fortran) we have a negative
1305 stride. It is possible to have a single element array with a
1306 negative stride in Fortran (this doesn't mean anything
1307 special, it's still just a single element array) so do
1308 consider that case when touching this code. */
1309 LONGEST element_count
= std::abs (high_bound
- low_bound
+ 1);
1311 = ((std::abs (stride
) * element_count
) + 7) / 8;
1314 TYPE_LENGTH (type
) =
1315 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
1317 /* If this array's element is itself an array with a bit stride,
1318 then we want to update this array's bit stride to reflect the
1319 size of the sub-array. Otherwise, we'll end up using the
1320 wrong size when trying to find elements of the outer
1322 if (element_type
->code () == TYPE_CODE_ARRAY
1323 && TYPE_LENGTH (element_type
) != 0
1324 && TYPE_FIELD_BITSIZE (element_type
, 0) != 0
1325 && get_array_bounds (element_type
, &low_bound
, &high_bound
)
1326 && high_bound
>= low_bound
)
1327 TYPE_FIELD_BITSIZE (type
, 0)
1328 = ((high_bound
- low_bound
+ 1)
1329 * TYPE_FIELD_BITSIZE (element_type
, 0));
1337 /* Create an array type using either a blank type supplied in
1338 RESULT_TYPE, or creating a new type, inheriting the objfile from
1341 Elements will be of type ELEMENT_TYPE, the indices will be of type
1344 BYTE_STRIDE_PROP, when not NULL, provides the array's byte stride.
1345 This byte stride property is added to the resulting array type
1346 as a DYN_PROP_BYTE_STRIDE. As a consequence, the BYTE_STRIDE_PROP
1347 argument can only be used to create types that are objfile-owned
1348 (see add_dyn_prop), meaning that either this function must be called
1349 with an objfile-owned RESULT_TYPE, or an objfile-owned RANGE_TYPE.
1351 BIT_STRIDE is taken into account only when BYTE_STRIDE_PROP is NULL.
1352 If BIT_STRIDE is not zero, build a packed array type whose element
1353 size is BIT_STRIDE. Otherwise, ignore this parameter.
1355 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1356 sure it is TYPE_CODE_UNDEF before we bash it into an array
1360 create_array_type_with_stride (struct type
*result_type
,
1361 struct type
*element_type
,
1362 struct type
*range_type
,
1363 struct dynamic_prop
*byte_stride_prop
,
1364 unsigned int bit_stride
)
1366 if (byte_stride_prop
!= NULL
1367 && byte_stride_prop
->kind () == PROP_CONST
)
1369 /* The byte stride is actually not dynamic. Pretend we were
1370 called with bit_stride set instead of byte_stride_prop.
1371 This will give us the same result type, while avoiding
1372 the need to handle this as a special case. */
1373 bit_stride
= byte_stride_prop
->const_val () * 8;
1374 byte_stride_prop
= NULL
;
1377 if (result_type
== NULL
)
1378 result_type
= alloc_type_copy (range_type
);
1380 result_type
->set_code (TYPE_CODE_ARRAY
);
1381 TYPE_TARGET_TYPE (result_type
) = element_type
;
1383 result_type
->set_num_fields (1);
1384 result_type
->set_fields
1385 ((struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
)));
1386 result_type
->set_index_type (range_type
);
1387 if (byte_stride_prop
!= NULL
)
1388 result_type
->add_dyn_prop (DYN_PROP_BYTE_STRIDE
, *byte_stride_prop
);
1389 else if (bit_stride
> 0)
1390 TYPE_FIELD_BITSIZE (result_type
, 0) = bit_stride
;
1392 if (!update_static_array_size (result_type
))
1394 /* This type is dynamic and its length needs to be computed
1395 on demand. In the meantime, avoid leaving the TYPE_LENGTH
1396 undefined by setting it to zero. Although we are not expected
1397 to trust TYPE_LENGTH in this case, setting the size to zero
1398 allows us to avoid allocating objects of random sizes in case
1399 we accidently do. */
1400 TYPE_LENGTH (result_type
) = 0;
1403 /* TYPE_TARGET_STUB will take care of zero length arrays. */
1404 if (TYPE_LENGTH (result_type
) == 0)
1405 result_type
->set_target_is_stub (true);
1410 /* Same as create_array_type_with_stride but with no bit_stride
1411 (BIT_STRIDE = 0), thus building an unpacked array. */
1414 create_array_type (struct type
*result_type
,
1415 struct type
*element_type
,
1416 struct type
*range_type
)
1418 return create_array_type_with_stride (result_type
, element_type
,
1419 range_type
, NULL
, 0);
1423 lookup_array_range_type (struct type
*element_type
,
1424 LONGEST low_bound
, LONGEST high_bound
)
1426 struct type
*index_type
;
1427 struct type
*range_type
;
1429 if (TYPE_OBJFILE_OWNED (element_type
))
1430 index_type
= objfile_type (TYPE_OWNER (element_type
).objfile
)->builtin_int
;
1432 index_type
= builtin_type (get_type_arch (element_type
))->builtin_int
;
1433 range_type
= create_static_range_type (NULL
, index_type
,
1434 low_bound
, high_bound
);
1436 return create_array_type (NULL
, element_type
, range_type
);
1439 /* Create a string type using either a blank type supplied in
1440 RESULT_TYPE, or creating a new type. String types are similar
1441 enough to array of char types that we can use create_array_type to
1442 build the basic type and then bash it into a string type.
1444 For fixed length strings, the range type contains 0 as the lower
1445 bound and the length of the string minus one as the upper bound.
1447 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1448 sure it is TYPE_CODE_UNDEF before we bash it into a string
1452 create_string_type (struct type
*result_type
,
1453 struct type
*string_char_type
,
1454 struct type
*range_type
)
1456 result_type
= create_array_type (result_type
,
1459 result_type
->set_code (TYPE_CODE_STRING
);
1464 lookup_string_range_type (struct type
*string_char_type
,
1465 LONGEST low_bound
, LONGEST high_bound
)
1467 struct type
*result_type
;
1469 result_type
= lookup_array_range_type (string_char_type
,
1470 low_bound
, high_bound
);
1471 result_type
->set_code (TYPE_CODE_STRING
);
1476 create_set_type (struct type
*result_type
, struct type
*domain_type
)
1478 if (result_type
== NULL
)
1479 result_type
= alloc_type_copy (domain_type
);
1481 result_type
->set_code (TYPE_CODE_SET
);
1482 result_type
->set_num_fields (1);
1483 result_type
->set_fields
1484 ((struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
)));
1486 if (!domain_type
->is_stub ())
1488 LONGEST low_bound
, high_bound
, bit_length
;
1490 if (!get_discrete_bounds (domain_type
, &low_bound
, &high_bound
))
1491 low_bound
= high_bound
= 0;
1493 bit_length
= high_bound
- low_bound
+ 1;
1494 TYPE_LENGTH (result_type
)
1495 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
1497 result_type
->set_is_unsigned (true);
1499 result_type
->field (0).set_type (domain_type
);
1504 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
1505 and any array types nested inside it. */
1508 make_vector_type (struct type
*array_type
)
1510 struct type
*inner_array
, *elt_type
;
1512 /* Find the innermost array type, in case the array is
1513 multi-dimensional. */
1514 inner_array
= array_type
;
1515 while (TYPE_TARGET_TYPE (inner_array
)->code () == TYPE_CODE_ARRAY
)
1516 inner_array
= TYPE_TARGET_TYPE (inner_array
);
1518 elt_type
= TYPE_TARGET_TYPE (inner_array
);
1519 if (elt_type
->code () == TYPE_CODE_INT
)
1521 type_instance_flags flags
1522 = elt_type
->instance_flags () | TYPE_INSTANCE_FLAG_NOTTEXT
;
1523 elt_type
= make_qualified_type (elt_type
, flags
, NULL
);
1524 TYPE_TARGET_TYPE (inner_array
) = elt_type
;
1527 array_type
->set_is_vector (true);
1531 init_vector_type (struct type
*elt_type
, int n
)
1533 struct type
*array_type
;
1535 array_type
= lookup_array_range_type (elt_type
, 0, n
- 1);
1536 make_vector_type (array_type
);
1540 /* Internal routine called by TYPE_SELF_TYPE to return the type that TYPE
1541 belongs to. In c++ this is the class of "this", but TYPE_THIS_TYPE is too
1542 confusing. "self" is a common enough replacement for "this".
1543 TYPE must be one of TYPE_CODE_METHODPTR, TYPE_CODE_MEMBERPTR, or
1544 TYPE_CODE_METHOD. */
1547 internal_type_self_type (struct type
*type
)
1549 switch (type
->code ())
1551 case TYPE_CODE_METHODPTR
:
1552 case TYPE_CODE_MEMBERPTR
:
1553 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1555 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_SELF_TYPE
);
1556 return TYPE_MAIN_TYPE (type
)->type_specific
.self_type
;
1557 case TYPE_CODE_METHOD
:
1558 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1560 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
1561 return TYPE_MAIN_TYPE (type
)->type_specific
.func_stuff
->self_type
;
1563 gdb_assert_not_reached ("bad type");
1567 /* Set the type of the class that TYPE belongs to.
1568 In c++ this is the class of "this".
1569 TYPE must be one of TYPE_CODE_METHODPTR, TYPE_CODE_MEMBERPTR, or
1570 TYPE_CODE_METHOD. */
1573 set_type_self_type (struct type
*type
, struct type
*self_type
)
1575 switch (type
->code ())
1577 case TYPE_CODE_METHODPTR
:
1578 case TYPE_CODE_MEMBERPTR
:
1579 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1580 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_SELF_TYPE
;
1581 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_SELF_TYPE
);
1582 TYPE_MAIN_TYPE (type
)->type_specific
.self_type
= self_type
;
1584 case TYPE_CODE_METHOD
:
1585 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1586 INIT_FUNC_SPECIFIC (type
);
1587 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
1588 TYPE_MAIN_TYPE (type
)->type_specific
.func_stuff
->self_type
= self_type
;
1591 gdb_assert_not_reached ("bad type");
1595 /* Smash TYPE to be a type of pointers to members of SELF_TYPE with type
1596 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1597 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1598 TYPE doesn't include the offset (that's the value of the MEMBER
1599 itself), but does include the structure type into which it points
1602 When "smashing" the type, we preserve the objfile that the old type
1603 pointed to, since we aren't changing where the type is actually
1607 smash_to_memberptr_type (struct type
*type
, struct type
*self_type
,
1608 struct type
*to_type
)
1611 type
->set_code (TYPE_CODE_MEMBERPTR
);
1612 TYPE_TARGET_TYPE (type
) = to_type
;
1613 set_type_self_type (type
, self_type
);
1614 /* Assume that a data member pointer is the same size as a normal
1617 = gdbarch_ptr_bit (get_type_arch (to_type
)) / TARGET_CHAR_BIT
;
1620 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1622 When "smashing" the type, we preserve the objfile that the old type
1623 pointed to, since we aren't changing where the type is actually
1627 smash_to_methodptr_type (struct type
*type
, struct type
*to_type
)
1630 type
->set_code (TYPE_CODE_METHODPTR
);
1631 TYPE_TARGET_TYPE (type
) = to_type
;
1632 set_type_self_type (type
, TYPE_SELF_TYPE (to_type
));
1633 TYPE_LENGTH (type
) = cplus_method_ptr_size (to_type
);
1636 /* Smash TYPE to be a type of method of SELF_TYPE with type TO_TYPE.
1637 METHOD just means `function that gets an extra "this" argument'.
1639 When "smashing" the type, we preserve the objfile that the old type
1640 pointed to, since we aren't changing where the type is actually
1644 smash_to_method_type (struct type
*type
, struct type
*self_type
,
1645 struct type
*to_type
, struct field
*args
,
1646 int nargs
, int varargs
)
1649 type
->set_code (TYPE_CODE_METHOD
);
1650 TYPE_TARGET_TYPE (type
) = to_type
;
1651 set_type_self_type (type
, self_type
);
1652 type
->set_fields (args
);
1653 type
->set_num_fields (nargs
);
1655 type
->set_has_varargs (true);
1656 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1659 /* A wrapper of TYPE_NAME which calls error if the type is anonymous.
1660 Since GCC PR debug/47510 DWARF provides associated information to detect the
1661 anonymous class linkage name from its typedef.
1663 Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
1667 type_name_or_error (struct type
*type
)
1669 struct type
*saved_type
= type
;
1671 struct objfile
*objfile
;
1673 type
= check_typedef (type
);
1675 name
= type
->name ();
1679 name
= saved_type
->name ();
1680 objfile
= TYPE_OBJFILE (saved_type
);
1681 error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
1682 name
? name
: "<anonymous>",
1683 objfile
? objfile_name (objfile
) : "<arch>");
1686 /* Lookup a typedef or primitive type named NAME, visible in lexical
1687 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1688 suitably defined. */
1691 lookup_typename (const struct language_defn
*language
,
1693 const struct block
*block
, int noerr
)
1697 sym
= lookup_symbol_in_language (name
, block
, VAR_DOMAIN
,
1698 language
->la_language
, NULL
).symbol
;
1699 if (sym
!= NULL
&& SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
1700 return SYMBOL_TYPE (sym
);
1704 error (_("No type named %s."), name
);
1708 lookup_unsigned_typename (const struct language_defn
*language
,
1711 char *uns
= (char *) alloca (strlen (name
) + 10);
1713 strcpy (uns
, "unsigned ");
1714 strcpy (uns
+ 9, name
);
1715 return lookup_typename (language
, uns
, NULL
, 0);
1719 lookup_signed_typename (const struct language_defn
*language
, const char *name
)
1722 char *uns
= (char *) alloca (strlen (name
) + 8);
1724 strcpy (uns
, "signed ");
1725 strcpy (uns
+ 7, name
);
1726 t
= lookup_typename (language
, uns
, NULL
, 1);
1727 /* If we don't find "signed FOO" just try again with plain "FOO". */
1730 return lookup_typename (language
, name
, NULL
, 0);
1733 /* Lookup a structure type named "struct NAME",
1734 visible in lexical block BLOCK. */
1737 lookup_struct (const char *name
, const struct block
*block
)
1741 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
1745 error (_("No struct type named %s."), name
);
1747 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_STRUCT
)
1749 error (_("This context has class, union or enum %s, not a struct."),
1752 return (SYMBOL_TYPE (sym
));
1755 /* Lookup a union type named "union NAME",
1756 visible in lexical block BLOCK. */
1759 lookup_union (const char *name
, const struct block
*block
)
1764 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
1767 error (_("No union type named %s."), name
);
1769 t
= SYMBOL_TYPE (sym
);
1771 if (t
->code () == TYPE_CODE_UNION
)
1774 /* If we get here, it's not a union. */
1775 error (_("This context has class, struct or enum %s, not a union."),
1779 /* Lookup an enum type named "enum NAME",
1780 visible in lexical block BLOCK. */
1783 lookup_enum (const char *name
, const struct block
*block
)
1787 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
1790 error (_("No enum type named %s."), name
);
1792 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_ENUM
)
1794 error (_("This context has class, struct or union %s, not an enum."),
1797 return (SYMBOL_TYPE (sym
));
1800 /* Lookup a template type named "template NAME<TYPE>",
1801 visible in lexical block BLOCK. */
1804 lookup_template_type (const char *name
, struct type
*type
,
1805 const struct block
*block
)
1808 char *nam
= (char *)
1809 alloca (strlen (name
) + strlen (type
->name ()) + 4);
1813 strcat (nam
, type
->name ());
1814 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1816 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0).symbol
;
1820 error (_("No template type named %s."), name
);
1822 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_STRUCT
)
1824 error (_("This context has class, union or enum %s, not a struct."),
1827 return (SYMBOL_TYPE (sym
));
1830 /* See gdbtypes.h. */
1833 lookup_struct_elt (struct type
*type
, const char *name
, int noerr
)
1839 type
= check_typedef (type
);
1840 if (type
->code () != TYPE_CODE_PTR
1841 && type
->code () != TYPE_CODE_REF
)
1843 type
= TYPE_TARGET_TYPE (type
);
1846 if (type
->code () != TYPE_CODE_STRUCT
1847 && type
->code () != TYPE_CODE_UNION
)
1849 std::string type_name
= type_to_string (type
);
1850 error (_("Type %s is not a structure or union type."),
1851 type_name
.c_str ());
1854 for (i
= type
->num_fields () - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1856 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1858 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1860 return {&type
->field (i
), TYPE_FIELD_BITPOS (type
, i
)};
1862 else if (!t_field_name
|| *t_field_name
== '\0')
1865 = lookup_struct_elt (type
->field (i
).type (), name
, 1);
1866 if (elt
.field
!= NULL
)
1868 elt
.offset
+= TYPE_FIELD_BITPOS (type
, i
);
1874 /* OK, it's not in this class. Recursively check the baseclasses. */
1875 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1877 struct_elt elt
= lookup_struct_elt (TYPE_BASECLASS (type
, i
), name
, 1);
1878 if (elt
.field
!= NULL
)
1883 return {nullptr, 0};
1885 std::string type_name
= type_to_string (type
);
1886 error (_("Type %s has no component named %s."), type_name
.c_str (), name
);
1889 /* See gdbtypes.h. */
1892 lookup_struct_elt_type (struct type
*type
, const char *name
, int noerr
)
1894 struct_elt elt
= lookup_struct_elt (type
, name
, noerr
);
1895 if (elt
.field
!= NULL
)
1896 return elt
.field
->type ();
1901 /* Store in *MAX the largest number representable by unsigned integer type
1905 get_unsigned_type_max (struct type
*type
, ULONGEST
*max
)
1909 type
= check_typedef (type
);
1910 gdb_assert (type
->code () == TYPE_CODE_INT
&& type
->is_unsigned ());
1911 gdb_assert (TYPE_LENGTH (type
) <= sizeof (ULONGEST
));
1913 /* Written this way to avoid overflow. */
1914 n
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
1915 *max
= ((((ULONGEST
) 1 << (n
- 1)) - 1) << 1) | 1;
1918 /* Store in *MIN, *MAX the smallest and largest numbers representable by
1919 signed integer type TYPE. */
1922 get_signed_type_minmax (struct type
*type
, LONGEST
*min
, LONGEST
*max
)
1926 type
= check_typedef (type
);
1927 gdb_assert (type
->code () == TYPE_CODE_INT
&& !type
->is_unsigned ());
1928 gdb_assert (TYPE_LENGTH (type
) <= sizeof (LONGEST
));
1930 n
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
1931 *min
= -((ULONGEST
) 1 << (n
- 1));
1932 *max
= ((ULONGEST
) 1 << (n
- 1)) - 1;
1935 /* Internal routine called by TYPE_VPTR_FIELDNO to return the value of
1936 cplus_stuff.vptr_fieldno.
1938 cplus_stuff is initialized to cplus_struct_default which does not
1939 set vptr_fieldno to -1 for portability reasons (IWBN to use C99
1940 designated initializers). We cope with that here. */
1943 internal_type_vptr_fieldno (struct type
*type
)
1945 type
= check_typedef (type
);
1946 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1947 || type
->code () == TYPE_CODE_UNION
);
1948 if (!HAVE_CPLUS_STRUCT (type
))
1950 return TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_fieldno
;
1953 /* Set the value of cplus_stuff.vptr_fieldno. */
1956 set_type_vptr_fieldno (struct type
*type
, int fieldno
)
1958 type
= check_typedef (type
);
1959 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1960 || type
->code () == TYPE_CODE_UNION
);
1961 if (!HAVE_CPLUS_STRUCT (type
))
1962 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1963 TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_fieldno
= fieldno
;
1966 /* Internal routine called by TYPE_VPTR_BASETYPE to return the value of
1967 cplus_stuff.vptr_basetype. */
1970 internal_type_vptr_basetype (struct type
*type
)
1972 type
= check_typedef (type
);
1973 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1974 || type
->code () == TYPE_CODE_UNION
);
1975 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_CPLUS_STUFF
);
1976 return TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_basetype
;
1979 /* Set the value of cplus_stuff.vptr_basetype. */
1982 set_type_vptr_basetype (struct type
*type
, struct type
*basetype
)
1984 type
= check_typedef (type
);
1985 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1986 || type
->code () == TYPE_CODE_UNION
);
1987 if (!HAVE_CPLUS_STRUCT (type
))
1988 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1989 TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_basetype
= basetype
;
1992 /* Lookup the vptr basetype/fieldno values for TYPE.
1993 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1994 vptr_fieldno. Also, if found and basetype is from the same objfile,
1996 If not found, return -1 and ignore BASETYPEP.
1997 Callers should be aware that in some cases (for example,
1998 the type or one of its baseclasses is a stub type and we are
1999 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
2000 this function will not be able to find the
2001 virtual function table pointer, and vptr_fieldno will remain -1 and
2002 vptr_basetype will remain NULL or incomplete. */
2005 get_vptr_fieldno (struct type
*type
, struct type
**basetypep
)
2007 type
= check_typedef (type
);
2009 if (TYPE_VPTR_FIELDNO (type
) < 0)
2013 /* We must start at zero in case the first (and only) baseclass
2014 is virtual (and hence we cannot share the table pointer). */
2015 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
2017 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
2019 struct type
*basetype
;
2021 fieldno
= get_vptr_fieldno (baseclass
, &basetype
);
2024 /* If the type comes from a different objfile we can't cache
2025 it, it may have a different lifetime. PR 2384 */
2026 if (TYPE_OBJFILE (type
) == TYPE_OBJFILE (basetype
))
2028 set_type_vptr_fieldno (type
, fieldno
);
2029 set_type_vptr_basetype (type
, basetype
);
2032 *basetypep
= basetype
;
2043 *basetypep
= TYPE_VPTR_BASETYPE (type
);
2044 return TYPE_VPTR_FIELDNO (type
);
2049 stub_noname_complaint (void)
2051 complaint (_("stub type has NULL name"));
2054 /* Return nonzero if TYPE has a DYN_PROP_BYTE_STRIDE dynamic property
2055 attached to it, and that property has a non-constant value. */
2058 array_type_has_dynamic_stride (struct type
*type
)
2060 struct dynamic_prop
*prop
= type
->dyn_prop (DYN_PROP_BYTE_STRIDE
);
2062 return (prop
!= NULL
&& prop
->kind () != PROP_CONST
);
2065 /* Worker for is_dynamic_type. */
2068 is_dynamic_type_internal (struct type
*type
, int top_level
)
2070 type
= check_typedef (type
);
2072 /* We only want to recognize references at the outermost level. */
2073 if (top_level
&& type
->code () == TYPE_CODE_REF
)
2074 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2076 /* Types that have a dynamic TYPE_DATA_LOCATION are considered
2077 dynamic, even if the type itself is statically defined.
2078 From a user's point of view, this may appear counter-intuitive;
2079 but it makes sense in this context, because the point is to determine
2080 whether any part of the type needs to be resolved before it can
2082 if (TYPE_DATA_LOCATION (type
) != NULL
2083 && (TYPE_DATA_LOCATION_KIND (type
) == PROP_LOCEXPR
2084 || TYPE_DATA_LOCATION_KIND (type
) == PROP_LOCLIST
))
2087 if (TYPE_ASSOCIATED_PROP (type
))
2090 if (TYPE_ALLOCATED_PROP (type
))
2093 struct dynamic_prop
*prop
= type
->dyn_prop (DYN_PROP_VARIANT_PARTS
);
2094 if (prop
!= nullptr && prop
->kind () != PROP_TYPE
)
2097 if (TYPE_HAS_DYNAMIC_LENGTH (type
))
2100 switch (type
->code ())
2102 case TYPE_CODE_RANGE
:
2104 /* A range type is obviously dynamic if it has at least one
2105 dynamic bound. But also consider the range type to be
2106 dynamic when its subtype is dynamic, even if the bounds
2107 of the range type are static. It allows us to assume that
2108 the subtype of a static range type is also static. */
2109 return (!has_static_range (type
->bounds ())
2110 || is_dynamic_type_internal (TYPE_TARGET_TYPE (type
), 0));
2113 case TYPE_CODE_STRING
:
2114 /* Strings are very much like an array of characters, and can be
2115 treated as one here. */
2116 case TYPE_CODE_ARRAY
:
2118 gdb_assert (type
->num_fields () == 1);
2120 /* The array is dynamic if either the bounds are dynamic... */
2121 if (is_dynamic_type_internal (type
->index_type (), 0))
2123 /* ... or the elements it contains have a dynamic contents... */
2124 if (is_dynamic_type_internal (TYPE_TARGET_TYPE (type
), 0))
2126 /* ... or if it has a dynamic stride... */
2127 if (array_type_has_dynamic_stride (type
))
2132 case TYPE_CODE_STRUCT
:
2133 case TYPE_CODE_UNION
:
2137 bool is_cplus
= HAVE_CPLUS_STRUCT (type
);
2139 for (i
= 0; i
< type
->num_fields (); ++i
)
2141 /* Static fields can be ignored here. */
2142 if (field_is_static (&type
->field (i
)))
2144 /* If the field has dynamic type, then so does TYPE. */
2145 if (is_dynamic_type_internal (type
->field (i
).type (), 0))
2147 /* If the field is at a fixed offset, then it is not
2149 if (TYPE_FIELD_LOC_KIND (type
, i
) != FIELD_LOC_KIND_DWARF_BLOCK
)
2151 /* Do not consider C++ virtual base types to be dynamic
2152 due to the field's offset being dynamic; these are
2153 handled via other means. */
2154 if (is_cplus
&& BASETYPE_VIA_VIRTUAL (type
, i
))
2165 /* See gdbtypes.h. */
2168 is_dynamic_type (struct type
*type
)
2170 return is_dynamic_type_internal (type
, 1);
2173 static struct type
*resolve_dynamic_type_internal
2174 (struct type
*type
, struct property_addr_info
*addr_stack
, int top_level
);
2176 /* Given a dynamic range type (dyn_range_type) and a stack of
2177 struct property_addr_info elements, return a static version
2180 static struct type
*
2181 resolve_dynamic_range (struct type
*dyn_range_type
,
2182 struct property_addr_info
*addr_stack
)
2185 struct type
*static_range_type
, *static_target_type
;
2186 struct dynamic_prop low_bound
, high_bound
, stride
;
2188 gdb_assert (dyn_range_type
->code () == TYPE_CODE_RANGE
);
2190 const struct dynamic_prop
*prop
= &dyn_range_type
->bounds ()->low
;
2191 if (dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2192 low_bound
.set_const_val (value
);
2194 low_bound
.set_undefined ();
2196 prop
= &dyn_range_type
->bounds ()->high
;
2197 if (dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2199 high_bound
.set_const_val (value
);
2201 if (dyn_range_type
->bounds ()->flag_upper_bound_is_count
)
2202 high_bound
.set_const_val
2203 (low_bound
.const_val () + high_bound
.const_val () - 1);
2206 high_bound
.set_undefined ();
2208 bool byte_stride_p
= dyn_range_type
->bounds ()->flag_is_byte_stride
;
2209 prop
= &dyn_range_type
->bounds ()->stride
;
2210 if (dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2212 stride
.set_const_val (value
);
2214 /* If we have a bit stride that is not an exact number of bytes then
2215 I really don't think this is going to work with current GDB, the
2216 array indexing code in GDB seems to be pretty heavily tied to byte
2217 offsets right now. Assuming 8 bits in a byte. */
2218 struct gdbarch
*gdbarch
= get_type_arch (dyn_range_type
);
2219 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
2220 if (!byte_stride_p
&& (value
% (unit_size
* 8)) != 0)
2221 error (_("bit strides that are not a multiple of the byte size "
2222 "are currently not supported"));
2226 stride
.set_undefined ();
2227 byte_stride_p
= true;
2231 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (dyn_range_type
),
2233 LONGEST bias
= dyn_range_type
->bounds ()->bias
;
2234 static_range_type
= create_range_type_with_stride
2235 (copy_type (dyn_range_type
), static_target_type
,
2236 &low_bound
, &high_bound
, bias
, &stride
, byte_stride_p
);
2237 static_range_type
->bounds ()->flag_bound_evaluated
= 1;
2238 return static_range_type
;
2241 /* Resolves dynamic bound values of an array or string type TYPE to static
2242 ones. ADDR_STACK is a stack of struct property_addr_info to be used if
2243 needed during the dynamic resolution. */
2245 static struct type
*
2246 resolve_dynamic_array_or_string (struct type
*type
,
2247 struct property_addr_info
*addr_stack
)
2250 struct type
*elt_type
;
2251 struct type
*range_type
;
2252 struct type
*ary_dim
;
2253 struct dynamic_prop
*prop
;
2254 unsigned int bit_stride
= 0;
2256 /* For dynamic type resolution strings can be treated like arrays of
2258 gdb_assert (type
->code () == TYPE_CODE_ARRAY
2259 || type
->code () == TYPE_CODE_STRING
);
2261 type
= copy_type (type
);
2264 range_type
= check_typedef (elt_type
->index_type ());
2265 range_type
= resolve_dynamic_range (range_type
, addr_stack
);
2267 /* Resolve allocated/associated here before creating a new array type, which
2268 will update the length of the array accordingly. */
2269 prop
= TYPE_ALLOCATED_PROP (type
);
2270 if (prop
!= NULL
&& dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2271 prop
->set_const_val (value
);
2273 prop
= TYPE_ASSOCIATED_PROP (type
);
2274 if (prop
!= NULL
&& dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2275 prop
->set_const_val (value
);
2277 ary_dim
= check_typedef (TYPE_TARGET_TYPE (elt_type
));
2279 if (ary_dim
!= NULL
&& ary_dim
->code () == TYPE_CODE_ARRAY
)
2280 elt_type
= resolve_dynamic_array_or_string (ary_dim
, addr_stack
);
2282 elt_type
= TYPE_TARGET_TYPE (type
);
2284 prop
= type
->dyn_prop (DYN_PROP_BYTE_STRIDE
);
2287 if (dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2289 type
->remove_dyn_prop (DYN_PROP_BYTE_STRIDE
);
2290 bit_stride
= (unsigned int) (value
* 8);
2294 /* Could be a bug in our code, but it could also happen
2295 if the DWARF info is not correct. Issue a warning,
2296 and assume no byte/bit stride (leave bit_stride = 0). */
2297 warning (_("cannot determine array stride for type %s"),
2298 type
->name () ? type
->name () : "<no name>");
2302 bit_stride
= TYPE_FIELD_BITSIZE (type
, 0);
2304 return create_array_type_with_stride (type
, elt_type
, range_type
, NULL
,
2308 /* Resolve dynamic bounds of members of the union TYPE to static
2309 bounds. ADDR_STACK is a stack of struct property_addr_info
2310 to be used if needed during the dynamic resolution. */
2312 static struct type
*
2313 resolve_dynamic_union (struct type
*type
,
2314 struct property_addr_info
*addr_stack
)
2316 struct type
*resolved_type
;
2318 unsigned int max_len
= 0;
2320 gdb_assert (type
->code () == TYPE_CODE_UNION
);
2322 resolved_type
= copy_type (type
);
2323 resolved_type
->set_fields
2325 TYPE_ALLOC (resolved_type
,
2326 resolved_type
->num_fields () * sizeof (struct field
)));
2327 memcpy (resolved_type
->fields (),
2329 resolved_type
->num_fields () * sizeof (struct field
));
2330 for (i
= 0; i
< resolved_type
->num_fields (); ++i
)
2334 if (field_is_static (&type
->field (i
)))
2337 t
= resolve_dynamic_type_internal (resolved_type
->field (i
).type (),
2339 resolved_type
->field (i
).set_type (t
);
2341 struct type
*real_type
= check_typedef (t
);
2342 if (TYPE_LENGTH (real_type
) > max_len
)
2343 max_len
= TYPE_LENGTH (real_type
);
2346 TYPE_LENGTH (resolved_type
) = max_len
;
2347 return resolved_type
;
2350 /* See gdbtypes.h. */
2353 variant::matches (ULONGEST value
, bool is_unsigned
) const
2355 for (const discriminant_range
&range
: discriminants
)
2356 if (range
.contains (value
, is_unsigned
))
2362 compute_variant_fields_inner (struct type
*type
,
2363 struct property_addr_info
*addr_stack
,
2364 const variant_part
&part
,
2365 std::vector
<bool> &flags
);
2367 /* A helper function to determine which variant fields will be active.
2368 This handles both the variant's direct fields, and any variant
2369 parts embedded in this variant. TYPE is the type we're examining.
2370 ADDR_STACK holds information about the concrete object. VARIANT is
2371 the current variant to be handled. FLAGS is where the results are
2372 stored -- this function sets the Nth element in FLAGS if the
2373 corresponding field is enabled. ENABLED is whether this variant is
2377 compute_variant_fields_recurse (struct type
*type
,
2378 struct property_addr_info
*addr_stack
,
2379 const variant
&variant
,
2380 std::vector
<bool> &flags
,
2383 for (int field
= variant
.first_field
; field
< variant
.last_field
; ++field
)
2384 flags
[field
] = enabled
;
2386 for (const variant_part
&new_part
: variant
.parts
)
2389 compute_variant_fields_inner (type
, addr_stack
, new_part
, flags
);
2392 for (const auto &sub_variant
: new_part
.variants
)
2393 compute_variant_fields_recurse (type
, addr_stack
, sub_variant
,
2399 /* A helper function to determine which variant fields will be active.
2400 This evaluates the discriminant, decides which variant (if any) is
2401 active, and then updates FLAGS to reflect which fields should be
2402 available. TYPE is the type we're examining. ADDR_STACK holds
2403 information about the concrete object. VARIANT is the current
2404 variant to be handled. FLAGS is where the results are stored --
2405 this function sets the Nth element in FLAGS if the corresponding
2406 field is enabled. */
2409 compute_variant_fields_inner (struct type
*type
,
2410 struct property_addr_info
*addr_stack
,
2411 const variant_part
&part
,
2412 std::vector
<bool> &flags
)
2414 /* Evaluate the discriminant. */
2415 gdb::optional
<ULONGEST
> discr_value
;
2416 if (part
.discriminant_index
!= -1)
2418 int idx
= part
.discriminant_index
;
2420 if (TYPE_FIELD_LOC_KIND (type
, idx
) != FIELD_LOC_KIND_BITPOS
)
2421 error (_("Cannot determine struct field location"
2422 " (invalid location kind)"));
2424 if (addr_stack
->valaddr
.data () != NULL
)
2425 discr_value
= unpack_field_as_long (type
, addr_stack
->valaddr
.data (),
2429 CORE_ADDR addr
= (addr_stack
->addr
2430 + (TYPE_FIELD_BITPOS (type
, idx
)
2431 / TARGET_CHAR_BIT
));
2433 LONGEST bitsize
= TYPE_FIELD_BITSIZE (type
, idx
);
2434 LONGEST size
= bitsize
/ 8;
2436 size
= TYPE_LENGTH (type
->field (idx
).type ());
2438 gdb_byte bits
[sizeof (ULONGEST
)];
2439 read_memory (addr
, bits
, size
);
2441 LONGEST bitpos
= (TYPE_FIELD_BITPOS (type
, idx
)
2444 discr_value
= unpack_bits_as_long (type
->field (idx
).type (),
2445 bits
, bitpos
, bitsize
);
2449 /* Go through each variant and see which applies. */
2450 const variant
*default_variant
= nullptr;
2451 const variant
*applied_variant
= nullptr;
2452 for (const auto &variant
: part
.variants
)
2454 if (variant
.is_default ())
2455 default_variant
= &variant
;
2456 else if (discr_value
.has_value ()
2457 && variant
.matches (*discr_value
, part
.is_unsigned
))
2459 applied_variant
= &variant
;
2463 if (applied_variant
== nullptr)
2464 applied_variant
= default_variant
;
2466 for (const auto &variant
: part
.variants
)
2467 compute_variant_fields_recurse (type
, addr_stack
, variant
,
2468 flags
, applied_variant
== &variant
);
2471 /* Determine which variant fields are available in TYPE. The enabled
2472 fields are stored in RESOLVED_TYPE. ADDR_STACK holds information
2473 about the concrete object. PARTS describes the top-level variant
2474 parts for this type. */
2477 compute_variant_fields (struct type
*type
,
2478 struct type
*resolved_type
,
2479 struct property_addr_info
*addr_stack
,
2480 const gdb::array_view
<variant_part
> &parts
)
2482 /* Assume all fields are included by default. */
2483 std::vector
<bool> flags (resolved_type
->num_fields (), true);
2485 /* Now disable fields based on the variants that control them. */
2486 for (const auto &part
: parts
)
2487 compute_variant_fields_inner (type
, addr_stack
, part
, flags
);
2489 resolved_type
->set_num_fields
2490 (std::count (flags
.begin (), flags
.end (), true));
2491 resolved_type
->set_fields
2493 TYPE_ALLOC (resolved_type
,
2494 resolved_type
->num_fields () * sizeof (struct field
)));
2497 for (int i
= 0; i
< type
->num_fields (); ++i
)
2502 resolved_type
->field (out
) = type
->field (i
);
2507 /* Resolve dynamic bounds of members of the struct TYPE to static
2508 bounds. ADDR_STACK is a stack of struct property_addr_info to
2509 be used if needed during the dynamic resolution. */
2511 static struct type
*
2512 resolve_dynamic_struct (struct type
*type
,
2513 struct property_addr_info
*addr_stack
)
2515 struct type
*resolved_type
;
2517 unsigned resolved_type_bit_length
= 0;
2519 gdb_assert (type
->code () == TYPE_CODE_STRUCT
);
2520 gdb_assert (type
->num_fields () > 0);
2522 resolved_type
= copy_type (type
);
2524 dynamic_prop
*variant_prop
= resolved_type
->dyn_prop (DYN_PROP_VARIANT_PARTS
);
2525 if (variant_prop
!= nullptr && variant_prop
->kind () == PROP_VARIANT_PARTS
)
2527 compute_variant_fields (type
, resolved_type
, addr_stack
,
2528 *variant_prop
->variant_parts ());
2529 /* We want to leave the property attached, so that the Rust code
2530 can tell whether the type was originally an enum. */
2531 variant_prop
->set_original_type (type
);
2535 resolved_type
->set_fields
2537 TYPE_ALLOC (resolved_type
,
2538 resolved_type
->num_fields () * sizeof (struct field
)));
2539 memcpy (resolved_type
->fields (),
2541 resolved_type
->num_fields () * sizeof (struct field
));
2544 for (i
= 0; i
< resolved_type
->num_fields (); ++i
)
2546 unsigned new_bit_length
;
2547 struct property_addr_info pinfo
;
2549 if (field_is_static (&resolved_type
->field (i
)))
2552 if (TYPE_FIELD_LOC_KIND (resolved_type
, i
) == FIELD_LOC_KIND_DWARF_BLOCK
)
2554 struct dwarf2_property_baton baton
;
2556 = lookup_pointer_type (resolved_type
->field (i
).type ());
2557 baton
.locexpr
= *TYPE_FIELD_DWARF_BLOCK (resolved_type
, i
);
2559 struct dynamic_prop prop
;
2560 prop
.set_locexpr (&baton
);
2563 if (dwarf2_evaluate_property (&prop
, nullptr, addr_stack
, &addr
,
2565 SET_FIELD_BITPOS (resolved_type
->field (i
),
2566 TARGET_CHAR_BIT
* (addr
- addr_stack
->addr
));
2569 /* As we know this field is not a static field, the field's
2570 field_loc_kind should be FIELD_LOC_KIND_BITPOS. Verify
2571 this is the case, but only trigger a simple error rather
2572 than an internal error if that fails. While failing
2573 that verification indicates a bug in our code, the error
2574 is not severe enough to suggest to the user he stops
2575 his debugging session because of it. */
2576 if (TYPE_FIELD_LOC_KIND (resolved_type
, i
) != FIELD_LOC_KIND_BITPOS
)
2577 error (_("Cannot determine struct field location"
2578 " (invalid location kind)"));
2580 pinfo
.type
= check_typedef (resolved_type
->field (i
).type ());
2581 pinfo
.valaddr
= addr_stack
->valaddr
;
2584 + (TYPE_FIELD_BITPOS (resolved_type
, i
) / TARGET_CHAR_BIT
));
2585 pinfo
.next
= addr_stack
;
2587 resolved_type
->field (i
).set_type
2588 (resolve_dynamic_type_internal (resolved_type
->field (i
).type (),
2590 gdb_assert (TYPE_FIELD_LOC_KIND (resolved_type
, i
)
2591 == FIELD_LOC_KIND_BITPOS
);
2593 new_bit_length
= TYPE_FIELD_BITPOS (resolved_type
, i
);
2594 if (TYPE_FIELD_BITSIZE (resolved_type
, i
) != 0)
2595 new_bit_length
+= TYPE_FIELD_BITSIZE (resolved_type
, i
);
2598 struct type
*real_type
2599 = check_typedef (resolved_type
->field (i
).type ());
2601 new_bit_length
+= (TYPE_LENGTH (real_type
) * TARGET_CHAR_BIT
);
2604 /* Normally, we would use the position and size of the last field
2605 to determine the size of the enclosing structure. But GCC seems
2606 to be encoding the position of some fields incorrectly when
2607 the struct contains a dynamic field that is not placed last.
2608 So we compute the struct size based on the field that has
2609 the highest position + size - probably the best we can do. */
2610 if (new_bit_length
> resolved_type_bit_length
)
2611 resolved_type_bit_length
= new_bit_length
;
2614 /* The length of a type won't change for fortran, but it does for C and Ada.
2615 For fortran the size of dynamic fields might change over time but not the
2616 type length of the structure. If we adapt it, we run into problems
2617 when calculating the element offset for arrays of structs. */
2618 if (current_language
->la_language
!= language_fortran
)
2619 TYPE_LENGTH (resolved_type
)
2620 = (resolved_type_bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
2622 /* The Ada language uses this field as a cache for static fixed types: reset
2623 it as RESOLVED_TYPE must have its own static fixed type. */
2624 TYPE_TARGET_TYPE (resolved_type
) = NULL
;
2626 return resolved_type
;
2629 /* Worker for resolved_dynamic_type. */
2631 static struct type
*
2632 resolve_dynamic_type_internal (struct type
*type
,
2633 struct property_addr_info
*addr_stack
,
2636 struct type
*real_type
= check_typedef (type
);
2637 struct type
*resolved_type
= nullptr;
2638 struct dynamic_prop
*prop
;
2641 if (!is_dynamic_type_internal (real_type
, top_level
))
2644 gdb::optional
<CORE_ADDR
> type_length
;
2645 prop
= TYPE_DYNAMIC_LENGTH (type
);
2647 && dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2648 type_length
= value
;
2650 if (type
->code () == TYPE_CODE_TYPEDEF
)
2652 resolved_type
= copy_type (type
);
2653 TYPE_TARGET_TYPE (resolved_type
)
2654 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type
), addr_stack
,
2659 /* Before trying to resolve TYPE, make sure it is not a stub. */
2662 switch (type
->code ())
2666 struct property_addr_info pinfo
;
2668 pinfo
.type
= check_typedef (TYPE_TARGET_TYPE (type
));
2670 if (addr_stack
->valaddr
.data () != NULL
)
2671 pinfo
.addr
= extract_typed_address (addr_stack
->valaddr
.data (),
2674 pinfo
.addr
= read_memory_typed_address (addr_stack
->addr
, type
);
2675 pinfo
.next
= addr_stack
;
2677 resolved_type
= copy_type (type
);
2678 TYPE_TARGET_TYPE (resolved_type
)
2679 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type
),
2684 case TYPE_CODE_STRING
:
2685 /* Strings are very much like an array of characters, and can be
2686 treated as one here. */
2687 case TYPE_CODE_ARRAY
:
2688 resolved_type
= resolve_dynamic_array_or_string (type
, addr_stack
);
2691 case TYPE_CODE_RANGE
:
2692 resolved_type
= resolve_dynamic_range (type
, addr_stack
);
2695 case TYPE_CODE_UNION
:
2696 resolved_type
= resolve_dynamic_union (type
, addr_stack
);
2699 case TYPE_CODE_STRUCT
:
2700 resolved_type
= resolve_dynamic_struct (type
, addr_stack
);
2705 if (resolved_type
== nullptr)
2708 if (type_length
.has_value ())
2710 TYPE_LENGTH (resolved_type
) = *type_length
;
2711 resolved_type
->remove_dyn_prop (DYN_PROP_BYTE_SIZE
);
2714 /* Resolve data_location attribute. */
2715 prop
= TYPE_DATA_LOCATION (resolved_type
);
2717 && dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2719 /* Start of Fortran hack. See comment in f-lang.h for what is going
2721 if (current_language
->la_language
== language_fortran
2722 && resolved_type
->code () == TYPE_CODE_ARRAY
)
2723 value
= fortran_adjust_dynamic_array_base_address_hack (resolved_type
,
2725 /* End of Fortran hack. */
2726 prop
->set_const_val (value
);
2729 return resolved_type
;
2732 /* See gdbtypes.h */
2735 resolve_dynamic_type (struct type
*type
,
2736 gdb::array_view
<const gdb_byte
> valaddr
,
2739 struct property_addr_info pinfo
2740 = {check_typedef (type
), valaddr
, addr
, NULL
};
2742 return resolve_dynamic_type_internal (type
, &pinfo
, 1);
2745 /* See gdbtypes.h */
2748 type::dyn_prop (dynamic_prop_node_kind prop_kind
) const
2750 dynamic_prop_list
*node
= this->main_type
->dyn_prop_list
;
2752 while (node
!= NULL
)
2754 if (node
->prop_kind
== prop_kind
)
2761 /* See gdbtypes.h */
2764 type::add_dyn_prop (dynamic_prop_node_kind prop_kind
, dynamic_prop prop
)
2766 struct dynamic_prop_list
*temp
;
2768 gdb_assert (TYPE_OBJFILE_OWNED (this));
2770 temp
= XOBNEW (&TYPE_OBJFILE (this)->objfile_obstack
,
2771 struct dynamic_prop_list
);
2772 temp
->prop_kind
= prop_kind
;
2774 temp
->next
= this->main_type
->dyn_prop_list
;
2776 this->main_type
->dyn_prop_list
= temp
;
2779 /* See gdbtypes.h. */
2782 type::remove_dyn_prop (dynamic_prop_node_kind kind
)
2784 struct dynamic_prop_list
*prev_node
, *curr_node
;
2786 curr_node
= this->main_type
->dyn_prop_list
;
2789 while (NULL
!= curr_node
)
2791 if (curr_node
->prop_kind
== kind
)
2793 /* Update the linked list but don't free anything.
2794 The property was allocated on objstack and it is not known
2795 if we are on top of it. Nevertheless, everything is released
2796 when the complete objstack is freed. */
2797 if (NULL
== prev_node
)
2798 this->main_type
->dyn_prop_list
= curr_node
->next
;
2800 prev_node
->next
= curr_node
->next
;
2805 prev_node
= curr_node
;
2806 curr_node
= curr_node
->next
;
2810 /* Find the real type of TYPE. This function returns the real type,
2811 after removing all layers of typedefs, and completing opaque or stub
2812 types. Completion changes the TYPE argument, but stripping of
2815 Instance flags (e.g. const/volatile) are preserved as typedefs are
2816 stripped. If necessary a new qualified form of the underlying type
2819 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
2820 not been computed and we're either in the middle of reading symbols, or
2821 there was no name for the typedef in the debug info.
2823 NOTE: Lookup of opaque types can throw errors for invalid symbol files.
2824 QUITs in the symbol reading code can also throw.
2825 Thus this function can throw an exception.
2827 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
2830 If this is a stubbed struct (i.e. declared as struct foo *), see if
2831 we can find a full definition in some other file. If so, copy this
2832 definition, so we can use it in future. There used to be a comment
2833 (but not any code) that if we don't find a full definition, we'd
2834 set a flag so we don't spend time in the future checking the same
2835 type. That would be a mistake, though--we might load in more
2836 symbols which contain a full definition for the type. */
2839 check_typedef (struct type
*type
)
2841 struct type
*orig_type
= type
;
2845 /* While we're removing typedefs, we don't want to lose qualifiers.
2846 E.g., const/volatile. */
2847 type_instance_flags instance_flags
= type
->instance_flags ();
2849 while (type
->code () == TYPE_CODE_TYPEDEF
)
2851 if (!TYPE_TARGET_TYPE (type
))
2856 /* It is dangerous to call lookup_symbol if we are currently
2857 reading a symtab. Infinite recursion is one danger. */
2858 if (currently_reading_symtab
)
2859 return make_qualified_type (type
, instance_flags
, NULL
);
2861 name
= type
->name ();
2862 /* FIXME: shouldn't we look in STRUCT_DOMAIN and/or
2863 VAR_DOMAIN as appropriate? */
2866 stub_noname_complaint ();
2867 return make_qualified_type (type
, instance_flags
, NULL
);
2869 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0).symbol
;
2871 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
2872 else /* TYPE_CODE_UNDEF */
2873 TYPE_TARGET_TYPE (type
) = alloc_type_arch (get_type_arch (type
));
2875 type
= TYPE_TARGET_TYPE (type
);
2877 /* Preserve the instance flags as we traverse down the typedef chain.
2879 Handling address spaces/classes is nasty, what do we do if there's a
2881 E.g., what if an outer typedef marks the type as class_1 and an inner
2882 typedef marks the type as class_2?
2883 This is the wrong place to do such error checking. We leave it to
2884 the code that created the typedef in the first place to flag the
2885 error. We just pick the outer address space (akin to letting the
2886 outer cast in a chain of casting win), instead of assuming
2887 "it can't happen". */
2889 const type_instance_flags ALL_SPACES
2890 = (TYPE_INSTANCE_FLAG_CODE_SPACE
2891 | TYPE_INSTANCE_FLAG_DATA_SPACE
);
2892 const type_instance_flags ALL_CLASSES
2893 = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
;
2895 type_instance_flags new_instance_flags
= type
->instance_flags ();
2897 /* Treat code vs data spaces and address classes separately. */
2898 if ((instance_flags
& ALL_SPACES
) != 0)
2899 new_instance_flags
&= ~ALL_SPACES
;
2900 if ((instance_flags
& ALL_CLASSES
) != 0)
2901 new_instance_flags
&= ~ALL_CLASSES
;
2903 instance_flags
|= new_instance_flags
;
2907 /* If this is a struct/class/union with no fields, then check
2908 whether a full definition exists somewhere else. This is for
2909 systems where a type definition with no fields is issued for such
2910 types, instead of identifying them as stub types in the first
2913 if (TYPE_IS_OPAQUE (type
)
2914 && opaque_type_resolution
2915 && !currently_reading_symtab
)
2917 const char *name
= type
->name ();
2918 struct type
*newtype
;
2922 stub_noname_complaint ();
2923 return make_qualified_type (type
, instance_flags
, NULL
);
2925 newtype
= lookup_transparent_type (name
);
2929 /* If the resolved type and the stub are in the same
2930 objfile, then replace the stub type with the real deal.
2931 But if they're in separate objfiles, leave the stub
2932 alone; we'll just look up the transparent type every time
2933 we call check_typedef. We can't create pointers between
2934 types allocated to different objfiles, since they may
2935 have different lifetimes. Trying to copy NEWTYPE over to
2936 TYPE's objfile is pointless, too, since you'll have to
2937 move over any other types NEWTYPE refers to, which could
2938 be an unbounded amount of stuff. */
2939 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
2940 type
= make_qualified_type (newtype
, type
->instance_flags (), type
);
2945 /* Otherwise, rely on the stub flag being set for opaque/stubbed
2947 else if (type
->is_stub () && !currently_reading_symtab
)
2949 const char *name
= type
->name ();
2950 /* FIXME: shouldn't we look in STRUCT_DOMAIN and/or VAR_DOMAIN
2956 stub_noname_complaint ();
2957 return make_qualified_type (type
, instance_flags
, NULL
);
2959 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0).symbol
;
2962 /* Same as above for opaque types, we can replace the stub
2963 with the complete type only if they are in the same
2965 if (TYPE_OBJFILE (SYMBOL_TYPE (sym
)) == TYPE_OBJFILE (type
))
2966 type
= make_qualified_type (SYMBOL_TYPE (sym
),
2967 type
->instance_flags (), type
);
2969 type
= SYMBOL_TYPE (sym
);
2973 if (type
->target_is_stub ())
2975 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
2977 if (target_type
->is_stub () || target_type
->target_is_stub ())
2979 /* Nothing we can do. */
2981 else if (type
->code () == TYPE_CODE_RANGE
)
2983 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
2984 type
->set_target_is_stub (false);
2986 else if (type
->code () == TYPE_CODE_ARRAY
2987 && update_static_array_size (type
))
2988 type
->set_target_is_stub (false);
2991 type
= make_qualified_type (type
, instance_flags
, NULL
);
2993 /* Cache TYPE_LENGTH for future use. */
2994 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
2999 /* Parse a type expression in the string [P..P+LENGTH). If an error
3000 occurs, silently return a void type. */
3002 static struct type
*
3003 safe_parse_type (struct gdbarch
*gdbarch
, char *p
, int length
)
3005 struct ui_file
*saved_gdb_stderr
;
3006 struct type
*type
= NULL
; /* Initialize to keep gcc happy. */
3008 /* Suppress error messages. */
3009 saved_gdb_stderr
= gdb_stderr
;
3010 gdb_stderr
= &null_stream
;
3012 /* Call parse_and_eval_type() without fear of longjmp()s. */
3015 type
= parse_and_eval_type (p
, length
);
3017 catch (const gdb_exception_error
&except
)
3019 type
= builtin_type (gdbarch
)->builtin_void
;
3022 /* Stop suppressing error messages. */
3023 gdb_stderr
= saved_gdb_stderr
;
3028 /* Ugly hack to convert method stubs into method types.
3030 He ain't kiddin'. This demangles the name of the method into a
3031 string including argument types, parses out each argument type,
3032 generates a string casting a zero to that type, evaluates the
3033 string, and stuffs the resulting type into an argtype vector!!!
3034 Then it knows the type of the whole function (including argument
3035 types for overloading), which info used to be in the stab's but was
3036 removed to hack back the space required for them. */
3039 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
3041 struct gdbarch
*gdbarch
= get_type_arch (type
);
3043 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
3044 char *demangled_name
= gdb_demangle (mangled_name
,
3045 DMGL_PARAMS
| DMGL_ANSI
);
3046 char *argtypetext
, *p
;
3047 int depth
= 0, argcount
= 1;
3048 struct field
*argtypes
;
3051 /* Make sure we got back a function string that we can use. */
3053 p
= strchr (demangled_name
, '(');
3057 if (demangled_name
== NULL
|| p
== NULL
)
3058 error (_("Internal: Cannot demangle mangled name `%s'."),
3061 /* Now, read in the parameters that define this type. */
3066 if (*p
== '(' || *p
== '<')
3070 else if (*p
== ')' || *p
== '>')
3074 else if (*p
== ',' && depth
== 0)
3082 /* If we read one argument and it was ``void'', don't count it. */
3083 if (startswith (argtypetext
, "(void)"))
3086 /* We need one extra slot, for the THIS pointer. */
3088 argtypes
= (struct field
*)
3089 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
3092 /* Add THIS pointer for non-static methods. */
3093 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
3094 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
3098 argtypes
[0].set_type (lookup_pointer_type (type
));
3102 if (*p
!= ')') /* () means no args, skip while. */
3107 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
3109 /* Avoid parsing of ellipsis, they will be handled below.
3110 Also avoid ``void'' as above. */
3111 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
3112 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
3114 argtypes
[argcount
].set_type
3115 (safe_parse_type (gdbarch
, argtypetext
, p
- argtypetext
));
3118 argtypetext
= p
+ 1;
3121 if (*p
== '(' || *p
== '<')
3125 else if (*p
== ')' || *p
== '>')
3134 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
3136 /* Now update the old "stub" type into a real type. */
3137 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
3138 /* MTYPE may currently be a function (TYPE_CODE_FUNC).
3139 We want a method (TYPE_CODE_METHOD). */
3140 smash_to_method_type (mtype
, type
, TYPE_TARGET_TYPE (mtype
),
3141 argtypes
, argcount
, p
[-2] == '.');
3142 mtype
->set_is_stub (false);
3143 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
3145 xfree (demangled_name
);
3148 /* This is the external interface to check_stub_method, above. This
3149 function unstubs all of the signatures for TYPE's METHOD_ID method
3150 name. After calling this function TYPE_FN_FIELD_STUB will be
3151 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
3154 This function unfortunately can not die until stabs do. */
3157 check_stub_method_group (struct type
*type
, int method_id
)
3159 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
3160 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
3162 for (int j
= 0; j
< len
; j
++)
3164 if (TYPE_FN_FIELD_STUB (f
, j
))
3165 check_stub_method (type
, method_id
, j
);
3169 /* Ensure it is in .rodata (if available) by working around GCC PR 44690. */
3170 const struct cplus_struct_type cplus_struct_default
= { };
3173 allocate_cplus_struct_type (struct type
*type
)
3175 if (HAVE_CPLUS_STRUCT (type
))
3176 /* Structure was already allocated. Nothing more to do. */
3179 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_CPLUS_STUFF
;
3180 TYPE_RAW_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
3181 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
3182 *(TYPE_RAW_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
3183 set_type_vptr_fieldno (type
, -1);
3186 const struct gnat_aux_type gnat_aux_default
=
3189 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
3190 and allocate the associated gnat-specific data. The gnat-specific
3191 data is also initialized to gnat_aux_default. */
3194 allocate_gnat_aux_type (struct type
*type
)
3196 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_GNAT_STUFF
;
3197 TYPE_GNAT_SPECIFIC (type
) = (struct gnat_aux_type
*)
3198 TYPE_ALLOC (type
, sizeof (struct gnat_aux_type
));
3199 *(TYPE_GNAT_SPECIFIC (type
)) = gnat_aux_default
;
3202 /* Helper function to initialize a newly allocated type. Set type code
3203 to CODE and initialize the type-specific fields accordingly. */
3206 set_type_code (struct type
*type
, enum type_code code
)
3208 type
->set_code (code
);
3212 case TYPE_CODE_STRUCT
:
3213 case TYPE_CODE_UNION
:
3214 case TYPE_CODE_NAMESPACE
:
3215 INIT_CPLUS_SPECIFIC (type
);
3218 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_FLOATFORMAT
;
3220 case TYPE_CODE_FUNC
:
3221 INIT_FUNC_SPECIFIC (type
);
3223 case TYPE_CODE_FIXED_POINT
:
3224 INIT_FIXED_POINT_SPECIFIC (type
);
3229 /* Helper function to verify floating-point format and size.
3230 BIT is the type size in bits; if BIT equals -1, the size is
3231 determined by the floatformat. Returns size to be used. */
3234 verify_floatformat (int bit
, const struct floatformat
*floatformat
)
3236 gdb_assert (floatformat
!= NULL
);
3239 bit
= floatformat
->totalsize
;
3241 gdb_assert (bit
>= 0);
3242 gdb_assert (bit
>= floatformat
->totalsize
);
3247 /* Return the floating-point format for a floating-point variable of
3250 const struct floatformat
*
3251 floatformat_from_type (const struct type
*type
)
3253 gdb_assert (type
->code () == TYPE_CODE_FLT
);
3254 gdb_assert (TYPE_FLOATFORMAT (type
));
3255 return TYPE_FLOATFORMAT (type
);
3258 /* Helper function to initialize the standard scalar types.
3260 If NAME is non-NULL, then it is used to initialize the type name.
3261 Note that NAME is not copied; it is required to have a lifetime at
3262 least as long as OBJFILE. */
3265 init_type (struct objfile
*objfile
, enum type_code code
, int bit
,
3270 type
= alloc_type (objfile
);
3271 set_type_code (type
, code
);
3272 gdb_assert ((bit
% TARGET_CHAR_BIT
) == 0);
3273 TYPE_LENGTH (type
) = bit
/ TARGET_CHAR_BIT
;
3274 type
->set_name (name
);
3279 /* Allocate a TYPE_CODE_ERROR type structure associated with OBJFILE,
3280 to use with variables that have no debug info. NAME is the type
3283 static struct type
*
3284 init_nodebug_var_type (struct objfile
*objfile
, const char *name
)
3286 return init_type (objfile
, TYPE_CODE_ERROR
, 0, name
);
3289 /* Allocate a TYPE_CODE_INT type structure associated with OBJFILE.
3290 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3291 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3294 init_integer_type (struct objfile
*objfile
,
3295 int bit
, int unsigned_p
, const char *name
)
3299 t
= init_type (objfile
, TYPE_CODE_INT
, bit
, name
);
3301 t
->set_is_unsigned (true);
3303 TYPE_SPECIFIC_FIELD (t
) = TYPE_SPECIFIC_INT
;
3304 TYPE_MAIN_TYPE (t
)->type_specific
.int_stuff
.bit_size
= bit
;
3305 TYPE_MAIN_TYPE (t
)->type_specific
.int_stuff
.bit_offset
= 0;
3310 /* Allocate a TYPE_CODE_CHAR type structure associated with OBJFILE.
3311 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3312 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3315 init_character_type (struct objfile
*objfile
,
3316 int bit
, int unsigned_p
, const char *name
)
3320 t
= init_type (objfile
, TYPE_CODE_CHAR
, bit
, name
);
3322 t
->set_is_unsigned (true);
3327 /* Allocate a TYPE_CODE_BOOL type structure associated with OBJFILE.
3328 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3329 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3332 init_boolean_type (struct objfile
*objfile
,
3333 int bit
, int unsigned_p
, const char *name
)
3337 t
= init_type (objfile
, TYPE_CODE_BOOL
, bit
, name
);
3339 t
->set_is_unsigned (true);
3341 TYPE_SPECIFIC_FIELD (t
) = TYPE_SPECIFIC_INT
;
3342 TYPE_MAIN_TYPE (t
)->type_specific
.int_stuff
.bit_size
= bit
;
3343 TYPE_MAIN_TYPE (t
)->type_specific
.int_stuff
.bit_offset
= 0;
3348 /* Allocate a TYPE_CODE_FLT type structure associated with OBJFILE.
3349 BIT is the type size in bits; if BIT equals -1, the size is
3350 determined by the floatformat. NAME is the type name. Set the
3351 TYPE_FLOATFORMAT from FLOATFORMATS. BYTE_ORDER is the byte order
3352 to use. If it is BFD_ENDIAN_UNKNOWN (the default), then the byte
3353 order of the objfile's architecture is used. */
3356 init_float_type (struct objfile
*objfile
,
3357 int bit
, const char *name
,
3358 const struct floatformat
**floatformats
,
3359 enum bfd_endian byte_order
)
3361 if (byte_order
== BFD_ENDIAN_UNKNOWN
)
3363 struct gdbarch
*gdbarch
= objfile
->arch ();
3364 byte_order
= gdbarch_byte_order (gdbarch
);
3366 const struct floatformat
*fmt
= floatformats
[byte_order
];
3369 bit
= verify_floatformat (bit
, fmt
);
3370 t
= init_type (objfile
, TYPE_CODE_FLT
, bit
, name
);
3371 TYPE_FLOATFORMAT (t
) = fmt
;
3376 /* Allocate a TYPE_CODE_DECFLOAT type structure associated with OBJFILE.
3377 BIT is the type size in bits. NAME is the type name. */
3380 init_decfloat_type (struct objfile
*objfile
, int bit
, const char *name
)
3384 t
= init_type (objfile
, TYPE_CODE_DECFLOAT
, bit
, name
);
3388 /* Allocate a TYPE_CODE_COMPLEX type structure. NAME is the type
3389 name. TARGET_TYPE is the component type. */
3392 init_complex_type (const char *name
, struct type
*target_type
)
3396 gdb_assert (target_type
->code () == TYPE_CODE_INT
3397 || target_type
->code () == TYPE_CODE_FLT
);
3399 if (TYPE_MAIN_TYPE (target_type
)->flds_bnds
.complex_type
== nullptr)
3401 if (name
== nullptr && target_type
->name () != nullptr)
3404 = (char *) TYPE_ALLOC (target_type
,
3405 strlen (target_type
->name ())
3406 + strlen ("_Complex ") + 1);
3407 strcpy (new_name
, "_Complex ");
3408 strcat (new_name
, target_type
->name ());
3412 t
= alloc_type_copy (target_type
);
3413 set_type_code (t
, TYPE_CODE_COMPLEX
);
3414 TYPE_LENGTH (t
) = 2 * TYPE_LENGTH (target_type
);
3417 TYPE_TARGET_TYPE (t
) = target_type
;
3418 TYPE_MAIN_TYPE (target_type
)->flds_bnds
.complex_type
= t
;
3421 return TYPE_MAIN_TYPE (target_type
)->flds_bnds
.complex_type
;
3424 /* Allocate a TYPE_CODE_PTR type structure associated with OBJFILE.
3425 BIT is the pointer type size in bits. NAME is the type name.
3426 TARGET_TYPE is the pointer target type. Always sets the pointer type's
3427 TYPE_UNSIGNED flag. */
3430 init_pointer_type (struct objfile
*objfile
,
3431 int bit
, const char *name
, struct type
*target_type
)
3435 t
= init_type (objfile
, TYPE_CODE_PTR
, bit
, name
);
3436 TYPE_TARGET_TYPE (t
) = target_type
;
3437 t
->set_is_unsigned (true);
3441 /* Allocate a TYPE_CODE_FIXED_POINT type structure associated with OBJFILE.
3442 BIT is the pointer type size in bits.
3443 UNSIGNED_P should be nonzero if the type is unsigned.
3444 NAME is the type name. */
3447 init_fixed_point_type (struct objfile
*objfile
,
3448 int bit
, int unsigned_p
, const char *name
)
3452 t
= init_type (objfile
, TYPE_CODE_FIXED_POINT
, bit
, name
);
3454 t
->set_is_unsigned (true);
3459 /* See gdbtypes.h. */
3462 type_raw_align (struct type
*type
)
3464 if (type
->align_log2
!= 0)
3465 return 1 << (type
->align_log2
- 1);
3469 /* See gdbtypes.h. */
3472 type_align (struct type
*type
)
3474 /* Check alignment provided in the debug information. */
3475 unsigned raw_align
= type_raw_align (type
);
3479 /* Allow the architecture to provide an alignment. */
3480 struct gdbarch
*arch
= get_type_arch (type
);
3481 ULONGEST align
= gdbarch_type_align (arch
, type
);
3485 switch (type
->code ())
3488 case TYPE_CODE_FUNC
:
3489 case TYPE_CODE_FLAGS
:
3491 case TYPE_CODE_RANGE
:
3493 case TYPE_CODE_ENUM
:
3495 case TYPE_CODE_RVALUE_REF
:
3496 case TYPE_CODE_CHAR
:
3497 case TYPE_CODE_BOOL
:
3498 case TYPE_CODE_DECFLOAT
:
3499 case TYPE_CODE_METHODPTR
:
3500 case TYPE_CODE_MEMBERPTR
:
3501 align
= type_length_units (check_typedef (type
));
3504 case TYPE_CODE_ARRAY
:
3505 case TYPE_CODE_COMPLEX
:
3506 case TYPE_CODE_TYPEDEF
:
3507 align
= type_align (TYPE_TARGET_TYPE (type
));
3510 case TYPE_CODE_STRUCT
:
3511 case TYPE_CODE_UNION
:
3513 int number_of_non_static_fields
= 0;
3514 for (unsigned i
= 0; i
< type
->num_fields (); ++i
)
3516 if (!field_is_static (&type
->field (i
)))
3518 number_of_non_static_fields
++;
3519 ULONGEST f_align
= type_align (type
->field (i
).type ());
3522 /* Don't pretend we know something we don't. */
3526 if (f_align
> align
)
3530 /* A struct with no fields, or with only static fields has an
3532 if (number_of_non_static_fields
== 0)
3538 case TYPE_CODE_STRING
:
3539 /* Not sure what to do here, and these can't appear in C or C++
3543 case TYPE_CODE_VOID
:
3547 case TYPE_CODE_ERROR
:
3548 case TYPE_CODE_METHOD
:
3553 if ((align
& (align
- 1)) != 0)
3555 /* Not a power of 2, so pass. */
3562 /* See gdbtypes.h. */
3565 set_type_align (struct type
*type
, ULONGEST align
)
3567 /* Must be a power of 2. Zero is ok. */
3568 gdb_assert ((align
& (align
- 1)) == 0);
3570 unsigned result
= 0;
3577 if (result
>= (1 << TYPE_ALIGN_BITS
))
3580 type
->align_log2
= result
;
3585 /* Queries on types. */
3588 can_dereference (struct type
*t
)
3590 /* FIXME: Should we return true for references as well as
3592 t
= check_typedef (t
);
3595 && t
->code () == TYPE_CODE_PTR
3596 && TYPE_TARGET_TYPE (t
)->code () != TYPE_CODE_VOID
);
3600 is_integral_type (struct type
*t
)
3602 t
= check_typedef (t
);
3605 && !is_fixed_point_type (t
)
3606 && ((t
->code () == TYPE_CODE_INT
)
3607 || (t
->code () == TYPE_CODE_ENUM
)
3608 || (t
->code () == TYPE_CODE_FLAGS
)
3609 || (t
->code () == TYPE_CODE_CHAR
)
3610 || (t
->code () == TYPE_CODE_RANGE
)
3611 || (t
->code () == TYPE_CODE_BOOL
)));
3615 is_floating_type (struct type
*t
)
3617 t
= check_typedef (t
);
3620 && ((t
->code () == TYPE_CODE_FLT
)
3621 || (t
->code () == TYPE_CODE_DECFLOAT
)));
3624 /* Return true if TYPE is scalar. */
3627 is_scalar_type (struct type
*type
)
3629 type
= check_typedef (type
);
3631 if (is_fixed_point_type (type
))
3632 return 0; /* Implemented as a scalar, but more like a floating point. */
3634 switch (type
->code ())
3636 case TYPE_CODE_ARRAY
:
3637 case TYPE_CODE_STRUCT
:
3638 case TYPE_CODE_UNION
:
3640 case TYPE_CODE_STRING
:
3647 /* Return true if T is scalar, or a composite type which in practice has
3648 the memory layout of a scalar type. E.g., an array or struct with only
3649 one scalar element inside it, or a union with only scalar elements. */
3652 is_scalar_type_recursive (struct type
*t
)
3654 t
= check_typedef (t
);
3656 if (is_scalar_type (t
))
3658 /* Are we dealing with an array or string of known dimensions? */
3659 else if ((t
->code () == TYPE_CODE_ARRAY
3660 || t
->code () == TYPE_CODE_STRING
) && t
->num_fields () == 1
3661 && t
->index_type ()->code () == TYPE_CODE_RANGE
)
3663 LONGEST low_bound
, high_bound
;
3664 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (t
));
3666 get_discrete_bounds (t
->index_type (), &low_bound
, &high_bound
);
3668 return high_bound
== low_bound
&& is_scalar_type_recursive (elt_type
);
3670 /* Are we dealing with a struct with one element? */
3671 else if (t
->code () == TYPE_CODE_STRUCT
&& t
->num_fields () == 1)
3672 return is_scalar_type_recursive (t
->field (0).type ());
3673 else if (t
->code () == TYPE_CODE_UNION
)
3675 int i
, n
= t
->num_fields ();
3677 /* If all elements of the union are scalar, then the union is scalar. */
3678 for (i
= 0; i
< n
; i
++)
3679 if (!is_scalar_type_recursive (t
->field (i
).type ()))
3688 /* Return true is T is a class or a union. False otherwise. */
3691 class_or_union_p (const struct type
*t
)
3693 return (t
->code () == TYPE_CODE_STRUCT
3694 || t
->code () == TYPE_CODE_UNION
);
3697 /* A helper function which returns true if types A and B represent the
3698 "same" class type. This is true if the types have the same main
3699 type, or the same name. */
3702 class_types_same_p (const struct type
*a
, const struct type
*b
)
3704 return (TYPE_MAIN_TYPE (a
) == TYPE_MAIN_TYPE (b
)
3705 || (a
->name () && b
->name ()
3706 && !strcmp (a
->name (), b
->name ())));
3709 /* If BASE is an ancestor of DCLASS return the distance between them.
3710 otherwise return -1;
3714 class B: public A {};
3715 class C: public B {};
3718 distance_to_ancestor (A, A, 0) = 0
3719 distance_to_ancestor (A, B, 0) = 1
3720 distance_to_ancestor (A, C, 0) = 2
3721 distance_to_ancestor (A, D, 0) = 3
3723 If PUBLIC is 1 then only public ancestors are considered,
3724 and the function returns the distance only if BASE is a public ancestor
3728 distance_to_ancestor (A, D, 1) = -1. */
3731 distance_to_ancestor (struct type
*base
, struct type
*dclass
, int is_public
)
3736 base
= check_typedef (base
);
3737 dclass
= check_typedef (dclass
);
3739 if (class_types_same_p (base
, dclass
))
3742 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
3744 if (is_public
&& ! BASETYPE_VIA_PUBLIC (dclass
, i
))
3747 d
= distance_to_ancestor (base
, TYPE_BASECLASS (dclass
, i
), is_public
);
3755 /* Check whether BASE is an ancestor or base class or DCLASS
3756 Return 1 if so, and 0 if not.
3757 Note: If BASE and DCLASS are of the same type, this function
3758 will return 1. So for some class A, is_ancestor (A, A) will
3762 is_ancestor (struct type
*base
, struct type
*dclass
)
3764 return distance_to_ancestor (base
, dclass
, 0) >= 0;
3767 /* Like is_ancestor, but only returns true when BASE is a public
3768 ancestor of DCLASS. */
3771 is_public_ancestor (struct type
*base
, struct type
*dclass
)
3773 return distance_to_ancestor (base
, dclass
, 1) >= 0;
3776 /* A helper function for is_unique_ancestor. */
3779 is_unique_ancestor_worker (struct type
*base
, struct type
*dclass
,
3781 const gdb_byte
*valaddr
, int embedded_offset
,
3782 CORE_ADDR address
, struct value
*val
)
3786 base
= check_typedef (base
);
3787 dclass
= check_typedef (dclass
);
3789 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
) && count
< 2; ++i
)
3794 iter
= check_typedef (TYPE_BASECLASS (dclass
, i
));
3796 this_offset
= baseclass_offset (dclass
, i
, valaddr
, embedded_offset
,
3799 if (class_types_same_p (base
, iter
))
3801 /* If this is the first subclass, set *OFFSET and set count
3802 to 1. Otherwise, if this is at the same offset as
3803 previous instances, do nothing. Otherwise, increment
3807 *offset
= this_offset
;
3810 else if (this_offset
== *offset
)
3818 count
+= is_unique_ancestor_worker (base
, iter
, offset
,
3820 embedded_offset
+ this_offset
,
3827 /* Like is_ancestor, but only returns true if BASE is a unique base
3828 class of the type of VAL. */
3831 is_unique_ancestor (struct type
*base
, struct value
*val
)
3835 return is_unique_ancestor_worker (base
, value_type (val
), &offset
,
3836 value_contents_for_printing (val
),
3837 value_embedded_offset (val
),
3838 value_address (val
), val
) == 1;
3841 /* See gdbtypes.h. */
3844 type_byte_order (const struct type
*type
)
3846 bfd_endian byteorder
= gdbarch_byte_order (get_type_arch (type
));
3847 if (type
->endianity_is_not_default ())
3849 if (byteorder
== BFD_ENDIAN_BIG
)
3850 return BFD_ENDIAN_LITTLE
;
3853 gdb_assert (byteorder
== BFD_ENDIAN_LITTLE
);
3854 return BFD_ENDIAN_BIG
;
3862 /* Overload resolution. */
3864 /* Return the sum of the rank of A with the rank of B. */
3867 sum_ranks (struct rank a
, struct rank b
)
3870 c
.rank
= a
.rank
+ b
.rank
;
3871 c
.subrank
= a
.subrank
+ b
.subrank
;
3875 /* Compare rank A and B and return:
3877 1 if a is better than b
3878 -1 if b is better than a. */
3881 compare_ranks (struct rank a
, struct rank b
)
3883 if (a
.rank
== b
.rank
)
3885 if (a
.subrank
== b
.subrank
)
3887 if (a
.subrank
< b
.subrank
)
3889 if (a
.subrank
> b
.subrank
)
3893 if (a
.rank
< b
.rank
)
3896 /* a.rank > b.rank */
3900 /* Functions for overload resolution begin here. */
3902 /* Compare two badness vectors A and B and return the result.
3903 0 => A and B are identical
3904 1 => A and B are incomparable
3905 2 => A is better than B
3906 3 => A is worse than B */
3909 compare_badness (const badness_vector
&a
, const badness_vector
&b
)
3913 short found_pos
= 0; /* any positives in c? */
3914 short found_neg
= 0; /* any negatives in c? */
3916 /* differing sizes => incomparable */
3917 if (a
.size () != b
.size ())
3920 /* Subtract b from a */
3921 for (i
= 0; i
< a
.size (); i
++)
3923 tmp
= compare_ranks (b
[i
], a
[i
]);
3933 return 1; /* incomparable */
3935 return 3; /* A > B */
3941 return 2; /* A < B */
3943 return 0; /* A == B */
3947 /* Rank a function by comparing its parameter types (PARMS), to the
3948 types of an argument list (ARGS). Return the badness vector. This
3949 has ARGS.size() + 1 entries. */
3952 rank_function (gdb::array_view
<type
*> parms
,
3953 gdb::array_view
<value
*> args
)
3955 /* add 1 for the length-match rank. */
3957 bv
.reserve (1 + args
.size ());
3959 /* First compare the lengths of the supplied lists.
3960 If there is a mismatch, set it to a high value. */
3962 /* pai/1997-06-03 FIXME: when we have debug info about default
3963 arguments and ellipsis parameter lists, we should consider those
3964 and rank the length-match more finely. */
3966 bv
.push_back ((args
.size () != parms
.size ())
3967 ? LENGTH_MISMATCH_BADNESS
3968 : EXACT_MATCH_BADNESS
);
3970 /* Now rank all the parameters of the candidate function. */
3971 size_t min_len
= std::min (parms
.size (), args
.size ());
3973 for (size_t i
= 0; i
< min_len
; i
++)
3974 bv
.push_back (rank_one_type (parms
[i
], value_type (args
[i
]),
3977 /* If more arguments than parameters, add dummy entries. */
3978 for (size_t i
= min_len
; i
< args
.size (); i
++)
3979 bv
.push_back (TOO_FEW_PARAMS_BADNESS
);
3984 /* Compare the names of two integer types, assuming that any sign
3985 qualifiers have been checked already. We do it this way because
3986 there may be an "int" in the name of one of the types. */
3989 integer_types_same_name_p (const char *first
, const char *second
)
3991 int first_p
, second_p
;
3993 /* If both are shorts, return 1; if neither is a short, keep
3995 first_p
= (strstr (first
, "short") != NULL
);
3996 second_p
= (strstr (second
, "short") != NULL
);
3997 if (first_p
&& second_p
)
3999 if (first_p
|| second_p
)
4002 /* Likewise for long. */
4003 first_p
= (strstr (first
, "long") != NULL
);
4004 second_p
= (strstr (second
, "long") != NULL
);
4005 if (first_p
&& second_p
)
4007 if (first_p
|| second_p
)
4010 /* Likewise for char. */
4011 first_p
= (strstr (first
, "char") != NULL
);
4012 second_p
= (strstr (second
, "char") != NULL
);
4013 if (first_p
&& second_p
)
4015 if (first_p
|| second_p
)
4018 /* They must both be ints. */
4022 /* Compares type A to type B. Returns true if they represent the same
4023 type, false otherwise. */
4026 types_equal (struct type
*a
, struct type
*b
)
4028 /* Identical type pointers. */
4029 /* However, this still doesn't catch all cases of same type for b
4030 and a. The reason is that builtin types are different from
4031 the same ones constructed from the object. */
4035 /* Resolve typedefs */
4036 if (a
->code () == TYPE_CODE_TYPEDEF
)
4037 a
= check_typedef (a
);
4038 if (b
->code () == TYPE_CODE_TYPEDEF
)
4039 b
= check_typedef (b
);
4041 /* If after resolving typedefs a and b are not of the same type
4042 code then they are not equal. */
4043 if (a
->code () != b
->code ())
4046 /* If a and b are both pointers types or both reference types then
4047 they are equal of the same type iff the objects they refer to are
4048 of the same type. */
4049 if (a
->code () == TYPE_CODE_PTR
4050 || a
->code () == TYPE_CODE_REF
)
4051 return types_equal (TYPE_TARGET_TYPE (a
),
4052 TYPE_TARGET_TYPE (b
));
4054 /* Well, damnit, if the names are exactly the same, I'll say they
4055 are exactly the same. This happens when we generate method
4056 stubs. The types won't point to the same address, but they
4057 really are the same. */
4059 if (a
->name () && b
->name ()
4060 && strcmp (a
->name (), b
->name ()) == 0)
4063 /* Check if identical after resolving typedefs. */
4067 /* Two function types are equal if their argument and return types
4069 if (a
->code () == TYPE_CODE_FUNC
)
4073 if (a
->num_fields () != b
->num_fields ())
4076 if (!types_equal (TYPE_TARGET_TYPE (a
), TYPE_TARGET_TYPE (b
)))
4079 for (i
= 0; i
< a
->num_fields (); ++i
)
4080 if (!types_equal (a
->field (i
).type (), b
->field (i
).type ()))
4089 /* Deep comparison of types. */
4091 /* An entry in the type-equality bcache. */
4093 struct type_equality_entry
4095 type_equality_entry (struct type
*t1
, struct type
*t2
)
4101 struct type
*type1
, *type2
;
4104 /* A helper function to compare two strings. Returns true if they are
4105 the same, false otherwise. Handles NULLs properly. */
4108 compare_maybe_null_strings (const char *s
, const char *t
)
4110 if (s
== NULL
|| t
== NULL
)
4112 return strcmp (s
, t
) == 0;
4115 /* A helper function for check_types_worklist that checks two types for
4116 "deep" equality. Returns true if the types are considered the
4117 same, false otherwise. */
4120 check_types_equal (struct type
*type1
, struct type
*type2
,
4121 std::vector
<type_equality_entry
> *worklist
)
4123 type1
= check_typedef (type1
);
4124 type2
= check_typedef (type2
);
4129 if (type1
->code () != type2
->code ()
4130 || TYPE_LENGTH (type1
) != TYPE_LENGTH (type2
)
4131 || type1
->is_unsigned () != type2
->is_unsigned ()
4132 || type1
->has_no_signedness () != type2
->has_no_signedness ()
4133 || type1
->endianity_is_not_default () != type2
->endianity_is_not_default ()
4134 || type1
->has_varargs () != type2
->has_varargs ()
4135 || type1
->is_vector () != type2
->is_vector ()
4136 || TYPE_NOTTEXT (type1
) != TYPE_NOTTEXT (type2
)
4137 || type1
->instance_flags () != type2
->instance_flags ()
4138 || type1
->num_fields () != type2
->num_fields ())
4141 if (!compare_maybe_null_strings (type1
->name (), type2
->name ()))
4143 if (!compare_maybe_null_strings (type1
->name (), type2
->name ()))
4146 if (type1
->code () == TYPE_CODE_RANGE
)
4148 if (*type1
->bounds () != *type2
->bounds ())
4155 for (i
= 0; i
< type1
->num_fields (); ++i
)
4157 const struct field
*field1
= &type1
->field (i
);
4158 const struct field
*field2
= &type2
->field (i
);
4160 if (FIELD_ARTIFICIAL (*field1
) != FIELD_ARTIFICIAL (*field2
)
4161 || FIELD_BITSIZE (*field1
) != FIELD_BITSIZE (*field2
)
4162 || FIELD_LOC_KIND (*field1
) != FIELD_LOC_KIND (*field2
))
4164 if (!compare_maybe_null_strings (FIELD_NAME (*field1
),
4165 FIELD_NAME (*field2
)))
4167 switch (FIELD_LOC_KIND (*field1
))
4169 case FIELD_LOC_KIND_BITPOS
:
4170 if (FIELD_BITPOS (*field1
) != FIELD_BITPOS (*field2
))
4173 case FIELD_LOC_KIND_ENUMVAL
:
4174 if (FIELD_ENUMVAL (*field1
) != FIELD_ENUMVAL (*field2
))
4177 case FIELD_LOC_KIND_PHYSADDR
:
4178 if (FIELD_STATIC_PHYSADDR (*field1
)
4179 != FIELD_STATIC_PHYSADDR (*field2
))
4182 case FIELD_LOC_KIND_PHYSNAME
:
4183 if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1
),
4184 FIELD_STATIC_PHYSNAME (*field2
)))
4187 case FIELD_LOC_KIND_DWARF_BLOCK
:
4189 struct dwarf2_locexpr_baton
*block1
, *block2
;
4191 block1
= FIELD_DWARF_BLOCK (*field1
);
4192 block2
= FIELD_DWARF_BLOCK (*field2
);
4193 if (block1
->per_cu
!= block2
->per_cu
4194 || block1
->size
!= block2
->size
4195 || memcmp (block1
->data
, block2
->data
, block1
->size
) != 0)
4200 internal_error (__FILE__
, __LINE__
, _("Unsupported field kind "
4201 "%d by check_types_equal"),
4202 FIELD_LOC_KIND (*field1
));
4205 worklist
->emplace_back (field1
->type (), field2
->type ());
4209 if (TYPE_TARGET_TYPE (type1
) != NULL
)
4211 if (TYPE_TARGET_TYPE (type2
) == NULL
)
4214 worklist
->emplace_back (TYPE_TARGET_TYPE (type1
),
4215 TYPE_TARGET_TYPE (type2
));
4217 else if (TYPE_TARGET_TYPE (type2
) != NULL
)
4223 /* Check types on a worklist for equality. Returns false if any pair
4224 is not equal, true if they are all considered equal. */
4227 check_types_worklist (std::vector
<type_equality_entry
> *worklist
,
4230 while (!worklist
->empty ())
4234 struct type_equality_entry entry
= std::move (worklist
->back ());
4235 worklist
->pop_back ();
4237 /* If the type pair has already been visited, we know it is
4239 cache
->insert (&entry
, sizeof (entry
), &added
);
4243 if (!check_types_equal (entry
.type1
, entry
.type2
, worklist
))
4250 /* Return true if types TYPE1 and TYPE2 are equal, as determined by a
4251 "deep comparison". Otherwise return false. */
4254 types_deeply_equal (struct type
*type1
, struct type
*type2
)
4256 std::vector
<type_equality_entry
> worklist
;
4258 gdb_assert (type1
!= NULL
&& type2
!= NULL
);
4260 /* Early exit for the simple case. */
4265 worklist
.emplace_back (type1
, type2
);
4266 return check_types_worklist (&worklist
, &cache
);
4269 /* Allocated status of type TYPE. Return zero if type TYPE is allocated.
4270 Otherwise return one. */
4273 type_not_allocated (const struct type
*type
)
4275 struct dynamic_prop
*prop
= TYPE_ALLOCATED_PROP (type
);
4277 return (prop
!= nullptr && prop
->kind () == PROP_CONST
4278 && prop
->const_val () == 0);
4281 /* Associated status of type TYPE. Return zero if type TYPE is associated.
4282 Otherwise return one. */
4285 type_not_associated (const struct type
*type
)
4287 struct dynamic_prop
*prop
= TYPE_ASSOCIATED_PROP (type
);
4289 return (prop
!= nullptr && prop
->kind () == PROP_CONST
4290 && prop
->const_val () == 0);
4293 /* rank_one_type helper for when PARM's type code is TYPE_CODE_PTR. */
4296 rank_one_type_parm_ptr (struct type
*parm
, struct type
*arg
, struct value
*value
)
4298 struct rank rank
= {0,0};
4300 switch (arg
->code ())
4304 /* Allowed pointer conversions are:
4305 (a) pointer to void-pointer conversion. */
4306 if (TYPE_TARGET_TYPE (parm
)->code () == TYPE_CODE_VOID
)
4307 return VOID_PTR_CONVERSION_BADNESS
;
4309 /* (b) pointer to ancestor-pointer conversion. */
4310 rank
.subrank
= distance_to_ancestor (TYPE_TARGET_TYPE (parm
),
4311 TYPE_TARGET_TYPE (arg
),
4313 if (rank
.subrank
>= 0)
4314 return sum_ranks (BASE_PTR_CONVERSION_BADNESS
, rank
);
4316 return INCOMPATIBLE_TYPE_BADNESS
;
4317 case TYPE_CODE_ARRAY
:
4319 struct type
*t1
= TYPE_TARGET_TYPE (parm
);
4320 struct type
*t2
= TYPE_TARGET_TYPE (arg
);
4322 if (types_equal (t1
, t2
))
4324 /* Make sure they are CV equal. */
4325 if (TYPE_CONST (t1
) != TYPE_CONST (t2
))
4326 rank
.subrank
|= CV_CONVERSION_CONST
;
4327 if (TYPE_VOLATILE (t1
) != TYPE_VOLATILE (t2
))
4328 rank
.subrank
|= CV_CONVERSION_VOLATILE
;
4329 if (rank
.subrank
!= 0)
4330 return sum_ranks (CV_CONVERSION_BADNESS
, rank
);
4331 return EXACT_MATCH_BADNESS
;
4333 return INCOMPATIBLE_TYPE_BADNESS
;
4335 case TYPE_CODE_FUNC
:
4336 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
);
4338 if (value
!= NULL
&& value_type (value
)->code () == TYPE_CODE_INT
)
4340 if (value_as_long (value
) == 0)
4342 /* Null pointer conversion: allow it to be cast to a pointer.
4343 [4.10.1 of C++ standard draft n3290] */
4344 return NULL_POINTER_CONVERSION_BADNESS
;
4348 /* If type checking is disabled, allow the conversion. */
4349 if (!strict_type_checking
)
4350 return NS_INTEGER_POINTER_CONVERSION_BADNESS
;
4354 case TYPE_CODE_ENUM
:
4355 case TYPE_CODE_FLAGS
:
4356 case TYPE_CODE_CHAR
:
4357 case TYPE_CODE_RANGE
:
4358 case TYPE_CODE_BOOL
:
4360 return INCOMPATIBLE_TYPE_BADNESS
;
4364 /* rank_one_type helper for when PARM's type code is TYPE_CODE_ARRAY. */
4367 rank_one_type_parm_array (struct type
*parm
, struct type
*arg
, struct value
*value
)
4369 switch (arg
->code ())
4372 case TYPE_CODE_ARRAY
:
4373 return rank_one_type (TYPE_TARGET_TYPE (parm
),
4374 TYPE_TARGET_TYPE (arg
), NULL
);
4376 return INCOMPATIBLE_TYPE_BADNESS
;
4380 /* rank_one_type helper for when PARM's type code is TYPE_CODE_FUNC. */
4383 rank_one_type_parm_func (struct type
*parm
, struct type
*arg
, struct value
*value
)
4385 switch (arg
->code ())
4387 case TYPE_CODE_PTR
: /* funcptr -> func */
4388 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
);
4390 return INCOMPATIBLE_TYPE_BADNESS
;
4394 /* rank_one_type helper for when PARM's type code is TYPE_CODE_INT. */
4397 rank_one_type_parm_int (struct type
*parm
, struct type
*arg
, struct value
*value
)
4399 switch (arg
->code ())
4402 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
4404 /* Deal with signed, unsigned, and plain chars and
4405 signed and unsigned ints. */
4406 if (parm
->has_no_signedness ())
4408 /* This case only for character types. */
4409 if (arg
->has_no_signedness ())
4410 return EXACT_MATCH_BADNESS
; /* plain char -> plain char */
4411 else /* signed/unsigned char -> plain char */
4412 return INTEGER_CONVERSION_BADNESS
;
4414 else if (parm
->is_unsigned ())
4416 if (arg
->is_unsigned ())
4418 /* unsigned int -> unsigned int, or
4419 unsigned long -> unsigned long */
4420 if (integer_types_same_name_p (parm
->name (),
4422 return EXACT_MATCH_BADNESS
;
4423 else if (integer_types_same_name_p (arg
->name (),
4425 && integer_types_same_name_p (parm
->name (),
4427 /* unsigned int -> unsigned long */
4428 return INTEGER_PROMOTION_BADNESS
;
4430 /* unsigned long -> unsigned int */
4431 return INTEGER_CONVERSION_BADNESS
;
4435 if (integer_types_same_name_p (arg
->name (),
4437 && integer_types_same_name_p (parm
->name (),
4439 /* signed long -> unsigned int */
4440 return INTEGER_CONVERSION_BADNESS
;
4442 /* signed int/long -> unsigned int/long */
4443 return INTEGER_CONVERSION_BADNESS
;
4446 else if (!arg
->has_no_signedness () && !arg
->is_unsigned ())
4448 if (integer_types_same_name_p (parm
->name (),
4450 return EXACT_MATCH_BADNESS
;
4451 else if (integer_types_same_name_p (arg
->name (),
4453 && integer_types_same_name_p (parm
->name (),
4455 return INTEGER_PROMOTION_BADNESS
;
4457 return INTEGER_CONVERSION_BADNESS
;
4460 return INTEGER_CONVERSION_BADNESS
;
4462 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
4463 return INTEGER_PROMOTION_BADNESS
;
4465 return INTEGER_CONVERSION_BADNESS
;
4466 case TYPE_CODE_ENUM
:
4467 case TYPE_CODE_FLAGS
:
4468 case TYPE_CODE_CHAR
:
4469 case TYPE_CODE_RANGE
:
4470 case TYPE_CODE_BOOL
:
4471 if (TYPE_DECLARED_CLASS (arg
))
4472 return INCOMPATIBLE_TYPE_BADNESS
;
4473 return INTEGER_PROMOTION_BADNESS
;
4475 return INT_FLOAT_CONVERSION_BADNESS
;
4477 return NS_POINTER_CONVERSION_BADNESS
;
4479 return INCOMPATIBLE_TYPE_BADNESS
;
4483 /* rank_one_type helper for when PARM's type code is TYPE_CODE_ENUM. */
4486 rank_one_type_parm_enum (struct type
*parm
, struct type
*arg
, struct value
*value
)
4488 switch (arg
->code ())
4491 case TYPE_CODE_CHAR
:
4492 case TYPE_CODE_RANGE
:
4493 case TYPE_CODE_BOOL
:
4494 case TYPE_CODE_ENUM
:
4495 if (TYPE_DECLARED_CLASS (parm
) || TYPE_DECLARED_CLASS (arg
))
4496 return INCOMPATIBLE_TYPE_BADNESS
;
4497 return INTEGER_CONVERSION_BADNESS
;
4499 return INT_FLOAT_CONVERSION_BADNESS
;
4501 return INCOMPATIBLE_TYPE_BADNESS
;
4505 /* rank_one_type helper for when PARM's type code is TYPE_CODE_CHAR. */
4508 rank_one_type_parm_char (struct type
*parm
, struct type
*arg
, struct value
*value
)
4510 switch (arg
->code ())
4512 case TYPE_CODE_RANGE
:
4513 case TYPE_CODE_BOOL
:
4514 case TYPE_CODE_ENUM
:
4515 if (TYPE_DECLARED_CLASS (arg
))
4516 return INCOMPATIBLE_TYPE_BADNESS
;
4517 return INTEGER_CONVERSION_BADNESS
;
4519 return INT_FLOAT_CONVERSION_BADNESS
;
4521 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
4522 return INTEGER_CONVERSION_BADNESS
;
4523 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
4524 return INTEGER_PROMOTION_BADNESS
;
4526 case TYPE_CODE_CHAR
:
4527 /* Deal with signed, unsigned, and plain chars for C++ and
4528 with int cases falling through from previous case. */
4529 if (parm
->has_no_signedness ())
4531 if (arg
->has_no_signedness ())
4532 return EXACT_MATCH_BADNESS
;
4534 return INTEGER_CONVERSION_BADNESS
;
4536 else if (parm
->is_unsigned ())
4538 if (arg
->is_unsigned ())
4539 return EXACT_MATCH_BADNESS
;
4541 return INTEGER_PROMOTION_BADNESS
;
4543 else if (!arg
->has_no_signedness () && !arg
->is_unsigned ())
4544 return EXACT_MATCH_BADNESS
;
4546 return INTEGER_CONVERSION_BADNESS
;
4548 return INCOMPATIBLE_TYPE_BADNESS
;
4552 /* rank_one_type helper for when PARM's type code is TYPE_CODE_RANGE. */
4555 rank_one_type_parm_range (struct type
*parm
, struct type
*arg
, struct value
*value
)
4557 switch (arg
->code ())
4560 case TYPE_CODE_CHAR
:
4561 case TYPE_CODE_RANGE
:
4562 case TYPE_CODE_BOOL
:
4563 case TYPE_CODE_ENUM
:
4564 return INTEGER_CONVERSION_BADNESS
;
4566 return INT_FLOAT_CONVERSION_BADNESS
;
4568 return INCOMPATIBLE_TYPE_BADNESS
;
4572 /* rank_one_type helper for when PARM's type code is TYPE_CODE_BOOL. */
4575 rank_one_type_parm_bool (struct type
*parm
, struct type
*arg
, struct value
*value
)
4577 switch (arg
->code ())
4579 /* n3290 draft, section 4.12.1 (conv.bool):
4581 "A prvalue of arithmetic, unscoped enumeration, pointer, or
4582 pointer to member type can be converted to a prvalue of type
4583 bool. A zero value, null pointer value, or null member pointer
4584 value is converted to false; any other value is converted to
4585 true. A prvalue of type std::nullptr_t can be converted to a
4586 prvalue of type bool; the resulting value is false." */
4588 case TYPE_CODE_CHAR
:
4589 case TYPE_CODE_ENUM
:
4591 case TYPE_CODE_MEMBERPTR
:
4593 return BOOL_CONVERSION_BADNESS
;
4594 case TYPE_CODE_RANGE
:
4595 return INCOMPATIBLE_TYPE_BADNESS
;
4596 case TYPE_CODE_BOOL
:
4597 return EXACT_MATCH_BADNESS
;
4599 return INCOMPATIBLE_TYPE_BADNESS
;
4603 /* rank_one_type helper for when PARM's type code is TYPE_CODE_FLOAT. */
4606 rank_one_type_parm_float (struct type
*parm
, struct type
*arg
, struct value
*value
)
4608 switch (arg
->code ())
4611 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
4612 return FLOAT_PROMOTION_BADNESS
;
4613 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
4614 return EXACT_MATCH_BADNESS
;
4616 return FLOAT_CONVERSION_BADNESS
;
4618 case TYPE_CODE_BOOL
:
4619 case TYPE_CODE_ENUM
:
4620 case TYPE_CODE_RANGE
:
4621 case TYPE_CODE_CHAR
:
4622 return INT_FLOAT_CONVERSION_BADNESS
;
4624 return INCOMPATIBLE_TYPE_BADNESS
;
4628 /* rank_one_type helper for when PARM's type code is TYPE_CODE_COMPLEX. */
4631 rank_one_type_parm_complex (struct type
*parm
, struct type
*arg
, struct value
*value
)
4633 switch (arg
->code ())
4634 { /* Strictly not needed for C++, but... */
4636 return FLOAT_PROMOTION_BADNESS
;
4637 case TYPE_CODE_COMPLEX
:
4638 return EXACT_MATCH_BADNESS
;
4640 return INCOMPATIBLE_TYPE_BADNESS
;
4644 /* rank_one_type helper for when PARM's type code is TYPE_CODE_STRUCT. */
4647 rank_one_type_parm_struct (struct type
*parm
, struct type
*arg
, struct value
*value
)
4649 struct rank rank
= {0, 0};
4651 switch (arg
->code ())
4653 case TYPE_CODE_STRUCT
:
4654 /* Check for derivation */
4655 rank
.subrank
= distance_to_ancestor (parm
, arg
, 0);
4656 if (rank
.subrank
>= 0)
4657 return sum_ranks (BASE_CONVERSION_BADNESS
, rank
);
4660 return INCOMPATIBLE_TYPE_BADNESS
;
4664 /* rank_one_type helper for when PARM's type code is TYPE_CODE_SET. */
4667 rank_one_type_parm_set (struct type
*parm
, struct type
*arg
, struct value
*value
)
4669 switch (arg
->code ())
4673 return rank_one_type (parm
->field (0).type (),
4674 arg
->field (0).type (), NULL
);
4676 return INCOMPATIBLE_TYPE_BADNESS
;
4680 /* Compare one type (PARM) for compatibility with another (ARG).
4681 * PARM is intended to be the parameter type of a function; and
4682 * ARG is the supplied argument's type. This function tests if
4683 * the latter can be converted to the former.
4684 * VALUE is the argument's value or NULL if none (or called recursively)
4686 * Return 0 if they are identical types;
4687 * Otherwise, return an integer which corresponds to how compatible
4688 * PARM is to ARG. The higher the return value, the worse the match.
4689 * Generally the "bad" conversions are all uniformly assigned a 100. */
4692 rank_one_type (struct type
*parm
, struct type
*arg
, struct value
*value
)
4694 struct rank rank
= {0,0};
4696 /* Resolve typedefs */
4697 if (parm
->code () == TYPE_CODE_TYPEDEF
)
4698 parm
= check_typedef (parm
);
4699 if (arg
->code () == TYPE_CODE_TYPEDEF
)
4700 arg
= check_typedef (arg
);
4702 if (TYPE_IS_REFERENCE (parm
) && value
!= NULL
)
4704 if (VALUE_LVAL (value
) == not_lval
)
4706 /* Rvalues should preferably bind to rvalue references or const
4707 lvalue references. */
4708 if (parm
->code () == TYPE_CODE_RVALUE_REF
)
4709 rank
.subrank
= REFERENCE_CONVERSION_RVALUE
;
4710 else if (TYPE_CONST (TYPE_TARGET_TYPE (parm
)))
4711 rank
.subrank
= REFERENCE_CONVERSION_CONST_LVALUE
;
4713 return INCOMPATIBLE_TYPE_BADNESS
;
4714 return sum_ranks (rank
, REFERENCE_CONVERSION_BADNESS
);
4718 /* It's illegal to pass an lvalue as an rvalue. */
4719 if (parm
->code () == TYPE_CODE_RVALUE_REF
)
4720 return INCOMPATIBLE_TYPE_BADNESS
;
4724 if (types_equal (parm
, arg
))
4726 struct type
*t1
= parm
;
4727 struct type
*t2
= arg
;
4729 /* For pointers and references, compare target type. */
4730 if (parm
->code () == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (parm
))
4732 t1
= TYPE_TARGET_TYPE (parm
);
4733 t2
= TYPE_TARGET_TYPE (arg
);
4736 /* Make sure they are CV equal, too. */
4737 if (TYPE_CONST (t1
) != TYPE_CONST (t2
))
4738 rank
.subrank
|= CV_CONVERSION_CONST
;
4739 if (TYPE_VOLATILE (t1
) != TYPE_VOLATILE (t2
))
4740 rank
.subrank
|= CV_CONVERSION_VOLATILE
;
4741 if (rank
.subrank
!= 0)
4742 return sum_ranks (CV_CONVERSION_BADNESS
, rank
);
4743 return EXACT_MATCH_BADNESS
;
4746 /* See through references, since we can almost make non-references
4749 if (TYPE_IS_REFERENCE (arg
))
4750 return (sum_ranks (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
),
4751 REFERENCE_SEE_THROUGH_BADNESS
));
4752 if (TYPE_IS_REFERENCE (parm
))
4753 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
),
4754 REFERENCE_SEE_THROUGH_BADNESS
));
4756 /* Debugging only. */
4757 fprintf_filtered (gdb_stderr
,
4758 "------ Arg is %s [%d], parm is %s [%d]\n",
4759 arg
->name (), arg
->code (),
4760 parm
->name (), parm
->code ());
4762 /* x -> y means arg of type x being supplied for parameter of type y. */
4764 switch (parm
->code ())
4767 return rank_one_type_parm_ptr (parm
, arg
, value
);
4768 case TYPE_CODE_ARRAY
:
4769 return rank_one_type_parm_array (parm
, arg
, value
);
4770 case TYPE_CODE_FUNC
:
4771 return rank_one_type_parm_func (parm
, arg
, value
);
4773 return rank_one_type_parm_int (parm
, arg
, value
);
4774 case TYPE_CODE_ENUM
:
4775 return rank_one_type_parm_enum (parm
, arg
, value
);
4776 case TYPE_CODE_CHAR
:
4777 return rank_one_type_parm_char (parm
, arg
, value
);
4778 case TYPE_CODE_RANGE
:
4779 return rank_one_type_parm_range (parm
, arg
, value
);
4780 case TYPE_CODE_BOOL
:
4781 return rank_one_type_parm_bool (parm
, arg
, value
);
4783 return rank_one_type_parm_float (parm
, arg
, value
);
4784 case TYPE_CODE_COMPLEX
:
4785 return rank_one_type_parm_complex (parm
, arg
, value
);
4786 case TYPE_CODE_STRUCT
:
4787 return rank_one_type_parm_struct (parm
, arg
, value
);
4789 return rank_one_type_parm_set (parm
, arg
, value
);
4791 return INCOMPATIBLE_TYPE_BADNESS
;
4792 } /* switch (arg->code ()) */
4795 /* End of functions for overload resolution. */
4797 /* Routines to pretty-print types. */
4800 print_bit_vector (B_TYPE
*bits
, int nbits
)
4804 for (bitno
= 0; bitno
< nbits
; bitno
++)
4806 if ((bitno
% 8) == 0)
4808 puts_filtered (" ");
4810 if (B_TST (bits
, bitno
))
4811 printf_filtered (("1"));
4813 printf_filtered (("0"));
4817 /* Note the first arg should be the "this" pointer, we may not want to
4818 include it since we may get into a infinitely recursive
4822 print_args (struct field
*args
, int nargs
, int spaces
)
4828 for (i
= 0; i
< nargs
; i
++)
4830 printfi_filtered (spaces
, "[%d] name '%s'\n", i
,
4831 args
[i
].name
!= NULL
? args
[i
].name
: "<NULL>");
4832 recursive_dump_type (args
[i
].type (), spaces
+ 2);
4838 field_is_static (struct field
*f
)
4840 /* "static" fields are the fields whose location is not relative
4841 to the address of the enclosing struct. It would be nice to
4842 have a dedicated flag that would be set for static fields when
4843 the type is being created. But in practice, checking the field
4844 loc_kind should give us an accurate answer. */
4845 return (FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSNAME
4846 || FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSADDR
);
4850 dump_fn_fieldlists (struct type
*type
, int spaces
)
4856 printfi_filtered (spaces
, "fn_fieldlists ");
4857 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
4858 printf_filtered ("\n");
4859 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
4861 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
4862 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
4864 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
4865 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
4867 printf_filtered (_(") length %d\n"),
4868 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
4869 for (overload_idx
= 0;
4870 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
4873 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
4875 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
4876 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
4878 printf_filtered (")\n");
4879 printfi_filtered (spaces
+ 8, "type ");
4880 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
4882 printf_filtered ("\n");
4884 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
4887 printfi_filtered (spaces
+ 8, "args ");
4888 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
4890 printf_filtered ("\n");
4891 print_args (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
4892 TYPE_FN_FIELD_TYPE (f
, overload_idx
)->num_fields (),
4894 printfi_filtered (spaces
+ 8, "fcontext ");
4895 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
4897 printf_filtered ("\n");
4899 printfi_filtered (spaces
+ 8, "is_const %d\n",
4900 TYPE_FN_FIELD_CONST (f
, overload_idx
));
4901 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
4902 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
4903 printfi_filtered (spaces
+ 8, "is_private %d\n",
4904 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
4905 printfi_filtered (spaces
+ 8, "is_protected %d\n",
4906 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
4907 printfi_filtered (spaces
+ 8, "is_stub %d\n",
4908 TYPE_FN_FIELD_STUB (f
, overload_idx
));
4909 printfi_filtered (spaces
+ 8, "defaulted %d\n",
4910 TYPE_FN_FIELD_DEFAULTED (f
, overload_idx
));
4911 printfi_filtered (spaces
+ 8, "is_deleted %d\n",
4912 TYPE_FN_FIELD_DELETED (f
, overload_idx
));
4913 printfi_filtered (spaces
+ 8, "voffset %u\n",
4914 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
4920 print_cplus_stuff (struct type
*type
, int spaces
)
4922 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
4923 printfi_filtered (spaces
, "vptr_basetype ");
4924 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
4925 puts_filtered ("\n");
4926 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
4927 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
4929 printfi_filtered (spaces
, "n_baseclasses %d\n",
4930 TYPE_N_BASECLASSES (type
));
4931 printfi_filtered (spaces
, "nfn_fields %d\n",
4932 TYPE_NFN_FIELDS (type
));
4933 if (TYPE_N_BASECLASSES (type
) > 0)
4935 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
4936 TYPE_N_BASECLASSES (type
));
4937 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
4939 printf_filtered (")");
4941 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
4942 TYPE_N_BASECLASSES (type
));
4943 puts_filtered ("\n");
4945 if (type
->num_fields () > 0)
4947 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
4949 printfi_filtered (spaces
,
4950 "private_field_bits (%d bits at *",
4951 type
->num_fields ());
4952 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
4954 printf_filtered (")");
4955 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
4956 type
->num_fields ());
4957 puts_filtered ("\n");
4959 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
4961 printfi_filtered (spaces
,
4962 "protected_field_bits (%d bits at *",
4963 type
->num_fields ());
4964 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
4966 printf_filtered (")");
4967 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
4968 type
->num_fields ());
4969 puts_filtered ("\n");
4972 if (TYPE_NFN_FIELDS (type
) > 0)
4974 dump_fn_fieldlists (type
, spaces
);
4977 printfi_filtered (spaces
, "calling_convention %d\n",
4978 TYPE_CPLUS_CALLING_CONVENTION (type
));
4981 /* Print the contents of the TYPE's type_specific union, assuming that
4982 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
4985 print_gnat_stuff (struct type
*type
, int spaces
)
4987 struct type
*descriptive_type
= TYPE_DESCRIPTIVE_TYPE (type
);
4989 if (descriptive_type
== NULL
)
4990 printfi_filtered (spaces
+ 2, "no descriptive type\n");
4993 printfi_filtered (spaces
+ 2, "descriptive type\n");
4994 recursive_dump_type (descriptive_type
, spaces
+ 4);
4998 /* Print the contents of the TYPE's type_specific union, assuming that
4999 its type-specific kind is TYPE_SPECIFIC_FIXED_POINT. */
5002 print_fixed_point_type_info (struct type
*type
, int spaces
)
5004 printfi_filtered (spaces
+ 2, "scaling factor: %s\n",
5005 type
->fixed_point_scaling_factor ().str ().c_str ());
5008 static struct obstack dont_print_type_obstack
;
5010 /* Print the dynamic_prop PROP. */
5013 dump_dynamic_prop (dynamic_prop
const& prop
)
5015 switch (prop
.kind ())
5018 printf_filtered ("%s", plongest (prop
.const_val ()));
5020 case PROP_UNDEFINED
:
5021 printf_filtered ("(undefined)");
5025 printf_filtered ("(dynamic)");
5028 gdb_assert_not_reached ("unhandled prop kind");
5034 recursive_dump_type (struct type
*type
, int spaces
)
5039 obstack_begin (&dont_print_type_obstack
, 0);
5041 if (type
->num_fields () > 0
5042 || (HAVE_CPLUS_STRUCT (type
) && TYPE_NFN_FIELDS (type
) > 0))
5044 struct type
**first_dont_print
5045 = (struct type
**) obstack_base (&dont_print_type_obstack
);
5047 int i
= (struct type
**)
5048 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
5052 if (type
== first_dont_print
[i
])
5054 printfi_filtered (spaces
, "type node ");
5055 gdb_print_host_address (type
, gdb_stdout
);
5056 printf_filtered (_(" <same as already seen type>\n"));
5061 obstack_ptr_grow (&dont_print_type_obstack
, type
);
5064 printfi_filtered (spaces
, "type node ");
5065 gdb_print_host_address (type
, gdb_stdout
);
5066 printf_filtered ("\n");
5067 printfi_filtered (spaces
, "name '%s' (",
5068 type
->name () ? type
->name () : "<NULL>");
5069 gdb_print_host_address (type
->name (), gdb_stdout
);
5070 printf_filtered (")\n");
5071 printfi_filtered (spaces
, "code 0x%x ", type
->code ());
5072 switch (type
->code ())
5074 case TYPE_CODE_UNDEF
:
5075 printf_filtered ("(TYPE_CODE_UNDEF)");
5078 printf_filtered ("(TYPE_CODE_PTR)");
5080 case TYPE_CODE_ARRAY
:
5081 printf_filtered ("(TYPE_CODE_ARRAY)");
5083 case TYPE_CODE_STRUCT
:
5084 printf_filtered ("(TYPE_CODE_STRUCT)");
5086 case TYPE_CODE_UNION
:
5087 printf_filtered ("(TYPE_CODE_UNION)");
5089 case TYPE_CODE_ENUM
:
5090 printf_filtered ("(TYPE_CODE_ENUM)");
5092 case TYPE_CODE_FLAGS
:
5093 printf_filtered ("(TYPE_CODE_FLAGS)");
5095 case TYPE_CODE_FUNC
:
5096 printf_filtered ("(TYPE_CODE_FUNC)");
5099 printf_filtered ("(TYPE_CODE_INT)");
5102 printf_filtered ("(TYPE_CODE_FLT)");
5104 case TYPE_CODE_VOID
:
5105 printf_filtered ("(TYPE_CODE_VOID)");
5108 printf_filtered ("(TYPE_CODE_SET)");
5110 case TYPE_CODE_RANGE
:
5111 printf_filtered ("(TYPE_CODE_RANGE)");
5113 case TYPE_CODE_STRING
:
5114 printf_filtered ("(TYPE_CODE_STRING)");
5116 case TYPE_CODE_ERROR
:
5117 printf_filtered ("(TYPE_CODE_ERROR)");
5119 case TYPE_CODE_MEMBERPTR
:
5120 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
5122 case TYPE_CODE_METHODPTR
:
5123 printf_filtered ("(TYPE_CODE_METHODPTR)");
5125 case TYPE_CODE_METHOD
:
5126 printf_filtered ("(TYPE_CODE_METHOD)");
5129 printf_filtered ("(TYPE_CODE_REF)");
5131 case TYPE_CODE_CHAR
:
5132 printf_filtered ("(TYPE_CODE_CHAR)");
5134 case TYPE_CODE_BOOL
:
5135 printf_filtered ("(TYPE_CODE_BOOL)");
5137 case TYPE_CODE_COMPLEX
:
5138 printf_filtered ("(TYPE_CODE_COMPLEX)");
5140 case TYPE_CODE_TYPEDEF
:
5141 printf_filtered ("(TYPE_CODE_TYPEDEF)");
5143 case TYPE_CODE_NAMESPACE
:
5144 printf_filtered ("(TYPE_CODE_NAMESPACE)");
5146 case TYPE_CODE_FIXED_POINT
:
5147 printf_filtered ("(TYPE_CODE_FIXED_POINT)");
5150 printf_filtered ("(UNKNOWN TYPE CODE)");
5153 puts_filtered ("\n");
5154 printfi_filtered (spaces
, "length %s\n", pulongest (TYPE_LENGTH (type
)));
5155 if (TYPE_OBJFILE_OWNED (type
))
5157 printfi_filtered (spaces
, "objfile ");
5158 gdb_print_host_address (TYPE_OWNER (type
).objfile
, gdb_stdout
);
5162 printfi_filtered (spaces
, "gdbarch ");
5163 gdb_print_host_address (TYPE_OWNER (type
).gdbarch
, gdb_stdout
);
5165 printf_filtered ("\n");
5166 printfi_filtered (spaces
, "target_type ");
5167 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
5168 printf_filtered ("\n");
5169 if (TYPE_TARGET_TYPE (type
) != NULL
)
5171 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
5173 printfi_filtered (spaces
, "pointer_type ");
5174 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
5175 printf_filtered ("\n");
5176 printfi_filtered (spaces
, "reference_type ");
5177 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
5178 printf_filtered ("\n");
5179 printfi_filtered (spaces
, "type_chain ");
5180 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
5181 printf_filtered ("\n");
5182 printfi_filtered (spaces
, "instance_flags 0x%x",
5183 (unsigned) type
->instance_flags ());
5184 if (TYPE_CONST (type
))
5186 puts_filtered (" TYPE_CONST");
5188 if (TYPE_VOLATILE (type
))
5190 puts_filtered (" TYPE_VOLATILE");
5192 if (TYPE_CODE_SPACE (type
))
5194 puts_filtered (" TYPE_CODE_SPACE");
5196 if (TYPE_DATA_SPACE (type
))
5198 puts_filtered (" TYPE_DATA_SPACE");
5200 if (TYPE_ADDRESS_CLASS_1 (type
))
5202 puts_filtered (" TYPE_ADDRESS_CLASS_1");
5204 if (TYPE_ADDRESS_CLASS_2 (type
))
5206 puts_filtered (" TYPE_ADDRESS_CLASS_2");
5208 if (TYPE_RESTRICT (type
))
5210 puts_filtered (" TYPE_RESTRICT");
5212 if (TYPE_ATOMIC (type
))
5214 puts_filtered (" TYPE_ATOMIC");
5216 puts_filtered ("\n");
5218 printfi_filtered (spaces
, "flags");
5219 if (type
->is_unsigned ())
5221 puts_filtered (" TYPE_UNSIGNED");
5223 if (type
->has_no_signedness ())
5225 puts_filtered (" TYPE_NOSIGN");
5227 if (type
->endianity_is_not_default ())
5229 puts_filtered (" TYPE_ENDIANITY_NOT_DEFAULT");
5231 if (type
->is_stub ())
5233 puts_filtered (" TYPE_STUB");
5235 if (type
->target_is_stub ())
5237 puts_filtered (" TYPE_TARGET_STUB");
5239 if (type
->is_prototyped ())
5241 puts_filtered (" TYPE_PROTOTYPED");
5243 if (type
->has_varargs ())
5245 puts_filtered (" TYPE_VARARGS");
5247 /* This is used for things like AltiVec registers on ppc. Gcc emits
5248 an attribute for the array type, which tells whether or not we
5249 have a vector, instead of a regular array. */
5250 if (type
->is_vector ())
5252 puts_filtered (" TYPE_VECTOR");
5254 if (type
->is_fixed_instance ())
5256 puts_filtered (" TYPE_FIXED_INSTANCE");
5258 if (type
->stub_is_supported ())
5260 puts_filtered (" TYPE_STUB_SUPPORTED");
5262 if (TYPE_NOTTEXT (type
))
5264 puts_filtered (" TYPE_NOTTEXT");
5266 puts_filtered ("\n");
5267 printfi_filtered (spaces
, "nfields %d ", type
->num_fields ());
5268 gdb_print_host_address (type
->fields (), gdb_stdout
);
5269 puts_filtered ("\n");
5270 for (idx
= 0; idx
< type
->num_fields (); idx
++)
5272 if (type
->code () == TYPE_CODE_ENUM
)
5273 printfi_filtered (spaces
+ 2,
5274 "[%d] enumval %s type ",
5275 idx
, plongest (TYPE_FIELD_ENUMVAL (type
, idx
)));
5277 printfi_filtered (spaces
+ 2,
5278 "[%d] bitpos %s bitsize %d type ",
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 printfi_filtered (spaces
, "low ");
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 printfi_filtered (spaces
, "cplus_stuff ");
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 printfi_filtered (spaces
, "gnat_stuff ");
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 printfi_filtered (spaces
, "floatformat ");
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 printfi_filtered (spaces
, "calling_convention %d\n",
5331 TYPE_CALLING_CONVENTION (type
));
5332 /* tail_call_list is not printed. */
5335 case TYPE_SPECIFIC_SELF_TYPE
:
5336 printfi_filtered (spaces
, "self_type ");
5337 gdb_print_host_address (TYPE_SELF_TYPE (type
), gdb_stdout
);
5338 puts_filtered ("\n");
5341 case TYPE_SPECIFIC_FIXED_POINT
:
5342 printfi_filtered (spaces
, "fixed_point_info ");
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 printfi_filtered (spaces
, " bit size = %u, bit offset = %u\n",
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
);