1 /* Support routines for manipulating internal types for GDB.
3 Copyright (C) 1992-2021 Free Software Foundation, Inc.
5 Contributed by Cygnus Support, using pieces from other GDB modules.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
28 #include "expression.h"
33 #include "complaints.h"
37 #include "cp-support.h"
39 #include "dwarf2/loc.h"
41 #include "floatformat.h"
44 #include "gmp-utils.h"
46 /* Initialize BADNESS constants. */
48 const struct rank LENGTH_MISMATCH_BADNESS
= {100,0};
50 const struct rank TOO_FEW_PARAMS_BADNESS
= {100,0};
51 const struct rank INCOMPATIBLE_TYPE_BADNESS
= {100,0};
53 const struct rank EXACT_MATCH_BADNESS
= {0,0};
55 const struct rank INTEGER_PROMOTION_BADNESS
= {1,0};
56 const struct rank FLOAT_PROMOTION_BADNESS
= {1,0};
57 const struct rank BASE_PTR_CONVERSION_BADNESS
= {1,0};
58 const struct rank CV_CONVERSION_BADNESS
= {1, 0};
59 const struct rank INTEGER_CONVERSION_BADNESS
= {2,0};
60 const struct rank FLOAT_CONVERSION_BADNESS
= {2,0};
61 const struct rank INT_FLOAT_CONVERSION_BADNESS
= {2,0};
62 const struct rank VOID_PTR_CONVERSION_BADNESS
= {2,0};
63 const struct rank BOOL_CONVERSION_BADNESS
= {3,0};
64 const struct rank BASE_CONVERSION_BADNESS
= {2,0};
65 const struct rank REFERENCE_CONVERSION_BADNESS
= {2,0};
66 const struct rank REFERENCE_SEE_THROUGH_BADNESS
= {0,1};
67 const struct rank NULL_POINTER_CONVERSION_BADNESS
= {2,0};
68 const struct rank NS_POINTER_CONVERSION_BADNESS
= {10,0};
69 const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS
= {3,0};
71 /* Floatformat pairs. */
72 const struct floatformat
*floatformats_ieee_half
[BFD_ENDIAN_UNKNOWN
] = {
73 &floatformat_ieee_half_big
,
74 &floatformat_ieee_half_little
76 const struct floatformat
*floatformats_ieee_single
[BFD_ENDIAN_UNKNOWN
] = {
77 &floatformat_ieee_single_big
,
78 &floatformat_ieee_single_little
80 const struct floatformat
*floatformats_ieee_double
[BFD_ENDIAN_UNKNOWN
] = {
81 &floatformat_ieee_double_big
,
82 &floatformat_ieee_double_little
84 const struct floatformat
*floatformats_ieee_double_littlebyte_bigword
[BFD_ENDIAN_UNKNOWN
] = {
85 &floatformat_ieee_double_big
,
86 &floatformat_ieee_double_littlebyte_bigword
88 const struct floatformat
*floatformats_i387_ext
[BFD_ENDIAN_UNKNOWN
] = {
89 &floatformat_i387_ext
,
92 const struct floatformat
*floatformats_m68881_ext
[BFD_ENDIAN_UNKNOWN
] = {
93 &floatformat_m68881_ext
,
94 &floatformat_m68881_ext
96 const struct floatformat
*floatformats_arm_ext
[BFD_ENDIAN_UNKNOWN
] = {
97 &floatformat_arm_ext_big
,
98 &floatformat_arm_ext_littlebyte_bigword
100 const struct floatformat
*floatformats_ia64_spill
[BFD_ENDIAN_UNKNOWN
] = {
101 &floatformat_ia64_spill_big
,
102 &floatformat_ia64_spill_little
104 const struct floatformat
*floatformats_ia64_quad
[BFD_ENDIAN_UNKNOWN
] = {
105 &floatformat_ia64_quad_big
,
106 &floatformat_ia64_quad_little
108 const struct floatformat
*floatformats_vax_f
[BFD_ENDIAN_UNKNOWN
] = {
112 const struct floatformat
*floatformats_vax_d
[BFD_ENDIAN_UNKNOWN
] = {
116 const struct floatformat
*floatformats_ibm_long_double
[BFD_ENDIAN_UNKNOWN
] = {
117 &floatformat_ibm_long_double_big
,
118 &floatformat_ibm_long_double_little
120 const struct floatformat
*floatformats_bfloat16
[BFD_ENDIAN_UNKNOWN
] = {
121 &floatformat_bfloat16_big
,
122 &floatformat_bfloat16_little
125 /* Should opaque types be resolved? */
127 static bool opaque_type_resolution
= true;
129 /* See gdbtypes.h. */
131 unsigned int overload_debug
= 0;
133 /* A flag to enable strict type checking. */
135 static bool strict_type_checking
= true;
137 /* A function to show whether opaque types are resolved. */
140 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
141 struct cmd_list_element
*c
,
144 fprintf_filtered (file
, _("Resolution of opaque struct/class/union types "
145 "(if set before loading symbols) is %s.\n"),
149 /* A function to show whether C++ overload debugging is enabled. */
152 show_overload_debug (struct ui_file
*file
, int from_tty
,
153 struct cmd_list_element
*c
, const char *value
)
155 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"),
159 /* A function to show the status of strict type checking. */
162 show_strict_type_checking (struct ui_file
*file
, int from_tty
,
163 struct cmd_list_element
*c
, const char *value
)
165 fprintf_filtered (file
, _("Strict type checking is %s.\n"), value
);
169 /* Allocate a new OBJFILE-associated type structure and fill it
170 with some defaults. Space for the type structure is allocated
171 on the objfile's objfile_obstack. */
174 alloc_type (struct objfile
*objfile
)
178 gdb_assert (objfile
!= NULL
);
180 /* Alloc the structure and start off with all fields zeroed. */
181 type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct type
);
182 TYPE_MAIN_TYPE (type
) = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
184 OBJSTAT (objfile
, n_types
++);
186 TYPE_OBJFILE_OWNED (type
) = 1;
187 TYPE_OWNER (type
).objfile
= objfile
;
189 /* Initialize the fields that might not be zero. */
191 type
->set_code (TYPE_CODE_UNDEF
);
192 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
197 /* Allocate a new GDBARCH-associated type structure and fill it
198 with some defaults. Space for the type structure is allocated
199 on the obstack associated with GDBARCH. */
202 alloc_type_arch (struct gdbarch
*gdbarch
)
206 gdb_assert (gdbarch
!= NULL
);
208 /* Alloc the structure and start off with all fields zeroed. */
210 type
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct type
);
211 TYPE_MAIN_TYPE (type
) = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct main_type
);
213 TYPE_OBJFILE_OWNED (type
) = 0;
214 TYPE_OWNER (type
).gdbarch
= gdbarch
;
216 /* Initialize the fields that might not be zero. */
218 type
->set_code (TYPE_CODE_UNDEF
);
219 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
224 /* If TYPE is objfile-associated, allocate a new type structure
225 associated with the same objfile. If TYPE is gdbarch-associated,
226 allocate a new type structure associated with the same gdbarch. */
229 alloc_type_copy (const struct type
*type
)
231 if (TYPE_OBJFILE_OWNED (type
))
232 return alloc_type (TYPE_OWNER (type
).objfile
);
234 return alloc_type_arch (TYPE_OWNER (type
).gdbarch
);
237 /* If TYPE is gdbarch-associated, return that architecture.
238 If TYPE is objfile-associated, return that objfile's architecture. */
241 get_type_arch (const struct type
*type
)
243 struct gdbarch
*arch
;
245 if (TYPE_OBJFILE_OWNED (type
))
246 arch
= TYPE_OWNER (type
).objfile
->arch ();
248 arch
= TYPE_OWNER (type
).gdbarch
;
250 /* The ARCH can be NULL if TYPE is associated with neither an objfile nor
251 a gdbarch, however, this is very rare, and even then, in most cases
252 that get_type_arch is called, we assume that a non-NULL value is
254 gdb_assert (arch
!= NULL
);
258 /* See gdbtypes.h. */
261 get_target_type (struct type
*type
)
265 type
= TYPE_TARGET_TYPE (type
);
267 type
= check_typedef (type
);
273 /* See gdbtypes.h. */
276 type_length_units (struct type
*type
)
278 struct gdbarch
*arch
= get_type_arch (type
);
279 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
281 return TYPE_LENGTH (type
) / unit_size
;
284 /* Alloc a new type instance structure, fill it with some defaults,
285 and point it at OLDTYPE. Allocate the new type instance from the
286 same place as OLDTYPE. */
289 alloc_type_instance (struct type
*oldtype
)
293 /* Allocate the structure. */
295 if (! TYPE_OBJFILE_OWNED (oldtype
))
296 type
= GDBARCH_OBSTACK_ZALLOC (get_type_arch (oldtype
), struct type
);
298 type
= OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype
)->objfile_obstack
,
301 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
303 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
308 /* Clear all remnants of the previous type at TYPE, in preparation for
309 replacing it with something else. Preserve owner information. */
312 smash_type (struct type
*type
)
314 int objfile_owned
= TYPE_OBJFILE_OWNED (type
);
315 union type_owner owner
= TYPE_OWNER (type
);
317 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
319 /* Restore owner information. */
320 TYPE_OBJFILE_OWNED (type
) = objfile_owned
;
321 TYPE_OWNER (type
) = owner
;
323 /* For now, delete the rings. */
324 TYPE_CHAIN (type
) = type
;
326 /* For now, leave the pointer/reference types alone. */
329 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
330 to a pointer to memory where the pointer type should be stored.
331 If *TYPEPTR is zero, update it to point to the pointer type we return.
332 We allocate new memory if needed. */
335 make_pointer_type (struct type
*type
, struct type
**typeptr
)
337 struct type
*ntype
; /* New type */
340 ntype
= TYPE_POINTER_TYPE (type
);
345 return ntype
; /* Don't care about alloc,
346 and have new type. */
347 else if (*typeptr
== 0)
349 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
354 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
356 ntype
= alloc_type_copy (type
);
360 else /* We have storage, but need to reset it. */
363 chain
= TYPE_CHAIN (ntype
);
365 TYPE_CHAIN (ntype
) = chain
;
368 TYPE_TARGET_TYPE (ntype
) = type
;
369 TYPE_POINTER_TYPE (type
) = ntype
;
371 /* FIXME! Assumes the machine has only one representation for pointers! */
374 = gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
375 ntype
->set_code (TYPE_CODE_PTR
);
377 /* Mark pointers as unsigned. The target converts between pointers
378 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
379 gdbarch_address_to_pointer. */
380 ntype
->set_is_unsigned (true);
382 /* Update the length of all the other variants of this type. */
383 chain
= TYPE_CHAIN (ntype
);
384 while (chain
!= ntype
)
386 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
387 chain
= TYPE_CHAIN (chain
);
393 /* Given a type TYPE, return a type of pointers to that type.
394 May need to construct such a type if this is the first use. */
397 lookup_pointer_type (struct type
*type
)
399 return make_pointer_type (type
, (struct type
**) 0);
402 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
403 points to a pointer to memory where the reference type should be
404 stored. If *TYPEPTR is zero, update it to point to the reference
405 type we return. We allocate new memory if needed. REFCODE denotes
406 the kind of reference type to lookup (lvalue or rvalue reference). */
409 make_reference_type (struct type
*type
, struct type
**typeptr
,
410 enum type_code refcode
)
412 struct type
*ntype
; /* New type */
413 struct type
**reftype
;
416 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
418 ntype
= (refcode
== TYPE_CODE_REF
? TYPE_REFERENCE_TYPE (type
)
419 : TYPE_RVALUE_REFERENCE_TYPE (type
));
424 return ntype
; /* Don't care about alloc,
425 and have new type. */
426 else if (*typeptr
== 0)
428 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
433 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
435 ntype
= alloc_type_copy (type
);
439 else /* We have storage, but need to reset it. */
442 chain
= TYPE_CHAIN (ntype
);
444 TYPE_CHAIN (ntype
) = chain
;
447 TYPE_TARGET_TYPE (ntype
) = type
;
448 reftype
= (refcode
== TYPE_CODE_REF
? &TYPE_REFERENCE_TYPE (type
)
449 : &TYPE_RVALUE_REFERENCE_TYPE (type
));
453 /* FIXME! Assume the machine has only one representation for
454 references, and that it matches the (only) representation for
457 TYPE_LENGTH (ntype
) =
458 gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
459 ntype
->set_code (refcode
);
463 /* Update the length of all the other variants of this type. */
464 chain
= TYPE_CHAIN (ntype
);
465 while (chain
!= ntype
)
467 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
468 chain
= TYPE_CHAIN (chain
);
474 /* Same as above, but caller doesn't care about memory allocation
478 lookup_reference_type (struct type
*type
, enum type_code refcode
)
480 return make_reference_type (type
, (struct type
**) 0, refcode
);
483 /* Lookup the lvalue reference type for the type TYPE. */
486 lookup_lvalue_reference_type (struct type
*type
)
488 return lookup_reference_type (type
, TYPE_CODE_REF
);
491 /* Lookup the rvalue reference type for the type TYPE. */
494 lookup_rvalue_reference_type (struct type
*type
)
496 return lookup_reference_type (type
, TYPE_CODE_RVALUE_REF
);
499 /* Lookup a function type that returns type TYPE. TYPEPTR, if
500 nonzero, points to a pointer to memory where the function type
501 should be stored. If *TYPEPTR is zero, update it to point to the
502 function type we return. We allocate new memory if needed. */
505 make_function_type (struct type
*type
, struct type
**typeptr
)
507 struct type
*ntype
; /* New type */
509 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
511 ntype
= alloc_type_copy (type
);
515 else /* We have storage, but need to reset it. */
521 TYPE_TARGET_TYPE (ntype
) = type
;
523 TYPE_LENGTH (ntype
) = 1;
524 ntype
->set_code (TYPE_CODE_FUNC
);
526 INIT_FUNC_SPECIFIC (ntype
);
531 /* Given a type TYPE, return a type of functions that return that type.
532 May need to construct such a type if this is the first use. */
535 lookup_function_type (struct type
*type
)
537 return make_function_type (type
, (struct type
**) 0);
540 /* Given a type TYPE and argument types, return the appropriate
541 function type. If the final type in PARAM_TYPES is NULL, make a
545 lookup_function_type_with_arguments (struct type
*type
,
547 struct type
**param_types
)
549 struct type
*fn
= make_function_type (type
, (struct type
**) 0);
554 if (param_types
[nparams
- 1] == NULL
)
557 fn
->set_has_varargs (true);
559 else if (check_typedef (param_types
[nparams
- 1])->code ()
563 /* Caller should have ensured this. */
564 gdb_assert (nparams
== 0);
565 fn
->set_is_prototyped (true);
568 fn
->set_is_prototyped (true);
571 fn
->set_num_fields (nparams
);
573 ((struct field
*) TYPE_ZALLOC (fn
, nparams
* sizeof (struct field
)));
574 for (i
= 0; i
< nparams
; ++i
)
575 fn
->field (i
).set_type (param_types
[i
]);
580 /* Identify address space identifier by name -- return a
581 type_instance_flags. */
584 address_space_name_to_type_instance_flags (struct gdbarch
*gdbarch
,
585 const char *space_identifier
)
587 type_instance_flags type_flags
;
589 /* Check for known address space delimiters. */
590 if (!strcmp (space_identifier
, "code"))
591 return TYPE_INSTANCE_FLAG_CODE_SPACE
;
592 else if (!strcmp (space_identifier
, "data"))
593 return TYPE_INSTANCE_FLAG_DATA_SPACE
;
594 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
595 && gdbarch_address_class_name_to_type_flags (gdbarch
,
600 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
603 /* Identify address space identifier by type_instance_flags and return
604 the string version of the adress space name. */
607 address_space_type_instance_flags_to_name (struct gdbarch
*gdbarch
,
608 type_instance_flags space_flag
)
610 if (space_flag
& TYPE_INSTANCE_FLAG_CODE_SPACE
)
612 else if (space_flag
& TYPE_INSTANCE_FLAG_DATA_SPACE
)
614 else if ((space_flag
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
615 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
616 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
621 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
623 If STORAGE is non-NULL, create the new type instance there.
624 STORAGE must be in the same obstack as TYPE. */
627 make_qualified_type (struct type
*type
, type_instance_flags new_flags
,
628 struct type
*storage
)
635 if (ntype
->instance_flags () == new_flags
)
637 ntype
= TYPE_CHAIN (ntype
);
639 while (ntype
!= type
);
641 /* Create a new type instance. */
643 ntype
= alloc_type_instance (type
);
646 /* If STORAGE was provided, it had better be in the same objfile
647 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
648 if one objfile is freed and the other kept, we'd have
649 dangling pointers. */
650 gdb_assert (TYPE_OBJFILE (type
) == TYPE_OBJFILE (storage
));
653 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
654 TYPE_CHAIN (ntype
) = ntype
;
657 /* Pointers or references to the original type are not relevant to
659 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
660 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
662 /* Chain the new qualified type to the old type. */
663 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
664 TYPE_CHAIN (type
) = ntype
;
666 /* Now set the instance flags and return the new type. */
667 ntype
->set_instance_flags (new_flags
);
669 /* Set length of new type to that of the original type. */
670 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
675 /* Make an address-space-delimited variant of a type -- a type that
676 is identical to the one supplied except that it has an address
677 space attribute attached to it (such as "code" or "data").
679 The space attributes "code" and "data" are for Harvard
680 architectures. The address space attributes are for architectures
681 which have alternately sized pointers or pointers with alternate
685 make_type_with_address_space (struct type
*type
,
686 type_instance_flags space_flag
)
688 type_instance_flags new_flags
= ((type
->instance_flags ()
689 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
690 | TYPE_INSTANCE_FLAG_DATA_SPACE
691 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
))
694 return make_qualified_type (type
, new_flags
, NULL
);
697 /* Make a "c-v" variant of a type -- a type that is identical to the
698 one supplied except that it may have const or volatile attributes
699 CNST is a flag for setting the const attribute
700 VOLTL is a flag for setting the volatile attribute
701 TYPE is the base type whose variant we are creating.
703 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
704 storage to hold the new qualified type; *TYPEPTR and TYPE must be
705 in the same objfile. Otherwise, allocate fresh memory for the new
706 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
707 new type we construct. */
710 make_cv_type (int cnst
, int voltl
,
712 struct type
**typeptr
)
714 struct type
*ntype
; /* New type */
716 type_instance_flags new_flags
= (type
->instance_flags ()
717 & ~(TYPE_INSTANCE_FLAG_CONST
718 | TYPE_INSTANCE_FLAG_VOLATILE
));
721 new_flags
|= TYPE_INSTANCE_FLAG_CONST
;
724 new_flags
|= TYPE_INSTANCE_FLAG_VOLATILE
;
726 if (typeptr
&& *typeptr
!= NULL
)
728 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
729 a C-V variant chain that threads across objfiles: if one
730 objfile gets freed, then the other has a broken C-V chain.
732 This code used to try to copy over the main type from TYPE to
733 *TYPEPTR if they were in different objfiles, but that's
734 wrong, too: TYPE may have a field list or member function
735 lists, which refer to types of their own, etc. etc. The
736 whole shebang would need to be copied over recursively; you
737 can't have inter-objfile pointers. The only thing to do is
738 to leave stub types as stub types, and look them up afresh by
739 name each time you encounter them. */
740 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
));
743 ntype
= make_qualified_type (type
, new_flags
,
744 typeptr
? *typeptr
: NULL
);
752 /* Make a 'restrict'-qualified version of TYPE. */
755 make_restrict_type (struct type
*type
)
757 return make_qualified_type (type
,
758 (type
->instance_flags ()
759 | TYPE_INSTANCE_FLAG_RESTRICT
),
763 /* Make a type without const, volatile, or restrict. */
766 make_unqualified_type (struct type
*type
)
768 return make_qualified_type (type
,
769 (type
->instance_flags ()
770 & ~(TYPE_INSTANCE_FLAG_CONST
771 | TYPE_INSTANCE_FLAG_VOLATILE
772 | TYPE_INSTANCE_FLAG_RESTRICT
)),
776 /* Make a '_Atomic'-qualified version of TYPE. */
779 make_atomic_type (struct type
*type
)
781 return make_qualified_type (type
,
782 (type
->instance_flags ()
783 | TYPE_INSTANCE_FLAG_ATOMIC
),
787 /* Replace the contents of ntype with the type *type. This changes the
788 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
789 the changes are propogated to all types in the TYPE_CHAIN.
791 In order to build recursive types, it's inevitable that we'll need
792 to update types in place --- but this sort of indiscriminate
793 smashing is ugly, and needs to be replaced with something more
794 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
795 clear if more steps are needed. */
798 replace_type (struct type
*ntype
, struct type
*type
)
802 /* These two types had better be in the same objfile. Otherwise,
803 the assignment of one type's main type structure to the other
804 will produce a type with references to objects (names; field
805 lists; etc.) allocated on an objfile other than its own. */
806 gdb_assert (TYPE_OBJFILE (ntype
) == TYPE_OBJFILE (type
));
808 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
810 /* The type length is not a part of the main type. Update it for
811 each type on the variant chain. */
815 /* Assert that this element of the chain has no address-class bits
816 set in its flags. Such type variants might have type lengths
817 which are supposed to be different from the non-address-class
818 variants. This assertion shouldn't ever be triggered because
819 symbol readers which do construct address-class variants don't
820 call replace_type(). */
821 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
823 TYPE_LENGTH (chain
) = TYPE_LENGTH (type
);
824 chain
= TYPE_CHAIN (chain
);
826 while (ntype
!= chain
);
828 /* Assert that the two types have equivalent instance qualifiers.
829 This should be true for at least all of our debug readers. */
830 gdb_assert (ntype
->instance_flags () == type
->instance_flags ());
833 /* Implement direct support for MEMBER_TYPE in GNU C++.
834 May need to construct such a type if this is the first use.
835 The TYPE is the type of the member. The DOMAIN is the type
836 of the aggregate that the member belongs to. */
839 lookup_memberptr_type (struct type
*type
, struct type
*domain
)
843 mtype
= alloc_type_copy (type
);
844 smash_to_memberptr_type (mtype
, domain
, type
);
848 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
851 lookup_methodptr_type (struct type
*to_type
)
855 mtype
= alloc_type_copy (to_type
);
856 smash_to_methodptr_type (mtype
, to_type
);
860 /* Allocate a stub method whose return type is TYPE. This apparently
861 happens for speed of symbol reading, since parsing out the
862 arguments to the method is cpu-intensive, the way we are doing it.
863 So, we will fill in arguments later. This always returns a fresh
867 allocate_stub_method (struct type
*type
)
871 mtype
= alloc_type_copy (type
);
872 mtype
->set_code (TYPE_CODE_METHOD
);
873 TYPE_LENGTH (mtype
) = 1;
874 mtype
->set_is_stub (true);
875 TYPE_TARGET_TYPE (mtype
) = type
;
876 /* TYPE_SELF_TYPE (mtype) = unknown yet */
880 /* See gdbtypes.h. */
883 operator== (const dynamic_prop
&l
, const dynamic_prop
&r
)
885 if (l
.kind () != r
.kind ())
893 return l
.const_val () == r
.const_val ();
894 case PROP_ADDR_OFFSET
:
897 return l
.baton () == r
.baton ();
898 case PROP_VARIANT_PARTS
:
899 return l
.variant_parts () == r
.variant_parts ();
901 return l
.original_type () == r
.original_type ();
904 gdb_assert_not_reached ("unhandled dynamic_prop kind");
907 /* See gdbtypes.h. */
910 operator== (const range_bounds
&l
, const range_bounds
&r
)
912 #define FIELD_EQ(FIELD) (l.FIELD == r.FIELD)
914 return (FIELD_EQ (low
)
916 && FIELD_EQ (flag_upper_bound_is_count
)
917 && FIELD_EQ (flag_bound_evaluated
)
923 /* Create a range type with a dynamic range from LOW_BOUND to
924 HIGH_BOUND, inclusive. See create_range_type for further details. */
927 create_range_type (struct type
*result_type
, struct type
*index_type
,
928 const struct dynamic_prop
*low_bound
,
929 const struct dynamic_prop
*high_bound
,
932 /* The INDEX_TYPE should be a type capable of holding the upper and lower
933 bounds, as such a zero sized, or void type makes no sense. */
934 gdb_assert (index_type
->code () != TYPE_CODE_VOID
);
935 gdb_assert (TYPE_LENGTH (index_type
) > 0);
937 if (result_type
== NULL
)
938 result_type
= alloc_type_copy (index_type
);
939 result_type
->set_code (TYPE_CODE_RANGE
);
940 TYPE_TARGET_TYPE (result_type
) = index_type
;
941 if (index_type
->is_stub ())
942 result_type
->set_target_is_stub (true);
944 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
947 = (struct range_bounds
*) TYPE_ZALLOC (result_type
, sizeof (range_bounds
));
948 bounds
->low
= *low_bound
;
949 bounds
->high
= *high_bound
;
951 bounds
->stride
.set_const_val (0);
953 result_type
->set_bounds (bounds
);
955 if (index_type
->code () == TYPE_CODE_FIXED_POINT
)
956 result_type
->set_is_unsigned (index_type
->is_unsigned ());
957 /* Note that the signed-ness of a range type can't simply be copied
958 from the underlying type. Consider a case where the underlying
959 type is 'int', but the range type can hold 0..65535, and where
960 the range is further specified to fit into 16 bits. In this
961 case, if we copy the underlying type's sign, then reading some
962 range values will cause an unwanted sign extension. So, we have
963 some heuristics here instead. */
964 else if (low_bound
->kind () == PROP_CONST
&& low_bound
->const_val () >= 0)
965 result_type
->set_is_unsigned (true);
966 /* Ada allows the declaration of range types whose upper bound is
967 less than the lower bound, so checking the lower bound is not
968 enough. Make sure we do not mark a range type whose upper bound
969 is negative as unsigned. */
970 if (high_bound
->kind () == PROP_CONST
&& high_bound
->const_val () < 0)
971 result_type
->set_is_unsigned (false);
973 result_type
->set_endianity_is_not_default
974 (index_type
->endianity_is_not_default ());
979 /* See gdbtypes.h. */
982 create_range_type_with_stride (struct type
*result_type
,
983 struct type
*index_type
,
984 const struct dynamic_prop
*low_bound
,
985 const struct dynamic_prop
*high_bound
,
987 const struct dynamic_prop
*stride
,
990 result_type
= create_range_type (result_type
, index_type
, low_bound
,
993 gdb_assert (stride
!= nullptr);
994 result_type
->bounds ()->stride
= *stride
;
995 result_type
->bounds ()->flag_is_byte_stride
= byte_stride_p
;
1002 /* Create a range type using either a blank type supplied in
1003 RESULT_TYPE, or creating a new type, inheriting the objfile from
1006 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
1007 to HIGH_BOUND, inclusive.
1009 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1010 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
1013 create_static_range_type (struct type
*result_type
, struct type
*index_type
,
1014 LONGEST low_bound
, LONGEST high_bound
)
1016 struct dynamic_prop low
, high
;
1018 low
.set_const_val (low_bound
);
1019 high
.set_const_val (high_bound
);
1021 result_type
= create_range_type (result_type
, index_type
, &low
, &high
, 0);
1026 /* Predicate tests whether BOUNDS are static. Returns 1 if all bounds values
1027 are static, otherwise returns 0. */
1030 has_static_range (const struct range_bounds
*bounds
)
1032 /* If the range doesn't have a defined stride then its stride field will
1033 be initialized to the constant 0. */
1034 return (bounds
->low
.kind () == PROP_CONST
1035 && bounds
->high
.kind () == PROP_CONST
1036 && bounds
->stride
.kind () == PROP_CONST
);
1039 /* See gdbtypes.h. */
1041 gdb::optional
<LONGEST
>
1042 get_discrete_low_bound (struct type
*type
)
1044 type
= check_typedef (type
);
1045 switch (type
->code ())
1047 case TYPE_CODE_RANGE
:
1049 /* This function only works for ranges with a constant low bound. */
1050 if (type
->bounds ()->low
.kind () != PROP_CONST
)
1053 LONGEST low
= type
->bounds ()->low
.const_val ();
1055 if (TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_ENUM
)
1057 gdb::optional
<LONGEST
> low_pos
1058 = discrete_position (TYPE_TARGET_TYPE (type
), low
);
1060 if (low_pos
.has_value ())
1067 case TYPE_CODE_ENUM
:
1069 if (type
->num_fields () > 0)
1071 /* The enums may not be sorted by value, so search all
1073 LONGEST low
= TYPE_FIELD_ENUMVAL (type
, 0);
1075 for (int i
= 0; i
< type
->num_fields (); i
++)
1077 if (TYPE_FIELD_ENUMVAL (type
, i
) < low
)
1078 low
= TYPE_FIELD_ENUMVAL (type
, i
);
1081 /* Set unsigned indicator if warranted. */
1083 type
->set_is_unsigned (true);
1091 case TYPE_CODE_BOOL
:
1095 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
1098 if (!type
->is_unsigned ())
1099 return -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
1102 case TYPE_CODE_CHAR
:
1110 /* See gdbtypes.h. */
1112 gdb::optional
<LONGEST
>
1113 get_discrete_high_bound (struct type
*type
)
1115 type
= check_typedef (type
);
1116 switch (type
->code ())
1118 case TYPE_CODE_RANGE
:
1120 /* This function only works for ranges with a constant high bound. */
1121 if (type
->bounds ()->high
.kind () != PROP_CONST
)
1124 LONGEST high
= type
->bounds ()->high
.const_val ();
1126 if (TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_ENUM
)
1128 gdb::optional
<LONGEST
> high_pos
1129 = discrete_position (TYPE_TARGET_TYPE (type
), high
);
1131 if (high_pos
.has_value ())
1138 case TYPE_CODE_ENUM
:
1140 if (type
->num_fields () > 0)
1142 /* The enums may not be sorted by value, so search all
1144 LONGEST high
= TYPE_FIELD_ENUMVAL (type
, 0);
1146 for (int i
= 0; i
< type
->num_fields (); i
++)
1148 if (TYPE_FIELD_ENUMVAL (type
, i
) > high
)
1149 high
= TYPE_FIELD_ENUMVAL (type
, i
);
1158 case TYPE_CODE_BOOL
:
1162 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
1165 if (!type
->is_unsigned ())
1167 LONGEST low
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
1172 case TYPE_CODE_CHAR
:
1174 /* This round-about calculation is to avoid shifting by
1175 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
1176 if TYPE_LENGTH (type) == sizeof (LONGEST). */
1177 LONGEST high
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
1178 return (high
- 1) | high
;
1186 /* See gdbtypes.h. */
1189 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
1191 gdb::optional
<LONGEST
> low
= get_discrete_low_bound (type
);
1192 if (!low
.has_value ())
1195 gdb::optional
<LONGEST
> high
= get_discrete_high_bound (type
);
1196 if (!high
.has_value ())
1205 /* See gdbtypes.h */
1208 get_array_bounds (struct type
*type
, LONGEST
*low_bound
, LONGEST
*high_bound
)
1210 struct type
*index
= type
->index_type ();
1217 if (!get_discrete_bounds (index
, &low
, &high
))
1229 /* Assuming that TYPE is a discrete type and VAL is a valid integer
1230 representation of a value of this type, save the corresponding
1231 position number in POS.
1233 Its differs from VAL only in the case of enumeration types. In
1234 this case, the position number of the value of the first listed
1235 enumeration literal is zero; the position number of the value of
1236 each subsequent enumeration literal is one more than that of its
1237 predecessor in the list.
1239 Return 1 if the operation was successful. Return zero otherwise,
1240 in which case the value of POS is unmodified.
1243 gdb::optional
<LONGEST
>
1244 discrete_position (struct type
*type
, LONGEST val
)
1246 if (type
->code () == TYPE_CODE_RANGE
)
1247 type
= TYPE_TARGET_TYPE (type
);
1249 if (type
->code () == TYPE_CODE_ENUM
)
1253 for (i
= 0; i
< type
->num_fields (); i
+= 1)
1255 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
1259 /* Invalid enumeration value. */
1266 /* If the array TYPE has static bounds calculate and update its
1267 size, then return true. Otherwise return false and leave TYPE
1271 update_static_array_size (struct type
*type
)
1273 gdb_assert (type
->code () == TYPE_CODE_ARRAY
);
1275 struct type
*range_type
= type
->index_type ();
1277 if (type
->dyn_prop (DYN_PROP_BYTE_STRIDE
) == nullptr
1278 && has_static_range (range_type
->bounds ())
1279 && (!type_not_associated (type
)
1280 && !type_not_allocated (type
)))
1282 LONGEST low_bound
, high_bound
;
1284 struct type
*element_type
;
1286 /* If the array itself doesn't provide a stride value then take
1287 whatever stride the range provides. Don't update BIT_STRIDE as
1288 we don't want to place the stride value from the range into this
1289 arrays bit size field. */
1290 stride
= TYPE_FIELD_BITSIZE (type
, 0);
1292 stride
= range_type
->bit_stride ();
1294 if (!get_discrete_bounds (range_type
, &low_bound
, &high_bound
))
1295 low_bound
= high_bound
= 0;
1297 element_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1298 /* Be careful when setting the array length. Ada arrays can be
1299 empty arrays with the high_bound being smaller than the low_bound.
1300 In such cases, the array length should be zero. */
1301 if (high_bound
< low_bound
)
1302 TYPE_LENGTH (type
) = 0;
1303 else if (stride
!= 0)
1305 /* Ensure that the type length is always positive, even in the
1306 case where (for example in Fortran) we have a negative
1307 stride. It is possible to have a single element array with a
1308 negative stride in Fortran (this doesn't mean anything
1309 special, it's still just a single element array) so do
1310 consider that case when touching this code. */
1311 LONGEST element_count
= std::abs (high_bound
- low_bound
+ 1);
1313 = ((std::abs (stride
) * element_count
) + 7) / 8;
1316 TYPE_LENGTH (type
) =
1317 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
1319 /* If this array's element is itself an array with a bit stride,
1320 then we want to update this array's bit stride to reflect the
1321 size of the sub-array. Otherwise, we'll end up using the
1322 wrong size when trying to find elements of the outer
1324 if (element_type
->code () == TYPE_CODE_ARRAY
1325 && TYPE_LENGTH (element_type
) != 0
1326 && TYPE_FIELD_BITSIZE (element_type
, 0) != 0
1327 && get_array_bounds (element_type
, &low_bound
, &high_bound
)
1328 && high_bound
>= low_bound
)
1329 TYPE_FIELD_BITSIZE (type
, 0)
1330 = ((high_bound
- low_bound
+ 1)
1331 * TYPE_FIELD_BITSIZE (element_type
, 0));
1339 /* Create an array type using either a blank type supplied in
1340 RESULT_TYPE, or creating a new type, inheriting the objfile from
1343 Elements will be of type ELEMENT_TYPE, the indices will be of type
1346 BYTE_STRIDE_PROP, when not NULL, provides the array's byte stride.
1347 This byte stride property is added to the resulting array type
1348 as a DYN_PROP_BYTE_STRIDE. As a consequence, the BYTE_STRIDE_PROP
1349 argument can only be used to create types that are objfile-owned
1350 (see add_dyn_prop), meaning that either this function must be called
1351 with an objfile-owned RESULT_TYPE, or an objfile-owned RANGE_TYPE.
1353 BIT_STRIDE is taken into account only when BYTE_STRIDE_PROP is NULL.
1354 If BIT_STRIDE is not zero, build a packed array type whose element
1355 size is BIT_STRIDE. Otherwise, ignore this parameter.
1357 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1358 sure it is TYPE_CODE_UNDEF before we bash it into an array
1362 create_array_type_with_stride (struct type
*result_type
,
1363 struct type
*element_type
,
1364 struct type
*range_type
,
1365 struct dynamic_prop
*byte_stride_prop
,
1366 unsigned int bit_stride
)
1368 if (byte_stride_prop
!= NULL
1369 && byte_stride_prop
->kind () == PROP_CONST
)
1371 /* The byte stride is actually not dynamic. Pretend we were
1372 called with bit_stride set instead of byte_stride_prop.
1373 This will give us the same result type, while avoiding
1374 the need to handle this as a special case. */
1375 bit_stride
= byte_stride_prop
->const_val () * 8;
1376 byte_stride_prop
= NULL
;
1379 if (result_type
== NULL
)
1380 result_type
= alloc_type_copy (range_type
);
1382 result_type
->set_code (TYPE_CODE_ARRAY
);
1383 TYPE_TARGET_TYPE (result_type
) = element_type
;
1385 result_type
->set_num_fields (1);
1386 result_type
->set_fields
1387 ((struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
)));
1388 result_type
->set_index_type (range_type
);
1389 if (byte_stride_prop
!= NULL
)
1390 result_type
->add_dyn_prop (DYN_PROP_BYTE_STRIDE
, *byte_stride_prop
);
1391 else if (bit_stride
> 0)
1392 TYPE_FIELD_BITSIZE (result_type
, 0) = bit_stride
;
1394 if (!update_static_array_size (result_type
))
1396 /* This type is dynamic and its length needs to be computed
1397 on demand. In the meantime, avoid leaving the TYPE_LENGTH
1398 undefined by setting it to zero. Although we are not expected
1399 to trust TYPE_LENGTH in this case, setting the size to zero
1400 allows us to avoid allocating objects of random sizes in case
1401 we accidently do. */
1402 TYPE_LENGTH (result_type
) = 0;
1405 /* TYPE_TARGET_STUB will take care of zero length arrays. */
1406 if (TYPE_LENGTH (result_type
) == 0)
1407 result_type
->set_target_is_stub (true);
1412 /* Same as create_array_type_with_stride but with no bit_stride
1413 (BIT_STRIDE = 0), thus building an unpacked array. */
1416 create_array_type (struct type
*result_type
,
1417 struct type
*element_type
,
1418 struct type
*range_type
)
1420 return create_array_type_with_stride (result_type
, element_type
,
1421 range_type
, NULL
, 0);
1425 lookup_array_range_type (struct type
*element_type
,
1426 LONGEST low_bound
, LONGEST high_bound
)
1428 struct type
*index_type
;
1429 struct type
*range_type
;
1431 if (TYPE_OBJFILE_OWNED (element_type
))
1432 index_type
= objfile_type (TYPE_OWNER (element_type
).objfile
)->builtin_int
;
1434 index_type
= builtin_type (get_type_arch (element_type
))->builtin_int
;
1435 range_type
= create_static_range_type (NULL
, index_type
,
1436 low_bound
, high_bound
);
1438 return create_array_type (NULL
, element_type
, range_type
);
1441 /* Create a string type using either a blank type supplied in
1442 RESULT_TYPE, or creating a new type. String types are similar
1443 enough to array of char types that we can use create_array_type to
1444 build the basic type and then bash it into a string type.
1446 For fixed length strings, the range type contains 0 as the lower
1447 bound and the length of the string minus one as the upper bound.
1449 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1450 sure it is TYPE_CODE_UNDEF before we bash it into a string
1454 create_string_type (struct type
*result_type
,
1455 struct type
*string_char_type
,
1456 struct type
*range_type
)
1458 result_type
= create_array_type (result_type
,
1461 result_type
->set_code (TYPE_CODE_STRING
);
1466 lookup_string_range_type (struct type
*string_char_type
,
1467 LONGEST low_bound
, LONGEST high_bound
)
1469 struct type
*result_type
;
1471 result_type
= lookup_array_range_type (string_char_type
,
1472 low_bound
, high_bound
);
1473 result_type
->set_code (TYPE_CODE_STRING
);
1478 create_set_type (struct type
*result_type
, struct type
*domain_type
)
1480 if (result_type
== NULL
)
1481 result_type
= alloc_type_copy (domain_type
);
1483 result_type
->set_code (TYPE_CODE_SET
);
1484 result_type
->set_num_fields (1);
1485 result_type
->set_fields
1486 ((struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
)));
1488 if (!domain_type
->is_stub ())
1490 LONGEST low_bound
, high_bound
, bit_length
;
1492 if (!get_discrete_bounds (domain_type
, &low_bound
, &high_bound
))
1493 low_bound
= high_bound
= 0;
1495 bit_length
= high_bound
- low_bound
+ 1;
1496 TYPE_LENGTH (result_type
)
1497 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
1499 result_type
->set_is_unsigned (true);
1501 result_type
->field (0).set_type (domain_type
);
1506 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
1507 and any array types nested inside it. */
1510 make_vector_type (struct type
*array_type
)
1512 struct type
*inner_array
, *elt_type
;
1514 /* Find the innermost array type, in case the array is
1515 multi-dimensional. */
1516 inner_array
= array_type
;
1517 while (TYPE_TARGET_TYPE (inner_array
)->code () == TYPE_CODE_ARRAY
)
1518 inner_array
= TYPE_TARGET_TYPE (inner_array
);
1520 elt_type
= TYPE_TARGET_TYPE (inner_array
);
1521 if (elt_type
->code () == TYPE_CODE_INT
)
1523 type_instance_flags flags
1524 = elt_type
->instance_flags () | TYPE_INSTANCE_FLAG_NOTTEXT
;
1525 elt_type
= make_qualified_type (elt_type
, flags
, NULL
);
1526 TYPE_TARGET_TYPE (inner_array
) = elt_type
;
1529 array_type
->set_is_vector (true);
1533 init_vector_type (struct type
*elt_type
, int n
)
1535 struct type
*array_type
;
1537 array_type
= lookup_array_range_type (elt_type
, 0, n
- 1);
1538 make_vector_type (array_type
);
1542 /* Internal routine called by TYPE_SELF_TYPE to return the type that TYPE
1543 belongs to. In c++ this is the class of "this", but TYPE_THIS_TYPE is too
1544 confusing. "self" is a common enough replacement for "this".
1545 TYPE must be one of TYPE_CODE_METHODPTR, TYPE_CODE_MEMBERPTR, or
1546 TYPE_CODE_METHOD. */
1549 internal_type_self_type (struct type
*type
)
1551 switch (type
->code ())
1553 case TYPE_CODE_METHODPTR
:
1554 case TYPE_CODE_MEMBERPTR
:
1555 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1557 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_SELF_TYPE
);
1558 return TYPE_MAIN_TYPE (type
)->type_specific
.self_type
;
1559 case TYPE_CODE_METHOD
:
1560 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1562 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
1563 return TYPE_MAIN_TYPE (type
)->type_specific
.func_stuff
->self_type
;
1565 gdb_assert_not_reached ("bad type");
1569 /* Set the type of the class that TYPE belongs to.
1570 In c++ this is the class of "this".
1571 TYPE must be one of TYPE_CODE_METHODPTR, TYPE_CODE_MEMBERPTR, or
1572 TYPE_CODE_METHOD. */
1575 set_type_self_type (struct type
*type
, struct type
*self_type
)
1577 switch (type
->code ())
1579 case TYPE_CODE_METHODPTR
:
1580 case TYPE_CODE_MEMBERPTR
:
1581 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1582 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_SELF_TYPE
;
1583 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_SELF_TYPE
);
1584 TYPE_MAIN_TYPE (type
)->type_specific
.self_type
= self_type
;
1586 case TYPE_CODE_METHOD
:
1587 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1588 INIT_FUNC_SPECIFIC (type
);
1589 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
1590 TYPE_MAIN_TYPE (type
)->type_specific
.func_stuff
->self_type
= self_type
;
1593 gdb_assert_not_reached ("bad type");
1597 /* Smash TYPE to be a type of pointers to members of SELF_TYPE with type
1598 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1599 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1600 TYPE doesn't include the offset (that's the value of the MEMBER
1601 itself), but does include the structure type into which it points
1604 When "smashing" the type, we preserve the objfile that the old type
1605 pointed to, since we aren't changing where the type is actually
1609 smash_to_memberptr_type (struct type
*type
, struct type
*self_type
,
1610 struct type
*to_type
)
1613 type
->set_code (TYPE_CODE_MEMBERPTR
);
1614 TYPE_TARGET_TYPE (type
) = to_type
;
1615 set_type_self_type (type
, self_type
);
1616 /* Assume that a data member pointer is the same size as a normal
1619 = gdbarch_ptr_bit (get_type_arch (to_type
)) / TARGET_CHAR_BIT
;
1622 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1624 When "smashing" the type, we preserve the objfile that the old type
1625 pointed to, since we aren't changing where the type is actually
1629 smash_to_methodptr_type (struct type
*type
, struct type
*to_type
)
1632 type
->set_code (TYPE_CODE_METHODPTR
);
1633 TYPE_TARGET_TYPE (type
) = to_type
;
1634 set_type_self_type (type
, TYPE_SELF_TYPE (to_type
));
1635 TYPE_LENGTH (type
) = cplus_method_ptr_size (to_type
);
1638 /* Smash TYPE to be a type of method of SELF_TYPE with type TO_TYPE.
1639 METHOD just means `function that gets an extra "this" argument'.
1641 When "smashing" the type, we preserve the objfile that the old type
1642 pointed to, since we aren't changing where the type is actually
1646 smash_to_method_type (struct type
*type
, struct type
*self_type
,
1647 struct type
*to_type
, struct field
*args
,
1648 int nargs
, int varargs
)
1651 type
->set_code (TYPE_CODE_METHOD
);
1652 TYPE_TARGET_TYPE (type
) = to_type
;
1653 set_type_self_type (type
, self_type
);
1654 type
->set_fields (args
);
1655 type
->set_num_fields (nargs
);
1657 type
->set_has_varargs (true);
1658 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1661 /* A wrapper of TYPE_NAME which calls error if the type is anonymous.
1662 Since GCC PR debug/47510 DWARF provides associated information to detect the
1663 anonymous class linkage name from its typedef.
1665 Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
1669 type_name_or_error (struct type
*type
)
1671 struct type
*saved_type
= type
;
1673 struct objfile
*objfile
;
1675 type
= check_typedef (type
);
1677 name
= type
->name ();
1681 name
= saved_type
->name ();
1682 objfile
= TYPE_OBJFILE (saved_type
);
1683 error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
1684 name
? name
: "<anonymous>",
1685 objfile
? objfile_name (objfile
) : "<arch>");
1688 /* Lookup a typedef or primitive type named NAME, visible in lexical
1689 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1690 suitably defined. */
1693 lookup_typename (const struct language_defn
*language
,
1695 const struct block
*block
, int noerr
)
1699 sym
= lookup_symbol_in_language (name
, block
, VAR_DOMAIN
,
1700 language
->la_language
, NULL
).symbol
;
1701 if (sym
!= NULL
&& SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
1702 return SYMBOL_TYPE (sym
);
1706 error (_("No type named %s."), name
);
1710 lookup_unsigned_typename (const struct language_defn
*language
,
1713 char *uns
= (char *) alloca (strlen (name
) + 10);
1715 strcpy (uns
, "unsigned ");
1716 strcpy (uns
+ 9, name
);
1717 return lookup_typename (language
, uns
, NULL
, 0);
1721 lookup_signed_typename (const struct language_defn
*language
, const char *name
)
1724 char *uns
= (char *) alloca (strlen (name
) + 8);
1726 strcpy (uns
, "signed ");
1727 strcpy (uns
+ 7, name
);
1728 t
= lookup_typename (language
, uns
, NULL
, 1);
1729 /* If we don't find "signed FOO" just try again with plain "FOO". */
1732 return lookup_typename (language
, name
, NULL
, 0);
1735 /* Lookup a structure type named "struct NAME",
1736 visible in lexical block BLOCK. */
1739 lookup_struct (const char *name
, const struct block
*block
)
1743 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
1747 error (_("No struct type named %s."), name
);
1749 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_STRUCT
)
1751 error (_("This context has class, union or enum %s, not a struct."),
1754 return (SYMBOL_TYPE (sym
));
1757 /* Lookup a union type named "union NAME",
1758 visible in lexical block BLOCK. */
1761 lookup_union (const char *name
, const struct block
*block
)
1766 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
1769 error (_("No union type named %s."), name
);
1771 t
= SYMBOL_TYPE (sym
);
1773 if (t
->code () == TYPE_CODE_UNION
)
1776 /* If we get here, it's not a union. */
1777 error (_("This context has class, struct or enum %s, not a union."),
1781 /* Lookup an enum type named "enum NAME",
1782 visible in lexical block BLOCK. */
1785 lookup_enum (const char *name
, const struct block
*block
)
1789 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
1792 error (_("No enum type named %s."), name
);
1794 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_ENUM
)
1796 error (_("This context has class, struct or union %s, not an enum."),
1799 return (SYMBOL_TYPE (sym
));
1802 /* Lookup a template type named "template NAME<TYPE>",
1803 visible in lexical block BLOCK. */
1806 lookup_template_type (const char *name
, struct type
*type
,
1807 const struct block
*block
)
1810 char *nam
= (char *)
1811 alloca (strlen (name
) + strlen (type
->name ()) + 4);
1815 strcat (nam
, type
->name ());
1816 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1818 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0).symbol
;
1822 error (_("No template type named %s."), name
);
1824 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_STRUCT
)
1826 error (_("This context has class, union or enum %s, not a struct."),
1829 return (SYMBOL_TYPE (sym
));
1832 /* See gdbtypes.h. */
1835 lookup_struct_elt (struct type
*type
, const char *name
, int noerr
)
1841 type
= check_typedef (type
);
1842 if (type
->code () != TYPE_CODE_PTR
1843 && type
->code () != TYPE_CODE_REF
)
1845 type
= TYPE_TARGET_TYPE (type
);
1848 if (type
->code () != TYPE_CODE_STRUCT
1849 && type
->code () != TYPE_CODE_UNION
)
1851 std::string type_name
= type_to_string (type
);
1852 error (_("Type %s is not a structure or union type."),
1853 type_name
.c_str ());
1856 for (i
= type
->num_fields () - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1858 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1860 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1862 return {&type
->field (i
), TYPE_FIELD_BITPOS (type
, i
)};
1864 else if (!t_field_name
|| *t_field_name
== '\0')
1867 = lookup_struct_elt (type
->field (i
).type (), name
, 1);
1868 if (elt
.field
!= NULL
)
1870 elt
.offset
+= TYPE_FIELD_BITPOS (type
, i
);
1876 /* OK, it's not in this class. Recursively check the baseclasses. */
1877 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1879 struct_elt elt
= lookup_struct_elt (TYPE_BASECLASS (type
, i
), name
, 1);
1880 if (elt
.field
!= NULL
)
1885 return {nullptr, 0};
1887 std::string type_name
= type_to_string (type
);
1888 error (_("Type %s has no component named %s."), type_name
.c_str (), name
);
1891 /* See gdbtypes.h. */
1894 lookup_struct_elt_type (struct type
*type
, const char *name
, int noerr
)
1896 struct_elt elt
= lookup_struct_elt (type
, name
, noerr
);
1897 if (elt
.field
!= NULL
)
1898 return elt
.field
->type ();
1903 /* Store in *MAX the largest number representable by unsigned integer type
1907 get_unsigned_type_max (struct type
*type
, ULONGEST
*max
)
1911 type
= check_typedef (type
);
1912 gdb_assert (type
->code () == TYPE_CODE_INT
&& type
->is_unsigned ());
1913 gdb_assert (TYPE_LENGTH (type
) <= sizeof (ULONGEST
));
1915 /* Written this way to avoid overflow. */
1916 n
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
1917 *max
= ((((ULONGEST
) 1 << (n
- 1)) - 1) << 1) | 1;
1920 /* Store in *MIN, *MAX the smallest and largest numbers representable by
1921 signed integer type TYPE. */
1924 get_signed_type_minmax (struct type
*type
, LONGEST
*min
, LONGEST
*max
)
1928 type
= check_typedef (type
);
1929 gdb_assert (type
->code () == TYPE_CODE_INT
&& !type
->is_unsigned ());
1930 gdb_assert (TYPE_LENGTH (type
) <= sizeof (LONGEST
));
1932 n
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
1933 *min
= -((ULONGEST
) 1 << (n
- 1));
1934 *max
= ((ULONGEST
) 1 << (n
- 1)) - 1;
1937 /* Internal routine called by TYPE_VPTR_FIELDNO to return the value of
1938 cplus_stuff.vptr_fieldno.
1940 cplus_stuff is initialized to cplus_struct_default which does not
1941 set vptr_fieldno to -1 for portability reasons (IWBN to use C99
1942 designated initializers). We cope with that here. */
1945 internal_type_vptr_fieldno (struct type
*type
)
1947 type
= check_typedef (type
);
1948 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1949 || type
->code () == TYPE_CODE_UNION
);
1950 if (!HAVE_CPLUS_STRUCT (type
))
1952 return TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_fieldno
;
1955 /* Set the value of cplus_stuff.vptr_fieldno. */
1958 set_type_vptr_fieldno (struct type
*type
, int fieldno
)
1960 type
= check_typedef (type
);
1961 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1962 || type
->code () == TYPE_CODE_UNION
);
1963 if (!HAVE_CPLUS_STRUCT (type
))
1964 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1965 TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_fieldno
= fieldno
;
1968 /* Internal routine called by TYPE_VPTR_BASETYPE to return the value of
1969 cplus_stuff.vptr_basetype. */
1972 internal_type_vptr_basetype (struct type
*type
)
1974 type
= check_typedef (type
);
1975 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1976 || type
->code () == TYPE_CODE_UNION
);
1977 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_CPLUS_STUFF
);
1978 return TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_basetype
;
1981 /* Set the value of cplus_stuff.vptr_basetype. */
1984 set_type_vptr_basetype (struct type
*type
, struct type
*basetype
)
1986 type
= check_typedef (type
);
1987 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1988 || type
->code () == TYPE_CODE_UNION
);
1989 if (!HAVE_CPLUS_STRUCT (type
))
1990 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1991 TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_basetype
= basetype
;
1994 /* Lookup the vptr basetype/fieldno values for TYPE.
1995 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1996 vptr_fieldno. Also, if found and basetype is from the same objfile,
1998 If not found, return -1 and ignore BASETYPEP.
1999 Callers should be aware that in some cases (for example,
2000 the type or one of its baseclasses is a stub type and we are
2001 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
2002 this function will not be able to find the
2003 virtual function table pointer, and vptr_fieldno will remain -1 and
2004 vptr_basetype will remain NULL or incomplete. */
2007 get_vptr_fieldno (struct type
*type
, struct type
**basetypep
)
2009 type
= check_typedef (type
);
2011 if (TYPE_VPTR_FIELDNO (type
) < 0)
2015 /* We must start at zero in case the first (and only) baseclass
2016 is virtual (and hence we cannot share the table pointer). */
2017 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
2019 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
2021 struct type
*basetype
;
2023 fieldno
= get_vptr_fieldno (baseclass
, &basetype
);
2026 /* If the type comes from a different objfile we can't cache
2027 it, it may have a different lifetime. PR 2384 */
2028 if (TYPE_OBJFILE (type
) == TYPE_OBJFILE (basetype
))
2030 set_type_vptr_fieldno (type
, fieldno
);
2031 set_type_vptr_basetype (type
, basetype
);
2034 *basetypep
= basetype
;
2045 *basetypep
= TYPE_VPTR_BASETYPE (type
);
2046 return TYPE_VPTR_FIELDNO (type
);
2051 stub_noname_complaint (void)
2053 complaint (_("stub type has NULL name"));
2056 /* Return nonzero if TYPE has a DYN_PROP_BYTE_STRIDE dynamic property
2057 attached to it, and that property has a non-constant value. */
2060 array_type_has_dynamic_stride (struct type
*type
)
2062 struct dynamic_prop
*prop
= type
->dyn_prop (DYN_PROP_BYTE_STRIDE
);
2064 return (prop
!= NULL
&& prop
->kind () != PROP_CONST
);
2067 /* Worker for is_dynamic_type. */
2070 is_dynamic_type_internal (struct type
*type
, int top_level
)
2072 type
= check_typedef (type
);
2074 /* We only want to recognize references at the outermost level. */
2075 if (top_level
&& type
->code () == TYPE_CODE_REF
)
2076 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2078 /* Types that have a dynamic TYPE_DATA_LOCATION are considered
2079 dynamic, even if the type itself is statically defined.
2080 From a user's point of view, this may appear counter-intuitive;
2081 but it makes sense in this context, because the point is to determine
2082 whether any part of the type needs to be resolved before it can
2084 if (TYPE_DATA_LOCATION (type
) != NULL
2085 && (TYPE_DATA_LOCATION_KIND (type
) == PROP_LOCEXPR
2086 || TYPE_DATA_LOCATION_KIND (type
) == PROP_LOCLIST
))
2089 if (TYPE_ASSOCIATED_PROP (type
))
2092 if (TYPE_ALLOCATED_PROP (type
))
2095 struct dynamic_prop
*prop
= type
->dyn_prop (DYN_PROP_VARIANT_PARTS
);
2096 if (prop
!= nullptr && prop
->kind () != PROP_TYPE
)
2099 if (TYPE_HAS_DYNAMIC_LENGTH (type
))
2102 switch (type
->code ())
2104 case TYPE_CODE_RANGE
:
2106 /* A range type is obviously dynamic if it has at least one
2107 dynamic bound. But also consider the range type to be
2108 dynamic when its subtype is dynamic, even if the bounds
2109 of the range type are static. It allows us to assume that
2110 the subtype of a static range type is also static. */
2111 return (!has_static_range (type
->bounds ())
2112 || is_dynamic_type_internal (TYPE_TARGET_TYPE (type
), 0));
2115 case TYPE_CODE_STRING
:
2116 /* Strings are very much like an array of characters, and can be
2117 treated as one here. */
2118 case TYPE_CODE_ARRAY
:
2120 gdb_assert (type
->num_fields () == 1);
2122 /* The array is dynamic if either the bounds are dynamic... */
2123 if (is_dynamic_type_internal (type
->index_type (), 0))
2125 /* ... or the elements it contains have a dynamic contents... */
2126 if (is_dynamic_type_internal (TYPE_TARGET_TYPE (type
), 0))
2128 /* ... or if it has a dynamic stride... */
2129 if (array_type_has_dynamic_stride (type
))
2134 case TYPE_CODE_STRUCT
:
2135 case TYPE_CODE_UNION
:
2139 bool is_cplus
= HAVE_CPLUS_STRUCT (type
);
2141 for (i
= 0; i
< type
->num_fields (); ++i
)
2143 /* Static fields can be ignored here. */
2144 if (field_is_static (&type
->field (i
)))
2146 /* If the field has dynamic type, then so does TYPE. */
2147 if (is_dynamic_type_internal (type
->field (i
).type (), 0))
2149 /* If the field is at a fixed offset, then it is not
2151 if (TYPE_FIELD_LOC_KIND (type
, i
) != FIELD_LOC_KIND_DWARF_BLOCK
)
2153 /* Do not consider C++ virtual base types to be dynamic
2154 due to the field's offset being dynamic; these are
2155 handled via other means. */
2156 if (is_cplus
&& BASETYPE_VIA_VIRTUAL (type
, i
))
2167 /* See gdbtypes.h. */
2170 is_dynamic_type (struct type
*type
)
2172 return is_dynamic_type_internal (type
, 1);
2175 static struct type
*resolve_dynamic_type_internal
2176 (struct type
*type
, struct property_addr_info
*addr_stack
, int top_level
);
2178 /* Given a dynamic range type (dyn_range_type) and a stack of
2179 struct property_addr_info elements, return a static version
2182 When RESOLVE_P is true then the returned static range is created by
2183 actually evaluating any dynamic properties within the range type, while
2184 when RESOLVE_P is false the returned static range has all of the bounds
2185 and stride information set to undefined. The RESOLVE_P set to false
2186 case will be used when evaluating a dynamic array that is not
2187 allocated, or not associated, i.e. the bounds information might not be
2190 static struct type
*
2191 resolve_dynamic_range (struct type
*dyn_range_type
,
2192 struct property_addr_info
*addr_stack
,
2193 bool resolve_p
= true)
2196 struct type
*static_range_type
, *static_target_type
;
2197 struct dynamic_prop low_bound
, high_bound
, stride
;
2199 gdb_assert (dyn_range_type
->code () == TYPE_CODE_RANGE
);
2201 const struct dynamic_prop
*prop
= &dyn_range_type
->bounds ()->low
;
2202 if (resolve_p
&& dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2203 low_bound
.set_const_val (value
);
2205 low_bound
.set_undefined ();
2207 prop
= &dyn_range_type
->bounds ()->high
;
2208 if (resolve_p
&& dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2210 high_bound
.set_const_val (value
);
2212 if (dyn_range_type
->bounds ()->flag_upper_bound_is_count
)
2213 high_bound
.set_const_val
2214 (low_bound
.const_val () + high_bound
.const_val () - 1);
2217 high_bound
.set_undefined ();
2219 bool byte_stride_p
= dyn_range_type
->bounds ()->flag_is_byte_stride
;
2220 prop
= &dyn_range_type
->bounds ()->stride
;
2221 if (resolve_p
&& dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2223 stride
.set_const_val (value
);
2225 /* If we have a bit stride that is not an exact number of bytes then
2226 I really don't think this is going to work with current GDB, the
2227 array indexing code in GDB seems to be pretty heavily tied to byte
2228 offsets right now. Assuming 8 bits in a byte. */
2229 struct gdbarch
*gdbarch
= get_type_arch (dyn_range_type
);
2230 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
2231 if (!byte_stride_p
&& (value
% (unit_size
* 8)) != 0)
2232 error (_("bit strides that are not a multiple of the byte size "
2233 "are currently not supported"));
2237 stride
.set_undefined ();
2238 byte_stride_p
= true;
2242 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (dyn_range_type
),
2244 LONGEST bias
= dyn_range_type
->bounds ()->bias
;
2245 static_range_type
= create_range_type_with_stride
2246 (copy_type (dyn_range_type
), static_target_type
,
2247 &low_bound
, &high_bound
, bias
, &stride
, byte_stride_p
);
2248 static_range_type
->bounds ()->flag_bound_evaluated
= 1;
2249 return static_range_type
;
2252 /* Resolves dynamic bound values of an array or string type TYPE to static
2253 ones. ADDR_STACK is a stack of struct property_addr_info to be used if
2254 needed during the dynamic resolution.
2256 When RESOLVE_P is true then the dynamic properties of TYPE are
2257 evaluated, otherwise the dynamic properties of TYPE are not evaluated,
2258 instead we assume the array is not allocated/associated yet. */
2260 static struct type
*
2261 resolve_dynamic_array_or_string (struct type
*type
,
2262 struct property_addr_info
*addr_stack
,
2263 bool resolve_p
= true)
2266 struct type
*elt_type
;
2267 struct type
*range_type
;
2268 struct type
*ary_dim
;
2269 struct dynamic_prop
*prop
;
2270 unsigned int bit_stride
= 0;
2272 /* For dynamic type resolution strings can be treated like arrays of
2274 gdb_assert (type
->code () == TYPE_CODE_ARRAY
2275 || type
->code () == TYPE_CODE_STRING
);
2277 type
= copy_type (type
);
2279 /* Resolve the allocated and associated properties before doing anything
2280 else. If an array is not allocated or not associated then (at least
2281 for Fortran) there is no guarantee that the data to define the upper
2282 bound, lower bound, or stride will be correct. If RESOLVE_P is
2283 already false at this point then this is not the first dimension of
2284 the array and a more outer dimension has already marked this array as
2285 not allocated/associated, as such we just ignore this property. This
2286 is fine as GDB only checks the allocated/associated on the outer most
2287 dimension of the array. */
2288 prop
= TYPE_ALLOCATED_PROP (type
);
2289 if (prop
!= NULL
&& resolve_p
2290 && dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2292 prop
->set_const_val (value
);
2297 prop
= TYPE_ASSOCIATED_PROP (type
);
2298 if (prop
!= NULL
&& resolve_p
2299 && dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2301 prop
->set_const_val (value
);
2306 range_type
= check_typedef (type
->index_type ());
2307 range_type
= resolve_dynamic_range (range_type
, addr_stack
, resolve_p
);
2309 ary_dim
= check_typedef (TYPE_TARGET_TYPE (type
));
2310 if (ary_dim
!= NULL
&& ary_dim
->code () == TYPE_CODE_ARRAY
)
2311 elt_type
= resolve_dynamic_array_or_string (ary_dim
, addr_stack
, resolve_p
);
2313 elt_type
= TYPE_TARGET_TYPE (type
);
2315 prop
= type
->dyn_prop (DYN_PROP_BYTE_STRIDE
);
2316 if (prop
!= NULL
&& resolve_p
)
2318 if (dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2320 type
->remove_dyn_prop (DYN_PROP_BYTE_STRIDE
);
2321 bit_stride
= (unsigned int) (value
* 8);
2325 /* Could be a bug in our code, but it could also happen
2326 if the DWARF info is not correct. Issue a warning,
2327 and assume no byte/bit stride (leave bit_stride = 0). */
2328 warning (_("cannot determine array stride for type %s"),
2329 type
->name () ? type
->name () : "<no name>");
2333 bit_stride
= TYPE_FIELD_BITSIZE (type
, 0);
2335 return create_array_type_with_stride (type
, elt_type
, range_type
, NULL
,
2339 /* Resolve dynamic bounds of members of the union TYPE to static
2340 bounds. ADDR_STACK is a stack of struct property_addr_info
2341 to be used if needed during the dynamic resolution. */
2343 static struct type
*
2344 resolve_dynamic_union (struct type
*type
,
2345 struct property_addr_info
*addr_stack
)
2347 struct type
*resolved_type
;
2349 unsigned int max_len
= 0;
2351 gdb_assert (type
->code () == TYPE_CODE_UNION
);
2353 resolved_type
= copy_type (type
);
2354 resolved_type
->set_fields
2356 TYPE_ALLOC (resolved_type
,
2357 resolved_type
->num_fields () * sizeof (struct field
)));
2358 memcpy (resolved_type
->fields (),
2360 resolved_type
->num_fields () * sizeof (struct field
));
2361 for (i
= 0; i
< resolved_type
->num_fields (); ++i
)
2365 if (field_is_static (&type
->field (i
)))
2368 t
= resolve_dynamic_type_internal (resolved_type
->field (i
).type (),
2370 resolved_type
->field (i
).set_type (t
);
2372 struct type
*real_type
= check_typedef (t
);
2373 if (TYPE_LENGTH (real_type
) > max_len
)
2374 max_len
= TYPE_LENGTH (real_type
);
2377 TYPE_LENGTH (resolved_type
) = max_len
;
2378 return resolved_type
;
2381 /* See gdbtypes.h. */
2384 variant::matches (ULONGEST value
, bool is_unsigned
) const
2386 for (const discriminant_range
&range
: discriminants
)
2387 if (range
.contains (value
, is_unsigned
))
2393 compute_variant_fields_inner (struct type
*type
,
2394 struct property_addr_info
*addr_stack
,
2395 const variant_part
&part
,
2396 std::vector
<bool> &flags
);
2398 /* A helper function to determine which variant fields will be active.
2399 This handles both the variant's direct fields, and any variant
2400 parts embedded in this variant. TYPE is the type we're examining.
2401 ADDR_STACK holds information about the concrete object. VARIANT is
2402 the current variant to be handled. FLAGS is where the results are
2403 stored -- this function sets the Nth element in FLAGS if the
2404 corresponding field is enabled. ENABLED is whether this variant is
2408 compute_variant_fields_recurse (struct type
*type
,
2409 struct property_addr_info
*addr_stack
,
2410 const variant
&variant
,
2411 std::vector
<bool> &flags
,
2414 for (int field
= variant
.first_field
; field
< variant
.last_field
; ++field
)
2415 flags
[field
] = enabled
;
2417 for (const variant_part
&new_part
: variant
.parts
)
2420 compute_variant_fields_inner (type
, addr_stack
, new_part
, flags
);
2423 for (const auto &sub_variant
: new_part
.variants
)
2424 compute_variant_fields_recurse (type
, addr_stack
, sub_variant
,
2430 /* A helper function to determine which variant fields will be active.
2431 This evaluates the discriminant, decides which variant (if any) is
2432 active, and then updates FLAGS to reflect which fields should be
2433 available. TYPE is the type we're examining. ADDR_STACK holds
2434 information about the concrete object. VARIANT is the current
2435 variant to be handled. FLAGS is where the results are stored --
2436 this function sets the Nth element in FLAGS if the corresponding
2437 field is enabled. */
2440 compute_variant_fields_inner (struct type
*type
,
2441 struct property_addr_info
*addr_stack
,
2442 const variant_part
&part
,
2443 std::vector
<bool> &flags
)
2445 /* Evaluate the discriminant. */
2446 gdb::optional
<ULONGEST
> discr_value
;
2447 if (part
.discriminant_index
!= -1)
2449 int idx
= part
.discriminant_index
;
2451 if (TYPE_FIELD_LOC_KIND (type
, idx
) != FIELD_LOC_KIND_BITPOS
)
2452 error (_("Cannot determine struct field location"
2453 " (invalid location kind)"));
2455 if (addr_stack
->valaddr
.data () != NULL
)
2456 discr_value
= unpack_field_as_long (type
, addr_stack
->valaddr
.data (),
2460 CORE_ADDR addr
= (addr_stack
->addr
2461 + (TYPE_FIELD_BITPOS (type
, idx
)
2462 / TARGET_CHAR_BIT
));
2464 LONGEST bitsize
= TYPE_FIELD_BITSIZE (type
, idx
);
2465 LONGEST size
= bitsize
/ 8;
2467 size
= TYPE_LENGTH (type
->field (idx
).type ());
2469 gdb_byte bits
[sizeof (ULONGEST
)];
2470 read_memory (addr
, bits
, size
);
2472 LONGEST bitpos
= (TYPE_FIELD_BITPOS (type
, idx
)
2475 discr_value
= unpack_bits_as_long (type
->field (idx
).type (),
2476 bits
, bitpos
, bitsize
);
2480 /* Go through each variant and see which applies. */
2481 const variant
*default_variant
= nullptr;
2482 const variant
*applied_variant
= nullptr;
2483 for (const auto &variant
: part
.variants
)
2485 if (variant
.is_default ())
2486 default_variant
= &variant
;
2487 else if (discr_value
.has_value ()
2488 && variant
.matches (*discr_value
, part
.is_unsigned
))
2490 applied_variant
= &variant
;
2494 if (applied_variant
== nullptr)
2495 applied_variant
= default_variant
;
2497 for (const auto &variant
: part
.variants
)
2498 compute_variant_fields_recurse (type
, addr_stack
, variant
,
2499 flags
, applied_variant
== &variant
);
2502 /* Determine which variant fields are available in TYPE. The enabled
2503 fields are stored in RESOLVED_TYPE. ADDR_STACK holds information
2504 about the concrete object. PARTS describes the top-level variant
2505 parts for this type. */
2508 compute_variant_fields (struct type
*type
,
2509 struct type
*resolved_type
,
2510 struct property_addr_info
*addr_stack
,
2511 const gdb::array_view
<variant_part
> &parts
)
2513 /* Assume all fields are included by default. */
2514 std::vector
<bool> flags (resolved_type
->num_fields (), true);
2516 /* Now disable fields based on the variants that control them. */
2517 for (const auto &part
: parts
)
2518 compute_variant_fields_inner (type
, addr_stack
, part
, flags
);
2520 resolved_type
->set_num_fields
2521 (std::count (flags
.begin (), flags
.end (), true));
2522 resolved_type
->set_fields
2524 TYPE_ALLOC (resolved_type
,
2525 resolved_type
->num_fields () * sizeof (struct field
)));
2528 for (int i
= 0; i
< type
->num_fields (); ++i
)
2533 resolved_type
->field (out
) = type
->field (i
);
2538 /* Resolve dynamic bounds of members of the struct TYPE to static
2539 bounds. ADDR_STACK is a stack of struct property_addr_info to
2540 be used if needed during the dynamic resolution. */
2542 static struct type
*
2543 resolve_dynamic_struct (struct type
*type
,
2544 struct property_addr_info
*addr_stack
)
2546 struct type
*resolved_type
;
2548 unsigned resolved_type_bit_length
= 0;
2550 gdb_assert (type
->code () == TYPE_CODE_STRUCT
);
2551 gdb_assert (type
->num_fields () > 0);
2553 resolved_type
= copy_type (type
);
2555 dynamic_prop
*variant_prop
= resolved_type
->dyn_prop (DYN_PROP_VARIANT_PARTS
);
2556 if (variant_prop
!= nullptr && variant_prop
->kind () == PROP_VARIANT_PARTS
)
2558 compute_variant_fields (type
, resolved_type
, addr_stack
,
2559 *variant_prop
->variant_parts ());
2560 /* We want to leave the property attached, so that the Rust code
2561 can tell whether the type was originally an enum. */
2562 variant_prop
->set_original_type (type
);
2566 resolved_type
->set_fields
2568 TYPE_ALLOC (resolved_type
,
2569 resolved_type
->num_fields () * sizeof (struct field
)));
2570 memcpy (resolved_type
->fields (),
2572 resolved_type
->num_fields () * sizeof (struct field
));
2575 for (i
= 0; i
< resolved_type
->num_fields (); ++i
)
2577 unsigned new_bit_length
;
2578 struct property_addr_info pinfo
;
2580 if (field_is_static (&resolved_type
->field (i
)))
2583 if (TYPE_FIELD_LOC_KIND (resolved_type
, i
) == FIELD_LOC_KIND_DWARF_BLOCK
)
2585 struct dwarf2_property_baton baton
;
2587 = lookup_pointer_type (resolved_type
->field (i
).type ());
2588 baton
.locexpr
= *TYPE_FIELD_DWARF_BLOCK (resolved_type
, i
);
2590 struct dynamic_prop prop
;
2591 prop
.set_locexpr (&baton
);
2594 if (dwarf2_evaluate_property (&prop
, nullptr, addr_stack
, &addr
,
2596 SET_FIELD_BITPOS (resolved_type
->field (i
),
2597 TARGET_CHAR_BIT
* (addr
- addr_stack
->addr
));
2600 /* As we know this field is not a static field, the field's
2601 field_loc_kind should be FIELD_LOC_KIND_BITPOS. Verify
2602 this is the case, but only trigger a simple error rather
2603 than an internal error if that fails. While failing
2604 that verification indicates a bug in our code, the error
2605 is not severe enough to suggest to the user he stops
2606 his debugging session because of it. */
2607 if (TYPE_FIELD_LOC_KIND (resolved_type
, i
) != FIELD_LOC_KIND_BITPOS
)
2608 error (_("Cannot determine struct field location"
2609 " (invalid location kind)"));
2611 pinfo
.type
= check_typedef (resolved_type
->field (i
).type ());
2612 pinfo
.valaddr
= addr_stack
->valaddr
;
2615 + (TYPE_FIELD_BITPOS (resolved_type
, i
) / TARGET_CHAR_BIT
));
2616 pinfo
.next
= addr_stack
;
2618 resolved_type
->field (i
).set_type
2619 (resolve_dynamic_type_internal (resolved_type
->field (i
).type (),
2621 gdb_assert (TYPE_FIELD_LOC_KIND (resolved_type
, i
)
2622 == FIELD_LOC_KIND_BITPOS
);
2624 new_bit_length
= TYPE_FIELD_BITPOS (resolved_type
, i
);
2625 if (TYPE_FIELD_BITSIZE (resolved_type
, i
) != 0)
2626 new_bit_length
+= TYPE_FIELD_BITSIZE (resolved_type
, i
);
2629 struct type
*real_type
2630 = check_typedef (resolved_type
->field (i
).type ());
2632 new_bit_length
+= (TYPE_LENGTH (real_type
) * TARGET_CHAR_BIT
);
2635 /* Normally, we would use the position and size of the last field
2636 to determine the size of the enclosing structure. But GCC seems
2637 to be encoding the position of some fields incorrectly when
2638 the struct contains a dynamic field that is not placed last.
2639 So we compute the struct size based on the field that has
2640 the highest position + size - probably the best we can do. */
2641 if (new_bit_length
> resolved_type_bit_length
)
2642 resolved_type_bit_length
= new_bit_length
;
2645 /* The length of a type won't change for fortran, but it does for C and Ada.
2646 For fortran the size of dynamic fields might change over time but not the
2647 type length of the structure. If we adapt it, we run into problems
2648 when calculating the element offset for arrays of structs. */
2649 if (current_language
->la_language
!= language_fortran
)
2650 TYPE_LENGTH (resolved_type
)
2651 = (resolved_type_bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
2653 /* The Ada language uses this field as a cache for static fixed types: reset
2654 it as RESOLVED_TYPE must have its own static fixed type. */
2655 TYPE_TARGET_TYPE (resolved_type
) = NULL
;
2657 return resolved_type
;
2660 /* Worker for resolved_dynamic_type. */
2662 static struct type
*
2663 resolve_dynamic_type_internal (struct type
*type
,
2664 struct property_addr_info
*addr_stack
,
2667 struct type
*real_type
= check_typedef (type
);
2668 struct type
*resolved_type
= nullptr;
2669 struct dynamic_prop
*prop
;
2672 if (!is_dynamic_type_internal (real_type
, top_level
))
2675 gdb::optional
<CORE_ADDR
> type_length
;
2676 prop
= TYPE_DYNAMIC_LENGTH (type
);
2678 && dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2679 type_length
= value
;
2681 if (type
->code () == TYPE_CODE_TYPEDEF
)
2683 resolved_type
= copy_type (type
);
2684 TYPE_TARGET_TYPE (resolved_type
)
2685 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type
), addr_stack
,
2690 /* Before trying to resolve TYPE, make sure it is not a stub. */
2693 switch (type
->code ())
2697 struct property_addr_info pinfo
;
2699 pinfo
.type
= check_typedef (TYPE_TARGET_TYPE (type
));
2701 if (addr_stack
->valaddr
.data () != NULL
)
2702 pinfo
.addr
= extract_typed_address (addr_stack
->valaddr
.data (),
2705 pinfo
.addr
= read_memory_typed_address (addr_stack
->addr
, type
);
2706 pinfo
.next
= addr_stack
;
2708 resolved_type
= copy_type (type
);
2709 TYPE_TARGET_TYPE (resolved_type
)
2710 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type
),
2715 case TYPE_CODE_STRING
:
2716 /* Strings are very much like an array of characters, and can be
2717 treated as one here. */
2718 case TYPE_CODE_ARRAY
:
2719 resolved_type
= resolve_dynamic_array_or_string (type
, addr_stack
);
2722 case TYPE_CODE_RANGE
:
2723 resolved_type
= resolve_dynamic_range (type
, addr_stack
);
2726 case TYPE_CODE_UNION
:
2727 resolved_type
= resolve_dynamic_union (type
, addr_stack
);
2730 case TYPE_CODE_STRUCT
:
2731 resolved_type
= resolve_dynamic_struct (type
, addr_stack
);
2736 if (resolved_type
== nullptr)
2739 if (type_length
.has_value ())
2741 TYPE_LENGTH (resolved_type
) = *type_length
;
2742 resolved_type
->remove_dyn_prop (DYN_PROP_BYTE_SIZE
);
2745 /* Resolve data_location attribute. */
2746 prop
= TYPE_DATA_LOCATION (resolved_type
);
2748 && dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2750 /* Start of Fortran hack. See comment in f-lang.h for what is going
2752 if (current_language
->la_language
== language_fortran
2753 && resolved_type
->code () == TYPE_CODE_ARRAY
)
2754 value
= fortran_adjust_dynamic_array_base_address_hack (resolved_type
,
2756 /* End of Fortran hack. */
2757 prop
->set_const_val (value
);
2760 return resolved_type
;
2763 /* See gdbtypes.h */
2766 resolve_dynamic_type (struct type
*type
,
2767 gdb::array_view
<const gdb_byte
> valaddr
,
2770 struct property_addr_info pinfo
2771 = {check_typedef (type
), valaddr
, addr
, NULL
};
2773 return resolve_dynamic_type_internal (type
, &pinfo
, 1);
2776 /* See gdbtypes.h */
2779 type::dyn_prop (dynamic_prop_node_kind prop_kind
) const
2781 dynamic_prop_list
*node
= this->main_type
->dyn_prop_list
;
2783 while (node
!= NULL
)
2785 if (node
->prop_kind
== prop_kind
)
2792 /* See gdbtypes.h */
2795 type::add_dyn_prop (dynamic_prop_node_kind prop_kind
, dynamic_prop prop
)
2797 struct dynamic_prop_list
*temp
;
2799 gdb_assert (TYPE_OBJFILE_OWNED (this));
2801 temp
= XOBNEW (&TYPE_OBJFILE (this)->objfile_obstack
,
2802 struct dynamic_prop_list
);
2803 temp
->prop_kind
= prop_kind
;
2805 temp
->next
= this->main_type
->dyn_prop_list
;
2807 this->main_type
->dyn_prop_list
= temp
;
2810 /* See gdbtypes.h. */
2813 type::remove_dyn_prop (dynamic_prop_node_kind kind
)
2815 struct dynamic_prop_list
*prev_node
, *curr_node
;
2817 curr_node
= this->main_type
->dyn_prop_list
;
2820 while (NULL
!= curr_node
)
2822 if (curr_node
->prop_kind
== kind
)
2824 /* Update the linked list but don't free anything.
2825 The property was allocated on objstack and it is not known
2826 if we are on top of it. Nevertheless, everything is released
2827 when the complete objstack is freed. */
2828 if (NULL
== prev_node
)
2829 this->main_type
->dyn_prop_list
= curr_node
->next
;
2831 prev_node
->next
= curr_node
->next
;
2836 prev_node
= curr_node
;
2837 curr_node
= curr_node
->next
;
2841 /* Find the real type of TYPE. This function returns the real type,
2842 after removing all layers of typedefs, and completing opaque or stub
2843 types. Completion changes the TYPE argument, but stripping of
2846 Instance flags (e.g. const/volatile) are preserved as typedefs are
2847 stripped. If necessary a new qualified form of the underlying type
2850 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
2851 not been computed and we're either in the middle of reading symbols, or
2852 there was no name for the typedef in the debug info.
2854 NOTE: Lookup of opaque types can throw errors for invalid symbol files.
2855 QUITs in the symbol reading code can also throw.
2856 Thus this function can throw an exception.
2858 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
2861 If this is a stubbed struct (i.e. declared as struct foo *), see if
2862 we can find a full definition in some other file. If so, copy this
2863 definition, so we can use it in future. There used to be a comment
2864 (but not any code) that if we don't find a full definition, we'd
2865 set a flag so we don't spend time in the future checking the same
2866 type. That would be a mistake, though--we might load in more
2867 symbols which contain a full definition for the type. */
2870 check_typedef (struct type
*type
)
2872 struct type
*orig_type
= type
;
2876 /* While we're removing typedefs, we don't want to lose qualifiers.
2877 E.g., const/volatile. */
2878 type_instance_flags instance_flags
= type
->instance_flags ();
2880 while (type
->code () == TYPE_CODE_TYPEDEF
)
2882 if (!TYPE_TARGET_TYPE (type
))
2887 /* It is dangerous to call lookup_symbol if we are currently
2888 reading a symtab. Infinite recursion is one danger. */
2889 if (currently_reading_symtab
)
2890 return make_qualified_type (type
, instance_flags
, NULL
);
2892 name
= type
->name ();
2893 /* FIXME: shouldn't we look in STRUCT_DOMAIN and/or
2894 VAR_DOMAIN as appropriate? */
2897 stub_noname_complaint ();
2898 return make_qualified_type (type
, instance_flags
, NULL
);
2900 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0).symbol
;
2902 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
2903 else /* TYPE_CODE_UNDEF */
2904 TYPE_TARGET_TYPE (type
) = alloc_type_arch (get_type_arch (type
));
2906 type
= TYPE_TARGET_TYPE (type
);
2908 /* Preserve the instance flags as we traverse down the typedef chain.
2910 Handling address spaces/classes is nasty, what do we do if there's a
2912 E.g., what if an outer typedef marks the type as class_1 and an inner
2913 typedef marks the type as class_2?
2914 This is the wrong place to do such error checking. We leave it to
2915 the code that created the typedef in the first place to flag the
2916 error. We just pick the outer address space (akin to letting the
2917 outer cast in a chain of casting win), instead of assuming
2918 "it can't happen". */
2920 const type_instance_flags ALL_SPACES
2921 = (TYPE_INSTANCE_FLAG_CODE_SPACE
2922 | TYPE_INSTANCE_FLAG_DATA_SPACE
);
2923 const type_instance_flags ALL_CLASSES
2924 = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
;
2926 type_instance_flags new_instance_flags
= type
->instance_flags ();
2928 /* Treat code vs data spaces and address classes separately. */
2929 if ((instance_flags
& ALL_SPACES
) != 0)
2930 new_instance_flags
&= ~ALL_SPACES
;
2931 if ((instance_flags
& ALL_CLASSES
) != 0)
2932 new_instance_flags
&= ~ALL_CLASSES
;
2934 instance_flags
|= new_instance_flags
;
2938 /* If this is a struct/class/union with no fields, then check
2939 whether a full definition exists somewhere else. This is for
2940 systems where a type definition with no fields is issued for such
2941 types, instead of identifying them as stub types in the first
2944 if (TYPE_IS_OPAQUE (type
)
2945 && opaque_type_resolution
2946 && !currently_reading_symtab
)
2948 const char *name
= type
->name ();
2949 struct type
*newtype
;
2953 stub_noname_complaint ();
2954 return make_qualified_type (type
, instance_flags
, NULL
);
2956 newtype
= lookup_transparent_type (name
);
2960 /* If the resolved type and the stub are in the same
2961 objfile, then replace the stub type with the real deal.
2962 But if they're in separate objfiles, leave the stub
2963 alone; we'll just look up the transparent type every time
2964 we call check_typedef. We can't create pointers between
2965 types allocated to different objfiles, since they may
2966 have different lifetimes. Trying to copy NEWTYPE over to
2967 TYPE's objfile is pointless, too, since you'll have to
2968 move over any other types NEWTYPE refers to, which could
2969 be an unbounded amount of stuff. */
2970 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
2971 type
= make_qualified_type (newtype
, type
->instance_flags (), type
);
2976 /* Otherwise, rely on the stub flag being set for opaque/stubbed
2978 else if (type
->is_stub () && !currently_reading_symtab
)
2980 const char *name
= type
->name ();
2981 /* FIXME: shouldn't we look in STRUCT_DOMAIN and/or VAR_DOMAIN
2987 stub_noname_complaint ();
2988 return make_qualified_type (type
, instance_flags
, NULL
);
2990 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0).symbol
;
2993 /* Same as above for opaque types, we can replace the stub
2994 with the complete type only if they are in the same
2996 if (TYPE_OBJFILE (SYMBOL_TYPE (sym
)) == TYPE_OBJFILE (type
))
2997 type
= make_qualified_type (SYMBOL_TYPE (sym
),
2998 type
->instance_flags (), type
);
3000 type
= SYMBOL_TYPE (sym
);
3004 if (type
->target_is_stub ())
3006 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
3008 if (target_type
->is_stub () || target_type
->target_is_stub ())
3010 /* Nothing we can do. */
3012 else if (type
->code () == TYPE_CODE_RANGE
)
3014 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
3015 type
->set_target_is_stub (false);
3017 else if (type
->code () == TYPE_CODE_ARRAY
3018 && update_static_array_size (type
))
3019 type
->set_target_is_stub (false);
3022 type
= make_qualified_type (type
, instance_flags
, NULL
);
3024 /* Cache TYPE_LENGTH for future use. */
3025 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
3030 /* Parse a type expression in the string [P..P+LENGTH). If an error
3031 occurs, silently return a void type. */
3033 static struct type
*
3034 safe_parse_type (struct gdbarch
*gdbarch
, const char *p
, int length
)
3036 struct ui_file
*saved_gdb_stderr
;
3037 struct type
*type
= NULL
; /* Initialize to keep gcc happy. */
3039 /* Suppress error messages. */
3040 saved_gdb_stderr
= gdb_stderr
;
3041 gdb_stderr
= &null_stream
;
3043 /* Call parse_and_eval_type() without fear of longjmp()s. */
3046 type
= parse_and_eval_type (p
, length
);
3048 catch (const gdb_exception_error
&except
)
3050 type
= builtin_type (gdbarch
)->builtin_void
;
3053 /* Stop suppressing error messages. */
3054 gdb_stderr
= saved_gdb_stderr
;
3059 /* Ugly hack to convert method stubs into method types.
3061 He ain't kiddin'. This demangles the name of the method into a
3062 string including argument types, parses out each argument type,
3063 generates a string casting a zero to that type, evaluates the
3064 string, and stuffs the resulting type into an argtype vector!!!
3065 Then it knows the type of the whole function (including argument
3066 types for overloading), which info used to be in the stab's but was
3067 removed to hack back the space required for them. */
3070 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
3072 struct gdbarch
*gdbarch
= get_type_arch (type
);
3074 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
3075 char *demangled_name
= gdb_demangle (mangled_name
,
3076 DMGL_PARAMS
| DMGL_ANSI
);
3077 char *argtypetext
, *p
;
3078 int depth
= 0, argcount
= 1;
3079 struct field
*argtypes
;
3082 /* Make sure we got back a function string that we can use. */
3084 p
= strchr (demangled_name
, '(');
3088 if (demangled_name
== NULL
|| p
== NULL
)
3089 error (_("Internal: Cannot demangle mangled name `%s'."),
3092 /* Now, read in the parameters that define this type. */
3097 if (*p
== '(' || *p
== '<')
3101 else if (*p
== ')' || *p
== '>')
3105 else if (*p
== ',' && depth
== 0)
3113 /* If we read one argument and it was ``void'', don't count it. */
3114 if (startswith (argtypetext
, "(void)"))
3117 /* We need one extra slot, for the THIS pointer. */
3119 argtypes
= (struct field
*)
3120 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
3123 /* Add THIS pointer for non-static methods. */
3124 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
3125 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
3129 argtypes
[0].set_type (lookup_pointer_type (type
));
3133 if (*p
!= ')') /* () means no args, skip while. */
3138 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
3140 /* Avoid parsing of ellipsis, they will be handled below.
3141 Also avoid ``void'' as above. */
3142 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
3143 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
3145 argtypes
[argcount
].set_type
3146 (safe_parse_type (gdbarch
, argtypetext
, p
- argtypetext
));
3149 argtypetext
= p
+ 1;
3152 if (*p
== '(' || *p
== '<')
3156 else if (*p
== ')' || *p
== '>')
3165 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
3167 /* Now update the old "stub" type into a real type. */
3168 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
3169 /* MTYPE may currently be a function (TYPE_CODE_FUNC).
3170 We want a method (TYPE_CODE_METHOD). */
3171 smash_to_method_type (mtype
, type
, TYPE_TARGET_TYPE (mtype
),
3172 argtypes
, argcount
, p
[-2] == '.');
3173 mtype
->set_is_stub (false);
3174 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
3176 xfree (demangled_name
);
3179 /* This is the external interface to check_stub_method, above. This
3180 function unstubs all of the signatures for TYPE's METHOD_ID method
3181 name. After calling this function TYPE_FN_FIELD_STUB will be
3182 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
3185 This function unfortunately can not die until stabs do. */
3188 check_stub_method_group (struct type
*type
, int method_id
)
3190 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
3191 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
3193 for (int j
= 0; j
< len
; j
++)
3195 if (TYPE_FN_FIELD_STUB (f
, j
))
3196 check_stub_method (type
, method_id
, j
);
3200 /* Ensure it is in .rodata (if available) by working around GCC PR 44690. */
3201 const struct cplus_struct_type cplus_struct_default
= { };
3204 allocate_cplus_struct_type (struct type
*type
)
3206 if (HAVE_CPLUS_STRUCT (type
))
3207 /* Structure was already allocated. Nothing more to do. */
3210 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_CPLUS_STUFF
;
3211 TYPE_RAW_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
3212 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
3213 *(TYPE_RAW_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
3214 set_type_vptr_fieldno (type
, -1);
3217 const struct gnat_aux_type gnat_aux_default
=
3220 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
3221 and allocate the associated gnat-specific data. The gnat-specific
3222 data is also initialized to gnat_aux_default. */
3225 allocate_gnat_aux_type (struct type
*type
)
3227 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_GNAT_STUFF
;
3228 TYPE_GNAT_SPECIFIC (type
) = (struct gnat_aux_type
*)
3229 TYPE_ALLOC (type
, sizeof (struct gnat_aux_type
));
3230 *(TYPE_GNAT_SPECIFIC (type
)) = gnat_aux_default
;
3233 /* Helper function to initialize a newly allocated type. Set type code
3234 to CODE and initialize the type-specific fields accordingly. */
3237 set_type_code (struct type
*type
, enum type_code code
)
3239 type
->set_code (code
);
3243 case TYPE_CODE_STRUCT
:
3244 case TYPE_CODE_UNION
:
3245 case TYPE_CODE_NAMESPACE
:
3246 INIT_CPLUS_SPECIFIC (type
);
3249 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_FLOATFORMAT
;
3251 case TYPE_CODE_FUNC
:
3252 INIT_FUNC_SPECIFIC (type
);
3254 case TYPE_CODE_FIXED_POINT
:
3255 INIT_FIXED_POINT_SPECIFIC (type
);
3260 /* Helper function to verify floating-point format and size.
3261 BIT is the type size in bits; if BIT equals -1, the size is
3262 determined by the floatformat. Returns size to be used. */
3265 verify_floatformat (int bit
, const struct floatformat
*floatformat
)
3267 gdb_assert (floatformat
!= NULL
);
3270 bit
= floatformat
->totalsize
;
3272 gdb_assert (bit
>= 0);
3273 gdb_assert (bit
>= floatformat
->totalsize
);
3278 /* Return the floating-point format for a floating-point variable of
3281 const struct floatformat
*
3282 floatformat_from_type (const struct type
*type
)
3284 gdb_assert (type
->code () == TYPE_CODE_FLT
);
3285 gdb_assert (TYPE_FLOATFORMAT (type
));
3286 return TYPE_FLOATFORMAT (type
);
3289 /* Helper function to initialize the standard scalar types.
3291 If NAME is non-NULL, then it is used to initialize the type name.
3292 Note that NAME is not copied; it is required to have a lifetime at
3293 least as long as OBJFILE. */
3296 init_type (struct objfile
*objfile
, enum type_code code
, int bit
,
3301 type
= alloc_type (objfile
);
3302 set_type_code (type
, code
);
3303 gdb_assert ((bit
% TARGET_CHAR_BIT
) == 0);
3304 TYPE_LENGTH (type
) = bit
/ TARGET_CHAR_BIT
;
3305 type
->set_name (name
);
3310 /* Allocate a TYPE_CODE_ERROR type structure associated with OBJFILE,
3311 to use with variables that have no debug info. NAME is the type
3314 static struct type
*
3315 init_nodebug_var_type (struct objfile
*objfile
, const char *name
)
3317 return init_type (objfile
, TYPE_CODE_ERROR
, 0, name
);
3320 /* Allocate a TYPE_CODE_INT type structure associated with OBJFILE.
3321 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3322 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3325 init_integer_type (struct objfile
*objfile
,
3326 int bit
, int unsigned_p
, const char *name
)
3330 t
= init_type (objfile
, TYPE_CODE_INT
, bit
, name
);
3332 t
->set_is_unsigned (true);
3334 TYPE_SPECIFIC_FIELD (t
) = TYPE_SPECIFIC_INT
;
3335 TYPE_MAIN_TYPE (t
)->type_specific
.int_stuff
.bit_size
= bit
;
3336 TYPE_MAIN_TYPE (t
)->type_specific
.int_stuff
.bit_offset
= 0;
3341 /* Allocate a TYPE_CODE_CHAR type structure associated with OBJFILE.
3342 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3343 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3346 init_character_type (struct objfile
*objfile
,
3347 int bit
, int unsigned_p
, const char *name
)
3351 t
= init_type (objfile
, TYPE_CODE_CHAR
, bit
, name
);
3353 t
->set_is_unsigned (true);
3358 /* Allocate a TYPE_CODE_BOOL type structure associated with OBJFILE.
3359 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3360 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3363 init_boolean_type (struct objfile
*objfile
,
3364 int bit
, int unsigned_p
, const char *name
)
3368 t
= init_type (objfile
, TYPE_CODE_BOOL
, bit
, name
);
3370 t
->set_is_unsigned (true);
3372 TYPE_SPECIFIC_FIELD (t
) = TYPE_SPECIFIC_INT
;
3373 TYPE_MAIN_TYPE (t
)->type_specific
.int_stuff
.bit_size
= bit
;
3374 TYPE_MAIN_TYPE (t
)->type_specific
.int_stuff
.bit_offset
= 0;
3379 /* Allocate a TYPE_CODE_FLT type structure associated with OBJFILE.
3380 BIT is the type size in bits; if BIT equals -1, the size is
3381 determined by the floatformat. NAME is the type name. Set the
3382 TYPE_FLOATFORMAT from FLOATFORMATS. BYTE_ORDER is the byte order
3383 to use. If it is BFD_ENDIAN_UNKNOWN (the default), then the byte
3384 order of the objfile's architecture is used. */
3387 init_float_type (struct objfile
*objfile
,
3388 int bit
, const char *name
,
3389 const struct floatformat
**floatformats
,
3390 enum bfd_endian byte_order
)
3392 if (byte_order
== BFD_ENDIAN_UNKNOWN
)
3394 struct gdbarch
*gdbarch
= objfile
->arch ();
3395 byte_order
= gdbarch_byte_order (gdbarch
);
3397 const struct floatformat
*fmt
= floatformats
[byte_order
];
3400 bit
= verify_floatformat (bit
, fmt
);
3401 t
= init_type (objfile
, TYPE_CODE_FLT
, bit
, name
);
3402 TYPE_FLOATFORMAT (t
) = fmt
;
3407 /* Allocate a TYPE_CODE_DECFLOAT type structure associated with OBJFILE.
3408 BIT is the type size in bits. NAME is the type name. */
3411 init_decfloat_type (struct objfile
*objfile
, int bit
, const char *name
)
3415 t
= init_type (objfile
, TYPE_CODE_DECFLOAT
, bit
, name
);
3419 /* Allocate a TYPE_CODE_COMPLEX type structure. NAME is the type
3420 name. TARGET_TYPE is the component type. */
3423 init_complex_type (const char *name
, struct type
*target_type
)
3427 gdb_assert (target_type
->code () == TYPE_CODE_INT
3428 || target_type
->code () == TYPE_CODE_FLT
);
3430 if (TYPE_MAIN_TYPE (target_type
)->flds_bnds
.complex_type
== nullptr)
3432 if (name
== nullptr && target_type
->name () != nullptr)
3435 = (char *) TYPE_ALLOC (target_type
,
3436 strlen (target_type
->name ())
3437 + strlen ("_Complex ") + 1);
3438 strcpy (new_name
, "_Complex ");
3439 strcat (new_name
, target_type
->name ());
3443 t
= alloc_type_copy (target_type
);
3444 set_type_code (t
, TYPE_CODE_COMPLEX
);
3445 TYPE_LENGTH (t
) = 2 * TYPE_LENGTH (target_type
);
3448 TYPE_TARGET_TYPE (t
) = target_type
;
3449 TYPE_MAIN_TYPE (target_type
)->flds_bnds
.complex_type
= t
;
3452 return TYPE_MAIN_TYPE (target_type
)->flds_bnds
.complex_type
;
3455 /* Allocate a TYPE_CODE_PTR type structure associated with OBJFILE.
3456 BIT is the pointer type size in bits. NAME is the type name.
3457 TARGET_TYPE is the pointer target type. Always sets the pointer type's
3458 TYPE_UNSIGNED flag. */
3461 init_pointer_type (struct objfile
*objfile
,
3462 int bit
, const char *name
, struct type
*target_type
)
3466 t
= init_type (objfile
, TYPE_CODE_PTR
, bit
, name
);
3467 TYPE_TARGET_TYPE (t
) = target_type
;
3468 t
->set_is_unsigned (true);
3472 /* Allocate a TYPE_CODE_FIXED_POINT type structure associated with OBJFILE.
3473 BIT is the pointer type size in bits.
3474 UNSIGNED_P should be nonzero if the type is unsigned.
3475 NAME is the type name. */
3478 init_fixed_point_type (struct objfile
*objfile
,
3479 int bit
, int unsigned_p
, const char *name
)
3483 t
= init_type (objfile
, TYPE_CODE_FIXED_POINT
, bit
, name
);
3485 t
->set_is_unsigned (true);
3490 /* See gdbtypes.h. */
3493 type_raw_align (struct type
*type
)
3495 if (type
->align_log2
!= 0)
3496 return 1 << (type
->align_log2
- 1);
3500 /* See gdbtypes.h. */
3503 type_align (struct type
*type
)
3505 /* Check alignment provided in the debug information. */
3506 unsigned raw_align
= type_raw_align (type
);
3510 /* Allow the architecture to provide an alignment. */
3511 struct gdbarch
*arch
= get_type_arch (type
);
3512 ULONGEST align
= gdbarch_type_align (arch
, type
);
3516 switch (type
->code ())
3519 case TYPE_CODE_FUNC
:
3520 case TYPE_CODE_FLAGS
:
3522 case TYPE_CODE_RANGE
:
3524 case TYPE_CODE_ENUM
:
3526 case TYPE_CODE_RVALUE_REF
:
3527 case TYPE_CODE_CHAR
:
3528 case TYPE_CODE_BOOL
:
3529 case TYPE_CODE_DECFLOAT
:
3530 case TYPE_CODE_METHODPTR
:
3531 case TYPE_CODE_MEMBERPTR
:
3532 align
= type_length_units (check_typedef (type
));
3535 case TYPE_CODE_ARRAY
:
3536 case TYPE_CODE_COMPLEX
:
3537 case TYPE_CODE_TYPEDEF
:
3538 align
= type_align (TYPE_TARGET_TYPE (type
));
3541 case TYPE_CODE_STRUCT
:
3542 case TYPE_CODE_UNION
:
3544 int number_of_non_static_fields
= 0;
3545 for (unsigned i
= 0; i
< type
->num_fields (); ++i
)
3547 if (!field_is_static (&type
->field (i
)))
3549 number_of_non_static_fields
++;
3550 ULONGEST f_align
= type_align (type
->field (i
).type ());
3553 /* Don't pretend we know something we don't. */
3557 if (f_align
> align
)
3561 /* A struct with no fields, or with only static fields has an
3563 if (number_of_non_static_fields
== 0)
3569 case TYPE_CODE_STRING
:
3570 /* Not sure what to do here, and these can't appear in C or C++
3574 case TYPE_CODE_VOID
:
3578 case TYPE_CODE_ERROR
:
3579 case TYPE_CODE_METHOD
:
3584 if ((align
& (align
- 1)) != 0)
3586 /* Not a power of 2, so pass. */
3593 /* See gdbtypes.h. */
3596 set_type_align (struct type
*type
, ULONGEST align
)
3598 /* Must be a power of 2. Zero is ok. */
3599 gdb_assert ((align
& (align
- 1)) == 0);
3601 unsigned result
= 0;
3608 if (result
>= (1 << TYPE_ALIGN_BITS
))
3611 type
->align_log2
= result
;
3616 /* Queries on types. */
3619 can_dereference (struct type
*t
)
3621 /* FIXME: Should we return true for references as well as
3623 t
= check_typedef (t
);
3626 && t
->code () == TYPE_CODE_PTR
3627 && TYPE_TARGET_TYPE (t
)->code () != TYPE_CODE_VOID
);
3631 is_integral_type (struct type
*t
)
3633 t
= check_typedef (t
);
3636 && !is_fixed_point_type (t
)
3637 && ((t
->code () == TYPE_CODE_INT
)
3638 || (t
->code () == TYPE_CODE_ENUM
)
3639 || (t
->code () == TYPE_CODE_FLAGS
)
3640 || (t
->code () == TYPE_CODE_CHAR
)
3641 || (t
->code () == TYPE_CODE_RANGE
)
3642 || (t
->code () == TYPE_CODE_BOOL
)));
3646 is_floating_type (struct type
*t
)
3648 t
= check_typedef (t
);
3651 && ((t
->code () == TYPE_CODE_FLT
)
3652 || (t
->code () == TYPE_CODE_DECFLOAT
)));
3655 /* Return true if TYPE is scalar. */
3658 is_scalar_type (struct type
*type
)
3660 type
= check_typedef (type
);
3662 if (is_fixed_point_type (type
))
3663 return 0; /* Implemented as a scalar, but more like a floating point. */
3665 switch (type
->code ())
3667 case TYPE_CODE_ARRAY
:
3668 case TYPE_CODE_STRUCT
:
3669 case TYPE_CODE_UNION
:
3671 case TYPE_CODE_STRING
:
3678 /* Return true if T is scalar, or a composite type which in practice has
3679 the memory layout of a scalar type. E.g., an array or struct with only
3680 one scalar element inside it, or a union with only scalar elements. */
3683 is_scalar_type_recursive (struct type
*t
)
3685 t
= check_typedef (t
);
3687 if (is_scalar_type (t
))
3689 /* Are we dealing with an array or string of known dimensions? */
3690 else if ((t
->code () == TYPE_CODE_ARRAY
3691 || t
->code () == TYPE_CODE_STRING
) && t
->num_fields () == 1
3692 && t
->index_type ()->code () == TYPE_CODE_RANGE
)
3694 LONGEST low_bound
, high_bound
;
3695 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (t
));
3697 if (get_discrete_bounds (t
->index_type (), &low_bound
, &high_bound
))
3698 return (high_bound
== low_bound
3699 && is_scalar_type_recursive (elt_type
));
3703 /* Are we dealing with a struct with one element? */
3704 else if (t
->code () == TYPE_CODE_STRUCT
&& t
->num_fields () == 1)
3705 return is_scalar_type_recursive (t
->field (0).type ());
3706 else if (t
->code () == TYPE_CODE_UNION
)
3708 int i
, n
= t
->num_fields ();
3710 /* If all elements of the union are scalar, then the union is scalar. */
3711 for (i
= 0; i
< n
; i
++)
3712 if (!is_scalar_type_recursive (t
->field (i
).type ()))
3721 /* Return true is T is a class or a union. False otherwise. */
3724 class_or_union_p (const struct type
*t
)
3726 return (t
->code () == TYPE_CODE_STRUCT
3727 || t
->code () == TYPE_CODE_UNION
);
3730 /* A helper function which returns true if types A and B represent the
3731 "same" class type. This is true if the types have the same main
3732 type, or the same name. */
3735 class_types_same_p (const struct type
*a
, const struct type
*b
)
3737 return (TYPE_MAIN_TYPE (a
) == TYPE_MAIN_TYPE (b
)
3738 || (a
->name () && b
->name ()
3739 && !strcmp (a
->name (), b
->name ())));
3742 /* If BASE is an ancestor of DCLASS return the distance between them.
3743 otherwise return -1;
3747 class B: public A {};
3748 class C: public B {};
3751 distance_to_ancestor (A, A, 0) = 0
3752 distance_to_ancestor (A, B, 0) = 1
3753 distance_to_ancestor (A, C, 0) = 2
3754 distance_to_ancestor (A, D, 0) = 3
3756 If PUBLIC is 1 then only public ancestors are considered,
3757 and the function returns the distance only if BASE is a public ancestor
3761 distance_to_ancestor (A, D, 1) = -1. */
3764 distance_to_ancestor (struct type
*base
, struct type
*dclass
, int is_public
)
3769 base
= check_typedef (base
);
3770 dclass
= check_typedef (dclass
);
3772 if (class_types_same_p (base
, dclass
))
3775 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
3777 if (is_public
&& ! BASETYPE_VIA_PUBLIC (dclass
, i
))
3780 d
= distance_to_ancestor (base
, TYPE_BASECLASS (dclass
, i
), is_public
);
3788 /* Check whether BASE is an ancestor or base class or DCLASS
3789 Return 1 if so, and 0 if not.
3790 Note: If BASE and DCLASS are of the same type, this function
3791 will return 1. So for some class A, is_ancestor (A, A) will
3795 is_ancestor (struct type
*base
, struct type
*dclass
)
3797 return distance_to_ancestor (base
, dclass
, 0) >= 0;
3800 /* Like is_ancestor, but only returns true when BASE is a public
3801 ancestor of DCLASS. */
3804 is_public_ancestor (struct type
*base
, struct type
*dclass
)
3806 return distance_to_ancestor (base
, dclass
, 1) >= 0;
3809 /* A helper function for is_unique_ancestor. */
3812 is_unique_ancestor_worker (struct type
*base
, struct type
*dclass
,
3814 const gdb_byte
*valaddr
, int embedded_offset
,
3815 CORE_ADDR address
, struct value
*val
)
3819 base
= check_typedef (base
);
3820 dclass
= check_typedef (dclass
);
3822 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
) && count
< 2; ++i
)
3827 iter
= check_typedef (TYPE_BASECLASS (dclass
, i
));
3829 this_offset
= baseclass_offset (dclass
, i
, valaddr
, embedded_offset
,
3832 if (class_types_same_p (base
, iter
))
3834 /* If this is the first subclass, set *OFFSET and set count
3835 to 1. Otherwise, if this is at the same offset as
3836 previous instances, do nothing. Otherwise, increment
3840 *offset
= this_offset
;
3843 else if (this_offset
== *offset
)
3851 count
+= is_unique_ancestor_worker (base
, iter
, offset
,
3853 embedded_offset
+ this_offset
,
3860 /* Like is_ancestor, but only returns true if BASE is a unique base
3861 class of the type of VAL. */
3864 is_unique_ancestor (struct type
*base
, struct value
*val
)
3868 return is_unique_ancestor_worker (base
, value_type (val
), &offset
,
3869 value_contents_for_printing (val
),
3870 value_embedded_offset (val
),
3871 value_address (val
), val
) == 1;
3874 /* See gdbtypes.h. */
3877 type_byte_order (const struct type
*type
)
3879 bfd_endian byteorder
= gdbarch_byte_order (get_type_arch (type
));
3880 if (type
->endianity_is_not_default ())
3882 if (byteorder
== BFD_ENDIAN_BIG
)
3883 return BFD_ENDIAN_LITTLE
;
3886 gdb_assert (byteorder
== BFD_ENDIAN_LITTLE
);
3887 return BFD_ENDIAN_BIG
;
3895 /* Overload resolution. */
3897 /* Return the sum of the rank of A with the rank of B. */
3900 sum_ranks (struct rank a
, struct rank b
)
3903 c
.rank
= a
.rank
+ b
.rank
;
3904 c
.subrank
= a
.subrank
+ b
.subrank
;
3908 /* Compare rank A and B and return:
3910 1 if a is better than b
3911 -1 if b is better than a. */
3914 compare_ranks (struct rank a
, struct rank b
)
3916 if (a
.rank
== b
.rank
)
3918 if (a
.subrank
== b
.subrank
)
3920 if (a
.subrank
< b
.subrank
)
3922 if (a
.subrank
> b
.subrank
)
3926 if (a
.rank
< b
.rank
)
3929 /* a.rank > b.rank */
3933 /* Functions for overload resolution begin here. */
3935 /* Compare two badness vectors A and B and return the result.
3936 0 => A and B are identical
3937 1 => A and B are incomparable
3938 2 => A is better than B
3939 3 => A is worse than B */
3942 compare_badness (const badness_vector
&a
, const badness_vector
&b
)
3946 short found_pos
= 0; /* any positives in c? */
3947 short found_neg
= 0; /* any negatives in c? */
3949 /* differing sizes => incomparable */
3950 if (a
.size () != b
.size ())
3953 /* Subtract b from a */
3954 for (i
= 0; i
< a
.size (); i
++)
3956 tmp
= compare_ranks (b
[i
], a
[i
]);
3966 return 1; /* incomparable */
3968 return 3; /* A > B */
3974 return 2; /* A < B */
3976 return 0; /* A == B */
3980 /* Rank a function by comparing its parameter types (PARMS), to the
3981 types of an argument list (ARGS). Return the badness vector. This
3982 has ARGS.size() + 1 entries. */
3985 rank_function (gdb::array_view
<type
*> parms
,
3986 gdb::array_view
<value
*> args
)
3988 /* add 1 for the length-match rank. */
3990 bv
.reserve (1 + args
.size ());
3992 /* First compare the lengths of the supplied lists.
3993 If there is a mismatch, set it to a high value. */
3995 /* pai/1997-06-03 FIXME: when we have debug info about default
3996 arguments and ellipsis parameter lists, we should consider those
3997 and rank the length-match more finely. */
3999 bv
.push_back ((args
.size () != parms
.size ())
4000 ? LENGTH_MISMATCH_BADNESS
4001 : EXACT_MATCH_BADNESS
);
4003 /* Now rank all the parameters of the candidate function. */
4004 size_t min_len
= std::min (parms
.size (), args
.size ());
4006 for (size_t i
= 0; i
< min_len
; i
++)
4007 bv
.push_back (rank_one_type (parms
[i
], value_type (args
[i
]),
4010 /* If more arguments than parameters, add dummy entries. */
4011 for (size_t i
= min_len
; i
< args
.size (); i
++)
4012 bv
.push_back (TOO_FEW_PARAMS_BADNESS
);
4017 /* Compare the names of two integer types, assuming that any sign
4018 qualifiers have been checked already. We do it this way because
4019 there may be an "int" in the name of one of the types. */
4022 integer_types_same_name_p (const char *first
, const char *second
)
4024 int first_p
, second_p
;
4026 /* If both are shorts, return 1; if neither is a short, keep
4028 first_p
= (strstr (first
, "short") != NULL
);
4029 second_p
= (strstr (second
, "short") != NULL
);
4030 if (first_p
&& second_p
)
4032 if (first_p
|| second_p
)
4035 /* Likewise for long. */
4036 first_p
= (strstr (first
, "long") != NULL
);
4037 second_p
= (strstr (second
, "long") != NULL
);
4038 if (first_p
&& second_p
)
4040 if (first_p
|| second_p
)
4043 /* Likewise for char. */
4044 first_p
= (strstr (first
, "char") != NULL
);
4045 second_p
= (strstr (second
, "char") != NULL
);
4046 if (first_p
&& second_p
)
4048 if (first_p
|| second_p
)
4051 /* They must both be ints. */
4055 /* Compares type A to type B. Returns true if they represent the same
4056 type, false otherwise. */
4059 types_equal (struct type
*a
, struct type
*b
)
4061 /* Identical type pointers. */
4062 /* However, this still doesn't catch all cases of same type for b
4063 and a. The reason is that builtin types are different from
4064 the same ones constructed from the object. */
4068 /* Resolve typedefs */
4069 if (a
->code () == TYPE_CODE_TYPEDEF
)
4070 a
= check_typedef (a
);
4071 if (b
->code () == TYPE_CODE_TYPEDEF
)
4072 b
= check_typedef (b
);
4074 /* If after resolving typedefs a and b are not of the same type
4075 code then they are not equal. */
4076 if (a
->code () != b
->code ())
4079 /* If a and b are both pointers types or both reference types then
4080 they are equal of the same type iff the objects they refer to are
4081 of the same type. */
4082 if (a
->code () == TYPE_CODE_PTR
4083 || a
->code () == TYPE_CODE_REF
)
4084 return types_equal (TYPE_TARGET_TYPE (a
),
4085 TYPE_TARGET_TYPE (b
));
4087 /* Well, damnit, if the names are exactly the same, I'll say they
4088 are exactly the same. This happens when we generate method
4089 stubs. The types won't point to the same address, but they
4090 really are the same. */
4092 if (a
->name () && b
->name ()
4093 && strcmp (a
->name (), b
->name ()) == 0)
4096 /* Check if identical after resolving typedefs. */
4100 /* Two function types are equal if their argument and return types
4102 if (a
->code () == TYPE_CODE_FUNC
)
4106 if (a
->num_fields () != b
->num_fields ())
4109 if (!types_equal (TYPE_TARGET_TYPE (a
), TYPE_TARGET_TYPE (b
)))
4112 for (i
= 0; i
< a
->num_fields (); ++i
)
4113 if (!types_equal (a
->field (i
).type (), b
->field (i
).type ()))
4122 /* Deep comparison of types. */
4124 /* An entry in the type-equality bcache. */
4126 struct type_equality_entry
4128 type_equality_entry (struct type
*t1
, struct type
*t2
)
4134 struct type
*type1
, *type2
;
4137 /* A helper function to compare two strings. Returns true if they are
4138 the same, false otherwise. Handles NULLs properly. */
4141 compare_maybe_null_strings (const char *s
, const char *t
)
4143 if (s
== NULL
|| t
== NULL
)
4145 return strcmp (s
, t
) == 0;
4148 /* A helper function for check_types_worklist that checks two types for
4149 "deep" equality. Returns true if the types are considered the
4150 same, false otherwise. */
4153 check_types_equal (struct type
*type1
, struct type
*type2
,
4154 std::vector
<type_equality_entry
> *worklist
)
4156 type1
= check_typedef (type1
);
4157 type2
= check_typedef (type2
);
4162 if (type1
->code () != type2
->code ()
4163 || TYPE_LENGTH (type1
) != TYPE_LENGTH (type2
)
4164 || type1
->is_unsigned () != type2
->is_unsigned ()
4165 || type1
->has_no_signedness () != type2
->has_no_signedness ()
4166 || type1
->endianity_is_not_default () != type2
->endianity_is_not_default ()
4167 || type1
->has_varargs () != type2
->has_varargs ()
4168 || type1
->is_vector () != type2
->is_vector ()
4169 || TYPE_NOTTEXT (type1
) != TYPE_NOTTEXT (type2
)
4170 || type1
->instance_flags () != type2
->instance_flags ()
4171 || type1
->num_fields () != type2
->num_fields ())
4174 if (!compare_maybe_null_strings (type1
->name (), type2
->name ()))
4176 if (!compare_maybe_null_strings (type1
->name (), type2
->name ()))
4179 if (type1
->code () == TYPE_CODE_RANGE
)
4181 if (*type1
->bounds () != *type2
->bounds ())
4188 for (i
= 0; i
< type1
->num_fields (); ++i
)
4190 const struct field
*field1
= &type1
->field (i
);
4191 const struct field
*field2
= &type2
->field (i
);
4193 if (FIELD_ARTIFICIAL (*field1
) != FIELD_ARTIFICIAL (*field2
)
4194 || FIELD_BITSIZE (*field1
) != FIELD_BITSIZE (*field2
)
4195 || FIELD_LOC_KIND (*field1
) != FIELD_LOC_KIND (*field2
))
4197 if (!compare_maybe_null_strings (FIELD_NAME (*field1
),
4198 FIELD_NAME (*field2
)))
4200 switch (FIELD_LOC_KIND (*field1
))
4202 case FIELD_LOC_KIND_BITPOS
:
4203 if (FIELD_BITPOS (*field1
) != FIELD_BITPOS (*field2
))
4206 case FIELD_LOC_KIND_ENUMVAL
:
4207 if (FIELD_ENUMVAL (*field1
) != FIELD_ENUMVAL (*field2
))
4209 /* Don't compare types of enum fields, because they don't
4212 case FIELD_LOC_KIND_PHYSADDR
:
4213 if (FIELD_STATIC_PHYSADDR (*field1
)
4214 != FIELD_STATIC_PHYSADDR (*field2
))
4217 case FIELD_LOC_KIND_PHYSNAME
:
4218 if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1
),
4219 FIELD_STATIC_PHYSNAME (*field2
)))
4222 case FIELD_LOC_KIND_DWARF_BLOCK
:
4224 struct dwarf2_locexpr_baton
*block1
, *block2
;
4226 block1
= FIELD_DWARF_BLOCK (*field1
);
4227 block2
= FIELD_DWARF_BLOCK (*field2
);
4228 if (block1
->per_cu
!= block2
->per_cu
4229 || block1
->size
!= block2
->size
4230 || memcmp (block1
->data
, block2
->data
, block1
->size
) != 0)
4235 internal_error (__FILE__
, __LINE__
, _("Unsupported field kind "
4236 "%d by check_types_equal"),
4237 FIELD_LOC_KIND (*field1
));
4240 worklist
->emplace_back (field1
->type (), field2
->type ());
4244 if (TYPE_TARGET_TYPE (type1
) != NULL
)
4246 if (TYPE_TARGET_TYPE (type2
) == NULL
)
4249 worklist
->emplace_back (TYPE_TARGET_TYPE (type1
),
4250 TYPE_TARGET_TYPE (type2
));
4252 else if (TYPE_TARGET_TYPE (type2
) != NULL
)
4258 /* Check types on a worklist for equality. Returns false if any pair
4259 is not equal, true if they are all considered equal. */
4262 check_types_worklist (std::vector
<type_equality_entry
> *worklist
,
4265 while (!worklist
->empty ())
4269 struct type_equality_entry entry
= std::move (worklist
->back ());
4270 worklist
->pop_back ();
4272 /* If the type pair has already been visited, we know it is
4274 cache
->insert (&entry
, sizeof (entry
), &added
);
4278 if (!check_types_equal (entry
.type1
, entry
.type2
, worklist
))
4285 /* Return true if types TYPE1 and TYPE2 are equal, as determined by a
4286 "deep comparison". Otherwise return false. */
4289 types_deeply_equal (struct type
*type1
, struct type
*type2
)
4291 std::vector
<type_equality_entry
> worklist
;
4293 gdb_assert (type1
!= NULL
&& type2
!= NULL
);
4295 /* Early exit for the simple case. */
4300 worklist
.emplace_back (type1
, type2
);
4301 return check_types_worklist (&worklist
, &cache
);
4304 /* Allocated status of type TYPE. Return zero if type TYPE is allocated.
4305 Otherwise return one. */
4308 type_not_allocated (const struct type
*type
)
4310 struct dynamic_prop
*prop
= TYPE_ALLOCATED_PROP (type
);
4312 return (prop
!= nullptr && prop
->kind () == PROP_CONST
4313 && prop
->const_val () == 0);
4316 /* Associated status of type TYPE. Return zero if type TYPE is associated.
4317 Otherwise return one. */
4320 type_not_associated (const struct type
*type
)
4322 struct dynamic_prop
*prop
= TYPE_ASSOCIATED_PROP (type
);
4324 return (prop
!= nullptr && prop
->kind () == PROP_CONST
4325 && prop
->const_val () == 0);
4328 /* rank_one_type helper for when PARM's type code is TYPE_CODE_PTR. */
4331 rank_one_type_parm_ptr (struct type
*parm
, struct type
*arg
, struct value
*value
)
4333 struct rank rank
= {0,0};
4335 switch (arg
->code ())
4339 /* Allowed pointer conversions are:
4340 (a) pointer to void-pointer conversion. */
4341 if (TYPE_TARGET_TYPE (parm
)->code () == TYPE_CODE_VOID
)
4342 return VOID_PTR_CONVERSION_BADNESS
;
4344 /* (b) pointer to ancestor-pointer conversion. */
4345 rank
.subrank
= distance_to_ancestor (TYPE_TARGET_TYPE (parm
),
4346 TYPE_TARGET_TYPE (arg
),
4348 if (rank
.subrank
>= 0)
4349 return sum_ranks (BASE_PTR_CONVERSION_BADNESS
, rank
);
4351 return INCOMPATIBLE_TYPE_BADNESS
;
4352 case TYPE_CODE_ARRAY
:
4354 struct type
*t1
= TYPE_TARGET_TYPE (parm
);
4355 struct type
*t2
= TYPE_TARGET_TYPE (arg
);
4357 if (types_equal (t1
, t2
))
4359 /* Make sure they are CV equal. */
4360 if (TYPE_CONST (t1
) != TYPE_CONST (t2
))
4361 rank
.subrank
|= CV_CONVERSION_CONST
;
4362 if (TYPE_VOLATILE (t1
) != TYPE_VOLATILE (t2
))
4363 rank
.subrank
|= CV_CONVERSION_VOLATILE
;
4364 if (rank
.subrank
!= 0)
4365 return sum_ranks (CV_CONVERSION_BADNESS
, rank
);
4366 return EXACT_MATCH_BADNESS
;
4368 return INCOMPATIBLE_TYPE_BADNESS
;
4370 case TYPE_CODE_FUNC
:
4371 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
);
4373 if (value
!= NULL
&& value_type (value
)->code () == TYPE_CODE_INT
)
4375 if (value_as_long (value
) == 0)
4377 /* Null pointer conversion: allow it to be cast to a pointer.
4378 [4.10.1 of C++ standard draft n3290] */
4379 return NULL_POINTER_CONVERSION_BADNESS
;
4383 /* If type checking is disabled, allow the conversion. */
4384 if (!strict_type_checking
)
4385 return NS_INTEGER_POINTER_CONVERSION_BADNESS
;
4389 case TYPE_CODE_ENUM
:
4390 case TYPE_CODE_FLAGS
:
4391 case TYPE_CODE_CHAR
:
4392 case TYPE_CODE_RANGE
:
4393 case TYPE_CODE_BOOL
:
4395 return INCOMPATIBLE_TYPE_BADNESS
;
4399 /* rank_one_type helper for when PARM's type code is TYPE_CODE_ARRAY. */
4402 rank_one_type_parm_array (struct type
*parm
, struct type
*arg
, struct value
*value
)
4404 switch (arg
->code ())
4407 case TYPE_CODE_ARRAY
:
4408 return rank_one_type (TYPE_TARGET_TYPE (parm
),
4409 TYPE_TARGET_TYPE (arg
), NULL
);
4411 return INCOMPATIBLE_TYPE_BADNESS
;
4415 /* rank_one_type helper for when PARM's type code is TYPE_CODE_FUNC. */
4418 rank_one_type_parm_func (struct type
*parm
, struct type
*arg
, struct value
*value
)
4420 switch (arg
->code ())
4422 case TYPE_CODE_PTR
: /* funcptr -> func */
4423 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
);
4425 return INCOMPATIBLE_TYPE_BADNESS
;
4429 /* rank_one_type helper for when PARM's type code is TYPE_CODE_INT. */
4432 rank_one_type_parm_int (struct type
*parm
, struct type
*arg
, struct value
*value
)
4434 switch (arg
->code ())
4437 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
4439 /* Deal with signed, unsigned, and plain chars and
4440 signed and unsigned ints. */
4441 if (parm
->has_no_signedness ())
4443 /* This case only for character types. */
4444 if (arg
->has_no_signedness ())
4445 return EXACT_MATCH_BADNESS
; /* plain char -> plain char */
4446 else /* signed/unsigned char -> plain char */
4447 return INTEGER_CONVERSION_BADNESS
;
4449 else if (parm
->is_unsigned ())
4451 if (arg
->is_unsigned ())
4453 /* unsigned int -> unsigned int, or
4454 unsigned long -> unsigned long */
4455 if (integer_types_same_name_p (parm
->name (),
4457 return EXACT_MATCH_BADNESS
;
4458 else if (integer_types_same_name_p (arg
->name (),
4460 && integer_types_same_name_p (parm
->name (),
4462 /* unsigned int -> unsigned long */
4463 return INTEGER_PROMOTION_BADNESS
;
4465 /* unsigned long -> unsigned int */
4466 return INTEGER_CONVERSION_BADNESS
;
4470 if (integer_types_same_name_p (arg
->name (),
4472 && integer_types_same_name_p (parm
->name (),
4474 /* signed long -> unsigned int */
4475 return INTEGER_CONVERSION_BADNESS
;
4477 /* signed int/long -> unsigned int/long */
4478 return INTEGER_CONVERSION_BADNESS
;
4481 else if (!arg
->has_no_signedness () && !arg
->is_unsigned ())
4483 if (integer_types_same_name_p (parm
->name (),
4485 return EXACT_MATCH_BADNESS
;
4486 else if (integer_types_same_name_p (arg
->name (),
4488 && integer_types_same_name_p (parm
->name (),
4490 return INTEGER_PROMOTION_BADNESS
;
4492 return INTEGER_CONVERSION_BADNESS
;
4495 return INTEGER_CONVERSION_BADNESS
;
4497 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
4498 return INTEGER_PROMOTION_BADNESS
;
4500 return INTEGER_CONVERSION_BADNESS
;
4501 case TYPE_CODE_ENUM
:
4502 case TYPE_CODE_FLAGS
:
4503 case TYPE_CODE_CHAR
:
4504 case TYPE_CODE_RANGE
:
4505 case TYPE_CODE_BOOL
:
4506 if (TYPE_DECLARED_CLASS (arg
))
4507 return INCOMPATIBLE_TYPE_BADNESS
;
4508 return INTEGER_PROMOTION_BADNESS
;
4510 return INT_FLOAT_CONVERSION_BADNESS
;
4512 return NS_POINTER_CONVERSION_BADNESS
;
4514 return INCOMPATIBLE_TYPE_BADNESS
;
4518 /* rank_one_type helper for when PARM's type code is TYPE_CODE_ENUM. */
4521 rank_one_type_parm_enum (struct type
*parm
, struct type
*arg
, struct value
*value
)
4523 switch (arg
->code ())
4526 case TYPE_CODE_CHAR
:
4527 case TYPE_CODE_RANGE
:
4528 case TYPE_CODE_BOOL
:
4529 case TYPE_CODE_ENUM
:
4530 if (TYPE_DECLARED_CLASS (parm
) || TYPE_DECLARED_CLASS (arg
))
4531 return INCOMPATIBLE_TYPE_BADNESS
;
4532 return INTEGER_CONVERSION_BADNESS
;
4534 return INT_FLOAT_CONVERSION_BADNESS
;
4536 return INCOMPATIBLE_TYPE_BADNESS
;
4540 /* rank_one_type helper for when PARM's type code is TYPE_CODE_CHAR. */
4543 rank_one_type_parm_char (struct type
*parm
, struct type
*arg
, struct value
*value
)
4545 switch (arg
->code ())
4547 case TYPE_CODE_RANGE
:
4548 case TYPE_CODE_BOOL
:
4549 case TYPE_CODE_ENUM
:
4550 if (TYPE_DECLARED_CLASS (arg
))
4551 return INCOMPATIBLE_TYPE_BADNESS
;
4552 return INTEGER_CONVERSION_BADNESS
;
4554 return INT_FLOAT_CONVERSION_BADNESS
;
4556 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
4557 return INTEGER_CONVERSION_BADNESS
;
4558 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
4559 return INTEGER_PROMOTION_BADNESS
;
4561 case TYPE_CODE_CHAR
:
4562 /* Deal with signed, unsigned, and plain chars for C++ and
4563 with int cases falling through from previous case. */
4564 if (parm
->has_no_signedness ())
4566 if (arg
->has_no_signedness ())
4567 return EXACT_MATCH_BADNESS
;
4569 return INTEGER_CONVERSION_BADNESS
;
4571 else if (parm
->is_unsigned ())
4573 if (arg
->is_unsigned ())
4574 return EXACT_MATCH_BADNESS
;
4576 return INTEGER_PROMOTION_BADNESS
;
4578 else if (!arg
->has_no_signedness () && !arg
->is_unsigned ())
4579 return EXACT_MATCH_BADNESS
;
4581 return INTEGER_CONVERSION_BADNESS
;
4583 return INCOMPATIBLE_TYPE_BADNESS
;
4587 /* rank_one_type helper for when PARM's type code is TYPE_CODE_RANGE. */
4590 rank_one_type_parm_range (struct type
*parm
, struct type
*arg
, struct value
*value
)
4592 switch (arg
->code ())
4595 case TYPE_CODE_CHAR
:
4596 case TYPE_CODE_RANGE
:
4597 case TYPE_CODE_BOOL
:
4598 case TYPE_CODE_ENUM
:
4599 return INTEGER_CONVERSION_BADNESS
;
4601 return INT_FLOAT_CONVERSION_BADNESS
;
4603 return INCOMPATIBLE_TYPE_BADNESS
;
4607 /* rank_one_type helper for when PARM's type code is TYPE_CODE_BOOL. */
4610 rank_one_type_parm_bool (struct type
*parm
, struct type
*arg
, struct value
*value
)
4612 switch (arg
->code ())
4614 /* n3290 draft, section 4.12.1 (conv.bool):
4616 "A prvalue of arithmetic, unscoped enumeration, pointer, or
4617 pointer to member type can be converted to a prvalue of type
4618 bool. A zero value, null pointer value, or null member pointer
4619 value is converted to false; any other value is converted to
4620 true. A prvalue of type std::nullptr_t can be converted to a
4621 prvalue of type bool; the resulting value is false." */
4623 case TYPE_CODE_CHAR
:
4624 case TYPE_CODE_ENUM
:
4626 case TYPE_CODE_MEMBERPTR
:
4628 return BOOL_CONVERSION_BADNESS
;
4629 case TYPE_CODE_RANGE
:
4630 return INCOMPATIBLE_TYPE_BADNESS
;
4631 case TYPE_CODE_BOOL
:
4632 return EXACT_MATCH_BADNESS
;
4634 return INCOMPATIBLE_TYPE_BADNESS
;
4638 /* rank_one_type helper for when PARM's type code is TYPE_CODE_FLOAT. */
4641 rank_one_type_parm_float (struct type
*parm
, struct type
*arg
, struct value
*value
)
4643 switch (arg
->code ())
4646 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
4647 return FLOAT_PROMOTION_BADNESS
;
4648 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
4649 return EXACT_MATCH_BADNESS
;
4651 return FLOAT_CONVERSION_BADNESS
;
4653 case TYPE_CODE_BOOL
:
4654 case TYPE_CODE_ENUM
:
4655 case TYPE_CODE_RANGE
:
4656 case TYPE_CODE_CHAR
:
4657 return INT_FLOAT_CONVERSION_BADNESS
;
4659 return INCOMPATIBLE_TYPE_BADNESS
;
4663 /* rank_one_type helper for when PARM's type code is TYPE_CODE_COMPLEX. */
4666 rank_one_type_parm_complex (struct type
*parm
, struct type
*arg
, struct value
*value
)
4668 switch (arg
->code ())
4669 { /* Strictly not needed for C++, but... */
4671 return FLOAT_PROMOTION_BADNESS
;
4672 case TYPE_CODE_COMPLEX
:
4673 return EXACT_MATCH_BADNESS
;
4675 return INCOMPATIBLE_TYPE_BADNESS
;
4679 /* rank_one_type helper for when PARM's type code is TYPE_CODE_STRUCT. */
4682 rank_one_type_parm_struct (struct type
*parm
, struct type
*arg
, struct value
*value
)
4684 struct rank rank
= {0, 0};
4686 switch (arg
->code ())
4688 case TYPE_CODE_STRUCT
:
4689 /* Check for derivation */
4690 rank
.subrank
= distance_to_ancestor (parm
, arg
, 0);
4691 if (rank
.subrank
>= 0)
4692 return sum_ranks (BASE_CONVERSION_BADNESS
, rank
);
4695 return INCOMPATIBLE_TYPE_BADNESS
;
4699 /* rank_one_type helper for when PARM's type code is TYPE_CODE_SET. */
4702 rank_one_type_parm_set (struct type
*parm
, struct type
*arg
, struct value
*value
)
4704 switch (arg
->code ())
4708 return rank_one_type (parm
->field (0).type (),
4709 arg
->field (0).type (), NULL
);
4711 return INCOMPATIBLE_TYPE_BADNESS
;
4715 /* Compare one type (PARM) for compatibility with another (ARG).
4716 * PARM is intended to be the parameter type of a function; and
4717 * ARG is the supplied argument's type. This function tests if
4718 * the latter can be converted to the former.
4719 * VALUE is the argument's value or NULL if none (or called recursively)
4721 * Return 0 if they are identical types;
4722 * Otherwise, return an integer which corresponds to how compatible
4723 * PARM is to ARG. The higher the return value, the worse the match.
4724 * Generally the "bad" conversions are all uniformly assigned a 100. */
4727 rank_one_type (struct type
*parm
, struct type
*arg
, struct value
*value
)
4729 struct rank rank
= {0,0};
4731 /* Resolve typedefs */
4732 if (parm
->code () == TYPE_CODE_TYPEDEF
)
4733 parm
= check_typedef (parm
);
4734 if (arg
->code () == TYPE_CODE_TYPEDEF
)
4735 arg
= check_typedef (arg
);
4737 if (TYPE_IS_REFERENCE (parm
) && value
!= NULL
)
4739 if (VALUE_LVAL (value
) == not_lval
)
4741 /* Rvalues should preferably bind to rvalue references or const
4742 lvalue references. */
4743 if (parm
->code () == TYPE_CODE_RVALUE_REF
)
4744 rank
.subrank
= REFERENCE_CONVERSION_RVALUE
;
4745 else if (TYPE_CONST (TYPE_TARGET_TYPE (parm
)))
4746 rank
.subrank
= REFERENCE_CONVERSION_CONST_LVALUE
;
4748 return INCOMPATIBLE_TYPE_BADNESS
;
4749 return sum_ranks (rank
, REFERENCE_CONVERSION_BADNESS
);
4753 /* It's illegal to pass an lvalue as an rvalue. */
4754 if (parm
->code () == TYPE_CODE_RVALUE_REF
)
4755 return INCOMPATIBLE_TYPE_BADNESS
;
4759 if (types_equal (parm
, arg
))
4761 struct type
*t1
= parm
;
4762 struct type
*t2
= arg
;
4764 /* For pointers and references, compare target type. */
4765 if (parm
->code () == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (parm
))
4767 t1
= TYPE_TARGET_TYPE (parm
);
4768 t2
= TYPE_TARGET_TYPE (arg
);
4771 /* Make sure they are CV equal, too. */
4772 if (TYPE_CONST (t1
) != TYPE_CONST (t2
))
4773 rank
.subrank
|= CV_CONVERSION_CONST
;
4774 if (TYPE_VOLATILE (t1
) != TYPE_VOLATILE (t2
))
4775 rank
.subrank
|= CV_CONVERSION_VOLATILE
;
4776 if (rank
.subrank
!= 0)
4777 return sum_ranks (CV_CONVERSION_BADNESS
, rank
);
4778 return EXACT_MATCH_BADNESS
;
4781 /* See through references, since we can almost make non-references
4784 if (TYPE_IS_REFERENCE (arg
))
4785 return (sum_ranks (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
),
4786 REFERENCE_SEE_THROUGH_BADNESS
));
4787 if (TYPE_IS_REFERENCE (parm
))
4788 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
),
4789 REFERENCE_SEE_THROUGH_BADNESS
));
4791 /* Debugging only. */
4792 fprintf_filtered (gdb_stderr
,
4793 "------ Arg is %s [%d], parm is %s [%d]\n",
4794 arg
->name (), arg
->code (),
4795 parm
->name (), parm
->code ());
4797 /* x -> y means arg of type x being supplied for parameter of type y. */
4799 switch (parm
->code ())
4802 return rank_one_type_parm_ptr (parm
, arg
, value
);
4803 case TYPE_CODE_ARRAY
:
4804 return rank_one_type_parm_array (parm
, arg
, value
);
4805 case TYPE_CODE_FUNC
:
4806 return rank_one_type_parm_func (parm
, arg
, value
);
4808 return rank_one_type_parm_int (parm
, arg
, value
);
4809 case TYPE_CODE_ENUM
:
4810 return rank_one_type_parm_enum (parm
, arg
, value
);
4811 case TYPE_CODE_CHAR
:
4812 return rank_one_type_parm_char (parm
, arg
, value
);
4813 case TYPE_CODE_RANGE
:
4814 return rank_one_type_parm_range (parm
, arg
, value
);
4815 case TYPE_CODE_BOOL
:
4816 return rank_one_type_parm_bool (parm
, arg
, value
);
4818 return rank_one_type_parm_float (parm
, arg
, value
);
4819 case TYPE_CODE_COMPLEX
:
4820 return rank_one_type_parm_complex (parm
, arg
, value
);
4821 case TYPE_CODE_STRUCT
:
4822 return rank_one_type_parm_struct (parm
, arg
, value
);
4824 return rank_one_type_parm_set (parm
, arg
, value
);
4826 return INCOMPATIBLE_TYPE_BADNESS
;
4827 } /* switch (arg->code ()) */
4830 /* End of functions for overload resolution. */
4832 /* Routines to pretty-print types. */
4835 print_bit_vector (B_TYPE
*bits
, int nbits
)
4839 for (bitno
= 0; bitno
< nbits
; bitno
++)
4841 if ((bitno
% 8) == 0)
4843 puts_filtered (" ");
4845 if (B_TST (bits
, bitno
))
4846 printf_filtered (("1"));
4848 printf_filtered (("0"));
4852 /* Note the first arg should be the "this" pointer, we may not want to
4853 include it since we may get into a infinitely recursive
4857 print_args (struct field
*args
, int nargs
, int spaces
)
4863 for (i
= 0; i
< nargs
; i
++)
4865 printf_filtered ("%*s[%d] name '%s'\n", spaces
, "", i
,
4866 args
[i
].name
!= NULL
? args
[i
].name
: "<NULL>");
4867 recursive_dump_type (args
[i
].type (), spaces
+ 2);
4873 field_is_static (struct field
*f
)
4875 /* "static" fields are the fields whose location is not relative
4876 to the address of the enclosing struct. It would be nice to
4877 have a dedicated flag that would be set for static fields when
4878 the type is being created. But in practice, checking the field
4879 loc_kind should give us an accurate answer. */
4880 return (FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSNAME
4881 || FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSADDR
);
4885 dump_fn_fieldlists (struct type
*type
, int spaces
)
4891 printf_filtered ("%*sfn_fieldlists ", spaces
, "");
4892 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
4893 printf_filtered ("\n");
4894 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
4896 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
4897 printf_filtered ("%*s[%d] name '%s' (", spaces
+ 2, "",
4899 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
4900 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
4902 printf_filtered (_(") length %d\n"),
4903 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
4904 for (overload_idx
= 0;
4905 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
4908 printf_filtered ("%*s[%d] physname '%s' (",
4909 spaces
+ 4, "", overload_idx
,
4910 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
4911 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
4913 printf_filtered (")\n");
4914 printf_filtered ("%*stype ", spaces
+ 8, "");
4915 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
4917 printf_filtered ("\n");
4919 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
4922 printf_filtered ("%*sargs ", spaces
+ 8, "");
4923 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
4925 printf_filtered ("\n");
4926 print_args (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
4927 TYPE_FN_FIELD_TYPE (f
, overload_idx
)->num_fields (),
4929 printf_filtered ("%*sfcontext ", spaces
+ 8, "");
4930 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
4932 printf_filtered ("\n");
4934 printf_filtered ("%*sis_const %d\n", spaces
+ 8, "",
4935 TYPE_FN_FIELD_CONST (f
, overload_idx
));
4936 printf_filtered ("%*sis_volatile %d\n", spaces
+ 8, "",
4937 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
4938 printf_filtered ("%*sis_private %d\n", spaces
+ 8, "",
4939 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
4940 printf_filtered ("%*sis_protected %d\n", spaces
+ 8, "",
4941 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
4942 printf_filtered ("%*sis_stub %d\n", spaces
+ 8, "",
4943 TYPE_FN_FIELD_STUB (f
, overload_idx
));
4944 printf_filtered ("%*sdefaulted %d\n", spaces
+ 8, "",
4945 TYPE_FN_FIELD_DEFAULTED (f
, overload_idx
));
4946 printf_filtered ("%*sis_deleted %d\n", spaces
+ 8, "",
4947 TYPE_FN_FIELD_DELETED (f
, overload_idx
));
4948 printf_filtered ("%*svoffset %u\n", spaces
+ 8, "",
4949 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
4955 print_cplus_stuff (struct type
*type
, int spaces
)
4957 printf_filtered ("%*svptr_fieldno %d\n", spaces
, "",
4958 TYPE_VPTR_FIELDNO (type
));
4959 printf_filtered ("%*svptr_basetype ", spaces
, "");
4960 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
4961 puts_filtered ("\n");
4962 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
4963 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
4965 printf_filtered ("%*sn_baseclasses %d\n", spaces
, "",
4966 TYPE_N_BASECLASSES (type
));
4967 printf_filtered ("%*snfn_fields %d\n", spaces
, "",
4968 TYPE_NFN_FIELDS (type
));
4969 if (TYPE_N_BASECLASSES (type
) > 0)
4971 printf_filtered ("%*svirtual_field_bits (%d bits at *",
4972 spaces
, "", TYPE_N_BASECLASSES (type
));
4973 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
4975 printf_filtered (")");
4977 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
4978 TYPE_N_BASECLASSES (type
));
4979 puts_filtered ("\n");
4981 if (type
->num_fields () > 0)
4983 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
4985 printf_filtered ("%*sprivate_field_bits (%d bits at *",
4986 spaces
, "", type
->num_fields ());
4987 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
4989 printf_filtered (")");
4990 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
4991 type
->num_fields ());
4992 puts_filtered ("\n");
4994 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
4996 printf_filtered ("%*sprotected_field_bits (%d bits at *",
4997 spaces
, "", type
->num_fields ());
4998 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
5000 printf_filtered (")");
5001 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
5002 type
->num_fields ());
5003 puts_filtered ("\n");
5006 if (TYPE_NFN_FIELDS (type
) > 0)
5008 dump_fn_fieldlists (type
, spaces
);
5011 printf_filtered ("%*scalling_convention %d\n", spaces
, "",
5012 TYPE_CPLUS_CALLING_CONVENTION (type
));
5015 /* Print the contents of the TYPE's type_specific union, assuming that
5016 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
5019 print_gnat_stuff (struct type
*type
, int spaces
)
5021 struct type
*descriptive_type
= TYPE_DESCRIPTIVE_TYPE (type
);
5023 if (descriptive_type
== NULL
)
5024 printf_filtered ("%*sno descriptive type\n", spaces
+ 2, "");
5027 printf_filtered ("%*sdescriptive type\n", spaces
+ 2, "");
5028 recursive_dump_type (descriptive_type
, spaces
+ 4);
5032 /* Print the contents of the TYPE's type_specific union, assuming that
5033 its type-specific kind is TYPE_SPECIFIC_FIXED_POINT. */
5036 print_fixed_point_type_info (struct type
*type
, int spaces
)
5038 printf_filtered ("%*sscaling factor: %s\n", spaces
+ 2, "",
5039 type
->fixed_point_scaling_factor ().str ().c_str ());
5042 static struct obstack dont_print_type_obstack
;
5044 /* Print the dynamic_prop PROP. */
5047 dump_dynamic_prop (dynamic_prop
const& prop
)
5049 switch (prop
.kind ())
5052 printf_filtered ("%s", plongest (prop
.const_val ()));
5054 case PROP_UNDEFINED
:
5055 printf_filtered ("(undefined)");
5059 printf_filtered ("(dynamic)");
5062 gdb_assert_not_reached ("unhandled prop kind");
5068 recursive_dump_type (struct type
*type
, int spaces
)
5073 obstack_begin (&dont_print_type_obstack
, 0);
5075 if (type
->num_fields () > 0
5076 || (HAVE_CPLUS_STRUCT (type
) && TYPE_NFN_FIELDS (type
) > 0))
5078 struct type
**first_dont_print
5079 = (struct type
**) obstack_base (&dont_print_type_obstack
);
5081 int i
= (struct type
**)
5082 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
5086 if (type
== first_dont_print
[i
])
5088 printf_filtered ("%*stype node ", spaces
, "");
5089 gdb_print_host_address (type
, gdb_stdout
);
5090 printf_filtered (_(" <same as already seen type>\n"));
5095 obstack_ptr_grow (&dont_print_type_obstack
, type
);
5098 printf_filtered ("%*stype node ", spaces
, "");
5099 gdb_print_host_address (type
, gdb_stdout
);
5100 printf_filtered ("\n");
5101 printf_filtered ("%*sname '%s' (", spaces
, "",
5102 type
->name () ? type
->name () : "<NULL>");
5103 gdb_print_host_address (type
->name (), gdb_stdout
);
5104 printf_filtered (")\n");
5105 printf_filtered ("%*scode 0x%x ", spaces
, "", type
->code ());
5106 switch (type
->code ())
5108 case TYPE_CODE_UNDEF
:
5109 printf_filtered ("(TYPE_CODE_UNDEF)");
5112 printf_filtered ("(TYPE_CODE_PTR)");
5114 case TYPE_CODE_ARRAY
:
5115 printf_filtered ("(TYPE_CODE_ARRAY)");
5117 case TYPE_CODE_STRUCT
:
5118 printf_filtered ("(TYPE_CODE_STRUCT)");
5120 case TYPE_CODE_UNION
:
5121 printf_filtered ("(TYPE_CODE_UNION)");
5123 case TYPE_CODE_ENUM
:
5124 printf_filtered ("(TYPE_CODE_ENUM)");
5126 case TYPE_CODE_FLAGS
:
5127 printf_filtered ("(TYPE_CODE_FLAGS)");
5129 case TYPE_CODE_FUNC
:
5130 printf_filtered ("(TYPE_CODE_FUNC)");
5133 printf_filtered ("(TYPE_CODE_INT)");
5136 printf_filtered ("(TYPE_CODE_FLT)");
5138 case TYPE_CODE_VOID
:
5139 printf_filtered ("(TYPE_CODE_VOID)");
5142 printf_filtered ("(TYPE_CODE_SET)");
5144 case TYPE_CODE_RANGE
:
5145 printf_filtered ("(TYPE_CODE_RANGE)");
5147 case TYPE_CODE_STRING
:
5148 printf_filtered ("(TYPE_CODE_STRING)");
5150 case TYPE_CODE_ERROR
:
5151 printf_filtered ("(TYPE_CODE_ERROR)");
5153 case TYPE_CODE_MEMBERPTR
:
5154 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
5156 case TYPE_CODE_METHODPTR
:
5157 printf_filtered ("(TYPE_CODE_METHODPTR)");
5159 case TYPE_CODE_METHOD
:
5160 printf_filtered ("(TYPE_CODE_METHOD)");
5163 printf_filtered ("(TYPE_CODE_REF)");
5165 case TYPE_CODE_CHAR
:
5166 printf_filtered ("(TYPE_CODE_CHAR)");
5168 case TYPE_CODE_BOOL
:
5169 printf_filtered ("(TYPE_CODE_BOOL)");
5171 case TYPE_CODE_COMPLEX
:
5172 printf_filtered ("(TYPE_CODE_COMPLEX)");
5174 case TYPE_CODE_TYPEDEF
:
5175 printf_filtered ("(TYPE_CODE_TYPEDEF)");
5177 case TYPE_CODE_NAMESPACE
:
5178 printf_filtered ("(TYPE_CODE_NAMESPACE)");
5180 case TYPE_CODE_FIXED_POINT
:
5181 printf_filtered ("(TYPE_CODE_FIXED_POINT)");
5184 printf_filtered ("(UNKNOWN TYPE CODE)");
5187 puts_filtered ("\n");
5188 printf_filtered ("%*slength %s\n", spaces
, "",
5189 pulongest (TYPE_LENGTH (type
)));
5190 if (TYPE_OBJFILE_OWNED (type
))
5192 printf_filtered ("%*sobjfile ", spaces
, "");
5193 gdb_print_host_address (TYPE_OWNER (type
).objfile
, gdb_stdout
);
5197 printf_filtered ("%*sgdbarch ", spaces
, "");
5198 gdb_print_host_address (TYPE_OWNER (type
).gdbarch
, gdb_stdout
);
5200 printf_filtered ("\n");
5201 printf_filtered ("%*starget_type ", spaces
, "");
5202 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
5203 printf_filtered ("\n");
5204 if (TYPE_TARGET_TYPE (type
) != NULL
)
5206 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
5208 printf_filtered ("%*spointer_type ", spaces
, "");
5209 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
5210 printf_filtered ("\n");
5211 printf_filtered ("%*sreference_type ", spaces
, "");
5212 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
5213 printf_filtered ("\n");
5214 printf_filtered ("%*stype_chain ", spaces
, "");
5215 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
5216 printf_filtered ("\n");
5217 printf_filtered ("%*sinstance_flags 0x%x", spaces
, "",
5218 (unsigned) type
->instance_flags ());
5219 if (TYPE_CONST (type
))
5221 puts_filtered (" TYPE_CONST");
5223 if (TYPE_VOLATILE (type
))
5225 puts_filtered (" TYPE_VOLATILE");
5227 if (TYPE_CODE_SPACE (type
))
5229 puts_filtered (" TYPE_CODE_SPACE");
5231 if (TYPE_DATA_SPACE (type
))
5233 puts_filtered (" TYPE_DATA_SPACE");
5235 if (TYPE_ADDRESS_CLASS_1 (type
))
5237 puts_filtered (" TYPE_ADDRESS_CLASS_1");
5239 if (TYPE_ADDRESS_CLASS_2 (type
))
5241 puts_filtered (" TYPE_ADDRESS_CLASS_2");
5243 if (TYPE_RESTRICT (type
))
5245 puts_filtered (" TYPE_RESTRICT");
5247 if (TYPE_ATOMIC (type
))
5249 puts_filtered (" TYPE_ATOMIC");
5251 puts_filtered ("\n");
5253 printf_filtered ("%*sflags", spaces
, "");
5254 if (type
->is_unsigned ())
5256 puts_filtered (" TYPE_UNSIGNED");
5258 if (type
->has_no_signedness ())
5260 puts_filtered (" TYPE_NOSIGN");
5262 if (type
->endianity_is_not_default ())
5264 puts_filtered (" TYPE_ENDIANITY_NOT_DEFAULT");
5266 if (type
->is_stub ())
5268 puts_filtered (" TYPE_STUB");
5270 if (type
->target_is_stub ())
5272 puts_filtered (" TYPE_TARGET_STUB");
5274 if (type
->is_prototyped ())
5276 puts_filtered (" TYPE_PROTOTYPED");
5278 if (type
->has_varargs ())
5280 puts_filtered (" TYPE_VARARGS");
5282 /* This is used for things like AltiVec registers on ppc. Gcc emits
5283 an attribute for the array type, which tells whether or not we
5284 have a vector, instead of a regular array. */
5285 if (type
->is_vector ())
5287 puts_filtered (" TYPE_VECTOR");
5289 if (type
->is_fixed_instance ())
5291 puts_filtered (" TYPE_FIXED_INSTANCE");
5293 if (type
->stub_is_supported ())
5295 puts_filtered (" TYPE_STUB_SUPPORTED");
5297 if (TYPE_NOTTEXT (type
))
5299 puts_filtered (" TYPE_NOTTEXT");
5301 puts_filtered ("\n");
5302 printf_filtered ("%*snfields %d ", spaces
, "", type
->num_fields ());
5303 if (TYPE_ASSOCIATED_PROP (type
) != nullptr
5304 || TYPE_ALLOCATED_PROP (type
) != nullptr)
5306 printf_filtered ("%*s", spaces
, "");
5307 if (TYPE_ASSOCIATED_PROP (type
) != nullptr)
5309 printf_filtered ("associated ");
5310 dump_dynamic_prop (*TYPE_ASSOCIATED_PROP (type
));
5312 if (TYPE_ALLOCATED_PROP (type
) != nullptr)
5314 if (TYPE_ASSOCIATED_PROP (type
) != nullptr)
5315 printf_filtered (" ");
5316 printf_filtered ("allocated ");
5317 dump_dynamic_prop (*TYPE_ALLOCATED_PROP (type
));
5319 printf_filtered ("\n");
5321 gdb_print_host_address (type
->fields (), gdb_stdout
);
5322 puts_filtered ("\n");
5323 for (idx
= 0; idx
< type
->num_fields (); idx
++)
5325 if (type
->code () == TYPE_CODE_ENUM
)
5326 printf_filtered ("%*s[%d] enumval %s type ", spaces
+ 2, "",
5327 idx
, plongest (TYPE_FIELD_ENUMVAL (type
, idx
)));
5329 printf_filtered ("%*s[%d] bitpos %s bitsize %d type ", spaces
+ 2, "",
5330 idx
, plongest (TYPE_FIELD_BITPOS (type
, idx
)),
5331 TYPE_FIELD_BITSIZE (type
, idx
));
5332 gdb_print_host_address (type
->field (idx
).type (), gdb_stdout
);
5333 printf_filtered (" name '%s' (",
5334 TYPE_FIELD_NAME (type
, idx
) != NULL
5335 ? TYPE_FIELD_NAME (type
, idx
)
5337 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
5338 printf_filtered (")\n");
5339 if (type
->field (idx
).type () != NULL
)
5341 recursive_dump_type (type
->field (idx
).type (), spaces
+ 4);
5344 if (type
->code () == TYPE_CODE_RANGE
)
5346 printf_filtered ("%*slow ", spaces
, "");
5347 dump_dynamic_prop (type
->bounds ()->low
);
5348 printf_filtered (" high ");
5349 dump_dynamic_prop (type
->bounds ()->high
);
5350 printf_filtered ("\n");
5353 switch (TYPE_SPECIFIC_FIELD (type
))
5355 case TYPE_SPECIFIC_CPLUS_STUFF
:
5356 printf_filtered ("%*scplus_stuff ", spaces
, "");
5357 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
),
5359 puts_filtered ("\n");
5360 print_cplus_stuff (type
, spaces
);
5363 case TYPE_SPECIFIC_GNAT_STUFF
:
5364 printf_filtered ("%*sgnat_stuff ", spaces
, "");
5365 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type
), gdb_stdout
);
5366 puts_filtered ("\n");
5367 print_gnat_stuff (type
, spaces
);
5370 case TYPE_SPECIFIC_FLOATFORMAT
:
5371 printf_filtered ("%*sfloatformat ", spaces
, "");
5372 if (TYPE_FLOATFORMAT (type
) == NULL
5373 || TYPE_FLOATFORMAT (type
)->name
== NULL
)
5374 puts_filtered ("(null)");
5376 puts_filtered (TYPE_FLOATFORMAT (type
)->name
);
5377 puts_filtered ("\n");
5380 case TYPE_SPECIFIC_FUNC
:
5381 printf_filtered ("%*scalling_convention %d\n", spaces
, "",
5382 TYPE_CALLING_CONVENTION (type
));
5383 /* tail_call_list is not printed. */
5386 case TYPE_SPECIFIC_SELF_TYPE
:
5387 printf_filtered ("%*sself_type ", spaces
, "");
5388 gdb_print_host_address (TYPE_SELF_TYPE (type
), gdb_stdout
);
5389 puts_filtered ("\n");
5392 case TYPE_SPECIFIC_FIXED_POINT
:
5393 printf_filtered ("%*sfixed_point_info ", spaces
, "");
5394 print_fixed_point_type_info (type
, spaces
);
5395 puts_filtered ("\n");
5398 case TYPE_SPECIFIC_INT
:
5399 if (type
->bit_size_differs_p ())
5401 unsigned bit_size
= type
->bit_size ();
5402 unsigned bit_off
= type
->bit_offset ();
5403 printf_filtered ("%*s bit size = %u, bit offset = %u\n", spaces
, "",
5410 obstack_free (&dont_print_type_obstack
, NULL
);
5413 /* Trivial helpers for the libiberty hash table, for mapping one
5416 struct type_pair
: public allocate_on_obstack
5418 type_pair (struct type
*old_
, struct type
*newobj_
)
5419 : old (old_
), newobj (newobj_
)
5422 struct type
* const old
, * const newobj
;
5426 type_pair_hash (const void *item
)
5428 const struct type_pair
*pair
= (const struct type_pair
*) item
;
5430 return htab_hash_pointer (pair
->old
);
5434 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
5436 const struct type_pair
*lhs
= (const struct type_pair
*) item_lhs
;
5437 const struct type_pair
*rhs
= (const struct type_pair
*) item_rhs
;
5439 return lhs
->old
== rhs
->old
;
5442 /* Allocate the hash table used by copy_type_recursive to walk
5443 types without duplicates. We use OBJFILE's obstack, because
5444 OBJFILE is about to be deleted. */
5447 create_copied_types_hash (struct objfile
*objfile
)
5449 return htab_up (htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
5450 NULL
, &objfile
->objfile_obstack
,
5451 hashtab_obstack_allocate
,
5452 dummy_obstack_deallocate
));
5455 /* Recursively copy (deep copy) a dynamic attribute list of a type. */
5457 static struct dynamic_prop_list
*
5458 copy_dynamic_prop_list (struct obstack
*objfile_obstack
,
5459 struct dynamic_prop_list
*list
)
5461 struct dynamic_prop_list
*copy
= list
;
5462 struct dynamic_prop_list
**node_ptr
= ©
;
5464 while (*node_ptr
!= NULL
)
5466 struct dynamic_prop_list
*node_copy
;
5468 node_copy
= ((struct dynamic_prop_list
*)
5469 obstack_copy (objfile_obstack
, *node_ptr
,
5470 sizeof (struct dynamic_prop_list
)));
5471 node_copy
->prop
= (*node_ptr
)->prop
;
5472 *node_ptr
= node_copy
;
5474 node_ptr
= &node_copy
->next
;
5480 /* Recursively copy (deep copy) TYPE, if it is associated with
5481 OBJFILE. Return a new type owned by the gdbarch associated with the type, a
5482 saved type if we have already visited TYPE (using COPIED_TYPES), or TYPE if
5483 it is not associated with OBJFILE. */
5486 copy_type_recursive (struct objfile
*objfile
,
5488 htab_t copied_types
)
5491 struct type
*new_type
;
5493 if (! TYPE_OBJFILE_OWNED (type
))
5496 /* This type shouldn't be pointing to any types in other objfiles;
5497 if it did, the type might disappear unexpectedly. */
5498 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
5500 struct type_pair
pair (type
, nullptr);
5502 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
5504 return ((struct type_pair
*) *slot
)->newobj
;
5506 new_type
= alloc_type_arch (get_type_arch (type
));
5508 /* We must add the new type to the hash table immediately, in case
5509 we encounter this type again during a recursive call below. */
5510 struct type_pair
*stored
5511 = new (&objfile
->objfile_obstack
) struct type_pair (type
, new_type
);
5515 /* Copy the common fields of types. For the main type, we simply
5516 copy the entire thing and then update specific fields as needed. */
5517 *TYPE_MAIN_TYPE (new_type
) = *TYPE_MAIN_TYPE (type
);
5518 TYPE_OBJFILE_OWNED (new_type
) = 0;
5519 TYPE_OWNER (new_type
).gdbarch
= get_type_arch (type
);
5522 new_type
->set_name (xstrdup (type
->name ()));
5524 new_type
->set_instance_flags (type
->instance_flags ());
5525 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
5527 /* Copy the fields. */
5528 if (type
->num_fields ())
5532 nfields
= type
->num_fields ();
5533 new_type
->set_fields
5535 TYPE_ZALLOC (new_type
, nfields
* sizeof (struct field
)));
5537 for (i
= 0; i
< nfields
; i
++)
5539 TYPE_FIELD_ARTIFICIAL (new_type
, i
) =
5540 TYPE_FIELD_ARTIFICIAL (type
, i
);
5541 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
5542 if (type
->field (i
).type ())
5543 new_type
->field (i
).set_type
5544 (copy_type_recursive (objfile
, type
->field (i
).type (),
5546 if (TYPE_FIELD_NAME (type
, i
))
5547 TYPE_FIELD_NAME (new_type
, i
) =
5548 xstrdup (TYPE_FIELD_NAME (type
, i
));
5549 switch (TYPE_FIELD_LOC_KIND (type
, i
))
5551 case FIELD_LOC_KIND_BITPOS
:
5552 SET_FIELD_BITPOS (new_type
->field (i
),
5553 TYPE_FIELD_BITPOS (type
, i
));
5555 case FIELD_LOC_KIND_ENUMVAL
:
5556 SET_FIELD_ENUMVAL (new_type
->field (i
),
5557 TYPE_FIELD_ENUMVAL (type
, i
));
5559 case FIELD_LOC_KIND_PHYSADDR
:
5560 SET_FIELD_PHYSADDR (new_type
->field (i
),
5561 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
5563 case FIELD_LOC_KIND_PHYSNAME
:
5564 SET_FIELD_PHYSNAME (new_type
->field (i
),
5565 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
,
5569 internal_error (__FILE__
, __LINE__
,
5570 _("Unexpected type field location kind: %d"),
5571 TYPE_FIELD_LOC_KIND (type
, i
));
5576 /* For range types, copy the bounds information. */
5577 if (type
->code () == TYPE_CODE_RANGE
)
5579 range_bounds
*bounds
5580 = ((struct range_bounds
*) TYPE_ALLOC
5581 (new_type
, sizeof (struct range_bounds
)));
5583 *bounds
= *type
->bounds ();
5584 new_type
->set_bounds (bounds
);
5587 if (type
->main_type
->dyn_prop_list
!= NULL
)
5588 new_type
->main_type
->dyn_prop_list
5589 = copy_dynamic_prop_list (&objfile
->objfile_obstack
,
5590 type
->main_type
->dyn_prop_list
);
5593 /* Copy pointers to other types. */
5594 if (TYPE_TARGET_TYPE (type
))
5595 TYPE_TARGET_TYPE (new_type
) =
5596 copy_type_recursive (objfile
,
5597 TYPE_TARGET_TYPE (type
),
5600 /* Maybe copy the type_specific bits.
5602 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
5603 base classes and methods. There's no fundamental reason why we
5604 can't, but at the moment it is not needed. */
5606 switch (TYPE_SPECIFIC_FIELD (type
))
5608 case TYPE_SPECIFIC_NONE
:
5610 case TYPE_SPECIFIC_FUNC
:
5611 INIT_FUNC_SPECIFIC (new_type
);
5612 TYPE_CALLING_CONVENTION (new_type
) = TYPE_CALLING_CONVENTION (type
);
5613 TYPE_NO_RETURN (new_type
) = TYPE_NO_RETURN (type
);
5614 TYPE_TAIL_CALL_LIST (new_type
) = NULL
;
5616 case TYPE_SPECIFIC_FLOATFORMAT
:
5617 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
5619 case TYPE_SPECIFIC_CPLUS_STUFF
:
5620 INIT_CPLUS_SPECIFIC (new_type
);
5622 case TYPE_SPECIFIC_GNAT_STUFF
:
5623 INIT_GNAT_SPECIFIC (new_type
);
5625 case TYPE_SPECIFIC_SELF_TYPE
:
5626 set_type_self_type (new_type
,
5627 copy_type_recursive (objfile
, TYPE_SELF_TYPE (type
),
5630 case TYPE_SPECIFIC_FIXED_POINT
:
5631 INIT_FIXED_POINT_SPECIFIC (new_type
);
5632 new_type
->fixed_point_info ().scaling_factor
5633 = type
->fixed_point_info ().scaling_factor
;
5635 case TYPE_SPECIFIC_INT
:
5636 TYPE_SPECIFIC_FIELD (new_type
) = TYPE_SPECIFIC_INT
;
5637 TYPE_MAIN_TYPE (new_type
)->type_specific
.int_stuff
5638 = TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
;
5642 gdb_assert_not_reached ("bad type_specific_kind");
5648 /* Make a copy of the given TYPE, except that the pointer & reference
5649 types are not preserved.
5651 This function assumes that the given type has an associated objfile.
5652 This objfile is used to allocate the new type. */
5655 copy_type (const struct type
*type
)
5657 struct type
*new_type
;
5659 gdb_assert (TYPE_OBJFILE_OWNED (type
));
5661 new_type
= alloc_type_copy (type
);
5662 new_type
->set_instance_flags (type
->instance_flags ());
5663 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
5664 memcpy (TYPE_MAIN_TYPE (new_type
), TYPE_MAIN_TYPE (type
),
5665 sizeof (struct main_type
));
5666 if (type
->main_type
->dyn_prop_list
!= NULL
)
5667 new_type
->main_type
->dyn_prop_list
5668 = copy_dynamic_prop_list (&TYPE_OBJFILE (type
) -> objfile_obstack
,
5669 type
->main_type
->dyn_prop_list
);
5674 /* Helper functions to initialize architecture-specific types. */
5676 /* Allocate a type structure associated with GDBARCH and set its
5677 CODE, LENGTH, and NAME fields. */
5680 arch_type (struct gdbarch
*gdbarch
,
5681 enum type_code code
, int bit
, const char *name
)
5685 type
= alloc_type_arch (gdbarch
);
5686 set_type_code (type
, code
);
5687 gdb_assert ((bit
% TARGET_CHAR_BIT
) == 0);
5688 TYPE_LENGTH (type
) = bit
/ TARGET_CHAR_BIT
;
5691 type
->set_name (gdbarch_obstack_strdup (gdbarch
, name
));
5696 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
5697 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
5698 the type's TYPE_UNSIGNED flag. NAME is the type name. */
5701 arch_integer_type (struct gdbarch
*gdbarch
,
5702 int bit
, int unsigned_p
, const char *name
)
5706 t
= arch_type (gdbarch
, TYPE_CODE_INT
, bit
, name
);
5708 t
->set_is_unsigned (true);
5713 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
5714 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
5715 the type's TYPE_UNSIGNED flag. NAME is the type name. */
5718 arch_character_type (struct gdbarch
*gdbarch
,
5719 int bit
, int unsigned_p
, const char *name
)
5723 t
= arch_type (gdbarch
, TYPE_CODE_CHAR
, bit
, name
);
5725 t
->set_is_unsigned (true);
5730 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
5731 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
5732 the type's TYPE_UNSIGNED flag. NAME is the type name. */
5735 arch_boolean_type (struct gdbarch
*gdbarch
,
5736 int bit
, int unsigned_p
, const char *name
)
5740 t
= arch_type (gdbarch
, TYPE_CODE_BOOL
, bit
, name
);
5742 t
->set_is_unsigned (true);
5747 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
5748 BIT is the type size in bits; if BIT equals -1, the size is
5749 determined by the floatformat. NAME is the type name. Set the
5750 TYPE_FLOATFORMAT from FLOATFORMATS. */
5753 arch_float_type (struct gdbarch
*gdbarch
,
5754 int bit
, const char *name
,
5755 const struct floatformat
**floatformats
)
5757 const struct floatformat
*fmt
= floatformats
[gdbarch_byte_order (gdbarch
)];
5760 bit
= verify_floatformat (bit
, fmt
);
5761 t
= arch_type (gdbarch
, TYPE_CODE_FLT
, bit
, name
);
5762 TYPE_FLOATFORMAT (t
) = fmt
;
5767 /* Allocate a TYPE_CODE_DECFLOAT type structure associated with GDBARCH.
5768 BIT is the type size in bits. NAME is the type name. */
5771 arch_decfloat_type (struct gdbarch
*gdbarch
, int bit
, const char *name
)
5775 t
= arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, bit
, name
);
5779 /* Allocate a TYPE_CODE_PTR type structure associated with GDBARCH.
5780 BIT is the pointer type size in bits. NAME is the type name.
5781 TARGET_TYPE is the pointer target type. Always sets the pointer type's
5782 TYPE_UNSIGNED flag. */
5785 arch_pointer_type (struct gdbarch
*gdbarch
,
5786 int bit
, const char *name
, struct type
*target_type
)
5790 t
= arch_type (gdbarch
, TYPE_CODE_PTR
, bit
, name
);
5791 TYPE_TARGET_TYPE (t
) = target_type
;
5792 t
->set_is_unsigned (true);
5796 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
5797 NAME is the type name. BIT is the size of the flag word in bits. */
5800 arch_flags_type (struct gdbarch
*gdbarch
, const char *name
, int bit
)
5804 type
= arch_type (gdbarch
, TYPE_CODE_FLAGS
, bit
, name
);
5805 type
->set_is_unsigned (true);
5806 type
->set_num_fields (0);
5807 /* Pre-allocate enough space assuming every field is one bit. */
5809 ((struct field
*) TYPE_ZALLOC (type
, bit
* sizeof (struct field
)));
5814 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
5815 position BITPOS is called NAME. Pass NAME as "" for fields that
5816 should not be printed. */
5819 append_flags_type_field (struct type
*type
, int start_bitpos
, int nr_bits
,
5820 struct type
*field_type
, const char *name
)
5822 int type_bitsize
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
5823 int field_nr
= type
->num_fields ();
5825 gdb_assert (type
->code () == TYPE_CODE_FLAGS
);
5826 gdb_assert (type
->num_fields () + 1 <= type_bitsize
);
5827 gdb_assert (start_bitpos
>= 0 && start_bitpos
< type_bitsize
);
5828 gdb_assert (nr_bits
>= 1 && nr_bits
<= type_bitsize
);
5829 gdb_assert (name
!= NULL
);
5831 TYPE_FIELD_NAME (type
, field_nr
) = xstrdup (name
);
5832 type
->field (field_nr
).set_type (field_type
);
5833 SET_FIELD_BITPOS (type
->field (field_nr
), start_bitpos
);
5834 TYPE_FIELD_BITSIZE (type
, field_nr
) = nr_bits
;
5835 type
->set_num_fields (type
->num_fields () + 1);
5838 /* Special version of append_flags_type_field to add a flag field.
5839 Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
5840 position BITPOS is called NAME. */
5843 append_flags_type_flag (struct type
*type
, int bitpos
, const char *name
)
5845 struct gdbarch
*gdbarch
= get_type_arch (type
);
5847 append_flags_type_field (type
, bitpos
, 1,
5848 builtin_type (gdbarch
)->builtin_bool
,
5852 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
5853 specified by CODE) associated with GDBARCH. NAME is the type name. */
5856 arch_composite_type (struct gdbarch
*gdbarch
, const char *name
,
5857 enum type_code code
)
5861 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
5862 t
= arch_type (gdbarch
, code
, 0, NULL
);
5864 INIT_CPLUS_SPECIFIC (t
);
5868 /* Add new field with name NAME and type FIELD to composite type T.
5869 Do not set the field's position or adjust the type's length;
5870 the caller should do so. Return the new field. */
5873 append_composite_type_field_raw (struct type
*t
, const char *name
,
5878 t
->set_num_fields (t
->num_fields () + 1);
5879 t
->set_fields (XRESIZEVEC (struct field
, t
->fields (),
5881 f
= &t
->field (t
->num_fields () - 1);
5882 memset (f
, 0, sizeof f
[0]);
5883 f
[0].set_type (field
);
5884 FIELD_NAME (f
[0]) = name
;
5888 /* Add new field with name NAME and type FIELD to composite type T.
5889 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
5892 append_composite_type_field_aligned (struct type
*t
, const char *name
,
5893 struct type
*field
, int alignment
)
5895 struct field
*f
= append_composite_type_field_raw (t
, name
, field
);
5897 if (t
->code () == TYPE_CODE_UNION
)
5899 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
5900 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
5902 else if (t
->code () == TYPE_CODE_STRUCT
)
5904 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
5905 if (t
->num_fields () > 1)
5907 SET_FIELD_BITPOS (f
[0],
5908 (FIELD_BITPOS (f
[-1])
5909 + (TYPE_LENGTH (f
[-1].type ())
5910 * TARGET_CHAR_BIT
)));
5916 alignment
*= TARGET_CHAR_BIT
;
5917 left
= FIELD_BITPOS (f
[0]) % alignment
;
5921 SET_FIELD_BITPOS (f
[0], FIELD_BITPOS (f
[0]) + (alignment
- left
));
5922 TYPE_LENGTH (t
) += (alignment
- left
) / TARGET_CHAR_BIT
;
5929 /* Add new field with name NAME and type FIELD to composite type T. */
5932 append_composite_type_field (struct type
*t
, const char *name
,
5935 append_composite_type_field_aligned (t
, name
, field
, 0);
5940 /* We manage the lifetimes of fixed_point_type_info objects by
5941 attaching them to the objfile. Currently, these objects are
5942 modified during construction, and GMP does not provide a way to
5943 hash the contents of an mpq_t; so it's a bit of a pain to hash-cons
5944 them. If we did do this, they could be moved to the per-BFD and
5945 shared across objfiles. */
5946 typedef std::vector
<std::unique_ptr
<fixed_point_type_info
>>
5947 fixed_point_type_storage
;
5949 /* Key used for managing the storage of fixed-point type info. */
5950 static const struct objfile_key
<fixed_point_type_storage
>
5951 fixed_point_objfile_key
;
5953 /* See gdbtypes.h. */
5956 allocate_fixed_point_type_info (struct type
*type
)
5958 std::unique_ptr
<fixed_point_type_info
> up (new fixed_point_type_info
);
5959 fixed_point_type_info
*info
;
5961 if (TYPE_OBJFILE_OWNED (type
))
5963 fixed_point_type_storage
*storage
5964 = fixed_point_objfile_key
.get (TYPE_OBJFILE (type
));
5965 if (storage
== nullptr)
5966 storage
= fixed_point_objfile_key
.emplace (TYPE_OBJFILE (type
));
5968 storage
->push_back (std::move (up
));
5972 /* We just leak the memory, because that's what we do generally
5973 for non-objfile-attached types. */
5974 info
= up
.release ();
5977 type
->set_fixed_point_info (info
);
5980 /* See gdbtypes.h. */
5983 is_fixed_point_type (struct type
*type
)
5985 while (check_typedef (type
)->code () == TYPE_CODE_RANGE
)
5986 type
= TYPE_TARGET_TYPE (check_typedef (type
));
5987 type
= check_typedef (type
);
5989 return type
->code () == TYPE_CODE_FIXED_POINT
;
5992 /* See gdbtypes.h. */
5995 type::fixed_point_type_base_type ()
5997 struct type
*type
= this;
5999 while (check_typedef (type
)->code () == TYPE_CODE_RANGE
)
6000 type
= TYPE_TARGET_TYPE (check_typedef (type
));
6001 type
= check_typedef (type
);
6003 gdb_assert (type
->code () == TYPE_CODE_FIXED_POINT
);
6007 /* See gdbtypes.h. */
6010 type::fixed_point_scaling_factor ()
6012 struct type
*type
= this->fixed_point_type_base_type ();
6014 return type
->fixed_point_info ().scaling_factor
;
6019 static struct gdbarch_data
*gdbtypes_data
;
6021 const struct builtin_type
*
6022 builtin_type (struct gdbarch
*gdbarch
)
6024 return (const struct builtin_type
*) gdbarch_data (gdbarch
, gdbtypes_data
);
6028 gdbtypes_post_init (struct gdbarch
*gdbarch
)
6030 struct builtin_type
*builtin_type
6031 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
6034 builtin_type
->builtin_void
6035 = arch_type (gdbarch
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, "void");
6036 builtin_type
->builtin_char
6037 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
6038 !gdbarch_char_signed (gdbarch
), "char");
6039 builtin_type
->builtin_char
->set_has_no_signedness (true);
6040 builtin_type
->builtin_signed_char
6041 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
6043 builtin_type
->builtin_unsigned_char
6044 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
6045 1, "unsigned char");
6046 builtin_type
->builtin_short
6047 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
6049 builtin_type
->builtin_unsigned_short
6050 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
6051 1, "unsigned short");
6052 builtin_type
->builtin_int
6053 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
6055 builtin_type
->builtin_unsigned_int
6056 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
6058 builtin_type
->builtin_long
6059 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
6061 builtin_type
->builtin_unsigned_long
6062 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
6063 1, "unsigned long");
6064 builtin_type
->builtin_long_long
6065 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
6067 builtin_type
->builtin_unsigned_long_long
6068 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
6069 1, "unsigned long long");
6070 builtin_type
->builtin_half
6071 = arch_float_type (gdbarch
, gdbarch_half_bit (gdbarch
),
6072 "half", gdbarch_half_format (gdbarch
));
6073 builtin_type
->builtin_float
6074 = arch_float_type (gdbarch
, gdbarch_float_bit (gdbarch
),
6075 "float", gdbarch_float_format (gdbarch
));
6076 builtin_type
->builtin_bfloat16
6077 = arch_float_type (gdbarch
, gdbarch_bfloat16_bit (gdbarch
),
6078 "bfloat16", gdbarch_bfloat16_format (gdbarch
));
6079 builtin_type
->builtin_double
6080 = arch_float_type (gdbarch
, gdbarch_double_bit (gdbarch
),
6081 "double", gdbarch_double_format (gdbarch
));
6082 builtin_type
->builtin_long_double
6083 = arch_float_type (gdbarch
, gdbarch_long_double_bit (gdbarch
),
6084 "long double", gdbarch_long_double_format (gdbarch
));
6085 builtin_type
->builtin_complex
6086 = init_complex_type ("complex", builtin_type
->builtin_float
);
6087 builtin_type
->builtin_double_complex
6088 = init_complex_type ("double complex", builtin_type
->builtin_double
);
6089 builtin_type
->builtin_string
6090 = arch_type (gdbarch
, TYPE_CODE_STRING
, TARGET_CHAR_BIT
, "string");
6091 builtin_type
->builtin_bool
6092 = arch_type (gdbarch
, TYPE_CODE_BOOL
, TARGET_CHAR_BIT
, "bool");
6094 /* The following three are about decimal floating point types, which
6095 are 32-bits, 64-bits and 128-bits respectively. */
6096 builtin_type
->builtin_decfloat
6097 = arch_decfloat_type (gdbarch
, 32, "_Decimal32");
6098 builtin_type
->builtin_decdouble
6099 = arch_decfloat_type (gdbarch
, 64, "_Decimal64");
6100 builtin_type
->builtin_declong
6101 = arch_decfloat_type (gdbarch
, 128, "_Decimal128");
6103 /* "True" character types. */
6104 builtin_type
->builtin_true_char
6105 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 0, "true character");
6106 builtin_type
->builtin_true_unsigned_char
6107 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 1, "true character");
6109 /* Fixed-size integer types. */
6110 builtin_type
->builtin_int0
6111 = arch_integer_type (gdbarch
, 0, 0, "int0_t");
6112 builtin_type
->builtin_int8
6113 = arch_integer_type (gdbarch
, 8, 0, "int8_t");
6114 builtin_type
->builtin_uint8
6115 = arch_integer_type (gdbarch
, 8, 1, "uint8_t");
6116 builtin_type
->builtin_int16
6117 = arch_integer_type (gdbarch
, 16, 0, "int16_t");
6118 builtin_type
->builtin_uint16
6119 = arch_integer_type (gdbarch
, 16, 1, "uint16_t");
6120 builtin_type
->builtin_int24
6121 = arch_integer_type (gdbarch
, 24, 0, "int24_t");
6122 builtin_type
->builtin_uint24
6123 = arch_integer_type (gdbarch
, 24, 1, "uint24_t");
6124 builtin_type
->builtin_int32
6125 = arch_integer_type (gdbarch
, 32, 0, "int32_t");
6126 builtin_type
->builtin_uint32
6127 = arch_integer_type (gdbarch
, 32, 1, "uint32_t");
6128 builtin_type
->builtin_int64
6129 = arch_integer_type (gdbarch
, 64, 0, "int64_t");
6130 builtin_type
->builtin_uint64
6131 = arch_integer_type (gdbarch
, 64, 1, "uint64_t");
6132 builtin_type
->builtin_int128
6133 = arch_integer_type (gdbarch
, 128, 0, "int128_t");
6134 builtin_type
->builtin_uint128
6135 = arch_integer_type (gdbarch
, 128, 1, "uint128_t");
6137 builtin_type
->builtin_int8
->set_instance_flags
6138 (builtin_type
->builtin_int8
->instance_flags ()
6139 | TYPE_INSTANCE_FLAG_NOTTEXT
);
6141 builtin_type
->builtin_uint8
->set_instance_flags
6142 (builtin_type
->builtin_uint8
->instance_flags ()
6143 | TYPE_INSTANCE_FLAG_NOTTEXT
);
6145 /* Wide character types. */
6146 builtin_type
->builtin_char16
6147 = arch_integer_type (gdbarch
, 16, 1, "char16_t");
6148 builtin_type
->builtin_char32
6149 = arch_integer_type (gdbarch
, 32, 1, "char32_t");
6150 builtin_type
->builtin_wchar
6151 = arch_integer_type (gdbarch
, gdbarch_wchar_bit (gdbarch
),
6152 !gdbarch_wchar_signed (gdbarch
), "wchar_t");
6154 /* Default data/code pointer types. */
6155 builtin_type
->builtin_data_ptr
6156 = lookup_pointer_type (builtin_type
->builtin_void
);
6157 builtin_type
->builtin_func_ptr
6158 = lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
6159 builtin_type
->builtin_func_func
6160 = lookup_function_type (builtin_type
->builtin_func_ptr
);
6162 /* This type represents a GDB internal function. */
6163 builtin_type
->internal_fn
6164 = arch_type (gdbarch
, TYPE_CODE_INTERNAL_FUNCTION
, 0,
6165 "<internal function>");
6167 /* This type represents an xmethod. */
6168 builtin_type
->xmethod
6169 = arch_type (gdbarch
, TYPE_CODE_XMETHOD
, 0, "<xmethod>");
6171 return builtin_type
;
6174 /* This set of objfile-based types is intended to be used by symbol
6175 readers as basic types. */
6177 static const struct objfile_key
<struct objfile_type
,
6178 gdb::noop_deleter
<struct objfile_type
>>
6181 const struct objfile_type
*
6182 objfile_type (struct objfile
*objfile
)
6184 struct gdbarch
*gdbarch
;
6185 struct objfile_type
*objfile_type
= objfile_type_data
.get (objfile
);
6188 return objfile_type
;
6190 objfile_type
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
6191 1, struct objfile_type
);
6193 /* Use the objfile architecture to determine basic type properties. */
6194 gdbarch
= objfile
->arch ();
6197 objfile_type
->builtin_void
6198 = init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, "void");
6199 objfile_type
->builtin_char
6200 = init_integer_type (objfile
, TARGET_CHAR_BIT
,
6201 !gdbarch_char_signed (gdbarch
), "char");
6202 objfile_type
->builtin_char
->set_has_no_signedness (true);
6203 objfile_type
->builtin_signed_char
6204 = init_integer_type (objfile
, TARGET_CHAR_BIT
,
6206 objfile_type
->builtin_unsigned_char
6207 = init_integer_type (objfile
, TARGET_CHAR_BIT
,
6208 1, "unsigned char");
6209 objfile_type
->builtin_short
6210 = init_integer_type (objfile
, gdbarch_short_bit (gdbarch
),
6212 objfile_type
->builtin_unsigned_short
6213 = init_integer_type (objfile
, gdbarch_short_bit (gdbarch
),
6214 1, "unsigned short");
6215 objfile_type
->builtin_int
6216 = init_integer_type (objfile
, gdbarch_int_bit (gdbarch
),
6218 objfile_type
->builtin_unsigned_int
6219 = init_integer_type (objfile
, gdbarch_int_bit (gdbarch
),
6221 objfile_type
->builtin_long
6222 = init_integer_type (objfile
, gdbarch_long_bit (gdbarch
),
6224 objfile_type
->builtin_unsigned_long
6225 = init_integer_type (objfile
, gdbarch_long_bit (gdbarch
),
6226 1, "unsigned long");
6227 objfile_type
->builtin_long_long
6228 = init_integer_type (objfile
, gdbarch_long_long_bit (gdbarch
),
6230 objfile_type
->builtin_unsigned_long_long
6231 = init_integer_type (objfile
, gdbarch_long_long_bit (gdbarch
),
6232 1, "unsigned long long");
6233 objfile_type
->builtin_float
6234 = init_float_type (objfile
, gdbarch_float_bit (gdbarch
),
6235 "float", gdbarch_float_format (gdbarch
));
6236 objfile_type
->builtin_double
6237 = init_float_type (objfile
, gdbarch_double_bit (gdbarch
),
6238 "double", gdbarch_double_format (gdbarch
));
6239 objfile_type
->builtin_long_double
6240 = init_float_type (objfile
, gdbarch_long_double_bit (gdbarch
),
6241 "long double", gdbarch_long_double_format (gdbarch
));
6243 /* This type represents a type that was unrecognized in symbol read-in. */
6244 objfile_type
->builtin_error
6245 = init_type (objfile
, TYPE_CODE_ERROR
, 0, "<unknown type>");
6247 /* The following set of types is used for symbols with no
6248 debug information. */
6249 objfile_type
->nodebug_text_symbol
6250 = init_type (objfile
, TYPE_CODE_FUNC
, TARGET_CHAR_BIT
,
6251 "<text variable, no debug info>");
6253 objfile_type
->nodebug_text_gnu_ifunc_symbol
6254 = init_type (objfile
, TYPE_CODE_FUNC
, TARGET_CHAR_BIT
,
6255 "<text gnu-indirect-function variable, no debug info>");
6256 objfile_type
->nodebug_text_gnu_ifunc_symbol
->set_is_gnu_ifunc (true);
6258 objfile_type
->nodebug_got_plt_symbol
6259 = init_pointer_type (objfile
, gdbarch_addr_bit (gdbarch
),
6260 "<text from jump slot in .got.plt, no debug info>",
6261 objfile_type
->nodebug_text_symbol
);
6262 objfile_type
->nodebug_data_symbol
6263 = init_nodebug_var_type (objfile
, "<data variable, no debug info>");
6264 objfile_type
->nodebug_unknown_symbol
6265 = init_nodebug_var_type (objfile
, "<variable (not text or data), no debug info>");
6266 objfile_type
->nodebug_tls_symbol
6267 = init_nodebug_var_type (objfile
, "<thread local variable, no debug info>");
6269 /* NOTE: on some targets, addresses and pointers are not necessarily
6273 - gdb's `struct type' always describes the target's
6275 - gdb's `struct value' objects should always hold values in
6277 - gdb's CORE_ADDR values are addresses in the unified virtual
6278 address space that the assembler and linker work with. Thus,
6279 since target_read_memory takes a CORE_ADDR as an argument, it
6280 can access any memory on the target, even if the processor has
6281 separate code and data address spaces.
6283 In this context, objfile_type->builtin_core_addr is a bit odd:
6284 it's a target type for a value the target will never see. It's
6285 only used to hold the values of (typeless) linker symbols, which
6286 are indeed in the unified virtual address space. */
6288 objfile_type
->builtin_core_addr
6289 = init_integer_type (objfile
, gdbarch_addr_bit (gdbarch
), 1,
6292 objfile_type_data
.set (objfile
, objfile_type
);
6293 return objfile_type
;
6296 void _initialize_gdbtypes ();
6298 _initialize_gdbtypes ()
6300 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
6302 add_setshow_zuinteger_cmd ("overload", no_class
, &overload_debug
,
6303 _("Set debugging of C++ overloading."),
6304 _("Show debugging of C++ overloading."),
6305 _("When enabled, ranking of the "
6306 "functions is displayed."),
6308 show_overload_debug
,
6309 &setdebuglist
, &showdebuglist
);
6311 /* Add user knob for controlling resolution of opaque types. */
6312 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
6313 &opaque_type_resolution
,
6314 _("Set resolution of opaque struct/class/union"
6315 " types (if set before loading symbols)."),
6316 _("Show resolution of opaque struct/class/union"
6317 " types (if set before loading symbols)."),
6319 show_opaque_type_resolution
,
6320 &setlist
, &showlist
);
6322 /* Add an option to permit non-strict type checking. */
6323 add_setshow_boolean_cmd ("type", class_support
,
6324 &strict_type_checking
,
6325 _("Set strict type checking."),
6326 _("Show strict type checking."),
6328 show_strict_type_checking
,
6329 &setchecklist
, &showchecklist
);