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"
40 #include "dwarf2/read.h"
42 #include "floatformat.h"
45 #include "gmp-utils.h"
47 /* Initialize BADNESS constants. */
49 const struct rank LENGTH_MISMATCH_BADNESS
= {100,0};
51 const struct rank TOO_FEW_PARAMS_BADNESS
= {100,0};
52 const struct rank INCOMPATIBLE_TYPE_BADNESS
= {100,0};
54 const struct rank EXACT_MATCH_BADNESS
= {0,0};
56 const struct rank INTEGER_PROMOTION_BADNESS
= {1,0};
57 const struct rank FLOAT_PROMOTION_BADNESS
= {1,0};
58 const struct rank BASE_PTR_CONVERSION_BADNESS
= {1,0};
59 const struct rank CV_CONVERSION_BADNESS
= {1, 0};
60 const struct rank INTEGER_CONVERSION_BADNESS
= {2,0};
61 const struct rank FLOAT_CONVERSION_BADNESS
= {2,0};
62 const struct rank INT_FLOAT_CONVERSION_BADNESS
= {2,0};
63 const struct rank VOID_PTR_CONVERSION_BADNESS
= {2,0};
64 const struct rank BOOL_CONVERSION_BADNESS
= {3,0};
65 const struct rank BASE_CONVERSION_BADNESS
= {2,0};
66 const struct rank REFERENCE_CONVERSION_BADNESS
= {2,0};
67 const struct rank REFERENCE_SEE_THROUGH_BADNESS
= {0,1};
68 const struct rank NULL_POINTER_CONVERSION_BADNESS
= {2,0};
69 const struct rank NS_POINTER_CONVERSION_BADNESS
= {10,0};
70 const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS
= {3,0};
72 /* Floatformat pairs. */
73 const struct floatformat
*floatformats_ieee_half
[BFD_ENDIAN_UNKNOWN
] = {
74 &floatformat_ieee_half_big
,
75 &floatformat_ieee_half_little
77 const struct floatformat
*floatformats_ieee_single
[BFD_ENDIAN_UNKNOWN
] = {
78 &floatformat_ieee_single_big
,
79 &floatformat_ieee_single_little
81 const struct floatformat
*floatformats_ieee_double
[BFD_ENDIAN_UNKNOWN
] = {
82 &floatformat_ieee_double_big
,
83 &floatformat_ieee_double_little
85 const struct floatformat
*floatformats_ieee_double_littlebyte_bigword
[BFD_ENDIAN_UNKNOWN
] = {
86 &floatformat_ieee_double_big
,
87 &floatformat_ieee_double_littlebyte_bigword
89 const struct floatformat
*floatformats_i387_ext
[BFD_ENDIAN_UNKNOWN
] = {
90 &floatformat_i387_ext
,
93 const struct floatformat
*floatformats_m68881_ext
[BFD_ENDIAN_UNKNOWN
] = {
94 &floatformat_m68881_ext
,
95 &floatformat_m68881_ext
97 const struct floatformat
*floatformats_arm_ext
[BFD_ENDIAN_UNKNOWN
] = {
98 &floatformat_arm_ext_big
,
99 &floatformat_arm_ext_littlebyte_bigword
101 const struct floatformat
*floatformats_ia64_spill
[BFD_ENDIAN_UNKNOWN
] = {
102 &floatformat_ia64_spill_big
,
103 &floatformat_ia64_spill_little
105 const struct floatformat
*floatformats_ia64_quad
[BFD_ENDIAN_UNKNOWN
] = {
106 &floatformat_ia64_quad_big
,
107 &floatformat_ia64_quad_little
109 const struct floatformat
*floatformats_vax_f
[BFD_ENDIAN_UNKNOWN
] = {
113 const struct floatformat
*floatformats_vax_d
[BFD_ENDIAN_UNKNOWN
] = {
117 const struct floatformat
*floatformats_ibm_long_double
[BFD_ENDIAN_UNKNOWN
] = {
118 &floatformat_ibm_long_double_big
,
119 &floatformat_ibm_long_double_little
121 const struct floatformat
*floatformats_bfloat16
[BFD_ENDIAN_UNKNOWN
] = {
122 &floatformat_bfloat16_big
,
123 &floatformat_bfloat16_little
126 /* Should opaque types be resolved? */
128 static bool opaque_type_resolution
= true;
130 /* See gdbtypes.h. */
132 unsigned int overload_debug
= 0;
134 /* A flag to enable strict type checking. */
136 static bool strict_type_checking
= true;
138 /* A function to show whether opaque types are resolved. */
141 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
142 struct cmd_list_element
*c
,
145 fprintf_filtered (file
, _("Resolution of opaque struct/class/union types "
146 "(if set before loading symbols) is %s.\n"),
150 /* A function to show whether C++ overload debugging is enabled. */
153 show_overload_debug (struct ui_file
*file
, int from_tty
,
154 struct cmd_list_element
*c
, const char *value
)
156 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"),
160 /* A function to show the status of strict type checking. */
163 show_strict_type_checking (struct ui_file
*file
, int from_tty
,
164 struct cmd_list_element
*c
, const char *value
)
166 fprintf_filtered (file
, _("Strict type checking is %s.\n"), value
);
170 /* Allocate a new OBJFILE-associated type structure and fill it
171 with some defaults. Space for the type structure is allocated
172 on the objfile's objfile_obstack. */
175 alloc_type (struct objfile
*objfile
)
179 gdb_assert (objfile
!= NULL
);
181 /* Alloc the structure and start off with all fields zeroed. */
182 type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct type
);
183 TYPE_MAIN_TYPE (type
) = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
185 OBJSTAT (objfile
, n_types
++);
187 type
->set_owner (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
->set_owner (gdbarch
);
215 /* Initialize the fields that might not be zero. */
217 type
->set_code (TYPE_CODE_UNDEF
);
218 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
223 /* If TYPE is objfile-associated, allocate a new type structure
224 associated with the same objfile. If TYPE is gdbarch-associated,
225 allocate a new type structure associated with the same gdbarch. */
228 alloc_type_copy (const struct type
*type
)
230 if (type
->is_objfile_owned ())
231 return alloc_type (type
->objfile_owner ());
233 return alloc_type_arch (type
->arch_owner ());
236 /* See gdbtypes.h. */
241 struct gdbarch
*arch
;
243 if (this->is_objfile_owned ())
244 arch
= this->objfile_owner ()->arch ();
246 arch
= this->arch_owner ();
248 /* The ARCH can be NULL if TYPE is associated with neither an objfile nor
249 a gdbarch, however, this is very rare, and even then, in most cases
250 that type::arch is called, we assume that a non-NULL value is
252 gdb_assert (arch
!= nullptr);
256 /* See gdbtypes.h. */
259 get_target_type (struct type
*type
)
263 type
= TYPE_TARGET_TYPE (type
);
265 type
= check_typedef (type
);
271 /* See gdbtypes.h. */
274 type_length_units (struct type
*type
)
276 int unit_size
= gdbarch_addressable_memory_unit_size (type
->arch ());
278 return TYPE_LENGTH (type
) / unit_size
;
281 /* Alloc a new type instance structure, fill it with some defaults,
282 and point it at OLDTYPE. Allocate the new type instance from the
283 same place as OLDTYPE. */
286 alloc_type_instance (struct type
*oldtype
)
290 /* Allocate the structure. */
292 if (!oldtype
->is_objfile_owned ())
293 type
= GDBARCH_OBSTACK_ZALLOC (oldtype
->arch_owner (), struct type
);
295 type
= OBSTACK_ZALLOC (&oldtype
->objfile_owner ()->objfile_obstack
,
298 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
300 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
305 /* Clear all remnants of the previous type at TYPE, in preparation for
306 replacing it with something else. Preserve owner information. */
309 smash_type (struct type
*type
)
311 bool objfile_owned
= type
->is_objfile_owned ();
312 objfile
*objfile
= type
->objfile_owner ();
313 gdbarch
*arch
= type
->arch_owner ();
315 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
317 /* Restore owner information. */
319 type
->set_owner (objfile
);
321 type
->set_owner (arch
);
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! */
373 TYPE_LENGTH (ntype
) = gdbarch_ptr_bit (type
->arch ()) / TARGET_CHAR_BIT
;
374 ntype
->set_code (TYPE_CODE_PTR
);
376 /* Mark pointers as unsigned. The target converts between pointers
377 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
378 gdbarch_address_to_pointer. */
379 ntype
->set_is_unsigned (true);
381 /* Update the length of all the other variants of this type. */
382 chain
= TYPE_CHAIN (ntype
);
383 while (chain
!= ntype
)
385 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
386 chain
= TYPE_CHAIN (chain
);
392 /* Given a type TYPE, return a type of pointers to that type.
393 May need to construct such a type if this is the first use. */
396 lookup_pointer_type (struct type
*type
)
398 return make_pointer_type (type
, (struct type
**) 0);
401 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
402 points to a pointer to memory where the reference type should be
403 stored. If *TYPEPTR is zero, update it to point to the reference
404 type we return. We allocate new memory if needed. REFCODE denotes
405 the kind of reference type to lookup (lvalue or rvalue reference). */
408 make_reference_type (struct type
*type
, struct type
**typeptr
,
409 enum type_code refcode
)
411 struct type
*ntype
; /* New type */
412 struct type
**reftype
;
415 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
417 ntype
= (refcode
== TYPE_CODE_REF
? TYPE_REFERENCE_TYPE (type
)
418 : TYPE_RVALUE_REFERENCE_TYPE (type
));
423 return ntype
; /* Don't care about alloc,
424 and have new type. */
425 else if (*typeptr
== 0)
427 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
432 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
434 ntype
= alloc_type_copy (type
);
438 else /* We have storage, but need to reset it. */
441 chain
= TYPE_CHAIN (ntype
);
443 TYPE_CHAIN (ntype
) = chain
;
446 TYPE_TARGET_TYPE (ntype
) = type
;
447 reftype
= (refcode
== TYPE_CODE_REF
? &TYPE_REFERENCE_TYPE (type
)
448 : &TYPE_RVALUE_REFERENCE_TYPE (type
));
452 /* FIXME! Assume the machine has only one representation for
453 references, and that it matches the (only) representation for
456 TYPE_LENGTH (ntype
) = gdbarch_ptr_bit (type
->arch ()) / TARGET_CHAR_BIT
;
457 ntype
->set_code (refcode
);
461 /* Update the length of all the other variants of this type. */
462 chain
= TYPE_CHAIN (ntype
);
463 while (chain
!= ntype
)
465 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
466 chain
= TYPE_CHAIN (chain
);
472 /* Same as above, but caller doesn't care about memory allocation
476 lookup_reference_type (struct type
*type
, enum type_code refcode
)
478 return make_reference_type (type
, (struct type
**) 0, refcode
);
481 /* Lookup the lvalue reference type for the type TYPE. */
484 lookup_lvalue_reference_type (struct type
*type
)
486 return lookup_reference_type (type
, TYPE_CODE_REF
);
489 /* Lookup the rvalue reference type for the type TYPE. */
492 lookup_rvalue_reference_type (struct type
*type
)
494 return lookup_reference_type (type
, TYPE_CODE_RVALUE_REF
);
497 /* Lookup a function type that returns type TYPE. TYPEPTR, if
498 nonzero, points to a pointer to memory where the function type
499 should be stored. If *TYPEPTR is zero, update it to point to the
500 function type we return. We allocate new memory if needed. */
503 make_function_type (struct type
*type
, struct type
**typeptr
)
505 struct type
*ntype
; /* New type */
507 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
509 ntype
= alloc_type_copy (type
);
513 else /* We have storage, but need to reset it. */
519 TYPE_TARGET_TYPE (ntype
) = type
;
521 TYPE_LENGTH (ntype
) = 1;
522 ntype
->set_code (TYPE_CODE_FUNC
);
524 INIT_FUNC_SPECIFIC (ntype
);
529 /* Given a type TYPE, return a type of functions that return that type.
530 May need to construct such a type if this is the first use. */
533 lookup_function_type (struct type
*type
)
535 return make_function_type (type
, (struct type
**) 0);
538 /* Given a type TYPE and argument types, return the appropriate
539 function type. If the final type in PARAM_TYPES is NULL, make a
543 lookup_function_type_with_arguments (struct type
*type
,
545 struct type
**param_types
)
547 struct type
*fn
= make_function_type (type
, (struct type
**) 0);
552 if (param_types
[nparams
- 1] == NULL
)
555 fn
->set_has_varargs (true);
557 else if (check_typedef (param_types
[nparams
- 1])->code ()
561 /* Caller should have ensured this. */
562 gdb_assert (nparams
== 0);
563 fn
->set_is_prototyped (true);
566 fn
->set_is_prototyped (true);
569 fn
->set_num_fields (nparams
);
571 ((struct field
*) TYPE_ZALLOC (fn
, nparams
* sizeof (struct field
)));
572 for (i
= 0; i
< nparams
; ++i
)
573 fn
->field (i
).set_type (param_types
[i
]);
578 /* Identify address space identifier by name -- return a
579 type_instance_flags. */
582 address_space_name_to_type_instance_flags (struct gdbarch
*gdbarch
,
583 const char *space_identifier
)
585 type_instance_flags type_flags
;
587 /* Check for known address space delimiters. */
588 if (!strcmp (space_identifier
, "code"))
589 return TYPE_INSTANCE_FLAG_CODE_SPACE
;
590 else if (!strcmp (space_identifier
, "data"))
591 return TYPE_INSTANCE_FLAG_DATA_SPACE
;
592 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
593 && gdbarch_address_class_name_to_type_flags (gdbarch
,
598 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
601 /* Identify address space identifier by type_instance_flags and return
602 the string version of the adress space name. */
605 address_space_type_instance_flags_to_name (struct gdbarch
*gdbarch
,
606 type_instance_flags space_flag
)
608 if (space_flag
& TYPE_INSTANCE_FLAG_CODE_SPACE
)
610 else if (space_flag
& TYPE_INSTANCE_FLAG_DATA_SPACE
)
612 else if ((space_flag
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
613 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
614 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
619 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
621 If STORAGE is non-NULL, create the new type instance there.
622 STORAGE must be in the same obstack as TYPE. */
625 make_qualified_type (struct type
*type
, type_instance_flags new_flags
,
626 struct type
*storage
)
633 if (ntype
->instance_flags () == new_flags
)
635 ntype
= TYPE_CHAIN (ntype
);
637 while (ntype
!= type
);
639 /* Create a new type instance. */
641 ntype
= alloc_type_instance (type
);
644 /* If STORAGE was provided, it had better be in the same objfile
645 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
646 if one objfile is freed and the other kept, we'd have
647 dangling pointers. */
648 gdb_assert (type
->objfile_owner () == storage
->objfile_owner ());
651 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
652 TYPE_CHAIN (ntype
) = ntype
;
655 /* Pointers or references to the original type are not relevant to
657 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
658 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
660 /* Chain the new qualified type to the old type. */
661 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
662 TYPE_CHAIN (type
) = ntype
;
664 /* Now set the instance flags and return the new type. */
665 ntype
->set_instance_flags (new_flags
);
667 /* Set length of new type to that of the original type. */
668 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
673 /* Make an address-space-delimited variant of a type -- a type that
674 is identical to the one supplied except that it has an address
675 space attribute attached to it (such as "code" or "data").
677 The space attributes "code" and "data" are for Harvard
678 architectures. The address space attributes are for architectures
679 which have alternately sized pointers or pointers with alternate
683 make_type_with_address_space (struct type
*type
,
684 type_instance_flags space_flag
)
686 type_instance_flags new_flags
= ((type
->instance_flags ()
687 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
688 | TYPE_INSTANCE_FLAG_DATA_SPACE
689 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
))
692 return make_qualified_type (type
, new_flags
, NULL
);
695 /* Make a "c-v" variant of a type -- a type that is identical to the
696 one supplied except that it may have const or volatile attributes
697 CNST is a flag for setting the const attribute
698 VOLTL is a flag for setting the volatile attribute
699 TYPE is the base type whose variant we are creating.
701 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
702 storage to hold the new qualified type; *TYPEPTR and TYPE must be
703 in the same objfile. Otherwise, allocate fresh memory for the new
704 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
705 new type we construct. */
708 make_cv_type (int cnst
, int voltl
,
710 struct type
**typeptr
)
712 struct type
*ntype
; /* New type */
714 type_instance_flags new_flags
= (type
->instance_flags ()
715 & ~(TYPE_INSTANCE_FLAG_CONST
716 | TYPE_INSTANCE_FLAG_VOLATILE
));
719 new_flags
|= TYPE_INSTANCE_FLAG_CONST
;
722 new_flags
|= TYPE_INSTANCE_FLAG_VOLATILE
;
724 if (typeptr
&& *typeptr
!= NULL
)
726 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
727 a C-V variant chain that threads across objfiles: if one
728 objfile gets freed, then the other has a broken C-V chain.
730 This code used to try to copy over the main type from TYPE to
731 *TYPEPTR if they were in different objfiles, but that's
732 wrong, too: TYPE may have a field list or member function
733 lists, which refer to types of their own, etc. etc. The
734 whole shebang would need to be copied over recursively; you
735 can't have inter-objfile pointers. The only thing to do is
736 to leave stub types as stub types, and look them up afresh by
737 name each time you encounter them. */
738 gdb_assert ((*typeptr
)->objfile_owner () == type
->objfile_owner ());
741 ntype
= make_qualified_type (type
, new_flags
,
742 typeptr
? *typeptr
: NULL
);
750 /* Make a 'restrict'-qualified version of TYPE. */
753 make_restrict_type (struct type
*type
)
755 return make_qualified_type (type
,
756 (type
->instance_flags ()
757 | TYPE_INSTANCE_FLAG_RESTRICT
),
761 /* Make a type without const, volatile, or restrict. */
764 make_unqualified_type (struct type
*type
)
766 return make_qualified_type (type
,
767 (type
->instance_flags ()
768 & ~(TYPE_INSTANCE_FLAG_CONST
769 | TYPE_INSTANCE_FLAG_VOLATILE
770 | TYPE_INSTANCE_FLAG_RESTRICT
)),
774 /* Make a '_Atomic'-qualified version of TYPE. */
777 make_atomic_type (struct type
*type
)
779 return make_qualified_type (type
,
780 (type
->instance_flags ()
781 | TYPE_INSTANCE_FLAG_ATOMIC
),
785 /* Replace the contents of ntype with the type *type. This changes the
786 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
787 the changes are propogated to all types in the TYPE_CHAIN.
789 In order to build recursive types, it's inevitable that we'll need
790 to update types in place --- but this sort of indiscriminate
791 smashing is ugly, and needs to be replaced with something more
792 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
793 clear if more steps are needed. */
796 replace_type (struct type
*ntype
, struct type
*type
)
800 /* These two types had better be in the same objfile. Otherwise,
801 the assignment of one type's main type structure to the other
802 will produce a type with references to objects (names; field
803 lists; etc.) allocated on an objfile other than its own. */
804 gdb_assert (ntype
->objfile_owner () == type
->objfile_owner ());
806 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
808 /* The type length is not a part of the main type. Update it for
809 each type on the variant chain. */
813 /* Assert that this element of the chain has no address-class bits
814 set in its flags. Such type variants might have type lengths
815 which are supposed to be different from the non-address-class
816 variants. This assertion shouldn't ever be triggered because
817 symbol readers which do construct address-class variants don't
818 call replace_type(). */
819 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
821 TYPE_LENGTH (chain
) = TYPE_LENGTH (type
);
822 chain
= TYPE_CHAIN (chain
);
824 while (ntype
!= chain
);
826 /* Assert that the two types have equivalent instance qualifiers.
827 This should be true for at least all of our debug readers. */
828 gdb_assert (ntype
->instance_flags () == type
->instance_flags ());
831 /* Implement direct support for MEMBER_TYPE in GNU C++.
832 May need to construct such a type if this is the first use.
833 The TYPE is the type of the member. The DOMAIN is the type
834 of the aggregate that the member belongs to. */
837 lookup_memberptr_type (struct type
*type
, struct type
*domain
)
841 mtype
= alloc_type_copy (type
);
842 smash_to_memberptr_type (mtype
, domain
, type
);
846 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
849 lookup_methodptr_type (struct type
*to_type
)
853 mtype
= alloc_type_copy (to_type
);
854 smash_to_methodptr_type (mtype
, to_type
);
858 /* Allocate a stub method whose return type is TYPE. This apparently
859 happens for speed of symbol reading, since parsing out the
860 arguments to the method is cpu-intensive, the way we are doing it.
861 So, we will fill in arguments later. This always returns a fresh
865 allocate_stub_method (struct type
*type
)
869 mtype
= alloc_type_copy (type
);
870 mtype
->set_code (TYPE_CODE_METHOD
);
871 TYPE_LENGTH (mtype
) = 1;
872 mtype
->set_is_stub (true);
873 TYPE_TARGET_TYPE (mtype
) = type
;
874 /* TYPE_SELF_TYPE (mtype) = unknown yet */
878 /* See gdbtypes.h. */
881 operator== (const dynamic_prop
&l
, const dynamic_prop
&r
)
883 if (l
.kind () != r
.kind ())
891 return l
.const_val () == r
.const_val ();
892 case PROP_ADDR_OFFSET
:
895 return l
.baton () == r
.baton ();
896 case PROP_VARIANT_PARTS
:
897 return l
.variant_parts () == r
.variant_parts ();
899 return l
.original_type () == r
.original_type ();
902 gdb_assert_not_reached ("unhandled dynamic_prop kind");
905 /* See gdbtypes.h. */
908 operator== (const range_bounds
&l
, const range_bounds
&r
)
910 #define FIELD_EQ(FIELD) (l.FIELD == r.FIELD)
912 return (FIELD_EQ (low
)
914 && FIELD_EQ (flag_upper_bound_is_count
)
915 && FIELD_EQ (flag_bound_evaluated
)
921 /* Create a range type with a dynamic range from LOW_BOUND to
922 HIGH_BOUND, inclusive. See create_range_type for further details. */
925 create_range_type (struct type
*result_type
, struct type
*index_type
,
926 const struct dynamic_prop
*low_bound
,
927 const struct dynamic_prop
*high_bound
,
930 /* The INDEX_TYPE should be a type capable of holding the upper and lower
931 bounds, as such a zero sized, or void type makes no sense. */
932 gdb_assert (index_type
->code () != TYPE_CODE_VOID
);
933 gdb_assert (TYPE_LENGTH (index_type
) > 0);
935 if (result_type
== NULL
)
936 result_type
= alloc_type_copy (index_type
);
937 result_type
->set_code (TYPE_CODE_RANGE
);
938 TYPE_TARGET_TYPE (result_type
) = index_type
;
939 if (index_type
->is_stub ())
940 result_type
->set_target_is_stub (true);
942 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
945 = (struct range_bounds
*) TYPE_ZALLOC (result_type
, sizeof (range_bounds
));
946 bounds
->low
= *low_bound
;
947 bounds
->high
= *high_bound
;
949 bounds
->stride
.set_const_val (0);
951 result_type
->set_bounds (bounds
);
953 if (index_type
->code () == TYPE_CODE_FIXED_POINT
)
954 result_type
->set_is_unsigned (index_type
->is_unsigned ());
955 /* Note that the signed-ness of a range type can't simply be copied
956 from the underlying type. Consider a case where the underlying
957 type is 'int', but the range type can hold 0..65535, and where
958 the range is further specified to fit into 16 bits. In this
959 case, if we copy the underlying type's sign, then reading some
960 range values will cause an unwanted sign extension. So, we have
961 some heuristics here instead. */
962 else if (low_bound
->kind () == PROP_CONST
&& low_bound
->const_val () >= 0)
963 result_type
->set_is_unsigned (true);
964 /* Ada allows the declaration of range types whose upper bound is
965 less than the lower bound, so checking the lower bound is not
966 enough. Make sure we do not mark a range type whose upper bound
967 is negative as unsigned. */
968 if (high_bound
->kind () == PROP_CONST
&& high_bound
->const_val () < 0)
969 result_type
->set_is_unsigned (false);
971 result_type
->set_endianity_is_not_default
972 (index_type
->endianity_is_not_default ());
977 /* See gdbtypes.h. */
980 create_range_type_with_stride (struct type
*result_type
,
981 struct type
*index_type
,
982 const struct dynamic_prop
*low_bound
,
983 const struct dynamic_prop
*high_bound
,
985 const struct dynamic_prop
*stride
,
988 result_type
= create_range_type (result_type
, index_type
, low_bound
,
991 gdb_assert (stride
!= nullptr);
992 result_type
->bounds ()->stride
= *stride
;
993 result_type
->bounds ()->flag_is_byte_stride
= byte_stride_p
;
1000 /* Create a range type using either a blank type supplied in
1001 RESULT_TYPE, or creating a new type, inheriting the objfile from
1004 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
1005 to HIGH_BOUND, inclusive.
1007 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1008 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
1011 create_static_range_type (struct type
*result_type
, struct type
*index_type
,
1012 LONGEST low_bound
, LONGEST high_bound
)
1014 struct dynamic_prop low
, high
;
1016 low
.set_const_val (low_bound
);
1017 high
.set_const_val (high_bound
);
1019 result_type
= create_range_type (result_type
, index_type
, &low
, &high
, 0);
1024 /* Predicate tests whether BOUNDS are static. Returns 1 if all bounds values
1025 are static, otherwise returns 0. */
1028 has_static_range (const struct range_bounds
*bounds
)
1030 /* If the range doesn't have a defined stride then its stride field will
1031 be initialized to the constant 0. */
1032 return (bounds
->low
.kind () == PROP_CONST
1033 && bounds
->high
.kind () == PROP_CONST
1034 && bounds
->stride
.kind () == PROP_CONST
);
1037 /* See gdbtypes.h. */
1039 gdb::optional
<LONGEST
>
1040 get_discrete_low_bound (struct type
*type
)
1042 type
= check_typedef (type
);
1043 switch (type
->code ())
1045 case TYPE_CODE_RANGE
:
1047 /* This function only works for ranges with a constant low bound. */
1048 if (type
->bounds ()->low
.kind () != PROP_CONST
)
1051 LONGEST low
= type
->bounds ()->low
.const_val ();
1053 if (TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_ENUM
)
1055 gdb::optional
<LONGEST
> low_pos
1056 = discrete_position (TYPE_TARGET_TYPE (type
), low
);
1058 if (low_pos
.has_value ())
1065 case TYPE_CODE_ENUM
:
1067 if (type
->num_fields () > 0)
1069 /* The enums may not be sorted by value, so search all
1071 LONGEST low
= type
->field (0).loc_enumval ();
1073 for (int i
= 0; i
< type
->num_fields (); i
++)
1075 if (type
->field (i
).loc_enumval () < low
)
1076 low
= type
->field (i
).loc_enumval ();
1079 /* Set unsigned indicator if warranted. */
1081 type
->set_is_unsigned (true);
1089 case TYPE_CODE_BOOL
:
1093 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
1096 if (!type
->is_unsigned ())
1097 return -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
1100 case TYPE_CODE_CHAR
:
1108 /* See gdbtypes.h. */
1110 gdb::optional
<LONGEST
>
1111 get_discrete_high_bound (struct type
*type
)
1113 type
= check_typedef (type
);
1114 switch (type
->code ())
1116 case TYPE_CODE_RANGE
:
1118 /* This function only works for ranges with a constant high bound. */
1119 if (type
->bounds ()->high
.kind () != PROP_CONST
)
1122 LONGEST high
= type
->bounds ()->high
.const_val ();
1124 if (TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_ENUM
)
1126 gdb::optional
<LONGEST
> high_pos
1127 = discrete_position (TYPE_TARGET_TYPE (type
), high
);
1129 if (high_pos
.has_value ())
1136 case TYPE_CODE_ENUM
:
1138 if (type
->num_fields () > 0)
1140 /* The enums may not be sorted by value, so search all
1142 LONGEST high
= type
->field (0).loc_enumval ();
1144 for (int i
= 0; i
< type
->num_fields (); i
++)
1146 if (type
->field (i
).loc_enumval () > high
)
1147 high
= type
->field (i
).loc_enumval ();
1156 case TYPE_CODE_BOOL
:
1160 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
1163 if (!type
->is_unsigned ())
1165 LONGEST low
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
1170 case TYPE_CODE_CHAR
:
1172 /* This round-about calculation is to avoid shifting by
1173 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
1174 if TYPE_LENGTH (type) == sizeof (LONGEST). */
1175 LONGEST high
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
1176 return (high
- 1) | high
;
1184 /* See gdbtypes.h. */
1187 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
1189 gdb::optional
<LONGEST
> low
= get_discrete_low_bound (type
);
1190 if (!low
.has_value ())
1193 gdb::optional
<LONGEST
> high
= get_discrete_high_bound (type
);
1194 if (!high
.has_value ())
1203 /* See gdbtypes.h */
1206 get_array_bounds (struct type
*type
, LONGEST
*low_bound
, LONGEST
*high_bound
)
1208 struct type
*index
= type
->index_type ();
1215 if (!get_discrete_bounds (index
, &low
, &high
))
1227 /* Assuming that TYPE is a discrete type and VAL is a valid integer
1228 representation of a value of this type, save the corresponding
1229 position number in POS.
1231 Its differs from VAL only in the case of enumeration types. In
1232 this case, the position number of the value of the first listed
1233 enumeration literal is zero; the position number of the value of
1234 each subsequent enumeration literal is one more than that of its
1235 predecessor in the list.
1237 Return 1 if the operation was successful. Return zero otherwise,
1238 in which case the value of POS is unmodified.
1241 gdb::optional
<LONGEST
>
1242 discrete_position (struct type
*type
, LONGEST val
)
1244 if (type
->code () == TYPE_CODE_RANGE
)
1245 type
= TYPE_TARGET_TYPE (type
);
1247 if (type
->code () == TYPE_CODE_ENUM
)
1251 for (i
= 0; i
< type
->num_fields (); i
+= 1)
1253 if (val
== type
->field (i
).loc_enumval ())
1257 /* Invalid enumeration value. */
1264 /* If the array TYPE has static bounds calculate and update its
1265 size, then return true. Otherwise return false and leave TYPE
1269 update_static_array_size (struct type
*type
)
1271 gdb_assert (type
->code () == TYPE_CODE_ARRAY
);
1273 struct type
*range_type
= type
->index_type ();
1275 if (type
->dyn_prop (DYN_PROP_BYTE_STRIDE
) == nullptr
1276 && has_static_range (range_type
->bounds ())
1277 && (!type_not_associated (type
)
1278 && !type_not_allocated (type
)))
1280 LONGEST low_bound
, high_bound
;
1282 struct type
*element_type
;
1284 stride
= type
->bit_stride ();
1286 if (!get_discrete_bounds (range_type
, &low_bound
, &high_bound
))
1287 low_bound
= high_bound
= 0;
1289 element_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1290 /* Be careful when setting the array length. Ada arrays can be
1291 empty arrays with the high_bound being smaller than the low_bound.
1292 In such cases, the array length should be zero. */
1293 if (high_bound
< low_bound
)
1294 TYPE_LENGTH (type
) = 0;
1295 else if (stride
!= 0)
1297 /* Ensure that the type length is always positive, even in the
1298 case where (for example in Fortran) we have a negative
1299 stride. It is possible to have a single element array with a
1300 negative stride in Fortran (this doesn't mean anything
1301 special, it's still just a single element array) so do
1302 consider that case when touching this code. */
1303 LONGEST element_count
= std::abs (high_bound
- low_bound
+ 1);
1305 = ((std::abs (stride
) * element_count
) + 7) / 8;
1308 TYPE_LENGTH (type
) =
1309 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
1311 /* If this array's element is itself an array with a bit stride,
1312 then we want to update this array's bit stride to reflect the
1313 size of the sub-array. Otherwise, we'll end up using the
1314 wrong size when trying to find elements of the outer
1316 if (element_type
->code () == TYPE_CODE_ARRAY
1317 && TYPE_LENGTH (element_type
) != 0
1318 && TYPE_FIELD_BITSIZE (element_type
, 0) != 0
1319 && get_array_bounds (element_type
, &low_bound
, &high_bound
)
1320 && high_bound
>= low_bound
)
1321 TYPE_FIELD_BITSIZE (type
, 0)
1322 = ((high_bound
- low_bound
+ 1)
1323 * TYPE_FIELD_BITSIZE (element_type
, 0));
1331 /* Create an array type using either a blank type supplied in
1332 RESULT_TYPE, or creating a new type, inheriting the objfile from
1335 Elements will be of type ELEMENT_TYPE, the indices will be of type
1338 BYTE_STRIDE_PROP, when not NULL, provides the array's byte stride.
1339 This byte stride property is added to the resulting array type
1340 as a DYN_PROP_BYTE_STRIDE. As a consequence, the BYTE_STRIDE_PROP
1341 argument can only be used to create types that are objfile-owned
1342 (see add_dyn_prop), meaning that either this function must be called
1343 with an objfile-owned RESULT_TYPE, or an objfile-owned RANGE_TYPE.
1345 BIT_STRIDE is taken into account only when BYTE_STRIDE_PROP is NULL.
1346 If BIT_STRIDE is not zero, build a packed array type whose element
1347 size is BIT_STRIDE. Otherwise, ignore this parameter.
1349 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1350 sure it is TYPE_CODE_UNDEF before we bash it into an array
1354 create_array_type_with_stride (struct type
*result_type
,
1355 struct type
*element_type
,
1356 struct type
*range_type
,
1357 struct dynamic_prop
*byte_stride_prop
,
1358 unsigned int bit_stride
)
1360 if (byte_stride_prop
!= NULL
1361 && byte_stride_prop
->kind () == PROP_CONST
)
1363 /* The byte stride is actually not dynamic. Pretend we were
1364 called with bit_stride set instead of byte_stride_prop.
1365 This will give us the same result type, while avoiding
1366 the need to handle this as a special case. */
1367 bit_stride
= byte_stride_prop
->const_val () * 8;
1368 byte_stride_prop
= NULL
;
1371 if (result_type
== NULL
)
1372 result_type
= alloc_type_copy (range_type
);
1374 result_type
->set_code (TYPE_CODE_ARRAY
);
1375 TYPE_TARGET_TYPE (result_type
) = element_type
;
1377 result_type
->set_num_fields (1);
1378 result_type
->set_fields
1379 ((struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
)));
1380 result_type
->set_index_type (range_type
);
1381 if (byte_stride_prop
!= NULL
)
1382 result_type
->add_dyn_prop (DYN_PROP_BYTE_STRIDE
, *byte_stride_prop
);
1383 else if (bit_stride
> 0)
1384 TYPE_FIELD_BITSIZE (result_type
, 0) = bit_stride
;
1386 if (!update_static_array_size (result_type
))
1388 /* This type is dynamic and its length needs to be computed
1389 on demand. In the meantime, avoid leaving the TYPE_LENGTH
1390 undefined by setting it to zero. Although we are not expected
1391 to trust TYPE_LENGTH in this case, setting the size to zero
1392 allows us to avoid allocating objects of random sizes in case
1393 we accidently do. */
1394 TYPE_LENGTH (result_type
) = 0;
1397 /* TYPE_TARGET_STUB will take care of zero length arrays. */
1398 if (TYPE_LENGTH (result_type
) == 0)
1399 result_type
->set_target_is_stub (true);
1404 /* Same as create_array_type_with_stride but with no bit_stride
1405 (BIT_STRIDE = 0), thus building an unpacked array. */
1408 create_array_type (struct type
*result_type
,
1409 struct type
*element_type
,
1410 struct type
*range_type
)
1412 return create_array_type_with_stride (result_type
, element_type
,
1413 range_type
, NULL
, 0);
1417 lookup_array_range_type (struct type
*element_type
,
1418 LONGEST low_bound
, LONGEST high_bound
)
1420 struct type
*index_type
;
1421 struct type
*range_type
;
1423 if (element_type
->is_objfile_owned ())
1424 index_type
= objfile_type (element_type
->objfile_owner ())->builtin_int
;
1426 index_type
= builtin_type (element_type
->arch_owner ())->builtin_int
;
1428 range_type
= create_static_range_type (NULL
, index_type
,
1429 low_bound
, high_bound
);
1431 return create_array_type (NULL
, element_type
, range_type
);
1434 /* Create a string type using either a blank type supplied in
1435 RESULT_TYPE, or creating a new type. String types are similar
1436 enough to array of char types that we can use create_array_type to
1437 build the basic type and then bash it into a string type.
1439 For fixed length strings, the range type contains 0 as the lower
1440 bound and the length of the string minus one as the upper bound.
1442 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1443 sure it is TYPE_CODE_UNDEF before we bash it into a string
1447 create_string_type (struct type
*result_type
,
1448 struct type
*string_char_type
,
1449 struct type
*range_type
)
1451 result_type
= create_array_type (result_type
,
1454 result_type
->set_code (TYPE_CODE_STRING
);
1459 lookup_string_range_type (struct type
*string_char_type
,
1460 LONGEST low_bound
, LONGEST high_bound
)
1462 struct type
*result_type
;
1464 result_type
= lookup_array_range_type (string_char_type
,
1465 low_bound
, high_bound
);
1466 result_type
->set_code (TYPE_CODE_STRING
);
1471 create_set_type (struct type
*result_type
, struct type
*domain_type
)
1473 if (result_type
== NULL
)
1474 result_type
= alloc_type_copy (domain_type
);
1476 result_type
->set_code (TYPE_CODE_SET
);
1477 result_type
->set_num_fields (1);
1478 result_type
->set_fields
1479 ((struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
)));
1481 if (!domain_type
->is_stub ())
1483 LONGEST low_bound
, high_bound
, bit_length
;
1485 if (!get_discrete_bounds (domain_type
, &low_bound
, &high_bound
))
1486 low_bound
= high_bound
= 0;
1488 bit_length
= high_bound
- low_bound
+ 1;
1489 TYPE_LENGTH (result_type
)
1490 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
1492 result_type
->set_is_unsigned (true);
1494 result_type
->field (0).set_type (domain_type
);
1499 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
1500 and any array types nested inside it. */
1503 make_vector_type (struct type
*array_type
)
1505 struct type
*inner_array
, *elt_type
;
1507 /* Find the innermost array type, in case the array is
1508 multi-dimensional. */
1509 inner_array
= array_type
;
1510 while (TYPE_TARGET_TYPE (inner_array
)->code () == TYPE_CODE_ARRAY
)
1511 inner_array
= TYPE_TARGET_TYPE (inner_array
);
1513 elt_type
= TYPE_TARGET_TYPE (inner_array
);
1514 if (elt_type
->code () == TYPE_CODE_INT
)
1516 type_instance_flags flags
1517 = elt_type
->instance_flags () | TYPE_INSTANCE_FLAG_NOTTEXT
;
1518 elt_type
= make_qualified_type (elt_type
, flags
, NULL
);
1519 TYPE_TARGET_TYPE (inner_array
) = elt_type
;
1522 array_type
->set_is_vector (true);
1526 init_vector_type (struct type
*elt_type
, int n
)
1528 struct type
*array_type
;
1530 array_type
= lookup_array_range_type (elt_type
, 0, n
- 1);
1531 make_vector_type (array_type
);
1535 /* Internal routine called by TYPE_SELF_TYPE to return the type that TYPE
1536 belongs to. In c++ this is the class of "this", but TYPE_THIS_TYPE is too
1537 confusing. "self" is a common enough replacement for "this".
1538 TYPE must be one of TYPE_CODE_METHODPTR, TYPE_CODE_MEMBERPTR, or
1539 TYPE_CODE_METHOD. */
1542 internal_type_self_type (struct type
*type
)
1544 switch (type
->code ())
1546 case TYPE_CODE_METHODPTR
:
1547 case TYPE_CODE_MEMBERPTR
:
1548 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1550 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_SELF_TYPE
);
1551 return TYPE_MAIN_TYPE (type
)->type_specific
.self_type
;
1552 case TYPE_CODE_METHOD
:
1553 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1555 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
1556 return TYPE_MAIN_TYPE (type
)->type_specific
.func_stuff
->self_type
;
1558 gdb_assert_not_reached ("bad type");
1562 /* Set the type of the class that TYPE belongs to.
1563 In c++ this is the class of "this".
1564 TYPE must be one of TYPE_CODE_METHODPTR, TYPE_CODE_MEMBERPTR, or
1565 TYPE_CODE_METHOD. */
1568 set_type_self_type (struct type
*type
, struct type
*self_type
)
1570 switch (type
->code ())
1572 case TYPE_CODE_METHODPTR
:
1573 case TYPE_CODE_MEMBERPTR
:
1574 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1575 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_SELF_TYPE
;
1576 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_SELF_TYPE
);
1577 TYPE_MAIN_TYPE (type
)->type_specific
.self_type
= self_type
;
1579 case TYPE_CODE_METHOD
:
1580 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1581 INIT_FUNC_SPECIFIC (type
);
1582 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
1583 TYPE_MAIN_TYPE (type
)->type_specific
.func_stuff
->self_type
= self_type
;
1586 gdb_assert_not_reached ("bad type");
1590 /* Smash TYPE to be a type of pointers to members of SELF_TYPE with type
1591 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1592 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1593 TYPE doesn't include the offset (that's the value of the MEMBER
1594 itself), but does include the structure type into which it points
1597 When "smashing" the type, we preserve the objfile that the old type
1598 pointed to, since we aren't changing where the type is actually
1602 smash_to_memberptr_type (struct type
*type
, struct type
*self_type
,
1603 struct type
*to_type
)
1606 type
->set_code (TYPE_CODE_MEMBERPTR
);
1607 TYPE_TARGET_TYPE (type
) = to_type
;
1608 set_type_self_type (type
, self_type
);
1609 /* Assume that a data member pointer is the same size as a normal
1611 TYPE_LENGTH (type
) = gdbarch_ptr_bit (to_type
->arch ()) / TARGET_CHAR_BIT
;
1614 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1616 When "smashing" the type, we preserve the objfile that the old type
1617 pointed to, since we aren't changing where the type is actually
1621 smash_to_methodptr_type (struct type
*type
, struct type
*to_type
)
1624 type
->set_code (TYPE_CODE_METHODPTR
);
1625 TYPE_TARGET_TYPE (type
) = to_type
;
1626 set_type_self_type (type
, TYPE_SELF_TYPE (to_type
));
1627 TYPE_LENGTH (type
) = cplus_method_ptr_size (to_type
);
1630 /* Smash TYPE to be a type of method of SELF_TYPE with type TO_TYPE.
1631 METHOD just means `function that gets an extra "this" argument'.
1633 When "smashing" the type, we preserve the objfile that the old type
1634 pointed to, since we aren't changing where the type is actually
1638 smash_to_method_type (struct type
*type
, struct type
*self_type
,
1639 struct type
*to_type
, struct field
*args
,
1640 int nargs
, int varargs
)
1643 type
->set_code (TYPE_CODE_METHOD
);
1644 TYPE_TARGET_TYPE (type
) = to_type
;
1645 set_type_self_type (type
, self_type
);
1646 type
->set_fields (args
);
1647 type
->set_num_fields (nargs
);
1649 type
->set_has_varargs (true);
1650 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1653 /* A wrapper of TYPE_NAME which calls error if the type is anonymous.
1654 Since GCC PR debug/47510 DWARF provides associated information to detect the
1655 anonymous class linkage name from its typedef.
1657 Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
1661 type_name_or_error (struct type
*type
)
1663 struct type
*saved_type
= type
;
1665 struct objfile
*objfile
;
1667 type
= check_typedef (type
);
1669 name
= type
->name ();
1673 name
= saved_type
->name ();
1674 objfile
= saved_type
->objfile_owner ();
1675 error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
1676 name
? name
: "<anonymous>",
1677 objfile
? objfile_name (objfile
) : "<arch>");
1680 /* Lookup a typedef or primitive type named NAME, visible in lexical
1681 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1682 suitably defined. */
1685 lookup_typename (const struct language_defn
*language
,
1687 const struct block
*block
, int noerr
)
1691 sym
= lookup_symbol_in_language (name
, block
, VAR_DOMAIN
,
1692 language
->la_language
, NULL
).symbol
;
1693 if (sym
!= NULL
&& SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
1694 return SYMBOL_TYPE (sym
);
1698 error (_("No type named %s."), name
);
1702 lookup_unsigned_typename (const struct language_defn
*language
,
1705 char *uns
= (char *) alloca (strlen (name
) + 10);
1707 strcpy (uns
, "unsigned ");
1708 strcpy (uns
+ 9, name
);
1709 return lookup_typename (language
, uns
, NULL
, 0);
1713 lookup_signed_typename (const struct language_defn
*language
, const char *name
)
1716 char *uns
= (char *) alloca (strlen (name
) + 8);
1718 strcpy (uns
, "signed ");
1719 strcpy (uns
+ 7, name
);
1720 t
= lookup_typename (language
, uns
, NULL
, 1);
1721 /* If we don't find "signed FOO" just try again with plain "FOO". */
1724 return lookup_typename (language
, name
, NULL
, 0);
1727 /* Lookup a structure type named "struct NAME",
1728 visible in lexical block BLOCK. */
1731 lookup_struct (const char *name
, const struct block
*block
)
1735 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
1739 error (_("No struct type named %s."), name
);
1741 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_STRUCT
)
1743 error (_("This context has class, union or enum %s, not a struct."),
1746 return (SYMBOL_TYPE (sym
));
1749 /* Lookup a union type named "union NAME",
1750 visible in lexical block BLOCK. */
1753 lookup_union (const char *name
, const struct block
*block
)
1758 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
1761 error (_("No union type named %s."), name
);
1763 t
= SYMBOL_TYPE (sym
);
1765 if (t
->code () == TYPE_CODE_UNION
)
1768 /* If we get here, it's not a union. */
1769 error (_("This context has class, struct or enum %s, not a union."),
1773 /* Lookup an enum type named "enum NAME",
1774 visible in lexical block BLOCK. */
1777 lookup_enum (const char *name
, const struct block
*block
)
1781 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
1784 error (_("No enum type named %s."), name
);
1786 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_ENUM
)
1788 error (_("This context has class, struct or union %s, not an enum."),
1791 return (SYMBOL_TYPE (sym
));
1794 /* Lookup a template type named "template NAME<TYPE>",
1795 visible in lexical block BLOCK. */
1798 lookup_template_type (const char *name
, struct type
*type
,
1799 const struct block
*block
)
1802 char *nam
= (char *)
1803 alloca (strlen (name
) + strlen (type
->name ()) + 4);
1807 strcat (nam
, type
->name ());
1808 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1810 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0).symbol
;
1814 error (_("No template type named %s."), name
);
1816 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_STRUCT
)
1818 error (_("This context has class, union or enum %s, not a struct."),
1821 return (SYMBOL_TYPE (sym
));
1824 /* See gdbtypes.h. */
1827 lookup_struct_elt (struct type
*type
, const char *name
, int noerr
)
1833 type
= check_typedef (type
);
1834 if (type
->code () != TYPE_CODE_PTR
1835 && type
->code () != TYPE_CODE_REF
)
1837 type
= TYPE_TARGET_TYPE (type
);
1840 if (type
->code () != TYPE_CODE_STRUCT
1841 && type
->code () != TYPE_CODE_UNION
)
1843 std::string type_name
= type_to_string (type
);
1844 error (_("Type %s is not a structure or union type."),
1845 type_name
.c_str ());
1848 for (i
= type
->num_fields () - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1850 const char *t_field_name
= type
->field (i
).name ();
1852 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1854 return {&type
->field (i
), type
->field (i
).loc_bitpos ()};
1856 else if (!t_field_name
|| *t_field_name
== '\0')
1859 = lookup_struct_elt (type
->field (i
).type (), name
, 1);
1860 if (elt
.field
!= NULL
)
1862 elt
.offset
+= type
->field (i
).loc_bitpos ();
1868 /* OK, it's not in this class. Recursively check the baseclasses. */
1869 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1871 struct_elt elt
= lookup_struct_elt (TYPE_BASECLASS (type
, i
), name
, 1);
1872 if (elt
.field
!= NULL
)
1877 return {nullptr, 0};
1879 std::string type_name
= type_to_string (type
);
1880 error (_("Type %s has no component named %s."), type_name
.c_str (), name
);
1883 /* See gdbtypes.h. */
1886 lookup_struct_elt_type (struct type
*type
, const char *name
, int noerr
)
1888 struct_elt elt
= lookup_struct_elt (type
, name
, noerr
);
1889 if (elt
.field
!= NULL
)
1890 return elt
.field
->type ();
1895 /* Return the largest number representable by unsigned integer type TYPE. */
1898 get_unsigned_type_max (struct type
*type
)
1902 type
= check_typedef (type
);
1903 gdb_assert (type
->code () == TYPE_CODE_INT
&& type
->is_unsigned ());
1904 gdb_assert (TYPE_LENGTH (type
) <= sizeof (ULONGEST
));
1906 /* Written this way to avoid overflow. */
1907 n
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
1908 return ((((ULONGEST
) 1 << (n
- 1)) - 1) << 1) | 1;
1911 /* Store in *MIN, *MAX the smallest and largest numbers representable by
1912 signed integer type TYPE. */
1915 get_signed_type_minmax (struct type
*type
, LONGEST
*min
, LONGEST
*max
)
1919 type
= check_typedef (type
);
1920 gdb_assert (type
->code () == TYPE_CODE_INT
&& !type
->is_unsigned ());
1921 gdb_assert (TYPE_LENGTH (type
) <= sizeof (LONGEST
));
1923 n
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
1924 *min
= -((ULONGEST
) 1 << (n
- 1));
1925 *max
= ((ULONGEST
) 1 << (n
- 1)) - 1;
1928 /* Return the largest value representable by pointer type TYPE. */
1931 get_pointer_type_max (struct type
*type
)
1935 type
= check_typedef (type
);
1936 gdb_assert (type
->code () == TYPE_CODE_PTR
);
1937 gdb_assert (TYPE_LENGTH (type
) <= sizeof (CORE_ADDR
));
1939 n
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
1940 return ((((CORE_ADDR
) 1 << (n
- 1)) - 1) << 1) | 1;
1943 /* Internal routine called by TYPE_VPTR_FIELDNO to return the value of
1944 cplus_stuff.vptr_fieldno.
1946 cplus_stuff is initialized to cplus_struct_default which does not
1947 set vptr_fieldno to -1 for portability reasons (IWBN to use C99
1948 designated initializers). We cope with that here. */
1951 internal_type_vptr_fieldno (struct type
*type
)
1953 type
= check_typedef (type
);
1954 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1955 || type
->code () == TYPE_CODE_UNION
);
1956 if (!HAVE_CPLUS_STRUCT (type
))
1958 return TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_fieldno
;
1961 /* Set the value of cplus_stuff.vptr_fieldno. */
1964 set_type_vptr_fieldno (struct type
*type
, int fieldno
)
1966 type
= check_typedef (type
);
1967 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1968 || type
->code () == TYPE_CODE_UNION
);
1969 if (!HAVE_CPLUS_STRUCT (type
))
1970 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1971 TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_fieldno
= fieldno
;
1974 /* Internal routine called by TYPE_VPTR_BASETYPE to return the value of
1975 cplus_stuff.vptr_basetype. */
1978 internal_type_vptr_basetype (struct type
*type
)
1980 type
= check_typedef (type
);
1981 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1982 || type
->code () == TYPE_CODE_UNION
);
1983 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_CPLUS_STUFF
);
1984 return TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_basetype
;
1987 /* Set the value of cplus_stuff.vptr_basetype. */
1990 set_type_vptr_basetype (struct type
*type
, struct type
*basetype
)
1992 type
= check_typedef (type
);
1993 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1994 || type
->code () == TYPE_CODE_UNION
);
1995 if (!HAVE_CPLUS_STRUCT (type
))
1996 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1997 TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_basetype
= basetype
;
2000 /* Lookup the vptr basetype/fieldno values for TYPE.
2001 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
2002 vptr_fieldno. Also, if found and basetype is from the same objfile,
2004 If not found, return -1 and ignore BASETYPEP.
2005 Callers should be aware that in some cases (for example,
2006 the type or one of its baseclasses is a stub type and we are
2007 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
2008 this function will not be able to find the
2009 virtual function table pointer, and vptr_fieldno will remain -1 and
2010 vptr_basetype will remain NULL or incomplete. */
2013 get_vptr_fieldno (struct type
*type
, struct type
**basetypep
)
2015 type
= check_typedef (type
);
2017 if (TYPE_VPTR_FIELDNO (type
) < 0)
2021 /* We must start at zero in case the first (and only) baseclass
2022 is virtual (and hence we cannot share the table pointer). */
2023 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
2025 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
2027 struct type
*basetype
;
2029 fieldno
= get_vptr_fieldno (baseclass
, &basetype
);
2032 /* If the type comes from a different objfile we can't cache
2033 it, it may have a different lifetime. PR 2384 */
2034 if (type
->objfile_owner () == basetype
->objfile_owner ())
2036 set_type_vptr_fieldno (type
, fieldno
);
2037 set_type_vptr_basetype (type
, basetype
);
2040 *basetypep
= basetype
;
2051 *basetypep
= TYPE_VPTR_BASETYPE (type
);
2052 return TYPE_VPTR_FIELDNO (type
);
2057 stub_noname_complaint (void)
2059 complaint (_("stub type has NULL name"));
2062 /* Return nonzero if TYPE has a DYN_PROP_BYTE_STRIDE dynamic property
2063 attached to it, and that property has a non-constant value. */
2066 array_type_has_dynamic_stride (struct type
*type
)
2068 struct dynamic_prop
*prop
= type
->dyn_prop (DYN_PROP_BYTE_STRIDE
);
2070 return (prop
!= NULL
&& prop
->kind () != PROP_CONST
);
2073 /* Worker for is_dynamic_type. */
2076 is_dynamic_type_internal (struct type
*type
, int top_level
)
2078 type
= check_typedef (type
);
2080 /* We only want to recognize references at the outermost level. */
2081 if (top_level
&& type
->code () == TYPE_CODE_REF
)
2082 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2084 /* Types that have a dynamic TYPE_DATA_LOCATION are considered
2085 dynamic, even if the type itself is statically defined.
2086 From a user's point of view, this may appear counter-intuitive;
2087 but it makes sense in this context, because the point is to determine
2088 whether any part of the type needs to be resolved before it can
2090 if (TYPE_DATA_LOCATION (type
) != NULL
2091 && (TYPE_DATA_LOCATION_KIND (type
) == PROP_LOCEXPR
2092 || TYPE_DATA_LOCATION_KIND (type
) == PROP_LOCLIST
))
2095 if (TYPE_ASSOCIATED_PROP (type
))
2098 if (TYPE_ALLOCATED_PROP (type
))
2101 struct dynamic_prop
*prop
= type
->dyn_prop (DYN_PROP_VARIANT_PARTS
);
2102 if (prop
!= nullptr && prop
->kind () != PROP_TYPE
)
2105 if (TYPE_HAS_DYNAMIC_LENGTH (type
))
2108 switch (type
->code ())
2110 case TYPE_CODE_RANGE
:
2112 /* A range type is obviously dynamic if it has at least one
2113 dynamic bound. But also consider the range type to be
2114 dynamic when its subtype is dynamic, even if the bounds
2115 of the range type are static. It allows us to assume that
2116 the subtype of a static range type is also static. */
2117 return (!has_static_range (type
->bounds ())
2118 || is_dynamic_type_internal (TYPE_TARGET_TYPE (type
), 0));
2121 case TYPE_CODE_STRING
:
2122 /* Strings are very much like an array of characters, and can be
2123 treated as one here. */
2124 case TYPE_CODE_ARRAY
:
2126 gdb_assert (type
->num_fields () == 1);
2128 /* The array is dynamic if either the bounds are dynamic... */
2129 if (is_dynamic_type_internal (type
->index_type (), 0))
2131 /* ... or the elements it contains have a dynamic contents... */
2132 if (is_dynamic_type_internal (TYPE_TARGET_TYPE (type
), 0))
2134 /* ... or if it has a dynamic stride... */
2135 if (array_type_has_dynamic_stride (type
))
2140 case TYPE_CODE_STRUCT
:
2141 case TYPE_CODE_UNION
:
2145 bool is_cplus
= HAVE_CPLUS_STRUCT (type
);
2147 for (i
= 0; i
< type
->num_fields (); ++i
)
2149 /* Static fields can be ignored here. */
2150 if (field_is_static (&type
->field (i
)))
2152 /* If the field has dynamic type, then so does TYPE. */
2153 if (is_dynamic_type_internal (type
->field (i
).type (), 0))
2155 /* If the field is at a fixed offset, then it is not
2157 if (type
->field (i
).loc_kind () != FIELD_LOC_KIND_DWARF_BLOCK
)
2159 /* Do not consider C++ virtual base types to be dynamic
2160 due to the field's offset being dynamic; these are
2161 handled via other means. */
2162 if (is_cplus
&& BASETYPE_VIA_VIRTUAL (type
, i
))
2173 /* See gdbtypes.h. */
2176 is_dynamic_type (struct type
*type
)
2178 return is_dynamic_type_internal (type
, 1);
2181 static struct type
*resolve_dynamic_type_internal
2182 (struct type
*type
, struct property_addr_info
*addr_stack
, int top_level
);
2184 /* Given a dynamic range type (dyn_range_type) and a stack of
2185 struct property_addr_info elements, return a static version
2188 When RESOLVE_P is true then the returned static range is created by
2189 actually evaluating any dynamic properties within the range type, while
2190 when RESOLVE_P is false the returned static range has all of the bounds
2191 and stride information set to undefined. The RESOLVE_P set to false
2192 case will be used when evaluating a dynamic array that is not
2193 allocated, or not associated, i.e. the bounds information might not be
2196 static struct type
*
2197 resolve_dynamic_range (struct type
*dyn_range_type
,
2198 struct property_addr_info
*addr_stack
,
2199 bool resolve_p
= true)
2202 struct type
*static_range_type
, *static_target_type
;
2203 struct dynamic_prop low_bound
, high_bound
, stride
;
2205 gdb_assert (dyn_range_type
->code () == TYPE_CODE_RANGE
);
2207 const struct dynamic_prop
*prop
= &dyn_range_type
->bounds ()->low
;
2208 if (resolve_p
&& dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2209 low_bound
.set_const_val (value
);
2211 low_bound
.set_undefined ();
2213 prop
= &dyn_range_type
->bounds ()->high
;
2214 if (resolve_p
&& dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2216 high_bound
.set_const_val (value
);
2218 if (dyn_range_type
->bounds ()->flag_upper_bound_is_count
)
2219 high_bound
.set_const_val
2220 (low_bound
.const_val () + high_bound
.const_val () - 1);
2223 high_bound
.set_undefined ();
2225 bool byte_stride_p
= dyn_range_type
->bounds ()->flag_is_byte_stride
;
2226 prop
= &dyn_range_type
->bounds ()->stride
;
2227 if (resolve_p
&& dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2229 stride
.set_const_val (value
);
2231 /* If we have a bit stride that is not an exact number of bytes then
2232 I really don't think this is going to work with current GDB, the
2233 array indexing code in GDB seems to be pretty heavily tied to byte
2234 offsets right now. Assuming 8 bits in a byte. */
2235 struct gdbarch
*gdbarch
= dyn_range_type
->arch ();
2236 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
2237 if (!byte_stride_p
&& (value
% (unit_size
* 8)) != 0)
2238 error (_("bit strides that are not a multiple of the byte size "
2239 "are currently not supported"));
2243 stride
.set_undefined ();
2244 byte_stride_p
= true;
2248 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (dyn_range_type
),
2250 LONGEST bias
= dyn_range_type
->bounds ()->bias
;
2251 static_range_type
= create_range_type_with_stride
2252 (copy_type (dyn_range_type
), static_target_type
,
2253 &low_bound
, &high_bound
, bias
, &stride
, byte_stride_p
);
2254 static_range_type
->bounds ()->flag_bound_evaluated
= 1;
2255 return static_range_type
;
2258 /* Resolves dynamic bound values of an array or string type TYPE to static
2259 ones. ADDR_STACK is a stack of struct property_addr_info to be used if
2260 needed during the dynamic resolution.
2262 When RESOLVE_P is true then the dynamic properties of TYPE are
2263 evaluated, otherwise the dynamic properties of TYPE are not evaluated,
2264 instead we assume the array is not allocated/associated yet. */
2266 static struct type
*
2267 resolve_dynamic_array_or_string (struct type
*type
,
2268 struct property_addr_info
*addr_stack
,
2269 bool resolve_p
= true)
2272 struct type
*elt_type
;
2273 struct type
*range_type
;
2274 struct type
*ary_dim
;
2275 struct dynamic_prop
*prop
;
2276 unsigned int bit_stride
= 0;
2278 /* For dynamic type resolution strings can be treated like arrays of
2280 gdb_assert (type
->code () == TYPE_CODE_ARRAY
2281 || type
->code () == TYPE_CODE_STRING
);
2283 type
= copy_type (type
);
2285 /* Resolve the allocated and associated properties before doing anything
2286 else. If an array is not allocated or not associated then (at least
2287 for Fortran) there is no guarantee that the data to define the upper
2288 bound, lower bound, or stride will be correct. If RESOLVE_P is
2289 already false at this point then this is not the first dimension of
2290 the array and a more outer dimension has already marked this array as
2291 not allocated/associated, as such we just ignore this property. This
2292 is fine as GDB only checks the allocated/associated on the outer most
2293 dimension of the array. */
2294 prop
= TYPE_ALLOCATED_PROP (type
);
2295 if (prop
!= NULL
&& resolve_p
2296 && dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2298 prop
->set_const_val (value
);
2303 prop
= TYPE_ASSOCIATED_PROP (type
);
2304 if (prop
!= NULL
&& resolve_p
2305 && dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2307 prop
->set_const_val (value
);
2312 range_type
= check_typedef (type
->index_type ());
2313 range_type
= resolve_dynamic_range (range_type
, addr_stack
, resolve_p
);
2315 ary_dim
= check_typedef (TYPE_TARGET_TYPE (type
));
2316 if (ary_dim
!= NULL
&& ary_dim
->code () == TYPE_CODE_ARRAY
)
2317 elt_type
= resolve_dynamic_array_or_string (ary_dim
, addr_stack
, resolve_p
);
2319 elt_type
= TYPE_TARGET_TYPE (type
);
2321 prop
= type
->dyn_prop (DYN_PROP_BYTE_STRIDE
);
2322 if (prop
!= NULL
&& resolve_p
)
2324 if (dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2326 type
->remove_dyn_prop (DYN_PROP_BYTE_STRIDE
);
2327 bit_stride
= (unsigned int) (value
* 8);
2331 /* Could be a bug in our code, but it could also happen
2332 if the DWARF info is not correct. Issue a warning,
2333 and assume no byte/bit stride (leave bit_stride = 0). */
2334 warning (_("cannot determine array stride for type %s"),
2335 type
->name () ? type
->name () : "<no name>");
2339 bit_stride
= TYPE_FIELD_BITSIZE (type
, 0);
2341 return create_array_type_with_stride (type
, elt_type
, range_type
, NULL
,
2345 /* Resolve dynamic bounds of members of the union TYPE to static
2346 bounds. ADDR_STACK is a stack of struct property_addr_info
2347 to be used if needed during the dynamic resolution. */
2349 static struct type
*
2350 resolve_dynamic_union (struct type
*type
,
2351 struct property_addr_info
*addr_stack
)
2353 struct type
*resolved_type
;
2355 unsigned int max_len
= 0;
2357 gdb_assert (type
->code () == TYPE_CODE_UNION
);
2359 resolved_type
= copy_type (type
);
2360 resolved_type
->set_fields
2362 TYPE_ALLOC (resolved_type
,
2363 resolved_type
->num_fields () * sizeof (struct field
)));
2364 memcpy (resolved_type
->fields (),
2366 resolved_type
->num_fields () * sizeof (struct field
));
2367 for (i
= 0; i
< resolved_type
->num_fields (); ++i
)
2371 if (field_is_static (&type
->field (i
)))
2374 t
= resolve_dynamic_type_internal (resolved_type
->field (i
).type (),
2376 resolved_type
->field (i
).set_type (t
);
2378 struct type
*real_type
= check_typedef (t
);
2379 if (TYPE_LENGTH (real_type
) > max_len
)
2380 max_len
= TYPE_LENGTH (real_type
);
2383 TYPE_LENGTH (resolved_type
) = max_len
;
2384 return resolved_type
;
2387 /* See gdbtypes.h. */
2390 variant::matches (ULONGEST value
, bool is_unsigned
) const
2392 for (const discriminant_range
&range
: discriminants
)
2393 if (range
.contains (value
, is_unsigned
))
2399 compute_variant_fields_inner (struct type
*type
,
2400 struct property_addr_info
*addr_stack
,
2401 const variant_part
&part
,
2402 std::vector
<bool> &flags
);
2404 /* A helper function to determine which variant fields will be active.
2405 This handles both the variant's direct fields, and any variant
2406 parts embedded in this variant. TYPE is the type we're examining.
2407 ADDR_STACK holds information about the concrete object. VARIANT is
2408 the current variant to be handled. FLAGS is where the results are
2409 stored -- this function sets the Nth element in FLAGS if the
2410 corresponding field is enabled. ENABLED is whether this variant is
2414 compute_variant_fields_recurse (struct type
*type
,
2415 struct property_addr_info
*addr_stack
,
2416 const variant
&variant
,
2417 std::vector
<bool> &flags
,
2420 for (int field
= variant
.first_field
; field
< variant
.last_field
; ++field
)
2421 flags
[field
] = enabled
;
2423 for (const variant_part
&new_part
: variant
.parts
)
2426 compute_variant_fields_inner (type
, addr_stack
, new_part
, flags
);
2429 for (const auto &sub_variant
: new_part
.variants
)
2430 compute_variant_fields_recurse (type
, addr_stack
, sub_variant
,
2436 /* A helper function to determine which variant fields will be active.
2437 This evaluates the discriminant, decides which variant (if any) is
2438 active, and then updates FLAGS to reflect which fields should be
2439 available. TYPE is the type we're examining. ADDR_STACK holds
2440 information about the concrete object. VARIANT is the current
2441 variant to be handled. FLAGS is where the results are stored --
2442 this function sets the Nth element in FLAGS if the corresponding
2443 field is enabled. */
2446 compute_variant_fields_inner (struct type
*type
,
2447 struct property_addr_info
*addr_stack
,
2448 const variant_part
&part
,
2449 std::vector
<bool> &flags
)
2451 /* Evaluate the discriminant. */
2452 gdb::optional
<ULONGEST
> discr_value
;
2453 if (part
.discriminant_index
!= -1)
2455 int idx
= part
.discriminant_index
;
2457 if (type
->field (idx
).loc_kind () != FIELD_LOC_KIND_BITPOS
)
2458 error (_("Cannot determine struct field location"
2459 " (invalid location kind)"));
2461 if (addr_stack
->valaddr
.data () != NULL
)
2462 discr_value
= unpack_field_as_long (type
, addr_stack
->valaddr
.data (),
2466 CORE_ADDR addr
= (addr_stack
->addr
2467 + (type
->field (idx
).loc_bitpos ()
2468 / TARGET_CHAR_BIT
));
2470 LONGEST bitsize
= TYPE_FIELD_BITSIZE (type
, idx
);
2471 LONGEST size
= bitsize
/ 8;
2473 size
= TYPE_LENGTH (type
->field (idx
).type ());
2475 gdb_byte bits
[sizeof (ULONGEST
)];
2476 read_memory (addr
, bits
, size
);
2478 LONGEST bitpos
= (type
->field (idx
).loc_bitpos ()
2481 discr_value
= unpack_bits_as_long (type
->field (idx
).type (),
2482 bits
, bitpos
, bitsize
);
2486 /* Go through each variant and see which applies. */
2487 const variant
*default_variant
= nullptr;
2488 const variant
*applied_variant
= nullptr;
2489 for (const auto &variant
: part
.variants
)
2491 if (variant
.is_default ())
2492 default_variant
= &variant
;
2493 else if (discr_value
.has_value ()
2494 && variant
.matches (*discr_value
, part
.is_unsigned
))
2496 applied_variant
= &variant
;
2500 if (applied_variant
== nullptr)
2501 applied_variant
= default_variant
;
2503 for (const auto &variant
: part
.variants
)
2504 compute_variant_fields_recurse (type
, addr_stack
, variant
,
2505 flags
, applied_variant
== &variant
);
2508 /* Determine which variant fields are available in TYPE. The enabled
2509 fields are stored in RESOLVED_TYPE. ADDR_STACK holds information
2510 about the concrete object. PARTS describes the top-level variant
2511 parts for this type. */
2514 compute_variant_fields (struct type
*type
,
2515 struct type
*resolved_type
,
2516 struct property_addr_info
*addr_stack
,
2517 const gdb::array_view
<variant_part
> &parts
)
2519 /* Assume all fields are included by default. */
2520 std::vector
<bool> flags (resolved_type
->num_fields (), true);
2522 /* Now disable fields based on the variants that control them. */
2523 for (const auto &part
: parts
)
2524 compute_variant_fields_inner (type
, addr_stack
, part
, flags
);
2526 resolved_type
->set_num_fields
2527 (std::count (flags
.begin (), flags
.end (), true));
2528 resolved_type
->set_fields
2530 TYPE_ALLOC (resolved_type
,
2531 resolved_type
->num_fields () * sizeof (struct field
)));
2534 for (int i
= 0; i
< type
->num_fields (); ++i
)
2539 resolved_type
->field (out
) = type
->field (i
);
2544 /* Resolve dynamic bounds of members of the struct TYPE to static
2545 bounds. ADDR_STACK is a stack of struct property_addr_info to
2546 be used if needed during the dynamic resolution. */
2548 static struct type
*
2549 resolve_dynamic_struct (struct type
*type
,
2550 struct property_addr_info
*addr_stack
)
2552 struct type
*resolved_type
;
2554 unsigned resolved_type_bit_length
= 0;
2556 gdb_assert (type
->code () == TYPE_CODE_STRUCT
);
2558 resolved_type
= copy_type (type
);
2560 dynamic_prop
*variant_prop
= resolved_type
->dyn_prop (DYN_PROP_VARIANT_PARTS
);
2561 if (variant_prop
!= nullptr && variant_prop
->kind () == PROP_VARIANT_PARTS
)
2563 compute_variant_fields (type
, resolved_type
, addr_stack
,
2564 *variant_prop
->variant_parts ());
2565 /* We want to leave the property attached, so that the Rust code
2566 can tell whether the type was originally an enum. */
2567 variant_prop
->set_original_type (type
);
2571 resolved_type
->set_fields
2573 TYPE_ALLOC (resolved_type
,
2574 resolved_type
->num_fields () * sizeof (struct field
)));
2575 if (type
->num_fields () > 0)
2576 memcpy (resolved_type
->fields (),
2578 resolved_type
->num_fields () * sizeof (struct field
));
2581 for (i
= 0; i
< resolved_type
->num_fields (); ++i
)
2583 unsigned new_bit_length
;
2584 struct property_addr_info pinfo
;
2586 if (field_is_static (&resolved_type
->field (i
)))
2589 if (resolved_type
->field (i
).loc_kind () == FIELD_LOC_KIND_DWARF_BLOCK
)
2591 struct dwarf2_property_baton baton
;
2593 = lookup_pointer_type (resolved_type
->field (i
).type ());
2594 baton
.locexpr
= *resolved_type
->field (i
).loc_dwarf_block ();
2596 struct dynamic_prop prop
;
2597 prop
.set_locexpr (&baton
);
2600 if (dwarf2_evaluate_property (&prop
, nullptr, addr_stack
, &addr
,
2602 resolved_type
->field (i
).set_loc_bitpos
2603 (TARGET_CHAR_BIT
* (addr
- addr_stack
->addr
));
2606 /* As we know this field is not a static field, the field's
2607 field_loc_kind should be FIELD_LOC_KIND_BITPOS. Verify
2608 this is the case, but only trigger a simple error rather
2609 than an internal error if that fails. While failing
2610 that verification indicates a bug in our code, the error
2611 is not severe enough to suggest to the user he stops
2612 his debugging session because of it. */
2613 if (resolved_type
->field (i
).loc_kind () != FIELD_LOC_KIND_BITPOS
)
2614 error (_("Cannot determine struct field location"
2615 " (invalid location kind)"));
2617 pinfo
.type
= check_typedef (resolved_type
->field (i
).type ());
2618 size_t offset
= resolved_type
->field (i
).loc_bitpos () / TARGET_CHAR_BIT
;
2619 pinfo
.valaddr
= addr_stack
->valaddr
;
2620 if (!pinfo
.valaddr
.empty ())
2621 pinfo
.valaddr
= pinfo
.valaddr
.slice (offset
);
2622 pinfo
.addr
= addr_stack
->addr
+ offset
;
2623 pinfo
.next
= addr_stack
;
2625 resolved_type
->field (i
).set_type
2626 (resolve_dynamic_type_internal (resolved_type
->field (i
).type (),
2628 gdb_assert (resolved_type
->field (i
).loc_kind ()
2629 == FIELD_LOC_KIND_BITPOS
);
2631 new_bit_length
= resolved_type
->field (i
).loc_bitpos ();
2632 if (TYPE_FIELD_BITSIZE (resolved_type
, i
) != 0)
2633 new_bit_length
+= TYPE_FIELD_BITSIZE (resolved_type
, i
);
2636 struct type
*real_type
2637 = check_typedef (resolved_type
->field (i
).type ());
2639 new_bit_length
+= (TYPE_LENGTH (real_type
) * TARGET_CHAR_BIT
);
2642 /* Normally, we would use the position and size of the last field
2643 to determine the size of the enclosing structure. But GCC seems
2644 to be encoding the position of some fields incorrectly when
2645 the struct contains a dynamic field that is not placed last.
2646 So we compute the struct size based on the field that has
2647 the highest position + size - probably the best we can do. */
2648 if (new_bit_length
> resolved_type_bit_length
)
2649 resolved_type_bit_length
= new_bit_length
;
2652 /* The length of a type won't change for fortran, but it does for C and Ada.
2653 For fortran the size of dynamic fields might change over time but not the
2654 type length of the structure. If we adapt it, we run into problems
2655 when calculating the element offset for arrays of structs. */
2656 if (current_language
->la_language
!= language_fortran
)
2657 TYPE_LENGTH (resolved_type
)
2658 = (resolved_type_bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
2660 /* The Ada language uses this field as a cache for static fixed types: reset
2661 it as RESOLVED_TYPE must have its own static fixed type. */
2662 TYPE_TARGET_TYPE (resolved_type
) = NULL
;
2664 return resolved_type
;
2667 /* Worker for resolved_dynamic_type. */
2669 static struct type
*
2670 resolve_dynamic_type_internal (struct type
*type
,
2671 struct property_addr_info
*addr_stack
,
2674 struct type
*real_type
= check_typedef (type
);
2675 struct type
*resolved_type
= nullptr;
2676 struct dynamic_prop
*prop
;
2679 if (!is_dynamic_type_internal (real_type
, top_level
))
2682 gdb::optional
<CORE_ADDR
> type_length
;
2683 prop
= TYPE_DYNAMIC_LENGTH (type
);
2685 && dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2686 type_length
= value
;
2688 if (type
->code () == TYPE_CODE_TYPEDEF
)
2690 resolved_type
= copy_type (type
);
2691 TYPE_TARGET_TYPE (resolved_type
)
2692 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type
), addr_stack
,
2697 /* Before trying to resolve TYPE, make sure it is not a stub. */
2700 switch (type
->code ())
2704 struct property_addr_info pinfo
;
2706 pinfo
.type
= check_typedef (TYPE_TARGET_TYPE (type
));
2708 if (addr_stack
->valaddr
.data () != NULL
)
2709 pinfo
.addr
= extract_typed_address (addr_stack
->valaddr
.data (),
2712 pinfo
.addr
= read_memory_typed_address (addr_stack
->addr
, type
);
2713 pinfo
.next
= addr_stack
;
2715 resolved_type
= copy_type (type
);
2716 TYPE_TARGET_TYPE (resolved_type
)
2717 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type
),
2722 case TYPE_CODE_STRING
:
2723 /* Strings are very much like an array of characters, and can be
2724 treated as one here. */
2725 case TYPE_CODE_ARRAY
:
2726 resolved_type
= resolve_dynamic_array_or_string (type
, addr_stack
);
2729 case TYPE_CODE_RANGE
:
2730 resolved_type
= resolve_dynamic_range (type
, addr_stack
);
2733 case TYPE_CODE_UNION
:
2734 resolved_type
= resolve_dynamic_union (type
, addr_stack
);
2737 case TYPE_CODE_STRUCT
:
2738 resolved_type
= resolve_dynamic_struct (type
, addr_stack
);
2743 if (resolved_type
== nullptr)
2746 if (type_length
.has_value ())
2748 TYPE_LENGTH (resolved_type
) = *type_length
;
2749 resolved_type
->remove_dyn_prop (DYN_PROP_BYTE_SIZE
);
2752 /* Resolve data_location attribute. */
2753 prop
= TYPE_DATA_LOCATION (resolved_type
);
2755 && dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2757 /* Start of Fortran hack. See comment in f-lang.h for what is going
2759 if (current_language
->la_language
== language_fortran
2760 && resolved_type
->code () == TYPE_CODE_ARRAY
)
2761 value
= fortran_adjust_dynamic_array_base_address_hack (resolved_type
,
2763 /* End of Fortran hack. */
2764 prop
->set_const_val (value
);
2767 return resolved_type
;
2770 /* See gdbtypes.h */
2773 resolve_dynamic_type (struct type
*type
,
2774 gdb::array_view
<const gdb_byte
> valaddr
,
2777 struct property_addr_info pinfo
2778 = {check_typedef (type
), valaddr
, addr
, NULL
};
2780 return resolve_dynamic_type_internal (type
, &pinfo
, 1);
2783 /* See gdbtypes.h */
2786 type::dyn_prop (dynamic_prop_node_kind prop_kind
) const
2788 dynamic_prop_list
*node
= this->main_type
->dyn_prop_list
;
2790 while (node
!= NULL
)
2792 if (node
->prop_kind
== prop_kind
)
2799 /* See gdbtypes.h */
2802 type::add_dyn_prop (dynamic_prop_node_kind prop_kind
, dynamic_prop prop
)
2804 struct dynamic_prop_list
*temp
;
2806 gdb_assert (this->is_objfile_owned ());
2808 temp
= XOBNEW (&this->objfile_owner ()->objfile_obstack
,
2809 struct dynamic_prop_list
);
2810 temp
->prop_kind
= prop_kind
;
2812 temp
->next
= this->main_type
->dyn_prop_list
;
2814 this->main_type
->dyn_prop_list
= temp
;
2817 /* See gdbtypes.h. */
2820 type::remove_dyn_prop (dynamic_prop_node_kind kind
)
2822 struct dynamic_prop_list
*prev_node
, *curr_node
;
2824 curr_node
= this->main_type
->dyn_prop_list
;
2827 while (NULL
!= curr_node
)
2829 if (curr_node
->prop_kind
== kind
)
2831 /* Update the linked list but don't free anything.
2832 The property was allocated on objstack and it is not known
2833 if we are on top of it. Nevertheless, everything is released
2834 when the complete objstack is freed. */
2835 if (NULL
== prev_node
)
2836 this->main_type
->dyn_prop_list
= curr_node
->next
;
2838 prev_node
->next
= curr_node
->next
;
2843 prev_node
= curr_node
;
2844 curr_node
= curr_node
->next
;
2848 /* Find the real type of TYPE. This function returns the real type,
2849 after removing all layers of typedefs, and completing opaque or stub
2850 types. Completion changes the TYPE argument, but stripping of
2853 Instance flags (e.g. const/volatile) are preserved as typedefs are
2854 stripped. If necessary a new qualified form of the underlying type
2857 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
2858 not been computed and we're either in the middle of reading symbols, or
2859 there was no name for the typedef in the debug info.
2861 NOTE: Lookup of opaque types can throw errors for invalid symbol files.
2862 QUITs in the symbol reading code can also throw.
2863 Thus this function can throw an exception.
2865 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
2868 If this is a stubbed struct (i.e. declared as struct foo *), see if
2869 we can find a full definition in some other file. If so, copy this
2870 definition, so we can use it in future. There used to be a comment
2871 (but not any code) that if we don't find a full definition, we'd
2872 set a flag so we don't spend time in the future checking the same
2873 type. That would be a mistake, though--we might load in more
2874 symbols which contain a full definition for the type. */
2877 check_typedef (struct type
*type
)
2879 struct type
*orig_type
= type
;
2883 /* While we're removing typedefs, we don't want to lose qualifiers.
2884 E.g., const/volatile. */
2885 type_instance_flags instance_flags
= type
->instance_flags ();
2887 while (type
->code () == TYPE_CODE_TYPEDEF
)
2889 if (!TYPE_TARGET_TYPE (type
))
2894 /* It is dangerous to call lookup_symbol if we are currently
2895 reading a symtab. Infinite recursion is one danger. */
2896 if (currently_reading_symtab
)
2897 return make_qualified_type (type
, instance_flags
, NULL
);
2899 name
= type
->name ();
2900 /* FIXME: shouldn't we look in STRUCT_DOMAIN and/or
2901 VAR_DOMAIN as appropriate? */
2904 stub_noname_complaint ();
2905 return make_qualified_type (type
, instance_flags
, NULL
);
2907 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0).symbol
;
2909 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
2910 else /* TYPE_CODE_UNDEF */
2911 TYPE_TARGET_TYPE (type
) = alloc_type_arch (type
->arch ());
2913 type
= TYPE_TARGET_TYPE (type
);
2915 /* Preserve the instance flags as we traverse down the typedef chain.
2917 Handling address spaces/classes is nasty, what do we do if there's a
2919 E.g., what if an outer typedef marks the type as class_1 and an inner
2920 typedef marks the type as class_2?
2921 This is the wrong place to do such error checking. We leave it to
2922 the code that created the typedef in the first place to flag the
2923 error. We just pick the outer address space (akin to letting the
2924 outer cast in a chain of casting win), instead of assuming
2925 "it can't happen". */
2927 const type_instance_flags ALL_SPACES
2928 = (TYPE_INSTANCE_FLAG_CODE_SPACE
2929 | TYPE_INSTANCE_FLAG_DATA_SPACE
);
2930 const type_instance_flags ALL_CLASSES
2931 = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
;
2933 type_instance_flags new_instance_flags
= type
->instance_flags ();
2935 /* Treat code vs data spaces and address classes separately. */
2936 if ((instance_flags
& ALL_SPACES
) != 0)
2937 new_instance_flags
&= ~ALL_SPACES
;
2938 if ((instance_flags
& ALL_CLASSES
) != 0)
2939 new_instance_flags
&= ~ALL_CLASSES
;
2941 instance_flags
|= new_instance_flags
;
2945 /* If this is a struct/class/union with no fields, then check
2946 whether a full definition exists somewhere else. This is for
2947 systems where a type definition with no fields is issued for such
2948 types, instead of identifying them as stub types in the first
2951 if (TYPE_IS_OPAQUE (type
)
2952 && opaque_type_resolution
2953 && !currently_reading_symtab
)
2955 const char *name
= type
->name ();
2956 struct type
*newtype
;
2960 stub_noname_complaint ();
2961 return make_qualified_type (type
, instance_flags
, NULL
);
2963 newtype
= lookup_transparent_type (name
);
2967 /* If the resolved type and the stub are in the same
2968 objfile, then replace the stub type with the real deal.
2969 But if they're in separate objfiles, leave the stub
2970 alone; we'll just look up the transparent type every time
2971 we call check_typedef. We can't create pointers between
2972 types allocated to different objfiles, since they may
2973 have different lifetimes. Trying to copy NEWTYPE over to
2974 TYPE's objfile is pointless, too, since you'll have to
2975 move over any other types NEWTYPE refers to, which could
2976 be an unbounded amount of stuff. */
2977 if (newtype
->objfile_owner () == type
->objfile_owner ())
2978 type
= make_qualified_type (newtype
, type
->instance_flags (), type
);
2983 /* Otherwise, rely on the stub flag being set for opaque/stubbed
2985 else if (type
->is_stub () && !currently_reading_symtab
)
2987 const char *name
= type
->name ();
2988 /* FIXME: shouldn't we look in STRUCT_DOMAIN and/or VAR_DOMAIN
2994 stub_noname_complaint ();
2995 return make_qualified_type (type
, instance_flags
, NULL
);
2997 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0).symbol
;
3000 /* Same as above for opaque types, we can replace the stub
3001 with the complete type only if they are in the same
3003 if (SYMBOL_TYPE (sym
)->objfile_owner () == type
->objfile_owner ())
3004 type
= make_qualified_type (SYMBOL_TYPE (sym
),
3005 type
->instance_flags (), type
);
3007 type
= SYMBOL_TYPE (sym
);
3011 if (type
->target_is_stub ())
3013 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
3015 if (target_type
->is_stub () || target_type
->target_is_stub ())
3017 /* Nothing we can do. */
3019 else if (type
->code () == TYPE_CODE_RANGE
)
3021 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
3022 type
->set_target_is_stub (false);
3024 else if (type
->code () == TYPE_CODE_ARRAY
3025 && update_static_array_size (type
))
3026 type
->set_target_is_stub (false);
3029 type
= make_qualified_type (type
, instance_flags
, NULL
);
3031 /* Cache TYPE_LENGTH for future use. */
3032 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
3037 /* Parse a type expression in the string [P..P+LENGTH). If an error
3038 occurs, silently return a void type. */
3040 static struct type
*
3041 safe_parse_type (struct gdbarch
*gdbarch
, const char *p
, int length
)
3043 struct ui_file
*saved_gdb_stderr
;
3044 struct type
*type
= NULL
; /* Initialize to keep gcc happy. */
3046 /* Suppress error messages. */
3047 saved_gdb_stderr
= gdb_stderr
;
3048 gdb_stderr
= &null_stream
;
3050 /* Call parse_and_eval_type() without fear of longjmp()s. */
3053 type
= parse_and_eval_type (p
, length
);
3055 catch (const gdb_exception_error
&except
)
3057 type
= builtin_type (gdbarch
)->builtin_void
;
3060 /* Stop suppressing error messages. */
3061 gdb_stderr
= saved_gdb_stderr
;
3066 /* Ugly hack to convert method stubs into method types.
3068 He ain't kiddin'. This demangles the name of the method into a
3069 string including argument types, parses out each argument type,
3070 generates a string casting a zero to that type, evaluates the
3071 string, and stuffs the resulting type into an argtype vector!!!
3072 Then it knows the type of the whole function (including argument
3073 types for overloading), which info used to be in the stab's but was
3074 removed to hack back the space required for them. */
3077 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
3079 struct gdbarch
*gdbarch
= type
->arch ();
3081 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
3082 gdb::unique_xmalloc_ptr
<char> demangled_name
3083 = gdb_demangle (mangled_name
, DMGL_PARAMS
| DMGL_ANSI
);
3084 char *argtypetext
, *p
;
3085 int depth
= 0, argcount
= 1;
3086 struct field
*argtypes
;
3089 /* Make sure we got back a function string that we can use. */
3091 p
= strchr (demangled_name
.get (), '(');
3095 if (demangled_name
== NULL
|| p
== NULL
)
3096 error (_("Internal: Cannot demangle mangled name `%s'."),
3099 /* Now, read in the parameters that define this type. */
3104 if (*p
== '(' || *p
== '<')
3108 else if (*p
== ')' || *p
== '>')
3112 else if (*p
== ',' && depth
== 0)
3120 /* If we read one argument and it was ``void'', don't count it. */
3121 if (startswith (argtypetext
, "(void)"))
3124 /* We need one extra slot, for the THIS pointer. */
3126 argtypes
= (struct field
*)
3127 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
3130 /* Add THIS pointer for non-static methods. */
3131 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
3132 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
3136 argtypes
[0].set_type (lookup_pointer_type (type
));
3140 if (*p
!= ')') /* () means no args, skip while. */
3145 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
3147 /* Avoid parsing of ellipsis, they will be handled below.
3148 Also avoid ``void'' as above. */
3149 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
3150 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
3152 argtypes
[argcount
].set_type
3153 (safe_parse_type (gdbarch
, argtypetext
, p
- argtypetext
));
3156 argtypetext
= p
+ 1;
3159 if (*p
== '(' || *p
== '<')
3163 else if (*p
== ')' || *p
== '>')
3172 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
3174 /* Now update the old "stub" type into a real type. */
3175 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
3176 /* MTYPE may currently be a function (TYPE_CODE_FUNC).
3177 We want a method (TYPE_CODE_METHOD). */
3178 smash_to_method_type (mtype
, type
, TYPE_TARGET_TYPE (mtype
),
3179 argtypes
, argcount
, p
[-2] == '.');
3180 mtype
->set_is_stub (false);
3181 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
3184 /* This is the external interface to check_stub_method, above. This
3185 function unstubs all of the signatures for TYPE's METHOD_ID method
3186 name. After calling this function TYPE_FN_FIELD_STUB will be
3187 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
3190 This function unfortunately can not die until stabs do. */
3193 check_stub_method_group (struct type
*type
, int method_id
)
3195 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
3196 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
3198 for (int j
= 0; j
< len
; j
++)
3200 if (TYPE_FN_FIELD_STUB (f
, j
))
3201 check_stub_method (type
, method_id
, j
);
3205 /* Ensure it is in .rodata (if available) by working around GCC PR 44690. */
3206 const struct cplus_struct_type cplus_struct_default
= { };
3209 allocate_cplus_struct_type (struct type
*type
)
3211 if (HAVE_CPLUS_STRUCT (type
))
3212 /* Structure was already allocated. Nothing more to do. */
3215 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_CPLUS_STUFF
;
3216 TYPE_RAW_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
3217 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
3218 *(TYPE_RAW_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
3219 set_type_vptr_fieldno (type
, -1);
3222 const struct gnat_aux_type gnat_aux_default
=
3225 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
3226 and allocate the associated gnat-specific data. The gnat-specific
3227 data is also initialized to gnat_aux_default. */
3230 allocate_gnat_aux_type (struct type
*type
)
3232 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_GNAT_STUFF
;
3233 TYPE_GNAT_SPECIFIC (type
) = (struct gnat_aux_type
*)
3234 TYPE_ALLOC (type
, sizeof (struct gnat_aux_type
));
3235 *(TYPE_GNAT_SPECIFIC (type
)) = gnat_aux_default
;
3238 /* Helper function to initialize a newly allocated type. Set type code
3239 to CODE and initialize the type-specific fields accordingly. */
3242 set_type_code (struct type
*type
, enum type_code code
)
3244 type
->set_code (code
);
3248 case TYPE_CODE_STRUCT
:
3249 case TYPE_CODE_UNION
:
3250 case TYPE_CODE_NAMESPACE
:
3251 INIT_CPLUS_SPECIFIC (type
);
3254 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_FLOATFORMAT
;
3256 case TYPE_CODE_FUNC
:
3257 INIT_FUNC_SPECIFIC (type
);
3259 case TYPE_CODE_FIXED_POINT
:
3260 INIT_FIXED_POINT_SPECIFIC (type
);
3265 /* Helper function to verify floating-point format and size.
3266 BIT is the type size in bits; if BIT equals -1, the size is
3267 determined by the floatformat. Returns size to be used. */
3270 verify_floatformat (int bit
, const struct floatformat
*floatformat
)
3272 gdb_assert (floatformat
!= NULL
);
3275 bit
= floatformat
->totalsize
;
3277 gdb_assert (bit
>= 0);
3278 gdb_assert (bit
>= floatformat
->totalsize
);
3283 /* Return the floating-point format for a floating-point variable of
3286 const struct floatformat
*
3287 floatformat_from_type (const struct type
*type
)
3289 gdb_assert (type
->code () == TYPE_CODE_FLT
);
3290 gdb_assert (TYPE_FLOATFORMAT (type
));
3291 return TYPE_FLOATFORMAT (type
);
3294 /* Helper function to initialize the standard scalar types.
3296 If NAME is non-NULL, then it is used to initialize the type name.
3297 Note that NAME is not copied; it is required to have a lifetime at
3298 least as long as OBJFILE. */
3301 init_type (struct objfile
*objfile
, enum type_code code
, int bit
,
3306 type
= alloc_type (objfile
);
3307 set_type_code (type
, code
);
3308 gdb_assert ((bit
% TARGET_CHAR_BIT
) == 0);
3309 TYPE_LENGTH (type
) = bit
/ TARGET_CHAR_BIT
;
3310 type
->set_name (name
);
3315 /* Allocate a TYPE_CODE_ERROR type structure associated with OBJFILE,
3316 to use with variables that have no debug info. NAME is the type
3319 static struct type
*
3320 init_nodebug_var_type (struct objfile
*objfile
, const char *name
)
3322 return init_type (objfile
, TYPE_CODE_ERROR
, 0, name
);
3325 /* Allocate a TYPE_CODE_INT type structure associated with OBJFILE.
3326 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3327 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3330 init_integer_type (struct objfile
*objfile
,
3331 int bit
, int unsigned_p
, const char *name
)
3335 t
= init_type (objfile
, TYPE_CODE_INT
, bit
, name
);
3337 t
->set_is_unsigned (true);
3339 TYPE_SPECIFIC_FIELD (t
) = TYPE_SPECIFIC_INT
;
3340 TYPE_MAIN_TYPE (t
)->type_specific
.int_stuff
.bit_size
= bit
;
3341 TYPE_MAIN_TYPE (t
)->type_specific
.int_stuff
.bit_offset
= 0;
3346 /* Allocate a TYPE_CODE_CHAR type structure associated with OBJFILE.
3347 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3348 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3351 init_character_type (struct objfile
*objfile
,
3352 int bit
, int unsigned_p
, const char *name
)
3356 t
= init_type (objfile
, TYPE_CODE_CHAR
, bit
, name
);
3358 t
->set_is_unsigned (true);
3363 /* Allocate a TYPE_CODE_BOOL type structure associated with OBJFILE.
3364 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3365 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3368 init_boolean_type (struct objfile
*objfile
,
3369 int bit
, int unsigned_p
, const char *name
)
3373 t
= init_type (objfile
, TYPE_CODE_BOOL
, bit
, name
);
3375 t
->set_is_unsigned (true);
3377 TYPE_SPECIFIC_FIELD (t
) = TYPE_SPECIFIC_INT
;
3378 TYPE_MAIN_TYPE (t
)->type_specific
.int_stuff
.bit_size
= bit
;
3379 TYPE_MAIN_TYPE (t
)->type_specific
.int_stuff
.bit_offset
= 0;
3384 /* Allocate a TYPE_CODE_FLT type structure associated with OBJFILE.
3385 BIT is the type size in bits; if BIT equals -1, the size is
3386 determined by the floatformat. NAME is the type name. Set the
3387 TYPE_FLOATFORMAT from FLOATFORMATS. BYTE_ORDER is the byte order
3388 to use. If it is BFD_ENDIAN_UNKNOWN (the default), then the byte
3389 order of the objfile's architecture is used. */
3392 init_float_type (struct objfile
*objfile
,
3393 int bit
, const char *name
,
3394 const struct floatformat
**floatformats
,
3395 enum bfd_endian byte_order
)
3397 if (byte_order
== BFD_ENDIAN_UNKNOWN
)
3399 struct gdbarch
*gdbarch
= objfile
->arch ();
3400 byte_order
= gdbarch_byte_order (gdbarch
);
3402 const struct floatformat
*fmt
= floatformats
[byte_order
];
3405 bit
= verify_floatformat (bit
, fmt
);
3406 t
= init_type (objfile
, TYPE_CODE_FLT
, bit
, name
);
3407 TYPE_FLOATFORMAT (t
) = fmt
;
3412 /* Allocate a TYPE_CODE_DECFLOAT type structure associated with OBJFILE.
3413 BIT is the type size in bits. NAME is the type name. */
3416 init_decfloat_type (struct objfile
*objfile
, int bit
, const char *name
)
3420 t
= init_type (objfile
, TYPE_CODE_DECFLOAT
, bit
, name
);
3424 /* Return true if init_complex_type can be called with TARGET_TYPE. */
3427 can_create_complex_type (struct type
*target_type
)
3429 return (target_type
->code () == TYPE_CODE_INT
3430 || target_type
->code () == TYPE_CODE_FLT
);
3433 /* Allocate a TYPE_CODE_COMPLEX type structure. NAME is the type
3434 name. TARGET_TYPE is the component type. */
3437 init_complex_type (const char *name
, struct type
*target_type
)
3441 gdb_assert (can_create_complex_type (target_type
));
3443 if (TYPE_MAIN_TYPE (target_type
)->flds_bnds
.complex_type
== nullptr)
3445 if (name
== nullptr && target_type
->name () != nullptr)
3448 = (char *) TYPE_ALLOC (target_type
,
3449 strlen (target_type
->name ())
3450 + strlen ("_Complex ") + 1);
3451 strcpy (new_name
, "_Complex ");
3452 strcat (new_name
, target_type
->name ());
3456 t
= alloc_type_copy (target_type
);
3457 set_type_code (t
, TYPE_CODE_COMPLEX
);
3458 TYPE_LENGTH (t
) = 2 * TYPE_LENGTH (target_type
);
3461 TYPE_TARGET_TYPE (t
) = target_type
;
3462 TYPE_MAIN_TYPE (target_type
)->flds_bnds
.complex_type
= t
;
3465 return TYPE_MAIN_TYPE (target_type
)->flds_bnds
.complex_type
;
3468 /* Allocate a TYPE_CODE_PTR type structure associated with OBJFILE.
3469 BIT is the pointer type size in bits. NAME is the type name.
3470 TARGET_TYPE is the pointer target type. Always sets the pointer type's
3471 TYPE_UNSIGNED flag. */
3474 init_pointer_type (struct objfile
*objfile
,
3475 int bit
, const char *name
, struct type
*target_type
)
3479 t
= init_type (objfile
, TYPE_CODE_PTR
, bit
, name
);
3480 TYPE_TARGET_TYPE (t
) = target_type
;
3481 t
->set_is_unsigned (true);
3485 /* Allocate a TYPE_CODE_FIXED_POINT type structure associated with OBJFILE.
3486 BIT is the pointer type size in bits.
3487 UNSIGNED_P should be nonzero if the type is unsigned.
3488 NAME is the type name. */
3491 init_fixed_point_type (struct objfile
*objfile
,
3492 int bit
, int unsigned_p
, const char *name
)
3496 t
= init_type (objfile
, TYPE_CODE_FIXED_POINT
, bit
, name
);
3498 t
->set_is_unsigned (true);
3503 /* See gdbtypes.h. */
3506 type_raw_align (struct type
*type
)
3508 if (type
->align_log2
!= 0)
3509 return 1 << (type
->align_log2
- 1);
3513 /* See gdbtypes.h. */
3516 type_align (struct type
*type
)
3518 /* Check alignment provided in the debug information. */
3519 unsigned raw_align
= type_raw_align (type
);
3523 /* Allow the architecture to provide an alignment. */
3524 ULONGEST align
= gdbarch_type_align (type
->arch (), type
);
3528 switch (type
->code ())
3531 case TYPE_CODE_FUNC
:
3532 case TYPE_CODE_FLAGS
:
3534 case TYPE_CODE_RANGE
:
3536 case TYPE_CODE_ENUM
:
3538 case TYPE_CODE_RVALUE_REF
:
3539 case TYPE_CODE_CHAR
:
3540 case TYPE_CODE_BOOL
:
3541 case TYPE_CODE_DECFLOAT
:
3542 case TYPE_CODE_METHODPTR
:
3543 case TYPE_CODE_MEMBERPTR
:
3544 align
= type_length_units (check_typedef (type
));
3547 case TYPE_CODE_ARRAY
:
3548 case TYPE_CODE_COMPLEX
:
3549 case TYPE_CODE_TYPEDEF
:
3550 align
= type_align (TYPE_TARGET_TYPE (type
));
3553 case TYPE_CODE_STRUCT
:
3554 case TYPE_CODE_UNION
:
3556 int number_of_non_static_fields
= 0;
3557 for (unsigned i
= 0; i
< type
->num_fields (); ++i
)
3559 if (!field_is_static (&type
->field (i
)))
3561 number_of_non_static_fields
++;
3562 ULONGEST f_align
= type_align (type
->field (i
).type ());
3565 /* Don't pretend we know something we don't. */
3569 if (f_align
> align
)
3573 /* A struct with no fields, or with only static fields has an
3575 if (number_of_non_static_fields
== 0)
3581 case TYPE_CODE_STRING
:
3582 /* Not sure what to do here, and these can't appear in C or C++
3586 case TYPE_CODE_VOID
:
3590 case TYPE_CODE_ERROR
:
3591 case TYPE_CODE_METHOD
:
3596 if ((align
& (align
- 1)) != 0)
3598 /* Not a power of 2, so pass. */
3605 /* See gdbtypes.h. */
3608 set_type_align (struct type
*type
, ULONGEST align
)
3610 /* Must be a power of 2. Zero is ok. */
3611 gdb_assert ((align
& (align
- 1)) == 0);
3613 unsigned result
= 0;
3620 if (result
>= (1 << TYPE_ALIGN_BITS
))
3623 type
->align_log2
= result
;
3628 /* Queries on types. */
3631 can_dereference (struct type
*t
)
3633 /* FIXME: Should we return true for references as well as
3635 t
= check_typedef (t
);
3638 && t
->code () == TYPE_CODE_PTR
3639 && TYPE_TARGET_TYPE (t
)->code () != TYPE_CODE_VOID
);
3643 is_integral_type (struct type
*t
)
3645 t
= check_typedef (t
);
3648 && !is_fixed_point_type (t
)
3649 && ((t
->code () == TYPE_CODE_INT
)
3650 || (t
->code () == TYPE_CODE_ENUM
)
3651 || (t
->code () == TYPE_CODE_FLAGS
)
3652 || (t
->code () == TYPE_CODE_CHAR
)
3653 || (t
->code () == TYPE_CODE_RANGE
)
3654 || (t
->code () == TYPE_CODE_BOOL
)));
3658 is_floating_type (struct type
*t
)
3660 t
= check_typedef (t
);
3663 && ((t
->code () == TYPE_CODE_FLT
)
3664 || (t
->code () == TYPE_CODE_DECFLOAT
)));
3667 /* Return true if TYPE is scalar. */
3670 is_scalar_type (struct type
*type
)
3672 type
= check_typedef (type
);
3674 if (is_fixed_point_type (type
))
3675 return 0; /* Implemented as a scalar, but more like a floating point. */
3677 switch (type
->code ())
3679 case TYPE_CODE_ARRAY
:
3680 case TYPE_CODE_STRUCT
:
3681 case TYPE_CODE_UNION
:
3683 case TYPE_CODE_STRING
:
3690 /* Return true if T is scalar, or a composite type which in practice has
3691 the memory layout of a scalar type. E.g., an array or struct with only
3692 one scalar element inside it, or a union with only scalar elements. */
3695 is_scalar_type_recursive (struct type
*t
)
3697 t
= check_typedef (t
);
3699 if (is_scalar_type (t
))
3701 /* Are we dealing with an array or string of known dimensions? */
3702 else if ((t
->code () == TYPE_CODE_ARRAY
3703 || t
->code () == TYPE_CODE_STRING
) && t
->num_fields () == 1
3704 && t
->index_type ()->code () == TYPE_CODE_RANGE
)
3706 LONGEST low_bound
, high_bound
;
3707 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (t
));
3709 if (get_discrete_bounds (t
->index_type (), &low_bound
, &high_bound
))
3710 return (high_bound
== low_bound
3711 && is_scalar_type_recursive (elt_type
));
3715 /* Are we dealing with a struct with one element? */
3716 else if (t
->code () == TYPE_CODE_STRUCT
&& t
->num_fields () == 1)
3717 return is_scalar_type_recursive (t
->field (0).type ());
3718 else if (t
->code () == TYPE_CODE_UNION
)
3720 int i
, n
= t
->num_fields ();
3722 /* If all elements of the union are scalar, then the union is scalar. */
3723 for (i
= 0; i
< n
; i
++)
3724 if (!is_scalar_type_recursive (t
->field (i
).type ()))
3733 /* Return true is T is a class or a union. False otherwise. */
3736 class_or_union_p (const struct type
*t
)
3738 return (t
->code () == TYPE_CODE_STRUCT
3739 || t
->code () == TYPE_CODE_UNION
);
3742 /* A helper function which returns true if types A and B represent the
3743 "same" class type. This is true if the types have the same main
3744 type, or the same name. */
3747 class_types_same_p (const struct type
*a
, const struct type
*b
)
3749 return (TYPE_MAIN_TYPE (a
) == TYPE_MAIN_TYPE (b
)
3750 || (a
->name () && b
->name ()
3751 && !strcmp (a
->name (), b
->name ())));
3754 /* If BASE is an ancestor of DCLASS return the distance between them.
3755 otherwise return -1;
3759 class B: public A {};
3760 class C: public B {};
3763 distance_to_ancestor (A, A, 0) = 0
3764 distance_to_ancestor (A, B, 0) = 1
3765 distance_to_ancestor (A, C, 0) = 2
3766 distance_to_ancestor (A, D, 0) = 3
3768 If PUBLIC is 1 then only public ancestors are considered,
3769 and the function returns the distance only if BASE is a public ancestor
3773 distance_to_ancestor (A, D, 1) = -1. */
3776 distance_to_ancestor (struct type
*base
, struct type
*dclass
, int is_public
)
3781 base
= check_typedef (base
);
3782 dclass
= check_typedef (dclass
);
3784 if (class_types_same_p (base
, dclass
))
3787 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
3789 if (is_public
&& ! BASETYPE_VIA_PUBLIC (dclass
, i
))
3792 d
= distance_to_ancestor (base
, TYPE_BASECLASS (dclass
, i
), is_public
);
3800 /* Check whether BASE is an ancestor or base class or DCLASS
3801 Return 1 if so, and 0 if not.
3802 Note: If BASE and DCLASS are of the same type, this function
3803 will return 1. So for some class A, is_ancestor (A, A) will
3807 is_ancestor (struct type
*base
, struct type
*dclass
)
3809 return distance_to_ancestor (base
, dclass
, 0) >= 0;
3812 /* Like is_ancestor, but only returns true when BASE is a public
3813 ancestor of DCLASS. */
3816 is_public_ancestor (struct type
*base
, struct type
*dclass
)
3818 return distance_to_ancestor (base
, dclass
, 1) >= 0;
3821 /* A helper function for is_unique_ancestor. */
3824 is_unique_ancestor_worker (struct type
*base
, struct type
*dclass
,
3826 const gdb_byte
*valaddr
, int embedded_offset
,
3827 CORE_ADDR address
, struct value
*val
)
3831 base
= check_typedef (base
);
3832 dclass
= check_typedef (dclass
);
3834 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
) && count
< 2; ++i
)
3839 iter
= check_typedef (TYPE_BASECLASS (dclass
, i
));
3841 this_offset
= baseclass_offset (dclass
, i
, valaddr
, embedded_offset
,
3844 if (class_types_same_p (base
, iter
))
3846 /* If this is the first subclass, set *OFFSET and set count
3847 to 1. Otherwise, if this is at the same offset as
3848 previous instances, do nothing. Otherwise, increment
3852 *offset
= this_offset
;
3855 else if (this_offset
== *offset
)
3863 count
+= is_unique_ancestor_worker (base
, iter
, offset
,
3865 embedded_offset
+ this_offset
,
3872 /* Like is_ancestor, but only returns true if BASE is a unique base
3873 class of the type of VAL. */
3876 is_unique_ancestor (struct type
*base
, struct value
*val
)
3880 return is_unique_ancestor_worker (base
, value_type (val
), &offset
,
3881 value_contents_for_printing (val
).data (),
3882 value_embedded_offset (val
),
3883 value_address (val
), val
) == 1;
3886 /* See gdbtypes.h. */
3889 type_byte_order (const struct type
*type
)
3891 bfd_endian byteorder
= gdbarch_byte_order (type
->arch ());
3892 if (type
->endianity_is_not_default ())
3894 if (byteorder
== BFD_ENDIAN_BIG
)
3895 return BFD_ENDIAN_LITTLE
;
3898 gdb_assert (byteorder
== BFD_ENDIAN_LITTLE
);
3899 return BFD_ENDIAN_BIG
;
3907 /* Overload resolution. */
3909 /* Return the sum of the rank of A with the rank of B. */
3912 sum_ranks (struct rank a
, struct rank b
)
3915 c
.rank
= a
.rank
+ b
.rank
;
3916 c
.subrank
= a
.subrank
+ b
.subrank
;
3920 /* Compare rank A and B and return:
3922 1 if a is better than b
3923 -1 if b is better than a. */
3926 compare_ranks (struct rank a
, struct rank b
)
3928 if (a
.rank
== b
.rank
)
3930 if (a
.subrank
== b
.subrank
)
3932 if (a
.subrank
< b
.subrank
)
3934 if (a
.subrank
> b
.subrank
)
3938 if (a
.rank
< b
.rank
)
3941 /* a.rank > b.rank */
3945 /* Functions for overload resolution begin here. */
3947 /* Compare two badness vectors A and B and return the result.
3948 0 => A and B are identical
3949 1 => A and B are incomparable
3950 2 => A is better than B
3951 3 => A is worse than B */
3954 compare_badness (const badness_vector
&a
, const badness_vector
&b
)
3958 short found_pos
= 0; /* any positives in c? */
3959 short found_neg
= 0; /* any negatives in c? */
3961 /* differing sizes => incomparable */
3962 if (a
.size () != b
.size ())
3965 /* Subtract b from a */
3966 for (i
= 0; i
< a
.size (); i
++)
3968 tmp
= compare_ranks (b
[i
], a
[i
]);
3978 return 1; /* incomparable */
3980 return 3; /* A > B */
3986 return 2; /* A < B */
3988 return 0; /* A == B */
3992 /* Rank a function by comparing its parameter types (PARMS), to the
3993 types of an argument list (ARGS). Return the badness vector. This
3994 has ARGS.size() + 1 entries. */
3997 rank_function (gdb::array_view
<type
*> parms
,
3998 gdb::array_view
<value
*> args
)
4000 /* add 1 for the length-match rank. */
4002 bv
.reserve (1 + args
.size ());
4004 /* First compare the lengths of the supplied lists.
4005 If there is a mismatch, set it to a high value. */
4007 /* pai/1997-06-03 FIXME: when we have debug info about default
4008 arguments and ellipsis parameter lists, we should consider those
4009 and rank the length-match more finely. */
4011 bv
.push_back ((args
.size () != parms
.size ())
4012 ? LENGTH_MISMATCH_BADNESS
4013 : EXACT_MATCH_BADNESS
);
4015 /* Now rank all the parameters of the candidate function. */
4016 size_t min_len
= std::min (parms
.size (), args
.size ());
4018 for (size_t i
= 0; i
< min_len
; i
++)
4019 bv
.push_back (rank_one_type (parms
[i
], value_type (args
[i
]),
4022 /* If more arguments than parameters, add dummy entries. */
4023 for (size_t i
= min_len
; i
< args
.size (); i
++)
4024 bv
.push_back (TOO_FEW_PARAMS_BADNESS
);
4029 /* Compare the names of two integer types, assuming that any sign
4030 qualifiers have been checked already. We do it this way because
4031 there may be an "int" in the name of one of the types. */
4034 integer_types_same_name_p (const char *first
, const char *second
)
4036 int first_p
, second_p
;
4038 /* If both are shorts, return 1; if neither is a short, keep
4040 first_p
= (strstr (first
, "short") != NULL
);
4041 second_p
= (strstr (second
, "short") != NULL
);
4042 if (first_p
&& second_p
)
4044 if (first_p
|| second_p
)
4047 /* Likewise for long. */
4048 first_p
= (strstr (first
, "long") != NULL
);
4049 second_p
= (strstr (second
, "long") != NULL
);
4050 if (first_p
&& second_p
)
4052 if (first_p
|| second_p
)
4055 /* Likewise for char. */
4056 first_p
= (strstr (first
, "char") != NULL
);
4057 second_p
= (strstr (second
, "char") != NULL
);
4058 if (first_p
&& second_p
)
4060 if (first_p
|| second_p
)
4063 /* They must both be ints. */
4067 /* Compares type A to type B. Returns true if they represent the same
4068 type, false otherwise. */
4071 types_equal (struct type
*a
, struct type
*b
)
4073 /* Identical type pointers. */
4074 /* However, this still doesn't catch all cases of same type for b
4075 and a. The reason is that builtin types are different from
4076 the same ones constructed from the object. */
4080 /* Resolve typedefs */
4081 if (a
->code () == TYPE_CODE_TYPEDEF
)
4082 a
= check_typedef (a
);
4083 if (b
->code () == TYPE_CODE_TYPEDEF
)
4084 b
= check_typedef (b
);
4086 /* Check if identical after resolving typedefs. */
4090 /* If after resolving typedefs a and b are not of the same type
4091 code then they are not equal. */
4092 if (a
->code () != b
->code ())
4095 /* If a and b are both pointers types or both reference types then
4096 they are equal of the same type iff the objects they refer to are
4097 of the same type. */
4098 if (a
->code () == TYPE_CODE_PTR
4099 || a
->code () == TYPE_CODE_REF
)
4100 return types_equal (TYPE_TARGET_TYPE (a
),
4101 TYPE_TARGET_TYPE (b
));
4103 /* Well, damnit, if the names are exactly the same, I'll say they
4104 are exactly the same. This happens when we generate method
4105 stubs. The types won't point to the same address, but they
4106 really are the same. */
4108 if (a
->name () && b
->name ()
4109 && strcmp (a
->name (), b
->name ()) == 0)
4112 /* Two function types are equal if their argument and return types
4114 if (a
->code () == TYPE_CODE_FUNC
)
4118 if (a
->num_fields () != b
->num_fields ())
4121 if (!types_equal (TYPE_TARGET_TYPE (a
), TYPE_TARGET_TYPE (b
)))
4124 for (i
= 0; i
< a
->num_fields (); ++i
)
4125 if (!types_equal (a
->field (i
).type (), b
->field (i
).type ()))
4134 /* Deep comparison of types. */
4136 /* An entry in the type-equality bcache. */
4138 struct type_equality_entry
4140 type_equality_entry (struct type
*t1
, struct type
*t2
)
4146 struct type
*type1
, *type2
;
4149 /* A helper function to compare two strings. Returns true if they are
4150 the same, false otherwise. Handles NULLs properly. */
4153 compare_maybe_null_strings (const char *s
, const char *t
)
4155 if (s
== NULL
|| t
== NULL
)
4157 return strcmp (s
, t
) == 0;
4160 /* A helper function for check_types_worklist that checks two types for
4161 "deep" equality. Returns true if the types are considered the
4162 same, false otherwise. */
4165 check_types_equal (struct type
*type1
, struct type
*type2
,
4166 std::vector
<type_equality_entry
> *worklist
)
4168 type1
= check_typedef (type1
);
4169 type2
= check_typedef (type2
);
4174 if (type1
->code () != type2
->code ()
4175 || TYPE_LENGTH (type1
) != TYPE_LENGTH (type2
)
4176 || type1
->is_unsigned () != type2
->is_unsigned ()
4177 || type1
->has_no_signedness () != type2
->has_no_signedness ()
4178 || type1
->endianity_is_not_default () != type2
->endianity_is_not_default ()
4179 || type1
->has_varargs () != type2
->has_varargs ()
4180 || type1
->is_vector () != type2
->is_vector ()
4181 || TYPE_NOTTEXT (type1
) != TYPE_NOTTEXT (type2
)
4182 || type1
->instance_flags () != type2
->instance_flags ()
4183 || type1
->num_fields () != type2
->num_fields ())
4186 if (!compare_maybe_null_strings (type1
->name (), type2
->name ()))
4188 if (!compare_maybe_null_strings (type1
->name (), type2
->name ()))
4191 if (type1
->code () == TYPE_CODE_RANGE
)
4193 if (*type1
->bounds () != *type2
->bounds ())
4200 for (i
= 0; i
< type1
->num_fields (); ++i
)
4202 const struct field
*field1
= &type1
->field (i
);
4203 const struct field
*field2
= &type2
->field (i
);
4205 if (FIELD_ARTIFICIAL (*field1
) != FIELD_ARTIFICIAL (*field2
)
4206 || FIELD_BITSIZE (*field1
) != FIELD_BITSIZE (*field2
)
4207 || field1
->loc_kind () != field2
->loc_kind ())
4209 if (!compare_maybe_null_strings (field1
->name (), field2
->name ()))
4211 switch (field1
->loc_kind ())
4213 case FIELD_LOC_KIND_BITPOS
:
4214 if (field1
->loc_bitpos () != field2
->loc_bitpos ())
4217 case FIELD_LOC_KIND_ENUMVAL
:
4218 if (field1
->loc_enumval () != field2
->loc_enumval ())
4220 /* Don't compare types of enum fields, because they don't
4223 case FIELD_LOC_KIND_PHYSADDR
:
4224 if (field1
->loc_physaddr () != field2
->loc_physaddr ())
4227 case FIELD_LOC_KIND_PHYSNAME
:
4228 if (!compare_maybe_null_strings (field1
->loc_physname (),
4229 field2
->loc_physname ()))
4232 case FIELD_LOC_KIND_DWARF_BLOCK
:
4234 struct dwarf2_locexpr_baton
*block1
, *block2
;
4236 block1
= field1
->loc_dwarf_block ();
4237 block2
= field2
->loc_dwarf_block ();
4238 if (block1
->per_cu
!= block2
->per_cu
4239 || block1
->size
!= block2
->size
4240 || memcmp (block1
->data
, block2
->data
, block1
->size
) != 0)
4245 internal_error (__FILE__
, __LINE__
, _("Unsupported field kind "
4246 "%d by check_types_equal"),
4247 field1
->loc_kind ());
4250 worklist
->emplace_back (field1
->type (), field2
->type ());
4254 if (TYPE_TARGET_TYPE (type1
) != NULL
)
4256 if (TYPE_TARGET_TYPE (type2
) == NULL
)
4259 worklist
->emplace_back (TYPE_TARGET_TYPE (type1
),
4260 TYPE_TARGET_TYPE (type2
));
4262 else if (TYPE_TARGET_TYPE (type2
) != NULL
)
4268 /* Check types on a worklist for equality. Returns false if any pair
4269 is not equal, true if they are all considered equal. */
4272 check_types_worklist (std::vector
<type_equality_entry
> *worklist
,
4275 while (!worklist
->empty ())
4279 struct type_equality_entry entry
= std::move (worklist
->back ());
4280 worklist
->pop_back ();
4282 /* If the type pair has already been visited, we know it is
4284 cache
->insert (&entry
, sizeof (entry
), &added
);
4288 if (!check_types_equal (entry
.type1
, entry
.type2
, worklist
))
4295 /* Return true if types TYPE1 and TYPE2 are equal, as determined by a
4296 "deep comparison". Otherwise return false. */
4299 types_deeply_equal (struct type
*type1
, struct type
*type2
)
4301 std::vector
<type_equality_entry
> worklist
;
4303 gdb_assert (type1
!= NULL
&& type2
!= NULL
);
4305 /* Early exit for the simple case. */
4310 worklist
.emplace_back (type1
, type2
);
4311 return check_types_worklist (&worklist
, &cache
);
4314 /* Allocated status of type TYPE. Return zero if type TYPE is allocated.
4315 Otherwise return one. */
4318 type_not_allocated (const struct type
*type
)
4320 struct dynamic_prop
*prop
= TYPE_ALLOCATED_PROP (type
);
4322 return (prop
!= nullptr && prop
->kind () == PROP_CONST
4323 && prop
->const_val () == 0);
4326 /* Associated status of type TYPE. Return zero if type TYPE is associated.
4327 Otherwise return one. */
4330 type_not_associated (const struct type
*type
)
4332 struct dynamic_prop
*prop
= TYPE_ASSOCIATED_PROP (type
);
4334 return (prop
!= nullptr && prop
->kind () == PROP_CONST
4335 && prop
->const_val () == 0);
4338 /* rank_one_type helper for when PARM's type code is TYPE_CODE_PTR. */
4341 rank_one_type_parm_ptr (struct type
*parm
, struct type
*arg
, struct value
*value
)
4343 struct rank rank
= {0,0};
4345 switch (arg
->code ())
4349 /* Allowed pointer conversions are:
4350 (a) pointer to void-pointer conversion. */
4351 if (TYPE_TARGET_TYPE (parm
)->code () == TYPE_CODE_VOID
)
4352 return VOID_PTR_CONVERSION_BADNESS
;
4354 /* (b) pointer to ancestor-pointer conversion. */
4355 rank
.subrank
= distance_to_ancestor (TYPE_TARGET_TYPE (parm
),
4356 TYPE_TARGET_TYPE (arg
),
4358 if (rank
.subrank
>= 0)
4359 return sum_ranks (BASE_PTR_CONVERSION_BADNESS
, rank
);
4361 return INCOMPATIBLE_TYPE_BADNESS
;
4362 case TYPE_CODE_ARRAY
:
4364 struct type
*t1
= TYPE_TARGET_TYPE (parm
);
4365 struct type
*t2
= TYPE_TARGET_TYPE (arg
);
4367 if (types_equal (t1
, t2
))
4369 /* Make sure they are CV equal. */
4370 if (TYPE_CONST (t1
) != TYPE_CONST (t2
))
4371 rank
.subrank
|= CV_CONVERSION_CONST
;
4372 if (TYPE_VOLATILE (t1
) != TYPE_VOLATILE (t2
))
4373 rank
.subrank
|= CV_CONVERSION_VOLATILE
;
4374 if (rank
.subrank
!= 0)
4375 return sum_ranks (CV_CONVERSION_BADNESS
, rank
);
4376 return EXACT_MATCH_BADNESS
;
4378 return INCOMPATIBLE_TYPE_BADNESS
;
4380 case TYPE_CODE_FUNC
:
4381 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
);
4383 if (value
!= NULL
&& value_type (value
)->code () == TYPE_CODE_INT
)
4385 if (value_as_long (value
) == 0)
4387 /* Null pointer conversion: allow it to be cast to a pointer.
4388 [4.10.1 of C++ standard draft n3290] */
4389 return NULL_POINTER_CONVERSION_BADNESS
;
4393 /* If type checking is disabled, allow the conversion. */
4394 if (!strict_type_checking
)
4395 return NS_INTEGER_POINTER_CONVERSION_BADNESS
;
4399 case TYPE_CODE_ENUM
:
4400 case TYPE_CODE_FLAGS
:
4401 case TYPE_CODE_CHAR
:
4402 case TYPE_CODE_RANGE
:
4403 case TYPE_CODE_BOOL
:
4405 return INCOMPATIBLE_TYPE_BADNESS
;
4409 /* rank_one_type helper for when PARM's type code is TYPE_CODE_ARRAY. */
4412 rank_one_type_parm_array (struct type
*parm
, struct type
*arg
, struct value
*value
)
4414 switch (arg
->code ())
4417 case TYPE_CODE_ARRAY
:
4418 return rank_one_type (TYPE_TARGET_TYPE (parm
),
4419 TYPE_TARGET_TYPE (arg
), NULL
);
4421 return INCOMPATIBLE_TYPE_BADNESS
;
4425 /* rank_one_type helper for when PARM's type code is TYPE_CODE_FUNC. */
4428 rank_one_type_parm_func (struct type
*parm
, struct type
*arg
, struct value
*value
)
4430 switch (arg
->code ())
4432 case TYPE_CODE_PTR
: /* funcptr -> func */
4433 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
);
4435 return INCOMPATIBLE_TYPE_BADNESS
;
4439 /* rank_one_type helper for when PARM's type code is TYPE_CODE_INT. */
4442 rank_one_type_parm_int (struct type
*parm
, struct type
*arg
, struct value
*value
)
4444 switch (arg
->code ())
4447 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
4449 /* Deal with signed, unsigned, and plain chars and
4450 signed and unsigned ints. */
4451 if (parm
->has_no_signedness ())
4453 /* This case only for character types. */
4454 if (arg
->has_no_signedness ())
4455 return EXACT_MATCH_BADNESS
; /* plain char -> plain char */
4456 else /* signed/unsigned char -> plain char */
4457 return INTEGER_CONVERSION_BADNESS
;
4459 else if (parm
->is_unsigned ())
4461 if (arg
->is_unsigned ())
4463 /* unsigned int -> unsigned int, or
4464 unsigned long -> unsigned long */
4465 if (integer_types_same_name_p (parm
->name (),
4467 return EXACT_MATCH_BADNESS
;
4468 else if (integer_types_same_name_p (arg
->name (),
4470 && integer_types_same_name_p (parm
->name (),
4472 /* unsigned int -> unsigned long */
4473 return INTEGER_PROMOTION_BADNESS
;
4475 /* unsigned long -> unsigned int */
4476 return INTEGER_CONVERSION_BADNESS
;
4480 if (integer_types_same_name_p (arg
->name (),
4482 && integer_types_same_name_p (parm
->name (),
4484 /* signed long -> unsigned int */
4485 return INTEGER_CONVERSION_BADNESS
;
4487 /* signed int/long -> unsigned int/long */
4488 return INTEGER_CONVERSION_BADNESS
;
4491 else if (!arg
->has_no_signedness () && !arg
->is_unsigned ())
4493 if (integer_types_same_name_p (parm
->name (),
4495 return EXACT_MATCH_BADNESS
;
4496 else if (integer_types_same_name_p (arg
->name (),
4498 && integer_types_same_name_p (parm
->name (),
4500 return INTEGER_PROMOTION_BADNESS
;
4502 return INTEGER_CONVERSION_BADNESS
;
4505 return INTEGER_CONVERSION_BADNESS
;
4507 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
4508 return INTEGER_PROMOTION_BADNESS
;
4510 return INTEGER_CONVERSION_BADNESS
;
4511 case TYPE_CODE_ENUM
:
4512 case TYPE_CODE_FLAGS
:
4513 case TYPE_CODE_CHAR
:
4514 case TYPE_CODE_RANGE
:
4515 case TYPE_CODE_BOOL
:
4516 if (arg
->is_declared_class ())
4517 return INCOMPATIBLE_TYPE_BADNESS
;
4518 return INTEGER_PROMOTION_BADNESS
;
4520 return INT_FLOAT_CONVERSION_BADNESS
;
4522 return NS_POINTER_CONVERSION_BADNESS
;
4524 return INCOMPATIBLE_TYPE_BADNESS
;
4528 /* rank_one_type helper for when PARM's type code is TYPE_CODE_ENUM. */
4531 rank_one_type_parm_enum (struct type
*parm
, struct type
*arg
, struct value
*value
)
4533 switch (arg
->code ())
4536 case TYPE_CODE_CHAR
:
4537 case TYPE_CODE_RANGE
:
4538 case TYPE_CODE_BOOL
:
4539 case TYPE_CODE_ENUM
:
4540 if (parm
->is_declared_class () || arg
->is_declared_class ())
4541 return INCOMPATIBLE_TYPE_BADNESS
;
4542 return INTEGER_CONVERSION_BADNESS
;
4544 return INT_FLOAT_CONVERSION_BADNESS
;
4546 return INCOMPATIBLE_TYPE_BADNESS
;
4550 /* rank_one_type helper for when PARM's type code is TYPE_CODE_CHAR. */
4553 rank_one_type_parm_char (struct type
*parm
, struct type
*arg
, struct value
*value
)
4555 switch (arg
->code ())
4557 case TYPE_CODE_RANGE
:
4558 case TYPE_CODE_BOOL
:
4559 case TYPE_CODE_ENUM
:
4560 if (arg
->is_declared_class ())
4561 return INCOMPATIBLE_TYPE_BADNESS
;
4562 return INTEGER_CONVERSION_BADNESS
;
4564 return INT_FLOAT_CONVERSION_BADNESS
;
4566 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
4567 return INTEGER_CONVERSION_BADNESS
;
4568 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
4569 return INTEGER_PROMOTION_BADNESS
;
4571 case TYPE_CODE_CHAR
:
4572 /* Deal with signed, unsigned, and plain chars for C++ and
4573 with int cases falling through from previous case. */
4574 if (parm
->has_no_signedness ())
4576 if (arg
->has_no_signedness ())
4577 return EXACT_MATCH_BADNESS
;
4579 return INTEGER_CONVERSION_BADNESS
;
4581 else if (parm
->is_unsigned ())
4583 if (arg
->is_unsigned ())
4584 return EXACT_MATCH_BADNESS
;
4586 return INTEGER_PROMOTION_BADNESS
;
4588 else if (!arg
->has_no_signedness () && !arg
->is_unsigned ())
4589 return EXACT_MATCH_BADNESS
;
4591 return INTEGER_CONVERSION_BADNESS
;
4593 return INCOMPATIBLE_TYPE_BADNESS
;
4597 /* rank_one_type helper for when PARM's type code is TYPE_CODE_RANGE. */
4600 rank_one_type_parm_range (struct type
*parm
, struct type
*arg
, struct value
*value
)
4602 switch (arg
->code ())
4605 case TYPE_CODE_CHAR
:
4606 case TYPE_CODE_RANGE
:
4607 case TYPE_CODE_BOOL
:
4608 case TYPE_CODE_ENUM
:
4609 return INTEGER_CONVERSION_BADNESS
;
4611 return INT_FLOAT_CONVERSION_BADNESS
;
4613 return INCOMPATIBLE_TYPE_BADNESS
;
4617 /* rank_one_type helper for when PARM's type code is TYPE_CODE_BOOL. */
4620 rank_one_type_parm_bool (struct type
*parm
, struct type
*arg
, struct value
*value
)
4622 switch (arg
->code ())
4624 /* n3290 draft, section 4.12.1 (conv.bool):
4626 "A prvalue of arithmetic, unscoped enumeration, pointer, or
4627 pointer to member type can be converted to a prvalue of type
4628 bool. A zero value, null pointer value, or null member pointer
4629 value is converted to false; any other value is converted to
4630 true. A prvalue of type std::nullptr_t can be converted to a
4631 prvalue of type bool; the resulting value is false." */
4633 case TYPE_CODE_CHAR
:
4634 case TYPE_CODE_ENUM
:
4636 case TYPE_CODE_MEMBERPTR
:
4638 return BOOL_CONVERSION_BADNESS
;
4639 case TYPE_CODE_RANGE
:
4640 return INCOMPATIBLE_TYPE_BADNESS
;
4641 case TYPE_CODE_BOOL
:
4642 return EXACT_MATCH_BADNESS
;
4644 return INCOMPATIBLE_TYPE_BADNESS
;
4648 /* rank_one_type helper for when PARM's type code is TYPE_CODE_FLOAT. */
4651 rank_one_type_parm_float (struct type
*parm
, struct type
*arg
, struct value
*value
)
4653 switch (arg
->code ())
4656 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
4657 return FLOAT_PROMOTION_BADNESS
;
4658 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
4659 return EXACT_MATCH_BADNESS
;
4661 return FLOAT_CONVERSION_BADNESS
;
4663 case TYPE_CODE_BOOL
:
4664 case TYPE_CODE_ENUM
:
4665 case TYPE_CODE_RANGE
:
4666 case TYPE_CODE_CHAR
:
4667 return INT_FLOAT_CONVERSION_BADNESS
;
4669 return INCOMPATIBLE_TYPE_BADNESS
;
4673 /* rank_one_type helper for when PARM's type code is TYPE_CODE_COMPLEX. */
4676 rank_one_type_parm_complex (struct type
*parm
, struct type
*arg
, struct value
*value
)
4678 switch (arg
->code ())
4679 { /* Strictly not needed for C++, but... */
4681 return FLOAT_PROMOTION_BADNESS
;
4682 case TYPE_CODE_COMPLEX
:
4683 return EXACT_MATCH_BADNESS
;
4685 return INCOMPATIBLE_TYPE_BADNESS
;
4689 /* rank_one_type helper for when PARM's type code is TYPE_CODE_STRUCT. */
4692 rank_one_type_parm_struct (struct type
*parm
, struct type
*arg
, struct value
*value
)
4694 struct rank rank
= {0, 0};
4696 switch (arg
->code ())
4698 case TYPE_CODE_STRUCT
:
4699 /* Check for derivation */
4700 rank
.subrank
= distance_to_ancestor (parm
, arg
, 0);
4701 if (rank
.subrank
>= 0)
4702 return sum_ranks (BASE_CONVERSION_BADNESS
, rank
);
4705 return INCOMPATIBLE_TYPE_BADNESS
;
4709 /* rank_one_type helper for when PARM's type code is TYPE_CODE_SET. */
4712 rank_one_type_parm_set (struct type
*parm
, struct type
*arg
, struct value
*value
)
4714 switch (arg
->code ())
4718 return rank_one_type (parm
->field (0).type (),
4719 arg
->field (0).type (), NULL
);
4721 return INCOMPATIBLE_TYPE_BADNESS
;
4725 /* Compare one type (PARM) for compatibility with another (ARG).
4726 * PARM is intended to be the parameter type of a function; and
4727 * ARG is the supplied argument's type. This function tests if
4728 * the latter can be converted to the former.
4729 * VALUE is the argument's value or NULL if none (or called recursively)
4731 * Return 0 if they are identical types;
4732 * Otherwise, return an integer which corresponds to how compatible
4733 * PARM is to ARG. The higher the return value, the worse the match.
4734 * Generally the "bad" conversions are all uniformly assigned a 100. */
4737 rank_one_type (struct type
*parm
, struct type
*arg
, struct value
*value
)
4739 struct rank rank
= {0,0};
4741 /* Resolve typedefs */
4742 if (parm
->code () == TYPE_CODE_TYPEDEF
)
4743 parm
= check_typedef (parm
);
4744 if (arg
->code () == TYPE_CODE_TYPEDEF
)
4745 arg
= check_typedef (arg
);
4747 if (TYPE_IS_REFERENCE (parm
) && value
!= NULL
)
4749 if (VALUE_LVAL (value
) == not_lval
)
4751 /* Rvalues should preferably bind to rvalue references or const
4752 lvalue references. */
4753 if (parm
->code () == TYPE_CODE_RVALUE_REF
)
4754 rank
.subrank
= REFERENCE_CONVERSION_RVALUE
;
4755 else if (TYPE_CONST (TYPE_TARGET_TYPE (parm
)))
4756 rank
.subrank
= REFERENCE_CONVERSION_CONST_LVALUE
;
4758 return INCOMPATIBLE_TYPE_BADNESS
;
4759 return sum_ranks (rank
, REFERENCE_CONVERSION_BADNESS
);
4763 /* It's illegal to pass an lvalue as an rvalue. */
4764 if (parm
->code () == TYPE_CODE_RVALUE_REF
)
4765 return INCOMPATIBLE_TYPE_BADNESS
;
4769 if (types_equal (parm
, arg
))
4771 struct type
*t1
= parm
;
4772 struct type
*t2
= arg
;
4774 /* For pointers and references, compare target type. */
4775 if (parm
->is_pointer_or_reference ())
4777 t1
= TYPE_TARGET_TYPE (parm
);
4778 t2
= TYPE_TARGET_TYPE (arg
);
4781 /* Make sure they are CV equal, too. */
4782 if (TYPE_CONST (t1
) != TYPE_CONST (t2
))
4783 rank
.subrank
|= CV_CONVERSION_CONST
;
4784 if (TYPE_VOLATILE (t1
) != TYPE_VOLATILE (t2
))
4785 rank
.subrank
|= CV_CONVERSION_VOLATILE
;
4786 if (rank
.subrank
!= 0)
4787 return sum_ranks (CV_CONVERSION_BADNESS
, rank
);
4788 return EXACT_MATCH_BADNESS
;
4791 /* See through references, since we can almost make non-references
4794 if (TYPE_IS_REFERENCE (arg
))
4795 return (sum_ranks (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
),
4796 REFERENCE_SEE_THROUGH_BADNESS
));
4797 if (TYPE_IS_REFERENCE (parm
))
4798 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
),
4799 REFERENCE_SEE_THROUGH_BADNESS
));
4802 /* Debugging only. */
4803 fprintf_filtered (gdb_stderr
,
4804 "------ Arg is %s [%d], parm is %s [%d]\n",
4805 arg
->name (), arg
->code (),
4806 parm
->name (), parm
->code ());
4809 /* x -> y means arg of type x being supplied for parameter of type y. */
4811 switch (parm
->code ())
4814 return rank_one_type_parm_ptr (parm
, arg
, value
);
4815 case TYPE_CODE_ARRAY
:
4816 return rank_one_type_parm_array (parm
, arg
, value
);
4817 case TYPE_CODE_FUNC
:
4818 return rank_one_type_parm_func (parm
, arg
, value
);
4820 return rank_one_type_parm_int (parm
, arg
, value
);
4821 case TYPE_CODE_ENUM
:
4822 return rank_one_type_parm_enum (parm
, arg
, value
);
4823 case TYPE_CODE_CHAR
:
4824 return rank_one_type_parm_char (parm
, arg
, value
);
4825 case TYPE_CODE_RANGE
:
4826 return rank_one_type_parm_range (parm
, arg
, value
);
4827 case TYPE_CODE_BOOL
:
4828 return rank_one_type_parm_bool (parm
, arg
, value
);
4830 return rank_one_type_parm_float (parm
, arg
, value
);
4831 case TYPE_CODE_COMPLEX
:
4832 return rank_one_type_parm_complex (parm
, arg
, value
);
4833 case TYPE_CODE_STRUCT
:
4834 return rank_one_type_parm_struct (parm
, arg
, value
);
4836 return rank_one_type_parm_set (parm
, arg
, value
);
4838 return INCOMPATIBLE_TYPE_BADNESS
;
4839 } /* switch (arg->code ()) */
4842 /* End of functions for overload resolution. */
4844 /* Routines to pretty-print types. */
4847 print_bit_vector (B_TYPE
*bits
, int nbits
)
4851 for (bitno
= 0; bitno
< nbits
; bitno
++)
4853 if ((bitno
% 8) == 0)
4855 puts_filtered (" ");
4857 if (B_TST (bits
, bitno
))
4858 printf_filtered (("1"));
4860 printf_filtered (("0"));
4864 /* Note the first arg should be the "this" pointer, we may not want to
4865 include it since we may get into a infinitely recursive
4869 print_args (struct field
*args
, int nargs
, int spaces
)
4875 for (i
= 0; i
< nargs
; i
++)
4878 ("%*s[%d] name '%s'\n", spaces
, "", i
,
4879 args
[i
].name () != NULL
? args
[i
].name () : "<NULL>");
4880 recursive_dump_type (args
[i
].type (), spaces
+ 2);
4886 field_is_static (struct field
*f
)
4888 /* "static" fields are the fields whose location is not relative
4889 to the address of the enclosing struct. It would be nice to
4890 have a dedicated flag that would be set for static fields when
4891 the type is being created. But in practice, checking the field
4892 loc_kind should give us an accurate answer. */
4893 return (f
->loc_kind () == FIELD_LOC_KIND_PHYSNAME
4894 || f
->loc_kind () == FIELD_LOC_KIND_PHYSADDR
);
4898 dump_fn_fieldlists (struct type
*type
, int spaces
)
4904 printf_filtered ("%*sfn_fieldlists ", spaces
, "");
4905 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
4906 printf_filtered ("\n");
4907 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
4909 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
4910 printf_filtered ("%*s[%d] name '%s' (", spaces
+ 2, "",
4912 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
4913 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
4915 printf_filtered (_(") length %d\n"),
4916 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
4917 for (overload_idx
= 0;
4918 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
4921 printf_filtered ("%*s[%d] physname '%s' (",
4922 spaces
+ 4, "", overload_idx
,
4923 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
4924 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
4926 printf_filtered (")\n");
4927 printf_filtered ("%*stype ", spaces
+ 8, "");
4928 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
4930 printf_filtered ("\n");
4932 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
4935 printf_filtered ("%*sargs ", spaces
+ 8, "");
4936 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
4938 printf_filtered ("\n");
4939 print_args (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
4940 TYPE_FN_FIELD_TYPE (f
, overload_idx
)->num_fields (),
4942 printf_filtered ("%*sfcontext ", spaces
+ 8, "");
4943 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
4945 printf_filtered ("\n");
4947 printf_filtered ("%*sis_const %d\n", spaces
+ 8, "",
4948 TYPE_FN_FIELD_CONST (f
, overload_idx
));
4949 printf_filtered ("%*sis_volatile %d\n", spaces
+ 8, "",
4950 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
4951 printf_filtered ("%*sis_private %d\n", spaces
+ 8, "",
4952 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
4953 printf_filtered ("%*sis_protected %d\n", spaces
+ 8, "",
4954 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
4955 printf_filtered ("%*sis_stub %d\n", spaces
+ 8, "",
4956 TYPE_FN_FIELD_STUB (f
, overload_idx
));
4957 printf_filtered ("%*sdefaulted %d\n", spaces
+ 8, "",
4958 TYPE_FN_FIELD_DEFAULTED (f
, overload_idx
));
4959 printf_filtered ("%*sis_deleted %d\n", spaces
+ 8, "",
4960 TYPE_FN_FIELD_DELETED (f
, overload_idx
));
4961 printf_filtered ("%*svoffset %u\n", spaces
+ 8, "",
4962 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
4968 print_cplus_stuff (struct type
*type
, int spaces
)
4970 printf_filtered ("%*svptr_fieldno %d\n", spaces
, "",
4971 TYPE_VPTR_FIELDNO (type
));
4972 printf_filtered ("%*svptr_basetype ", spaces
, "");
4973 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
4974 puts_filtered ("\n");
4975 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
4976 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
4978 printf_filtered ("%*sn_baseclasses %d\n", spaces
, "",
4979 TYPE_N_BASECLASSES (type
));
4980 printf_filtered ("%*snfn_fields %d\n", spaces
, "",
4981 TYPE_NFN_FIELDS (type
));
4982 if (TYPE_N_BASECLASSES (type
) > 0)
4984 printf_filtered ("%*svirtual_field_bits (%d bits at *",
4985 spaces
, "", TYPE_N_BASECLASSES (type
));
4986 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
4988 printf_filtered (")");
4990 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
4991 TYPE_N_BASECLASSES (type
));
4992 puts_filtered ("\n");
4994 if (type
->num_fields () > 0)
4996 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
4998 printf_filtered ("%*sprivate_field_bits (%d bits at *",
4999 spaces
, "", type
->num_fields ());
5000 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
5002 printf_filtered (")");
5003 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
5004 type
->num_fields ());
5005 puts_filtered ("\n");
5007 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
5009 printf_filtered ("%*sprotected_field_bits (%d bits at *",
5010 spaces
, "", type
->num_fields ());
5011 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
5013 printf_filtered (")");
5014 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
5015 type
->num_fields ());
5016 puts_filtered ("\n");
5019 if (TYPE_NFN_FIELDS (type
) > 0)
5021 dump_fn_fieldlists (type
, spaces
);
5024 printf_filtered ("%*scalling_convention %d\n", spaces
, "",
5025 TYPE_CPLUS_CALLING_CONVENTION (type
));
5028 /* Print the contents of the TYPE's type_specific union, assuming that
5029 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
5032 print_gnat_stuff (struct type
*type
, int spaces
)
5034 struct type
*descriptive_type
= TYPE_DESCRIPTIVE_TYPE (type
);
5036 if (descriptive_type
== NULL
)
5037 printf_filtered ("%*sno descriptive type\n", spaces
+ 2, "");
5040 printf_filtered ("%*sdescriptive type\n", spaces
+ 2, "");
5041 recursive_dump_type (descriptive_type
, spaces
+ 4);
5045 /* Print the contents of the TYPE's type_specific union, assuming that
5046 its type-specific kind is TYPE_SPECIFIC_FIXED_POINT. */
5049 print_fixed_point_type_info (struct type
*type
, int spaces
)
5051 printf_filtered ("%*sscaling factor: %s\n", spaces
+ 2, "",
5052 type
->fixed_point_scaling_factor ().str ().c_str ());
5055 static struct obstack dont_print_type_obstack
;
5057 /* Print the dynamic_prop PROP. */
5060 dump_dynamic_prop (dynamic_prop
const& prop
)
5062 switch (prop
.kind ())
5065 printf_filtered ("%s", plongest (prop
.const_val ()));
5067 case PROP_UNDEFINED
:
5068 printf_filtered ("(undefined)");
5072 printf_filtered ("(dynamic)");
5075 gdb_assert_not_reached ("unhandled prop kind");
5081 recursive_dump_type (struct type
*type
, int spaces
)
5086 obstack_begin (&dont_print_type_obstack
, 0);
5088 if (type
->num_fields () > 0
5089 || (HAVE_CPLUS_STRUCT (type
) && TYPE_NFN_FIELDS (type
) > 0))
5091 struct type
**first_dont_print
5092 = (struct type
**) obstack_base (&dont_print_type_obstack
);
5094 int i
= (struct type
**)
5095 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
5099 if (type
== first_dont_print
[i
])
5101 printf_filtered ("%*stype node ", spaces
, "");
5102 gdb_print_host_address (type
, gdb_stdout
);
5103 printf_filtered (_(" <same as already seen type>\n"));
5108 obstack_ptr_grow (&dont_print_type_obstack
, type
);
5111 printf_filtered ("%*stype node ", spaces
, "");
5112 gdb_print_host_address (type
, gdb_stdout
);
5113 printf_filtered ("\n");
5114 printf_filtered ("%*sname '%s' (", spaces
, "",
5115 type
->name () ? type
->name () : "<NULL>");
5116 gdb_print_host_address (type
->name (), gdb_stdout
);
5117 printf_filtered (")\n");
5118 printf_filtered ("%*scode 0x%x ", spaces
, "", type
->code ());
5119 switch (type
->code ())
5121 case TYPE_CODE_UNDEF
:
5122 printf_filtered ("(TYPE_CODE_UNDEF)");
5125 printf_filtered ("(TYPE_CODE_PTR)");
5127 case TYPE_CODE_ARRAY
:
5128 printf_filtered ("(TYPE_CODE_ARRAY)");
5130 case TYPE_CODE_STRUCT
:
5131 printf_filtered ("(TYPE_CODE_STRUCT)");
5133 case TYPE_CODE_UNION
:
5134 printf_filtered ("(TYPE_CODE_UNION)");
5136 case TYPE_CODE_ENUM
:
5137 printf_filtered ("(TYPE_CODE_ENUM)");
5139 case TYPE_CODE_FLAGS
:
5140 printf_filtered ("(TYPE_CODE_FLAGS)");
5142 case TYPE_CODE_FUNC
:
5143 printf_filtered ("(TYPE_CODE_FUNC)");
5146 printf_filtered ("(TYPE_CODE_INT)");
5149 printf_filtered ("(TYPE_CODE_FLT)");
5151 case TYPE_CODE_VOID
:
5152 printf_filtered ("(TYPE_CODE_VOID)");
5155 printf_filtered ("(TYPE_CODE_SET)");
5157 case TYPE_CODE_RANGE
:
5158 printf_filtered ("(TYPE_CODE_RANGE)");
5160 case TYPE_CODE_STRING
:
5161 printf_filtered ("(TYPE_CODE_STRING)");
5163 case TYPE_CODE_ERROR
:
5164 printf_filtered ("(TYPE_CODE_ERROR)");
5166 case TYPE_CODE_MEMBERPTR
:
5167 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
5169 case TYPE_CODE_METHODPTR
:
5170 printf_filtered ("(TYPE_CODE_METHODPTR)");
5172 case TYPE_CODE_METHOD
:
5173 printf_filtered ("(TYPE_CODE_METHOD)");
5176 printf_filtered ("(TYPE_CODE_REF)");
5178 case TYPE_CODE_CHAR
:
5179 printf_filtered ("(TYPE_CODE_CHAR)");
5181 case TYPE_CODE_BOOL
:
5182 printf_filtered ("(TYPE_CODE_BOOL)");
5184 case TYPE_CODE_COMPLEX
:
5185 printf_filtered ("(TYPE_CODE_COMPLEX)");
5187 case TYPE_CODE_TYPEDEF
:
5188 printf_filtered ("(TYPE_CODE_TYPEDEF)");
5190 case TYPE_CODE_NAMESPACE
:
5191 printf_filtered ("(TYPE_CODE_NAMESPACE)");
5193 case TYPE_CODE_FIXED_POINT
:
5194 printf_filtered ("(TYPE_CODE_FIXED_POINT)");
5197 printf_filtered ("(UNKNOWN TYPE CODE)");
5200 puts_filtered ("\n");
5201 printf_filtered ("%*slength %s\n", spaces
, "",
5202 pulongest (TYPE_LENGTH (type
)));
5203 if (type
->is_objfile_owned ())
5205 printf_filtered ("%*sobjfile ", spaces
, "");
5206 gdb_print_host_address (type
->objfile_owner (), gdb_stdout
);
5210 printf_filtered ("%*sgdbarch ", spaces
, "");
5211 gdb_print_host_address (type
->arch_owner (), gdb_stdout
);
5213 printf_filtered ("\n");
5214 printf_filtered ("%*starget_type ", spaces
, "");
5215 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
5216 printf_filtered ("\n");
5217 if (TYPE_TARGET_TYPE (type
) != NULL
)
5219 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
5221 printf_filtered ("%*spointer_type ", spaces
, "");
5222 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
5223 printf_filtered ("\n");
5224 printf_filtered ("%*sreference_type ", spaces
, "");
5225 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
5226 printf_filtered ("\n");
5227 printf_filtered ("%*stype_chain ", spaces
, "");
5228 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
5229 printf_filtered ("\n");
5230 printf_filtered ("%*sinstance_flags 0x%x", spaces
, "",
5231 (unsigned) type
->instance_flags ());
5232 if (TYPE_CONST (type
))
5234 puts_filtered (" TYPE_CONST");
5236 if (TYPE_VOLATILE (type
))
5238 puts_filtered (" TYPE_VOLATILE");
5240 if (TYPE_CODE_SPACE (type
))
5242 puts_filtered (" TYPE_CODE_SPACE");
5244 if (TYPE_DATA_SPACE (type
))
5246 puts_filtered (" TYPE_DATA_SPACE");
5248 if (TYPE_ADDRESS_CLASS_1 (type
))
5250 puts_filtered (" TYPE_ADDRESS_CLASS_1");
5252 if (TYPE_ADDRESS_CLASS_2 (type
))
5254 puts_filtered (" TYPE_ADDRESS_CLASS_2");
5256 if (TYPE_RESTRICT (type
))
5258 puts_filtered (" TYPE_RESTRICT");
5260 if (TYPE_ATOMIC (type
))
5262 puts_filtered (" TYPE_ATOMIC");
5264 puts_filtered ("\n");
5266 printf_filtered ("%*sflags", spaces
, "");
5267 if (type
->is_unsigned ())
5269 puts_filtered (" TYPE_UNSIGNED");
5271 if (type
->has_no_signedness ())
5273 puts_filtered (" TYPE_NOSIGN");
5275 if (type
->endianity_is_not_default ())
5277 puts_filtered (" TYPE_ENDIANITY_NOT_DEFAULT");
5279 if (type
->is_stub ())
5281 puts_filtered (" TYPE_STUB");
5283 if (type
->target_is_stub ())
5285 puts_filtered (" TYPE_TARGET_STUB");
5287 if (type
->is_prototyped ())
5289 puts_filtered (" TYPE_PROTOTYPED");
5291 if (type
->has_varargs ())
5293 puts_filtered (" TYPE_VARARGS");
5295 /* This is used for things like AltiVec registers on ppc. Gcc emits
5296 an attribute for the array type, which tells whether or not we
5297 have a vector, instead of a regular array. */
5298 if (type
->is_vector ())
5300 puts_filtered (" TYPE_VECTOR");
5302 if (type
->is_fixed_instance ())
5304 puts_filtered (" TYPE_FIXED_INSTANCE");
5306 if (type
->stub_is_supported ())
5308 puts_filtered (" TYPE_STUB_SUPPORTED");
5310 if (TYPE_NOTTEXT (type
))
5312 puts_filtered (" TYPE_NOTTEXT");
5314 puts_filtered ("\n");
5315 printf_filtered ("%*snfields %d ", spaces
, "", type
->num_fields ());
5316 if (TYPE_ASSOCIATED_PROP (type
) != nullptr
5317 || TYPE_ALLOCATED_PROP (type
) != nullptr)
5319 printf_filtered ("%*s", spaces
, "");
5320 if (TYPE_ASSOCIATED_PROP (type
) != nullptr)
5322 printf_filtered ("associated ");
5323 dump_dynamic_prop (*TYPE_ASSOCIATED_PROP (type
));
5325 if (TYPE_ALLOCATED_PROP (type
) != nullptr)
5327 if (TYPE_ASSOCIATED_PROP (type
) != nullptr)
5328 printf_filtered (" ");
5329 printf_filtered ("allocated ");
5330 dump_dynamic_prop (*TYPE_ALLOCATED_PROP (type
));
5332 printf_filtered ("\n");
5334 gdb_print_host_address (type
->fields (), gdb_stdout
);
5335 puts_filtered ("\n");
5336 for (idx
= 0; idx
< type
->num_fields (); idx
++)
5338 if (type
->code () == TYPE_CODE_ENUM
)
5339 printf_filtered ("%*s[%d] enumval %s type ", spaces
+ 2, "",
5340 idx
, plongest (type
->field (idx
).loc_enumval ()));
5342 printf_filtered ("%*s[%d] bitpos %s bitsize %d type ", spaces
+ 2, "",
5343 idx
, plongest (type
->field (idx
).loc_bitpos ()),
5344 TYPE_FIELD_BITSIZE (type
, idx
));
5345 gdb_print_host_address (type
->field (idx
).type (), gdb_stdout
);
5346 printf_filtered (" name '%s' (",
5347 type
->field (idx
).name () != NULL
5348 ? type
->field (idx
).name ()
5350 gdb_print_host_address (type
->field (idx
).name (), gdb_stdout
);
5351 printf_filtered (")\n");
5352 if (type
->field (idx
).type () != NULL
)
5354 recursive_dump_type (type
->field (idx
).type (), spaces
+ 4);
5357 if (type
->code () == TYPE_CODE_RANGE
)
5359 printf_filtered ("%*slow ", spaces
, "");
5360 dump_dynamic_prop (type
->bounds ()->low
);
5361 printf_filtered (" high ");
5362 dump_dynamic_prop (type
->bounds ()->high
);
5363 printf_filtered ("\n");
5366 switch (TYPE_SPECIFIC_FIELD (type
))
5368 case TYPE_SPECIFIC_CPLUS_STUFF
:
5369 printf_filtered ("%*scplus_stuff ", spaces
, "");
5370 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
),
5372 puts_filtered ("\n");
5373 print_cplus_stuff (type
, spaces
);
5376 case TYPE_SPECIFIC_GNAT_STUFF
:
5377 printf_filtered ("%*sgnat_stuff ", spaces
, "");
5378 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type
), gdb_stdout
);
5379 puts_filtered ("\n");
5380 print_gnat_stuff (type
, spaces
);
5383 case TYPE_SPECIFIC_FLOATFORMAT
:
5384 printf_filtered ("%*sfloatformat ", spaces
, "");
5385 if (TYPE_FLOATFORMAT (type
) == NULL
5386 || TYPE_FLOATFORMAT (type
)->name
== NULL
)
5387 puts_filtered ("(null)");
5389 puts_filtered (TYPE_FLOATFORMAT (type
)->name
);
5390 puts_filtered ("\n");
5393 case TYPE_SPECIFIC_FUNC
:
5394 printf_filtered ("%*scalling_convention %d\n", spaces
, "",
5395 TYPE_CALLING_CONVENTION (type
));
5396 /* tail_call_list is not printed. */
5399 case TYPE_SPECIFIC_SELF_TYPE
:
5400 printf_filtered ("%*sself_type ", spaces
, "");
5401 gdb_print_host_address (TYPE_SELF_TYPE (type
), gdb_stdout
);
5402 puts_filtered ("\n");
5405 case TYPE_SPECIFIC_FIXED_POINT
:
5406 printf_filtered ("%*sfixed_point_info ", spaces
, "");
5407 print_fixed_point_type_info (type
, spaces
);
5408 puts_filtered ("\n");
5411 case TYPE_SPECIFIC_INT
:
5412 if (type
->bit_size_differs_p ())
5414 unsigned bit_size
= type
->bit_size ();
5415 unsigned bit_off
= type
->bit_offset ();
5416 printf_filtered ("%*s bit size = %u, bit offset = %u\n", spaces
, "",
5423 obstack_free (&dont_print_type_obstack
, NULL
);
5426 /* Trivial helpers for the libiberty hash table, for mapping one
5429 struct type_pair
: public allocate_on_obstack
5431 type_pair (struct type
*old_
, struct type
*newobj_
)
5432 : old (old_
), newobj (newobj_
)
5435 struct type
* const old
, * const newobj
;
5439 type_pair_hash (const void *item
)
5441 const struct type_pair
*pair
= (const struct type_pair
*) item
;
5443 return htab_hash_pointer (pair
->old
);
5447 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
5449 const struct type_pair
*lhs
= (const struct type_pair
*) item_lhs
;
5450 const struct type_pair
*rhs
= (const struct type_pair
*) item_rhs
;
5452 return lhs
->old
== rhs
->old
;
5455 /* Allocate the hash table used by copy_type_recursive to walk
5456 types without duplicates. We use OBJFILE's obstack, because
5457 OBJFILE is about to be deleted. */
5460 create_copied_types_hash (struct objfile
*objfile
)
5462 return htab_up (htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
5463 NULL
, &objfile
->objfile_obstack
,
5464 hashtab_obstack_allocate
,
5465 dummy_obstack_deallocate
));
5468 /* Recursively copy (deep copy) a dynamic attribute list of a type. */
5470 static struct dynamic_prop_list
*
5471 copy_dynamic_prop_list (struct obstack
*objfile_obstack
,
5472 struct dynamic_prop_list
*list
)
5474 struct dynamic_prop_list
*copy
= list
;
5475 struct dynamic_prop_list
**node_ptr
= ©
;
5477 while (*node_ptr
!= NULL
)
5479 struct dynamic_prop_list
*node_copy
;
5481 node_copy
= ((struct dynamic_prop_list
*)
5482 obstack_copy (objfile_obstack
, *node_ptr
,
5483 sizeof (struct dynamic_prop_list
)));
5484 node_copy
->prop
= (*node_ptr
)->prop
;
5485 *node_ptr
= node_copy
;
5487 node_ptr
= &node_copy
->next
;
5493 /* Recursively copy (deep copy) TYPE, if it is associated with
5494 OBJFILE. Return a new type owned by the gdbarch associated with the type, a
5495 saved type if we have already visited TYPE (using COPIED_TYPES), or TYPE if
5496 it is not associated with OBJFILE. */
5499 copy_type_recursive (struct objfile
*objfile
,
5501 htab_t copied_types
)
5504 struct type
*new_type
;
5506 if (!type
->is_objfile_owned ())
5509 /* This type shouldn't be pointing to any types in other objfiles;
5510 if it did, the type might disappear unexpectedly. */
5511 gdb_assert (type
->objfile_owner () == objfile
);
5513 struct type_pair
pair (type
, nullptr);
5515 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
5517 return ((struct type_pair
*) *slot
)->newobj
;
5519 new_type
= alloc_type_arch (type
->arch ());
5521 /* We must add the new type to the hash table immediately, in case
5522 we encounter this type again during a recursive call below. */
5523 struct type_pair
*stored
5524 = new (&objfile
->objfile_obstack
) struct type_pair (type
, new_type
);
5528 /* Copy the common fields of types. For the main type, we simply
5529 copy the entire thing and then update specific fields as needed. */
5530 *TYPE_MAIN_TYPE (new_type
) = *TYPE_MAIN_TYPE (type
);
5532 new_type
->set_owner (type
->arch ());
5535 new_type
->set_name (xstrdup (type
->name ()));
5537 new_type
->set_instance_flags (type
->instance_flags ());
5538 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
5540 /* Copy the fields. */
5541 if (type
->num_fields ())
5545 nfields
= type
->num_fields ();
5546 new_type
->set_fields
5548 TYPE_ZALLOC (new_type
, nfields
* sizeof (struct field
)));
5550 for (i
= 0; i
< nfields
; i
++)
5552 TYPE_FIELD_ARTIFICIAL (new_type
, i
) =
5553 TYPE_FIELD_ARTIFICIAL (type
, i
);
5554 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
5555 if (type
->field (i
).type ())
5556 new_type
->field (i
).set_type
5557 (copy_type_recursive (objfile
, type
->field (i
).type (),
5559 if (type
->field (i
).name ())
5560 new_type
->field (i
).set_name (xstrdup (type
->field (i
).name ()));
5562 switch (type
->field (i
).loc_kind ())
5564 case FIELD_LOC_KIND_BITPOS
:
5565 new_type
->field (i
).set_loc_bitpos (type
->field (i
).loc_bitpos ());
5567 case FIELD_LOC_KIND_ENUMVAL
:
5568 new_type
->field (i
).set_loc_enumval (type
->field (i
).loc_enumval ());
5570 case FIELD_LOC_KIND_PHYSADDR
:
5571 new_type
->field (i
).set_loc_physaddr
5572 (type
->field (i
).loc_physaddr ());
5574 case FIELD_LOC_KIND_PHYSNAME
:
5575 new_type
->field (i
).set_loc_physname
5576 (xstrdup (type
->field (i
).loc_physname ()));
5578 case FIELD_LOC_KIND_DWARF_BLOCK
:
5579 new_type
->field (i
).set_loc_dwarf_block
5580 (type
->field (i
).loc_dwarf_block ());
5583 internal_error (__FILE__
, __LINE__
,
5584 _("Unexpected type field location kind: %d"),
5585 type
->field (i
).loc_kind ());
5590 /* For range types, copy the bounds information. */
5591 if (type
->code () == TYPE_CODE_RANGE
)
5593 range_bounds
*bounds
5594 = ((struct range_bounds
*) TYPE_ALLOC
5595 (new_type
, sizeof (struct range_bounds
)));
5597 *bounds
= *type
->bounds ();
5598 new_type
->set_bounds (bounds
);
5601 if (type
->main_type
->dyn_prop_list
!= NULL
)
5602 new_type
->main_type
->dyn_prop_list
5603 = copy_dynamic_prop_list (&objfile
->objfile_obstack
,
5604 type
->main_type
->dyn_prop_list
);
5607 /* Copy pointers to other types. */
5608 if (TYPE_TARGET_TYPE (type
))
5609 TYPE_TARGET_TYPE (new_type
) =
5610 copy_type_recursive (objfile
,
5611 TYPE_TARGET_TYPE (type
),
5614 /* Maybe copy the type_specific bits.
5616 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
5617 base classes and methods. There's no fundamental reason why we
5618 can't, but at the moment it is not needed. */
5620 switch (TYPE_SPECIFIC_FIELD (type
))
5622 case TYPE_SPECIFIC_NONE
:
5624 case TYPE_SPECIFIC_FUNC
:
5625 INIT_FUNC_SPECIFIC (new_type
);
5626 TYPE_CALLING_CONVENTION (new_type
) = TYPE_CALLING_CONVENTION (type
);
5627 TYPE_NO_RETURN (new_type
) = TYPE_NO_RETURN (type
);
5628 TYPE_TAIL_CALL_LIST (new_type
) = NULL
;
5630 case TYPE_SPECIFIC_FLOATFORMAT
:
5631 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
5633 case TYPE_SPECIFIC_CPLUS_STUFF
:
5634 INIT_CPLUS_SPECIFIC (new_type
);
5636 case TYPE_SPECIFIC_GNAT_STUFF
:
5637 INIT_GNAT_SPECIFIC (new_type
);
5639 case TYPE_SPECIFIC_SELF_TYPE
:
5640 set_type_self_type (new_type
,
5641 copy_type_recursive (objfile
, TYPE_SELF_TYPE (type
),
5644 case TYPE_SPECIFIC_FIXED_POINT
:
5645 INIT_FIXED_POINT_SPECIFIC (new_type
);
5646 new_type
->fixed_point_info ().scaling_factor
5647 = type
->fixed_point_info ().scaling_factor
;
5649 case TYPE_SPECIFIC_INT
:
5650 TYPE_SPECIFIC_FIELD (new_type
) = TYPE_SPECIFIC_INT
;
5651 TYPE_MAIN_TYPE (new_type
)->type_specific
.int_stuff
5652 = TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
;
5656 gdb_assert_not_reached ("bad type_specific_kind");
5662 /* Make a copy of the given TYPE, except that the pointer & reference
5663 types are not preserved.
5665 This function assumes that the given type has an associated objfile.
5666 This objfile is used to allocate the new type. */
5669 copy_type (const struct type
*type
)
5671 struct type
*new_type
;
5673 gdb_assert (type
->is_objfile_owned ());
5675 new_type
= alloc_type_copy (type
);
5676 new_type
->set_instance_flags (type
->instance_flags ());
5677 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
5678 memcpy (TYPE_MAIN_TYPE (new_type
), TYPE_MAIN_TYPE (type
),
5679 sizeof (struct main_type
));
5680 if (type
->main_type
->dyn_prop_list
!= NULL
)
5681 new_type
->main_type
->dyn_prop_list
5682 = copy_dynamic_prop_list (&type
->objfile_owner ()->objfile_obstack
,
5683 type
->main_type
->dyn_prop_list
);
5688 /* Helper functions to initialize architecture-specific types. */
5690 /* Allocate a type structure associated with GDBARCH and set its
5691 CODE, LENGTH, and NAME fields. */
5694 arch_type (struct gdbarch
*gdbarch
,
5695 enum type_code code
, int bit
, const char *name
)
5699 type
= alloc_type_arch (gdbarch
);
5700 set_type_code (type
, code
);
5701 gdb_assert ((bit
% TARGET_CHAR_BIT
) == 0);
5702 TYPE_LENGTH (type
) = bit
/ TARGET_CHAR_BIT
;
5705 type
->set_name (gdbarch_obstack_strdup (gdbarch
, name
));
5710 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
5711 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
5712 the type's TYPE_UNSIGNED flag. NAME is the type name. */
5715 arch_integer_type (struct gdbarch
*gdbarch
,
5716 int bit
, int unsigned_p
, const char *name
)
5720 t
= arch_type (gdbarch
, TYPE_CODE_INT
, bit
, name
);
5722 t
->set_is_unsigned (true);
5727 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
5728 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
5729 the type's TYPE_UNSIGNED flag. NAME is the type name. */
5732 arch_character_type (struct gdbarch
*gdbarch
,
5733 int bit
, int unsigned_p
, const char *name
)
5737 t
= arch_type (gdbarch
, TYPE_CODE_CHAR
, bit
, name
);
5739 t
->set_is_unsigned (true);
5744 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
5745 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
5746 the type's TYPE_UNSIGNED flag. NAME is the type name. */
5749 arch_boolean_type (struct gdbarch
*gdbarch
,
5750 int bit
, int unsigned_p
, const char *name
)
5754 t
= arch_type (gdbarch
, TYPE_CODE_BOOL
, bit
, name
);
5756 t
->set_is_unsigned (true);
5761 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
5762 BIT is the type size in bits; if BIT equals -1, the size is
5763 determined by the floatformat. NAME is the type name. Set the
5764 TYPE_FLOATFORMAT from FLOATFORMATS. */
5767 arch_float_type (struct gdbarch
*gdbarch
,
5768 int bit
, const char *name
,
5769 const struct floatformat
**floatformats
)
5771 const struct floatformat
*fmt
= floatformats
[gdbarch_byte_order (gdbarch
)];
5774 bit
= verify_floatformat (bit
, fmt
);
5775 t
= arch_type (gdbarch
, TYPE_CODE_FLT
, bit
, name
);
5776 TYPE_FLOATFORMAT (t
) = fmt
;
5781 /* Allocate a TYPE_CODE_DECFLOAT type structure associated with GDBARCH.
5782 BIT is the type size in bits. NAME is the type name. */
5785 arch_decfloat_type (struct gdbarch
*gdbarch
, int bit
, const char *name
)
5789 t
= arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, bit
, name
);
5793 /* Allocate a TYPE_CODE_PTR type structure associated with GDBARCH.
5794 BIT is the pointer type size in bits. NAME is the type name.
5795 TARGET_TYPE is the pointer target type. Always sets the pointer type's
5796 TYPE_UNSIGNED flag. */
5799 arch_pointer_type (struct gdbarch
*gdbarch
,
5800 int bit
, const char *name
, struct type
*target_type
)
5804 t
= arch_type (gdbarch
, TYPE_CODE_PTR
, bit
, name
);
5805 TYPE_TARGET_TYPE (t
) = target_type
;
5806 t
->set_is_unsigned (true);
5810 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
5811 NAME is the type name. BIT is the size of the flag word in bits. */
5814 arch_flags_type (struct gdbarch
*gdbarch
, const char *name
, int bit
)
5818 type
= arch_type (gdbarch
, TYPE_CODE_FLAGS
, bit
, name
);
5819 type
->set_is_unsigned (true);
5820 type
->set_num_fields (0);
5821 /* Pre-allocate enough space assuming every field is one bit. */
5823 ((struct field
*) TYPE_ZALLOC (type
, bit
* sizeof (struct field
)));
5828 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
5829 position BITPOS is called NAME. Pass NAME as "" for fields that
5830 should not be printed. */
5833 append_flags_type_field (struct type
*type
, int start_bitpos
, int nr_bits
,
5834 struct type
*field_type
, const char *name
)
5836 int type_bitsize
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
5837 int field_nr
= type
->num_fields ();
5839 gdb_assert (type
->code () == TYPE_CODE_FLAGS
);
5840 gdb_assert (type
->num_fields () + 1 <= type_bitsize
);
5841 gdb_assert (start_bitpos
>= 0 && start_bitpos
< type_bitsize
);
5842 gdb_assert (nr_bits
>= 1 && (start_bitpos
+ nr_bits
) <= type_bitsize
);
5843 gdb_assert (name
!= NULL
);
5845 type
->set_num_fields (type
->num_fields () + 1);
5846 type
->field (field_nr
).set_name (xstrdup (name
));
5847 type
->field (field_nr
).set_type (field_type
);
5848 type
->field (field_nr
).set_loc_bitpos (start_bitpos
);
5849 TYPE_FIELD_BITSIZE (type
, field_nr
) = nr_bits
;
5852 /* Special version of append_flags_type_field to add a flag field.
5853 Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
5854 position BITPOS is called NAME. */
5857 append_flags_type_flag (struct type
*type
, int bitpos
, const char *name
)
5859 append_flags_type_field (type
, bitpos
, 1,
5860 builtin_type (type
->arch ())->builtin_bool
,
5864 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
5865 specified by CODE) associated with GDBARCH. NAME is the type name. */
5868 arch_composite_type (struct gdbarch
*gdbarch
, const char *name
,
5869 enum type_code code
)
5873 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
5874 t
= arch_type (gdbarch
, code
, 0, NULL
);
5876 INIT_CPLUS_SPECIFIC (t
);
5880 /* Add new field with name NAME and type FIELD to composite type T.
5881 Do not set the field's position or adjust the type's length;
5882 the caller should do so. Return the new field. */
5885 append_composite_type_field_raw (struct type
*t
, const char *name
,
5890 t
->set_num_fields (t
->num_fields () + 1);
5891 t
->set_fields (XRESIZEVEC (struct field
, t
->fields (),
5893 f
= &t
->field (t
->num_fields () - 1);
5894 memset (f
, 0, sizeof f
[0]);
5895 f
[0].set_type (field
);
5896 f
[0].set_name (name
);
5900 /* Add new field with name NAME and type FIELD to composite type T.
5901 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
5904 append_composite_type_field_aligned (struct type
*t
, const char *name
,
5905 struct type
*field
, int alignment
)
5907 struct field
*f
= append_composite_type_field_raw (t
, name
, field
);
5909 if (t
->code () == TYPE_CODE_UNION
)
5911 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
5912 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
5914 else if (t
->code () == TYPE_CODE_STRUCT
)
5916 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
5917 if (t
->num_fields () > 1)
5920 (f
[-1].loc_bitpos () + (TYPE_LENGTH (f
[-1].type ()) * TARGET_CHAR_BIT
));
5926 alignment
*= TARGET_CHAR_BIT
;
5927 left
= f
[0].loc_bitpos () % alignment
;
5931 f
->set_loc_bitpos (f
[0].loc_bitpos () + (alignment
- left
));
5932 TYPE_LENGTH (t
) += (alignment
- left
) / TARGET_CHAR_BIT
;
5939 /* Add new field with name NAME and type FIELD to composite type T. */
5942 append_composite_type_field (struct type
*t
, const char *name
,
5945 append_composite_type_field_aligned (t
, name
, field
, 0);
5950 /* We manage the lifetimes of fixed_point_type_info objects by
5951 attaching them to the objfile. Currently, these objects are
5952 modified during construction, and GMP does not provide a way to
5953 hash the contents of an mpq_t; so it's a bit of a pain to hash-cons
5954 them. If we did do this, they could be moved to the per-BFD and
5955 shared across objfiles. */
5956 typedef std::vector
<std::unique_ptr
<fixed_point_type_info
>>
5957 fixed_point_type_storage
;
5959 /* Key used for managing the storage of fixed-point type info. */
5960 static const struct objfile_key
<fixed_point_type_storage
>
5961 fixed_point_objfile_key
;
5963 /* See gdbtypes.h. */
5966 allocate_fixed_point_type_info (struct type
*type
)
5968 std::unique_ptr
<fixed_point_type_info
> up (new fixed_point_type_info
);
5969 fixed_point_type_info
*info
;
5971 if (type
->is_objfile_owned ())
5973 fixed_point_type_storage
*storage
5974 = fixed_point_objfile_key
.get (type
->objfile_owner ());
5975 if (storage
== nullptr)
5976 storage
= fixed_point_objfile_key
.emplace (type
->objfile_owner ());
5978 storage
->push_back (std::move (up
));
5982 /* We just leak the memory, because that's what we do generally
5983 for non-objfile-attached types. */
5984 info
= up
.release ();
5987 type
->set_fixed_point_info (info
);
5990 /* See gdbtypes.h. */
5993 is_fixed_point_type (struct type
*type
)
5995 while (check_typedef (type
)->code () == TYPE_CODE_RANGE
)
5996 type
= TYPE_TARGET_TYPE (check_typedef (type
));
5997 type
= check_typedef (type
);
5999 return type
->code () == TYPE_CODE_FIXED_POINT
;
6002 /* See gdbtypes.h. */
6005 type::fixed_point_type_base_type ()
6007 struct type
*type
= this;
6009 while (check_typedef (type
)->code () == TYPE_CODE_RANGE
)
6010 type
= TYPE_TARGET_TYPE (check_typedef (type
));
6011 type
= check_typedef (type
);
6013 gdb_assert (type
->code () == TYPE_CODE_FIXED_POINT
);
6017 /* See gdbtypes.h. */
6020 type::fixed_point_scaling_factor ()
6022 struct type
*type
= this->fixed_point_type_base_type ();
6024 return type
->fixed_point_info ().scaling_factor
;
6029 static struct gdbarch_data
*gdbtypes_data
;
6031 const struct builtin_type
*
6032 builtin_type (struct gdbarch
*gdbarch
)
6034 return (const struct builtin_type
*) gdbarch_data (gdbarch
, gdbtypes_data
);
6038 gdbtypes_post_init (struct gdbarch
*gdbarch
)
6040 struct builtin_type
*builtin_type
6041 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
6044 builtin_type
->builtin_void
6045 = arch_type (gdbarch
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, "void");
6046 builtin_type
->builtin_char
6047 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
6048 !gdbarch_char_signed (gdbarch
), "char");
6049 builtin_type
->builtin_char
->set_has_no_signedness (true);
6050 builtin_type
->builtin_signed_char
6051 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
6053 builtin_type
->builtin_unsigned_char
6054 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
6055 1, "unsigned char");
6056 builtin_type
->builtin_short
6057 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
6059 builtin_type
->builtin_unsigned_short
6060 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
6061 1, "unsigned short");
6062 builtin_type
->builtin_int
6063 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
6065 builtin_type
->builtin_unsigned_int
6066 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
6068 builtin_type
->builtin_long
6069 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
6071 builtin_type
->builtin_unsigned_long
6072 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
6073 1, "unsigned long");
6074 builtin_type
->builtin_long_long
6075 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
6077 builtin_type
->builtin_unsigned_long_long
6078 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
6079 1, "unsigned long long");
6080 builtin_type
->builtin_half
6081 = arch_float_type (gdbarch
, gdbarch_half_bit (gdbarch
),
6082 "half", gdbarch_half_format (gdbarch
));
6083 builtin_type
->builtin_float
6084 = arch_float_type (gdbarch
, gdbarch_float_bit (gdbarch
),
6085 "float", gdbarch_float_format (gdbarch
));
6086 builtin_type
->builtin_bfloat16
6087 = arch_float_type (gdbarch
, gdbarch_bfloat16_bit (gdbarch
),
6088 "bfloat16", gdbarch_bfloat16_format (gdbarch
));
6089 builtin_type
->builtin_double
6090 = arch_float_type (gdbarch
, gdbarch_double_bit (gdbarch
),
6091 "double", gdbarch_double_format (gdbarch
));
6092 builtin_type
->builtin_long_double
6093 = arch_float_type (gdbarch
, gdbarch_long_double_bit (gdbarch
),
6094 "long double", gdbarch_long_double_format (gdbarch
));
6095 builtin_type
->builtin_complex
6096 = init_complex_type ("complex", builtin_type
->builtin_float
);
6097 builtin_type
->builtin_double_complex
6098 = init_complex_type ("double complex", builtin_type
->builtin_double
);
6099 builtin_type
->builtin_string
6100 = arch_type (gdbarch
, TYPE_CODE_STRING
, TARGET_CHAR_BIT
, "string");
6101 builtin_type
->builtin_bool
6102 = arch_boolean_type (gdbarch
, TARGET_CHAR_BIT
, 1, "bool");
6104 /* The following three are about decimal floating point types, which
6105 are 32-bits, 64-bits and 128-bits respectively. */
6106 builtin_type
->builtin_decfloat
6107 = arch_decfloat_type (gdbarch
, 32, "_Decimal32");
6108 builtin_type
->builtin_decdouble
6109 = arch_decfloat_type (gdbarch
, 64, "_Decimal64");
6110 builtin_type
->builtin_declong
6111 = arch_decfloat_type (gdbarch
, 128, "_Decimal128");
6113 /* "True" character types. */
6114 builtin_type
->builtin_true_char
6115 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 0, "true character");
6116 builtin_type
->builtin_true_unsigned_char
6117 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 1, "true character");
6119 /* Fixed-size integer types. */
6120 builtin_type
->builtin_int0
6121 = arch_integer_type (gdbarch
, 0, 0, "int0_t");
6122 builtin_type
->builtin_int8
6123 = arch_integer_type (gdbarch
, 8, 0, "int8_t");
6124 builtin_type
->builtin_uint8
6125 = arch_integer_type (gdbarch
, 8, 1, "uint8_t");
6126 builtin_type
->builtin_int16
6127 = arch_integer_type (gdbarch
, 16, 0, "int16_t");
6128 builtin_type
->builtin_uint16
6129 = arch_integer_type (gdbarch
, 16, 1, "uint16_t");
6130 builtin_type
->builtin_int24
6131 = arch_integer_type (gdbarch
, 24, 0, "int24_t");
6132 builtin_type
->builtin_uint24
6133 = arch_integer_type (gdbarch
, 24, 1, "uint24_t");
6134 builtin_type
->builtin_int32
6135 = arch_integer_type (gdbarch
, 32, 0, "int32_t");
6136 builtin_type
->builtin_uint32
6137 = arch_integer_type (gdbarch
, 32, 1, "uint32_t");
6138 builtin_type
->builtin_int64
6139 = arch_integer_type (gdbarch
, 64, 0, "int64_t");
6140 builtin_type
->builtin_uint64
6141 = arch_integer_type (gdbarch
, 64, 1, "uint64_t");
6142 builtin_type
->builtin_int128
6143 = arch_integer_type (gdbarch
, 128, 0, "int128_t");
6144 builtin_type
->builtin_uint128
6145 = arch_integer_type (gdbarch
, 128, 1, "uint128_t");
6147 builtin_type
->builtin_int8
->set_instance_flags
6148 (builtin_type
->builtin_int8
->instance_flags ()
6149 | TYPE_INSTANCE_FLAG_NOTTEXT
);
6151 builtin_type
->builtin_uint8
->set_instance_flags
6152 (builtin_type
->builtin_uint8
->instance_flags ()
6153 | TYPE_INSTANCE_FLAG_NOTTEXT
);
6155 /* Wide character types. */
6156 builtin_type
->builtin_char16
6157 = arch_integer_type (gdbarch
, 16, 1, "char16_t");
6158 builtin_type
->builtin_char32
6159 = arch_integer_type (gdbarch
, 32, 1, "char32_t");
6160 builtin_type
->builtin_wchar
6161 = arch_integer_type (gdbarch
, gdbarch_wchar_bit (gdbarch
),
6162 !gdbarch_wchar_signed (gdbarch
), "wchar_t");
6164 /* Default data/code pointer types. */
6165 builtin_type
->builtin_data_ptr
6166 = lookup_pointer_type (builtin_type
->builtin_void
);
6167 builtin_type
->builtin_func_ptr
6168 = lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
6169 builtin_type
->builtin_func_func
6170 = lookup_function_type (builtin_type
->builtin_func_ptr
);
6172 /* This type represents a GDB internal function. */
6173 builtin_type
->internal_fn
6174 = arch_type (gdbarch
, TYPE_CODE_INTERNAL_FUNCTION
, 0,
6175 "<internal function>");
6177 /* This type represents an xmethod. */
6178 builtin_type
->xmethod
6179 = arch_type (gdbarch
, TYPE_CODE_XMETHOD
, 0, "<xmethod>");
6181 return builtin_type
;
6184 /* This set of objfile-based types is intended to be used by symbol
6185 readers as basic types. */
6187 static const struct objfile_key
<struct objfile_type
,
6188 gdb::noop_deleter
<struct objfile_type
>>
6191 const struct objfile_type
*
6192 objfile_type (struct objfile
*objfile
)
6194 struct gdbarch
*gdbarch
;
6195 struct objfile_type
*objfile_type
= objfile_type_data
.get (objfile
);
6198 return objfile_type
;
6200 objfile_type
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
6201 1, struct objfile_type
);
6203 /* Use the objfile architecture to determine basic type properties. */
6204 gdbarch
= objfile
->arch ();
6207 objfile_type
->builtin_void
6208 = init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, "void");
6209 objfile_type
->builtin_char
6210 = init_integer_type (objfile
, TARGET_CHAR_BIT
,
6211 !gdbarch_char_signed (gdbarch
), "char");
6212 objfile_type
->builtin_char
->set_has_no_signedness (true);
6213 objfile_type
->builtin_signed_char
6214 = init_integer_type (objfile
, TARGET_CHAR_BIT
,
6216 objfile_type
->builtin_unsigned_char
6217 = init_integer_type (objfile
, TARGET_CHAR_BIT
,
6218 1, "unsigned char");
6219 objfile_type
->builtin_short
6220 = init_integer_type (objfile
, gdbarch_short_bit (gdbarch
),
6222 objfile_type
->builtin_unsigned_short
6223 = init_integer_type (objfile
, gdbarch_short_bit (gdbarch
),
6224 1, "unsigned short");
6225 objfile_type
->builtin_int
6226 = init_integer_type (objfile
, gdbarch_int_bit (gdbarch
),
6228 objfile_type
->builtin_unsigned_int
6229 = init_integer_type (objfile
, gdbarch_int_bit (gdbarch
),
6231 objfile_type
->builtin_long
6232 = init_integer_type (objfile
, gdbarch_long_bit (gdbarch
),
6234 objfile_type
->builtin_unsigned_long
6235 = init_integer_type (objfile
, gdbarch_long_bit (gdbarch
),
6236 1, "unsigned long");
6237 objfile_type
->builtin_long_long
6238 = init_integer_type (objfile
, gdbarch_long_long_bit (gdbarch
),
6240 objfile_type
->builtin_unsigned_long_long
6241 = init_integer_type (objfile
, gdbarch_long_long_bit (gdbarch
),
6242 1, "unsigned long long");
6243 objfile_type
->builtin_float
6244 = init_float_type (objfile
, gdbarch_float_bit (gdbarch
),
6245 "float", gdbarch_float_format (gdbarch
));
6246 objfile_type
->builtin_double
6247 = init_float_type (objfile
, gdbarch_double_bit (gdbarch
),
6248 "double", gdbarch_double_format (gdbarch
));
6249 objfile_type
->builtin_long_double
6250 = init_float_type (objfile
, gdbarch_long_double_bit (gdbarch
),
6251 "long double", gdbarch_long_double_format (gdbarch
));
6253 /* This type represents a type that was unrecognized in symbol read-in. */
6254 objfile_type
->builtin_error
6255 = init_type (objfile
, TYPE_CODE_ERROR
, 0, "<unknown type>");
6257 /* The following set of types is used for symbols with no
6258 debug information. */
6259 objfile_type
->nodebug_text_symbol
6260 = init_type (objfile
, TYPE_CODE_FUNC
, TARGET_CHAR_BIT
,
6261 "<text variable, no debug info>");
6263 objfile_type
->nodebug_text_gnu_ifunc_symbol
6264 = init_type (objfile
, TYPE_CODE_FUNC
, TARGET_CHAR_BIT
,
6265 "<text gnu-indirect-function variable, no debug info>");
6266 objfile_type
->nodebug_text_gnu_ifunc_symbol
->set_is_gnu_ifunc (true);
6268 objfile_type
->nodebug_got_plt_symbol
6269 = init_pointer_type (objfile
, gdbarch_addr_bit (gdbarch
),
6270 "<text from jump slot in .got.plt, no debug info>",
6271 objfile_type
->nodebug_text_symbol
);
6272 objfile_type
->nodebug_data_symbol
6273 = init_nodebug_var_type (objfile
, "<data variable, no debug info>");
6274 objfile_type
->nodebug_unknown_symbol
6275 = init_nodebug_var_type (objfile
, "<variable (not text or data), no debug info>");
6276 objfile_type
->nodebug_tls_symbol
6277 = init_nodebug_var_type (objfile
, "<thread local variable, no debug info>");
6279 /* NOTE: on some targets, addresses and pointers are not necessarily
6283 - gdb's `struct type' always describes the target's
6285 - gdb's `struct value' objects should always hold values in
6287 - gdb's CORE_ADDR values are addresses in the unified virtual
6288 address space that the assembler and linker work with. Thus,
6289 since target_read_memory takes a CORE_ADDR as an argument, it
6290 can access any memory on the target, even if the processor has
6291 separate code and data address spaces.
6293 In this context, objfile_type->builtin_core_addr is a bit odd:
6294 it's a target type for a value the target will never see. It's
6295 only used to hold the values of (typeless) linker symbols, which
6296 are indeed in the unified virtual address space. */
6298 objfile_type
->builtin_core_addr
6299 = init_integer_type (objfile
, gdbarch_addr_bit (gdbarch
), 1,
6302 objfile_type_data
.set (objfile
, objfile_type
);
6303 return objfile_type
;
6306 /* See gdbtypes.h. */
6309 call_site::pc () const
6311 compunit_symtab
*cust
= this->per_objfile
->get_symtab (this->per_cu
);
6313 = this->per_objfile
->objfile
->section_offsets
[COMPUNIT_BLOCK_LINE_SECTION (cust
)];
6314 return m_unrelocated_pc
+ delta
;
6317 void _initialize_gdbtypes ();
6319 _initialize_gdbtypes ()
6321 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
6323 add_setshow_zuinteger_cmd ("overload", no_class
, &overload_debug
,
6324 _("Set debugging of C++ overloading."),
6325 _("Show debugging of C++ overloading."),
6326 _("When enabled, ranking of the "
6327 "functions is displayed."),
6329 show_overload_debug
,
6330 &setdebuglist
, &showdebuglist
);
6332 /* Add user knob for controlling resolution of opaque types. */
6333 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
6334 &opaque_type_resolution
,
6335 _("Set resolution of opaque struct/class/union"
6336 " types (if set before loading symbols)."),
6337 _("Show resolution of opaque struct/class/union"
6338 " types (if set before loading symbols)."),
6340 show_opaque_type_resolution
,
6341 &setlist
, &showlist
);
6343 /* Add an option to permit non-strict type checking. */
6344 add_setshow_boolean_cmd ("type", class_support
,
6345 &strict_type_checking
,
6346 _("Set strict type checking."),
6347 _("Show strict type checking."),
6349 show_strict_type_checking
,
6350 &setchecklist
, &showchecklist
);