1 /* Support routines for manipulating internal types for GDB.
3 Copyright (C) 1992-2017 Free Software Foundation, Inc.
5 Contributed by Cygnus Support, using pieces from other GDB modules.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
28 #include "expression.h"
33 #include "complaints.h"
37 #include "cp-support.h"
39 #include "dwarf2loc.h"
41 #include "floatformat.h"
43 /* Initialize BADNESS constants. */
45 const struct rank LENGTH_MISMATCH_BADNESS
= {100,0};
47 const struct rank TOO_FEW_PARAMS_BADNESS
= {100,0};
48 const struct rank INCOMPATIBLE_TYPE_BADNESS
= {100,0};
50 const struct rank EXACT_MATCH_BADNESS
= {0,0};
52 const struct rank INTEGER_PROMOTION_BADNESS
= {1,0};
53 const struct rank FLOAT_PROMOTION_BADNESS
= {1,0};
54 const struct rank BASE_PTR_CONVERSION_BADNESS
= {1,0};
55 const struct rank CV_CONVERSION_BADNESS
= {1, 0};
56 const struct rank INTEGER_CONVERSION_BADNESS
= {2,0};
57 const struct rank FLOAT_CONVERSION_BADNESS
= {2,0};
58 const struct rank INT_FLOAT_CONVERSION_BADNESS
= {2,0};
59 const struct rank VOID_PTR_CONVERSION_BADNESS
= {2,0};
60 const struct rank BOOL_CONVERSION_BADNESS
= {3,0};
61 const struct rank BASE_CONVERSION_BADNESS
= {2,0};
62 const struct rank REFERENCE_CONVERSION_BADNESS
= {2,0};
63 const struct rank NULL_POINTER_CONVERSION_BADNESS
= {2,0};
64 const struct rank NS_POINTER_CONVERSION_BADNESS
= {10,0};
65 const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS
= {3,0};
67 /* Floatformat pairs. */
68 const struct floatformat
*floatformats_ieee_half
[BFD_ENDIAN_UNKNOWN
] = {
69 &floatformat_ieee_half_big
,
70 &floatformat_ieee_half_little
72 const struct floatformat
*floatformats_ieee_single
[BFD_ENDIAN_UNKNOWN
] = {
73 &floatformat_ieee_single_big
,
74 &floatformat_ieee_single_little
76 const struct floatformat
*floatformats_ieee_double
[BFD_ENDIAN_UNKNOWN
] = {
77 &floatformat_ieee_double_big
,
78 &floatformat_ieee_double_little
80 const struct floatformat
*floatformats_ieee_double_littlebyte_bigword
[BFD_ENDIAN_UNKNOWN
] = {
81 &floatformat_ieee_double_big
,
82 &floatformat_ieee_double_littlebyte_bigword
84 const struct floatformat
*floatformats_i387_ext
[BFD_ENDIAN_UNKNOWN
] = {
85 &floatformat_i387_ext
,
88 const struct floatformat
*floatformats_m68881_ext
[BFD_ENDIAN_UNKNOWN
] = {
89 &floatformat_m68881_ext
,
90 &floatformat_m68881_ext
92 const struct floatformat
*floatformats_arm_ext
[BFD_ENDIAN_UNKNOWN
] = {
93 &floatformat_arm_ext_big
,
94 &floatformat_arm_ext_littlebyte_bigword
96 const struct floatformat
*floatformats_ia64_spill
[BFD_ENDIAN_UNKNOWN
] = {
97 &floatformat_ia64_spill_big
,
98 &floatformat_ia64_spill_little
100 const struct floatformat
*floatformats_ia64_quad
[BFD_ENDIAN_UNKNOWN
] = {
101 &floatformat_ia64_quad_big
,
102 &floatformat_ia64_quad_little
104 const struct floatformat
*floatformats_vax_f
[BFD_ENDIAN_UNKNOWN
] = {
108 const struct floatformat
*floatformats_vax_d
[BFD_ENDIAN_UNKNOWN
] = {
112 const struct floatformat
*floatformats_ibm_long_double
[BFD_ENDIAN_UNKNOWN
] = {
113 &floatformat_ibm_long_double_big
,
114 &floatformat_ibm_long_double_little
117 /* Should opaque types be resolved? */
119 static int opaque_type_resolution
= 1;
121 /* A flag to enable printing of debugging information of C++
124 unsigned int overload_debug
= 0;
126 /* A flag to enable strict type checking. */
128 static int strict_type_checking
= 1;
130 /* A function to show whether opaque types are resolved. */
133 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
134 struct cmd_list_element
*c
,
137 fprintf_filtered (file
, _("Resolution of opaque struct/class/union types "
138 "(if set before loading symbols) is %s.\n"),
142 /* A function to show whether C++ overload debugging is enabled. */
145 show_overload_debug (struct ui_file
*file
, int from_tty
,
146 struct cmd_list_element
*c
, const char *value
)
148 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"),
152 /* A function to show the status of strict type checking. */
155 show_strict_type_checking (struct ui_file
*file
, int from_tty
,
156 struct cmd_list_element
*c
, const char *value
)
158 fprintf_filtered (file
, _("Strict type checking is %s.\n"), value
);
162 /* Allocate a new OBJFILE-associated type structure and fill it
163 with some defaults. Space for the type structure is allocated
164 on the objfile's objfile_obstack. */
167 alloc_type (struct objfile
*objfile
)
171 gdb_assert (objfile
!= NULL
);
173 /* Alloc the structure and start off with all fields zeroed. */
174 type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct type
);
175 TYPE_MAIN_TYPE (type
) = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
177 OBJSTAT (objfile
, n_types
++);
179 TYPE_OBJFILE_OWNED (type
) = 1;
180 TYPE_OWNER (type
).objfile
= objfile
;
182 /* Initialize the fields that might not be zero. */
184 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
185 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
190 /* Allocate a new GDBARCH-associated type structure and fill it
191 with some defaults. Space for the type structure is allocated
192 on the obstack associated with GDBARCH. */
195 alloc_type_arch (struct gdbarch
*gdbarch
)
199 gdb_assert (gdbarch
!= NULL
);
201 /* Alloc the structure and start off with all fields zeroed. */
203 type
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct type
);
204 TYPE_MAIN_TYPE (type
) = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct main_type
);
206 TYPE_OBJFILE_OWNED (type
) = 0;
207 TYPE_OWNER (type
).gdbarch
= gdbarch
;
209 /* Initialize the fields that might not be zero. */
211 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
212 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
217 /* If TYPE is objfile-associated, allocate a new type structure
218 associated with the same objfile. If TYPE is gdbarch-associated,
219 allocate a new type structure associated with the same gdbarch. */
222 alloc_type_copy (const struct type
*type
)
224 if (TYPE_OBJFILE_OWNED (type
))
225 return alloc_type (TYPE_OWNER (type
).objfile
);
227 return alloc_type_arch (TYPE_OWNER (type
).gdbarch
);
230 /* If TYPE is gdbarch-associated, return that architecture.
231 If TYPE is objfile-associated, return that objfile's architecture. */
234 get_type_arch (const struct type
*type
)
236 if (TYPE_OBJFILE_OWNED (type
))
237 return get_objfile_arch (TYPE_OWNER (type
).objfile
);
239 return TYPE_OWNER (type
).gdbarch
;
242 /* See gdbtypes.h. */
245 get_target_type (struct type
*type
)
249 type
= TYPE_TARGET_TYPE (type
);
251 type
= check_typedef (type
);
257 /* See gdbtypes.h. */
260 type_length_units (struct type
*type
)
262 struct gdbarch
*arch
= get_type_arch (type
);
263 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
265 return TYPE_LENGTH (type
) / unit_size
;
268 /* Alloc a new type instance structure, fill it with some defaults,
269 and point it at OLDTYPE. Allocate the new type instance from the
270 same place as OLDTYPE. */
273 alloc_type_instance (struct type
*oldtype
)
277 /* Allocate the structure. */
279 if (! TYPE_OBJFILE_OWNED (oldtype
))
280 type
= XCNEW (struct type
);
282 type
= OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype
)->objfile_obstack
,
285 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
287 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
292 /* Clear all remnants of the previous type at TYPE, in preparation for
293 replacing it with something else. Preserve owner information. */
296 smash_type (struct type
*type
)
298 int objfile_owned
= TYPE_OBJFILE_OWNED (type
);
299 union type_owner owner
= TYPE_OWNER (type
);
301 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
303 /* Restore owner information. */
304 TYPE_OBJFILE_OWNED (type
) = objfile_owned
;
305 TYPE_OWNER (type
) = owner
;
307 /* For now, delete the rings. */
308 TYPE_CHAIN (type
) = type
;
310 /* For now, leave the pointer/reference types alone. */
313 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
314 to a pointer to memory where the pointer type should be stored.
315 If *TYPEPTR is zero, update it to point to the pointer type we return.
316 We allocate new memory if needed. */
319 make_pointer_type (struct type
*type
, struct type
**typeptr
)
321 struct type
*ntype
; /* New type */
324 ntype
= TYPE_POINTER_TYPE (type
);
329 return ntype
; /* Don't care about alloc,
330 and have new type. */
331 else if (*typeptr
== 0)
333 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
338 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
340 ntype
= alloc_type_copy (type
);
344 else /* We have storage, but need to reset it. */
347 chain
= TYPE_CHAIN (ntype
);
349 TYPE_CHAIN (ntype
) = chain
;
352 TYPE_TARGET_TYPE (ntype
) = type
;
353 TYPE_POINTER_TYPE (type
) = ntype
;
355 /* FIXME! Assumes the machine has only one representation for pointers! */
358 = gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
359 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
361 /* Mark pointers as unsigned. The target converts between pointers
362 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
363 gdbarch_address_to_pointer. */
364 TYPE_UNSIGNED (ntype
) = 1;
366 /* Update the length of all the other variants of this type. */
367 chain
= TYPE_CHAIN (ntype
);
368 while (chain
!= ntype
)
370 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
371 chain
= TYPE_CHAIN (chain
);
377 /* Given a type TYPE, return a type of pointers to that type.
378 May need to construct such a type if this is the first use. */
381 lookup_pointer_type (struct type
*type
)
383 return make_pointer_type (type
, (struct type
**) 0);
386 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
387 points to a pointer to memory where the reference type should be
388 stored. If *TYPEPTR is zero, update it to point to the reference
389 type we return. We allocate new memory if needed. REFCODE denotes
390 the kind of reference type to lookup (lvalue or rvalue reference). */
393 make_reference_type (struct type
*type
, struct type
**typeptr
,
394 enum type_code refcode
)
396 struct type
*ntype
; /* New type */
397 struct type
**reftype
;
400 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
402 ntype
= (refcode
== TYPE_CODE_REF
? TYPE_REFERENCE_TYPE (type
)
403 : TYPE_RVALUE_REFERENCE_TYPE (type
));
408 return ntype
; /* Don't care about alloc,
409 and have new type. */
410 else if (*typeptr
== 0)
412 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
417 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
419 ntype
= alloc_type_copy (type
);
423 else /* We have storage, but need to reset it. */
426 chain
= TYPE_CHAIN (ntype
);
428 TYPE_CHAIN (ntype
) = chain
;
431 TYPE_TARGET_TYPE (ntype
) = type
;
432 reftype
= (refcode
== TYPE_CODE_REF
? &TYPE_REFERENCE_TYPE (type
)
433 : &TYPE_RVALUE_REFERENCE_TYPE (type
));
437 /* FIXME! Assume the machine has only one representation for
438 references, and that it matches the (only) representation for
441 TYPE_LENGTH (ntype
) =
442 gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
443 TYPE_CODE (ntype
) = refcode
;
447 /* Update the length of all the other variants of this type. */
448 chain
= TYPE_CHAIN (ntype
);
449 while (chain
!= ntype
)
451 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
452 chain
= TYPE_CHAIN (chain
);
458 /* Same as above, but caller doesn't care about memory allocation
462 lookup_reference_type (struct type
*type
, enum type_code refcode
)
464 return make_reference_type (type
, (struct type
**) 0, refcode
);
467 /* Lookup the lvalue reference type for the type TYPE. */
470 lookup_lvalue_reference_type (struct type
*type
)
472 return lookup_reference_type (type
, TYPE_CODE_REF
);
475 /* Lookup the rvalue reference type for the type TYPE. */
478 lookup_rvalue_reference_type (struct type
*type
)
480 return lookup_reference_type (type
, TYPE_CODE_RVALUE_REF
);
483 /* Lookup a function type that returns type TYPE. TYPEPTR, if
484 nonzero, points to a pointer to memory where the function type
485 should be stored. If *TYPEPTR is zero, update it to point to the
486 function type we return. We allocate new memory if needed. */
489 make_function_type (struct type
*type
, struct type
**typeptr
)
491 struct type
*ntype
; /* New type */
493 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
495 ntype
= alloc_type_copy (type
);
499 else /* We have storage, but need to reset it. */
505 TYPE_TARGET_TYPE (ntype
) = type
;
507 TYPE_LENGTH (ntype
) = 1;
508 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
510 INIT_FUNC_SPECIFIC (ntype
);
515 /* Given a type TYPE, return a type of functions that return that type.
516 May need to construct such a type if this is the first use. */
519 lookup_function_type (struct type
*type
)
521 return make_function_type (type
, (struct type
**) 0);
524 /* Given a type TYPE and argument types, return the appropriate
525 function type. If the final type in PARAM_TYPES is NULL, make a
529 lookup_function_type_with_arguments (struct type
*type
,
531 struct type
**param_types
)
533 struct type
*fn
= make_function_type (type
, (struct type
**) 0);
538 if (param_types
[nparams
- 1] == NULL
)
541 TYPE_VARARGS (fn
) = 1;
543 else if (TYPE_CODE (check_typedef (param_types
[nparams
- 1]))
547 /* Caller should have ensured this. */
548 gdb_assert (nparams
== 0);
549 TYPE_PROTOTYPED (fn
) = 1;
552 TYPE_PROTOTYPED (fn
) = 1;
555 TYPE_NFIELDS (fn
) = nparams
;
557 = (struct field
*) TYPE_ZALLOC (fn
, nparams
* sizeof (struct field
));
558 for (i
= 0; i
< nparams
; ++i
)
559 TYPE_FIELD_TYPE (fn
, i
) = param_types
[i
];
564 /* Identify address space identifier by name --
565 return the integer flag defined in gdbtypes.h. */
568 address_space_name_to_int (struct gdbarch
*gdbarch
, char *space_identifier
)
572 /* Check for known address space delimiters. */
573 if (!strcmp (space_identifier
, "code"))
574 return TYPE_INSTANCE_FLAG_CODE_SPACE
;
575 else if (!strcmp (space_identifier
, "data"))
576 return TYPE_INSTANCE_FLAG_DATA_SPACE
;
577 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
578 && gdbarch_address_class_name_to_type_flags (gdbarch
,
583 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
586 /* Identify address space identifier by integer flag as defined in
587 gdbtypes.h -- return the string version of the adress space name. */
590 address_space_int_to_name (struct gdbarch
*gdbarch
, int space_flag
)
592 if (space_flag
& TYPE_INSTANCE_FLAG_CODE_SPACE
)
594 else if (space_flag
& TYPE_INSTANCE_FLAG_DATA_SPACE
)
596 else if ((space_flag
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
597 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
598 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
603 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
605 If STORAGE is non-NULL, create the new type instance there.
606 STORAGE must be in the same obstack as TYPE. */
609 make_qualified_type (struct type
*type
, int new_flags
,
610 struct type
*storage
)
617 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
619 ntype
= TYPE_CHAIN (ntype
);
621 while (ntype
!= type
);
623 /* Create a new type instance. */
625 ntype
= alloc_type_instance (type
);
628 /* If STORAGE was provided, it had better be in the same objfile
629 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
630 if one objfile is freed and the other kept, we'd have
631 dangling pointers. */
632 gdb_assert (TYPE_OBJFILE (type
) == TYPE_OBJFILE (storage
));
635 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
636 TYPE_CHAIN (ntype
) = ntype
;
639 /* Pointers or references to the original type are not relevant to
641 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
642 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
644 /* Chain the new qualified type to the old type. */
645 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
646 TYPE_CHAIN (type
) = ntype
;
648 /* Now set the instance flags and return the new type. */
649 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
651 /* Set length of new type to that of the original type. */
652 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
657 /* Make an address-space-delimited variant of a type -- a type that
658 is identical to the one supplied except that it has an address
659 space attribute attached to it (such as "code" or "data").
661 The space attributes "code" and "data" are for Harvard
662 architectures. The address space attributes are for architectures
663 which have alternately sized pointers or pointers with alternate
667 make_type_with_address_space (struct type
*type
, int space_flag
)
669 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
670 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
671 | TYPE_INSTANCE_FLAG_DATA_SPACE
672 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
))
675 return make_qualified_type (type
, new_flags
, NULL
);
678 /* Make a "c-v" variant of a type -- a type that is identical to the
679 one supplied except that it may have const or volatile attributes
680 CNST is a flag for setting the const attribute
681 VOLTL is a flag for setting the volatile attribute
682 TYPE is the base type whose variant we are creating.
684 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
685 storage to hold the new qualified type; *TYPEPTR and TYPE must be
686 in the same objfile. Otherwise, allocate fresh memory for the new
687 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
688 new type we construct. */
691 make_cv_type (int cnst
, int voltl
,
693 struct type
**typeptr
)
695 struct type
*ntype
; /* New type */
697 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
698 & ~(TYPE_INSTANCE_FLAG_CONST
699 | TYPE_INSTANCE_FLAG_VOLATILE
));
702 new_flags
|= TYPE_INSTANCE_FLAG_CONST
;
705 new_flags
|= TYPE_INSTANCE_FLAG_VOLATILE
;
707 if (typeptr
&& *typeptr
!= NULL
)
709 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
710 a C-V variant chain that threads across objfiles: if one
711 objfile gets freed, then the other has a broken C-V chain.
713 This code used to try to copy over the main type from TYPE to
714 *TYPEPTR if they were in different objfiles, but that's
715 wrong, too: TYPE may have a field list or member function
716 lists, which refer to types of their own, etc. etc. The
717 whole shebang would need to be copied over recursively; you
718 can't have inter-objfile pointers. The only thing to do is
719 to leave stub types as stub types, and look them up afresh by
720 name each time you encounter them. */
721 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
));
724 ntype
= make_qualified_type (type
, new_flags
,
725 typeptr
? *typeptr
: NULL
);
733 /* Make a 'restrict'-qualified version of TYPE. */
736 make_restrict_type (struct type
*type
)
738 return make_qualified_type (type
,
739 (TYPE_INSTANCE_FLAGS (type
)
740 | TYPE_INSTANCE_FLAG_RESTRICT
),
744 /* Make a type without const, volatile, or restrict. */
747 make_unqualified_type (struct type
*type
)
749 return make_qualified_type (type
,
750 (TYPE_INSTANCE_FLAGS (type
)
751 & ~(TYPE_INSTANCE_FLAG_CONST
752 | TYPE_INSTANCE_FLAG_VOLATILE
753 | TYPE_INSTANCE_FLAG_RESTRICT
)),
757 /* Make a '_Atomic'-qualified version of TYPE. */
760 make_atomic_type (struct type
*type
)
762 return make_qualified_type (type
,
763 (TYPE_INSTANCE_FLAGS (type
)
764 | TYPE_INSTANCE_FLAG_ATOMIC
),
768 /* Replace the contents of ntype with the type *type. This changes the
769 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
770 the changes are propogated to all types in the TYPE_CHAIN.
772 In order to build recursive types, it's inevitable that we'll need
773 to update types in place --- but this sort of indiscriminate
774 smashing is ugly, and needs to be replaced with something more
775 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
776 clear if more steps are needed. */
779 replace_type (struct type
*ntype
, struct type
*type
)
783 /* These two types had better be in the same objfile. Otherwise,
784 the assignment of one type's main type structure to the other
785 will produce a type with references to objects (names; field
786 lists; etc.) allocated on an objfile other than its own. */
787 gdb_assert (TYPE_OBJFILE (ntype
) == TYPE_OBJFILE (type
));
789 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
791 /* The type length is not a part of the main type. Update it for
792 each type on the variant chain. */
796 /* Assert that this element of the chain has no address-class bits
797 set in its flags. Such type variants might have type lengths
798 which are supposed to be different from the non-address-class
799 variants. This assertion shouldn't ever be triggered because
800 symbol readers which do construct address-class variants don't
801 call replace_type(). */
802 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
804 TYPE_LENGTH (chain
) = TYPE_LENGTH (type
);
805 chain
= TYPE_CHAIN (chain
);
807 while (ntype
!= chain
);
809 /* Assert that the two types have equivalent instance qualifiers.
810 This should be true for at least all of our debug readers. */
811 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
814 /* Implement direct support for MEMBER_TYPE in GNU C++.
815 May need to construct such a type if this is the first use.
816 The TYPE is the type of the member. The DOMAIN is the type
817 of the aggregate that the member belongs to. */
820 lookup_memberptr_type (struct type
*type
, struct type
*domain
)
824 mtype
= alloc_type_copy (type
);
825 smash_to_memberptr_type (mtype
, domain
, type
);
829 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
832 lookup_methodptr_type (struct type
*to_type
)
836 mtype
= alloc_type_copy (to_type
);
837 smash_to_methodptr_type (mtype
, to_type
);
841 /* Allocate a stub method whose return type is TYPE. This apparently
842 happens for speed of symbol reading, since parsing out the
843 arguments to the method is cpu-intensive, the way we are doing it.
844 So, we will fill in arguments later. This always returns a fresh
848 allocate_stub_method (struct type
*type
)
852 mtype
= alloc_type_copy (type
);
853 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
854 TYPE_LENGTH (mtype
) = 1;
855 TYPE_STUB (mtype
) = 1;
856 TYPE_TARGET_TYPE (mtype
) = type
;
857 /* TYPE_SELF_TYPE (mtype) = unknown yet */
861 /* Create a range type with a dynamic range from LOW_BOUND to
862 HIGH_BOUND, inclusive. See create_range_type for further details. */
865 create_range_type (struct type
*result_type
, struct type
*index_type
,
866 const struct dynamic_prop
*low_bound
,
867 const struct dynamic_prop
*high_bound
)
869 if (result_type
== NULL
)
870 result_type
= alloc_type_copy (index_type
);
871 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
872 TYPE_TARGET_TYPE (result_type
) = index_type
;
873 if (TYPE_STUB (index_type
))
874 TYPE_TARGET_STUB (result_type
) = 1;
876 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
878 TYPE_RANGE_DATA (result_type
) = (struct range_bounds
*)
879 TYPE_ZALLOC (result_type
, sizeof (struct range_bounds
));
880 TYPE_RANGE_DATA (result_type
)->low
= *low_bound
;
881 TYPE_RANGE_DATA (result_type
)->high
= *high_bound
;
883 if (low_bound
->kind
== PROP_CONST
&& low_bound
->data
.const_val
>= 0)
884 TYPE_UNSIGNED (result_type
) = 1;
886 /* Ada allows the declaration of range types whose upper bound is
887 less than the lower bound, so checking the lower bound is not
888 enough. Make sure we do not mark a range type whose upper bound
889 is negative as unsigned. */
890 if (high_bound
->kind
== PROP_CONST
&& high_bound
->data
.const_val
< 0)
891 TYPE_UNSIGNED (result_type
) = 0;
896 /* Create a range type using either a blank type supplied in
897 RESULT_TYPE, or creating a new type, inheriting the objfile from
900 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
901 to HIGH_BOUND, inclusive.
903 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
904 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
907 create_static_range_type (struct type
*result_type
, struct type
*index_type
,
908 LONGEST low_bound
, LONGEST high_bound
)
910 struct dynamic_prop low
, high
;
912 low
.kind
= PROP_CONST
;
913 low
.data
.const_val
= low_bound
;
915 high
.kind
= PROP_CONST
;
916 high
.data
.const_val
= high_bound
;
918 result_type
= create_range_type (result_type
, index_type
, &low
, &high
);
923 /* Predicate tests whether BOUNDS are static. Returns 1 if all bounds values
924 are static, otherwise returns 0. */
927 has_static_range (const struct range_bounds
*bounds
)
929 return (bounds
->low
.kind
== PROP_CONST
930 && bounds
->high
.kind
== PROP_CONST
);
934 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
935 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
936 bounds will fit in LONGEST), or -1 otherwise. */
939 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
941 type
= check_typedef (type
);
942 switch (TYPE_CODE (type
))
944 case TYPE_CODE_RANGE
:
945 *lowp
= TYPE_LOW_BOUND (type
);
946 *highp
= TYPE_HIGH_BOUND (type
);
949 if (TYPE_NFIELDS (type
) > 0)
951 /* The enums may not be sorted by value, so search all
955 *lowp
= *highp
= TYPE_FIELD_ENUMVAL (type
, 0);
956 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
958 if (TYPE_FIELD_ENUMVAL (type
, i
) < *lowp
)
959 *lowp
= TYPE_FIELD_ENUMVAL (type
, i
);
960 if (TYPE_FIELD_ENUMVAL (type
, i
) > *highp
)
961 *highp
= TYPE_FIELD_ENUMVAL (type
, i
);
964 /* Set unsigned indicator if warranted. */
967 TYPE_UNSIGNED (type
) = 1;
981 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
983 if (!TYPE_UNSIGNED (type
))
985 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
989 /* ... fall through for unsigned ints ... */
992 /* This round-about calculation is to avoid shifting by
993 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
994 if TYPE_LENGTH (type) == sizeof (LONGEST). */
995 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
996 *highp
= (*highp
- 1) | *highp
;
1003 /* Assuming TYPE is a simple, non-empty array type, compute its upper
1004 and lower bound. Save the low bound into LOW_BOUND if not NULL.
1005 Save the high bound into HIGH_BOUND if not NULL.
1007 Return 1 if the operation was successful. Return zero otherwise,
1008 in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
1010 We now simply use get_discrete_bounds call to get the values
1011 of the low and high bounds.
1012 get_discrete_bounds can return three values:
1013 1, meaning that index is a range,
1014 0, meaning that index is a discrete type,
1015 or -1 for failure. */
1018 get_array_bounds (struct type
*type
, LONGEST
*low_bound
, LONGEST
*high_bound
)
1020 struct type
*index
= TYPE_INDEX_TYPE (type
);
1028 res
= get_discrete_bounds (index
, &low
, &high
);
1032 /* Check if the array bounds are undefined. */
1034 && ((low_bound
&& TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type
))
1035 || (high_bound
&& TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))))
1047 /* Assuming that TYPE is a discrete type and VAL is a valid integer
1048 representation of a value of this type, save the corresponding
1049 position number in POS.
1051 Its differs from VAL only in the case of enumeration types. In
1052 this case, the position number of the value of the first listed
1053 enumeration literal is zero; the position number of the value of
1054 each subsequent enumeration literal is one more than that of its
1055 predecessor in the list.
1057 Return 1 if the operation was successful. Return zero otherwise,
1058 in which case the value of POS is unmodified.
1062 discrete_position (struct type
*type
, LONGEST val
, LONGEST
*pos
)
1064 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
1068 for (i
= 0; i
< TYPE_NFIELDS (type
); i
+= 1)
1070 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
1076 /* Invalid enumeration value. */
1086 /* Create an array type using either a blank type supplied in
1087 RESULT_TYPE, or creating a new type, inheriting the objfile from
1090 Elements will be of type ELEMENT_TYPE, the indices will be of type
1093 If BIT_STRIDE is not zero, build a packed array type whose element
1094 size is BIT_STRIDE. Otherwise, ignore this parameter.
1096 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1097 sure it is TYPE_CODE_UNDEF before we bash it into an array
1101 create_array_type_with_stride (struct type
*result_type
,
1102 struct type
*element_type
,
1103 struct type
*range_type
,
1104 unsigned int bit_stride
)
1106 if (result_type
== NULL
)
1107 result_type
= alloc_type_copy (range_type
);
1109 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
1110 TYPE_TARGET_TYPE (result_type
) = element_type
;
1111 if (has_static_range (TYPE_RANGE_DATA (range_type
))
1112 && (!type_not_associated (result_type
)
1113 && !type_not_allocated (result_type
)))
1115 LONGEST low_bound
, high_bound
;
1117 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
1118 low_bound
= high_bound
= 0;
1119 element_type
= check_typedef (element_type
);
1120 /* Be careful when setting the array length. Ada arrays can be
1121 empty arrays with the high_bound being smaller than the low_bound.
1122 In such cases, the array length should be zero. */
1123 if (high_bound
< low_bound
)
1124 TYPE_LENGTH (result_type
) = 0;
1125 else if (bit_stride
> 0)
1126 TYPE_LENGTH (result_type
) =
1127 (bit_stride
* (high_bound
- low_bound
+ 1) + 7) / 8;
1129 TYPE_LENGTH (result_type
) =
1130 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
1134 /* This type is dynamic and its length needs to be computed
1135 on demand. In the meantime, avoid leaving the TYPE_LENGTH
1136 undefined by setting it to zero. Although we are not expected
1137 to trust TYPE_LENGTH in this case, setting the size to zero
1138 allows us to avoid allocating objects of random sizes in case
1139 we accidently do. */
1140 TYPE_LENGTH (result_type
) = 0;
1143 TYPE_NFIELDS (result_type
) = 1;
1144 TYPE_FIELDS (result_type
) =
1145 (struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
));
1146 TYPE_INDEX_TYPE (result_type
) = range_type
;
1148 TYPE_FIELD_BITSIZE (result_type
, 0) = bit_stride
;
1150 /* TYPE_TARGET_STUB will take care of zero length arrays. */
1151 if (TYPE_LENGTH (result_type
) == 0)
1152 TYPE_TARGET_STUB (result_type
) = 1;
1157 /* Same as create_array_type_with_stride but with no bit_stride
1158 (BIT_STRIDE = 0), thus building an unpacked array. */
1161 create_array_type (struct type
*result_type
,
1162 struct type
*element_type
,
1163 struct type
*range_type
)
1165 return create_array_type_with_stride (result_type
, element_type
,
1170 lookup_array_range_type (struct type
*element_type
,
1171 LONGEST low_bound
, LONGEST high_bound
)
1173 struct gdbarch
*gdbarch
= get_type_arch (element_type
);
1174 struct type
*index_type
= builtin_type (gdbarch
)->builtin_int
;
1175 struct type
*range_type
1176 = create_static_range_type (NULL
, index_type
, low_bound
, high_bound
);
1178 return create_array_type (NULL
, element_type
, range_type
);
1181 /* Create a string type using either a blank type supplied in
1182 RESULT_TYPE, or creating a new type. String types are similar
1183 enough to array of char types that we can use create_array_type to
1184 build the basic type and then bash it into a string type.
1186 For fixed length strings, the range type contains 0 as the lower
1187 bound and the length of the string minus one as the upper bound.
1189 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1190 sure it is TYPE_CODE_UNDEF before we bash it into a string
1194 create_string_type (struct type
*result_type
,
1195 struct type
*string_char_type
,
1196 struct type
*range_type
)
1198 result_type
= create_array_type (result_type
,
1201 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
1206 lookup_string_range_type (struct type
*string_char_type
,
1207 LONGEST low_bound
, LONGEST high_bound
)
1209 struct type
*result_type
;
1211 result_type
= lookup_array_range_type (string_char_type
,
1212 low_bound
, high_bound
);
1213 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
1218 create_set_type (struct type
*result_type
, struct type
*domain_type
)
1220 if (result_type
== NULL
)
1221 result_type
= alloc_type_copy (domain_type
);
1223 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
1224 TYPE_NFIELDS (result_type
) = 1;
1225 TYPE_FIELDS (result_type
)
1226 = (struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
));
1228 if (!TYPE_STUB (domain_type
))
1230 LONGEST low_bound
, high_bound
, bit_length
;
1232 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
1233 low_bound
= high_bound
= 0;
1234 bit_length
= high_bound
- low_bound
+ 1;
1235 TYPE_LENGTH (result_type
)
1236 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
1238 TYPE_UNSIGNED (result_type
) = 1;
1240 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
1245 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
1246 and any array types nested inside it. */
1249 make_vector_type (struct type
*array_type
)
1251 struct type
*inner_array
, *elt_type
;
1254 /* Find the innermost array type, in case the array is
1255 multi-dimensional. */
1256 inner_array
= array_type
;
1257 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
1258 inner_array
= TYPE_TARGET_TYPE (inner_array
);
1260 elt_type
= TYPE_TARGET_TYPE (inner_array
);
1261 if (TYPE_CODE (elt_type
) == TYPE_CODE_INT
)
1263 flags
= TYPE_INSTANCE_FLAGS (elt_type
) | TYPE_INSTANCE_FLAG_NOTTEXT
;
1264 elt_type
= make_qualified_type (elt_type
, flags
, NULL
);
1265 TYPE_TARGET_TYPE (inner_array
) = elt_type
;
1268 TYPE_VECTOR (array_type
) = 1;
1272 init_vector_type (struct type
*elt_type
, int n
)
1274 struct type
*array_type
;
1276 array_type
= lookup_array_range_type (elt_type
, 0, n
- 1);
1277 make_vector_type (array_type
);
1281 /* Internal routine called by TYPE_SELF_TYPE to return the type that TYPE
1282 belongs to. In c++ this is the class of "this", but TYPE_THIS_TYPE is too
1283 confusing. "self" is a common enough replacement for "this".
1284 TYPE must be one of TYPE_CODE_METHODPTR, TYPE_CODE_MEMBERPTR, or
1285 TYPE_CODE_METHOD. */
1288 internal_type_self_type (struct type
*type
)
1290 switch (TYPE_CODE (type
))
1292 case TYPE_CODE_METHODPTR
:
1293 case TYPE_CODE_MEMBERPTR
:
1294 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1296 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_SELF_TYPE
);
1297 return TYPE_MAIN_TYPE (type
)->type_specific
.self_type
;
1298 case TYPE_CODE_METHOD
:
1299 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1301 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
1302 return TYPE_MAIN_TYPE (type
)->type_specific
.func_stuff
->self_type
;
1304 gdb_assert_not_reached ("bad type");
1308 /* Set the type of the class that TYPE belongs to.
1309 In c++ this is the class of "this".
1310 TYPE must be one of TYPE_CODE_METHODPTR, TYPE_CODE_MEMBERPTR, or
1311 TYPE_CODE_METHOD. */
1314 set_type_self_type (struct type
*type
, struct type
*self_type
)
1316 switch (TYPE_CODE (type
))
1318 case TYPE_CODE_METHODPTR
:
1319 case TYPE_CODE_MEMBERPTR
:
1320 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1321 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_SELF_TYPE
;
1322 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_SELF_TYPE
);
1323 TYPE_MAIN_TYPE (type
)->type_specific
.self_type
= self_type
;
1325 case TYPE_CODE_METHOD
:
1326 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_NONE
)
1327 INIT_FUNC_SPECIFIC (type
);
1328 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
1329 TYPE_MAIN_TYPE (type
)->type_specific
.func_stuff
->self_type
= self_type
;
1332 gdb_assert_not_reached ("bad type");
1336 /* Smash TYPE to be a type of pointers to members of SELF_TYPE with type
1337 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1338 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1339 TYPE doesn't include the offset (that's the value of the MEMBER
1340 itself), but does include the structure type into which it points
1343 When "smashing" the type, we preserve the objfile that the old type
1344 pointed to, since we aren't changing where the type is actually
1348 smash_to_memberptr_type (struct type
*type
, struct type
*self_type
,
1349 struct type
*to_type
)
1352 TYPE_CODE (type
) = TYPE_CODE_MEMBERPTR
;
1353 TYPE_TARGET_TYPE (type
) = to_type
;
1354 set_type_self_type (type
, self_type
);
1355 /* Assume that a data member pointer is the same size as a normal
1358 = gdbarch_ptr_bit (get_type_arch (to_type
)) / TARGET_CHAR_BIT
;
1361 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1363 When "smashing" the type, we preserve the objfile that the old type
1364 pointed to, since we aren't changing where the type is actually
1368 smash_to_methodptr_type (struct type
*type
, struct type
*to_type
)
1371 TYPE_CODE (type
) = TYPE_CODE_METHODPTR
;
1372 TYPE_TARGET_TYPE (type
) = to_type
;
1373 set_type_self_type (type
, TYPE_SELF_TYPE (to_type
));
1374 TYPE_LENGTH (type
) = cplus_method_ptr_size (to_type
);
1377 /* Smash TYPE to be a type of method of SELF_TYPE with type TO_TYPE.
1378 METHOD just means `function that gets an extra "this" argument'.
1380 When "smashing" the type, we preserve the objfile that the old type
1381 pointed to, since we aren't changing where the type is actually
1385 smash_to_method_type (struct type
*type
, struct type
*self_type
,
1386 struct type
*to_type
, struct field
*args
,
1387 int nargs
, int varargs
)
1390 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
1391 TYPE_TARGET_TYPE (type
) = to_type
;
1392 set_type_self_type (type
, self_type
);
1393 TYPE_FIELDS (type
) = args
;
1394 TYPE_NFIELDS (type
) = nargs
;
1396 TYPE_VARARGS (type
) = 1;
1397 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1400 /* Return a typename for a struct/union/enum type without "struct ",
1401 "union ", or "enum ". If the type has a NULL name, return NULL. */
1404 type_name_no_tag (const struct type
*type
)
1406 if (TYPE_TAG_NAME (type
) != NULL
)
1407 return TYPE_TAG_NAME (type
);
1409 /* Is there code which expects this to return the name if there is
1410 no tag name? My guess is that this is mainly used for C++ in
1411 cases where the two will always be the same. */
1412 return TYPE_NAME (type
);
1415 /* A wrapper of type_name_no_tag which calls error if the type is anonymous.
1416 Since GCC PR debug/47510 DWARF provides associated information to detect the
1417 anonymous class linkage name from its typedef.
1419 Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
1423 type_name_no_tag_or_error (struct type
*type
)
1425 struct type
*saved_type
= type
;
1427 struct objfile
*objfile
;
1429 type
= check_typedef (type
);
1431 name
= type_name_no_tag (type
);
1435 name
= type_name_no_tag (saved_type
);
1436 objfile
= TYPE_OBJFILE (saved_type
);
1437 error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
1438 name
? name
: "<anonymous>",
1439 objfile
? objfile_name (objfile
) : "<arch>");
1442 /* Lookup a typedef or primitive type named NAME, visible in lexical
1443 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1444 suitably defined. */
1447 lookup_typename (const struct language_defn
*language
,
1448 struct gdbarch
*gdbarch
, const char *name
,
1449 const struct block
*block
, int noerr
)
1453 sym
= lookup_symbol_in_language (name
, block
, VAR_DOMAIN
,
1454 language
->la_language
, NULL
).symbol
;
1455 if (sym
!= NULL
&& SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
1456 return SYMBOL_TYPE (sym
);
1460 error (_("No type named %s."), name
);
1464 lookup_unsigned_typename (const struct language_defn
*language
,
1465 struct gdbarch
*gdbarch
, const char *name
)
1467 char *uns
= (char *) alloca (strlen (name
) + 10);
1469 strcpy (uns
, "unsigned ");
1470 strcpy (uns
+ 9, name
);
1471 return lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 0);
1475 lookup_signed_typename (const struct language_defn
*language
,
1476 struct gdbarch
*gdbarch
, const char *name
)
1479 char *uns
= (char *) alloca (strlen (name
) + 8);
1481 strcpy (uns
, "signed ");
1482 strcpy (uns
+ 7, name
);
1483 t
= lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 1);
1484 /* If we don't find "signed FOO" just try again with plain "FOO". */
1487 return lookup_typename (language
, gdbarch
, name
, (struct block
*) NULL
, 0);
1490 /* Lookup a structure type named "struct NAME",
1491 visible in lexical block BLOCK. */
1494 lookup_struct (const char *name
, const struct block
*block
)
1498 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
1502 error (_("No struct type named %s."), name
);
1504 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1506 error (_("This context has class, union or enum %s, not a struct."),
1509 return (SYMBOL_TYPE (sym
));
1512 /* Lookup a union type named "union NAME",
1513 visible in lexical block BLOCK. */
1516 lookup_union (const char *name
, const struct block
*block
)
1521 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
1524 error (_("No union type named %s."), name
);
1526 t
= SYMBOL_TYPE (sym
);
1528 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1531 /* If we get here, it's not a union. */
1532 error (_("This context has class, struct or enum %s, not a union."),
1536 /* Lookup an enum type named "enum NAME",
1537 visible in lexical block BLOCK. */
1540 lookup_enum (const char *name
, const struct block
*block
)
1544 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
1547 error (_("No enum type named %s."), name
);
1549 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1551 error (_("This context has class, struct or union %s, not an enum."),
1554 return (SYMBOL_TYPE (sym
));
1557 /* Lookup a template type named "template NAME<TYPE>",
1558 visible in lexical block BLOCK. */
1561 lookup_template_type (char *name
, struct type
*type
,
1562 const struct block
*block
)
1565 char *nam
= (char *)
1566 alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1570 strcat (nam
, TYPE_NAME (type
));
1571 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1573 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0).symbol
;
1577 error (_("No template type named %s."), name
);
1579 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1581 error (_("This context has class, union or enum %s, not a struct."),
1584 return (SYMBOL_TYPE (sym
));
1587 /* Given a type TYPE, lookup the type of the component of type named
1590 TYPE can be either a struct or union, or a pointer or reference to
1591 a struct or union. If it is a pointer or reference, its target
1592 type is automatically used. Thus '.' and '->' are interchangable,
1593 as specified for the definitions of the expression element types
1594 STRUCTOP_STRUCT and STRUCTOP_PTR.
1596 If NOERR is nonzero, return zero if NAME is not suitably defined.
1597 If NAME is the name of a baseclass type, return that type. */
1600 lookup_struct_elt_type (struct type
*type
, const char *name
, int noerr
)
1606 type
= check_typedef (type
);
1607 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1608 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1610 type
= TYPE_TARGET_TYPE (type
);
1613 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1614 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1616 std::string type_name
= type_to_string (type
);
1617 error (_("Type %s is not a structure or union type."),
1618 type_name
.c_str ());
1622 /* FIXME: This change put in by Michael seems incorrect for the case
1623 where the structure tag name is the same as the member name.
1624 I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
1625 foo; } bell;" Disabled by fnf. */
1629 type_name
= type_name_no_tag (type
);
1630 if (type_name
!= NULL
&& strcmp (type_name
, name
) == 0)
1635 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1637 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1639 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1641 return TYPE_FIELD_TYPE (type
, i
);
1643 else if (!t_field_name
|| *t_field_name
== '\0')
1645 struct type
*subtype
1646 = lookup_struct_elt_type (TYPE_FIELD_TYPE (type
, i
), name
, 1);
1648 if (subtype
!= NULL
)
1653 /* OK, it's not in this class. Recursively check the baseclasses. */
1654 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1658 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, 1);
1670 std::string type_name
= type_to_string (type
);
1671 error (_("Type %s has no component named %s."), type_name
.c_str (), name
);
1674 /* Store in *MAX the largest number representable by unsigned integer type
1678 get_unsigned_type_max (struct type
*type
, ULONGEST
*max
)
1682 type
= check_typedef (type
);
1683 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_INT
&& TYPE_UNSIGNED (type
));
1684 gdb_assert (TYPE_LENGTH (type
) <= sizeof (ULONGEST
));
1686 /* Written this way to avoid overflow. */
1687 n
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
1688 *max
= ((((ULONGEST
) 1 << (n
- 1)) - 1) << 1) | 1;
1691 /* Store in *MIN, *MAX the smallest and largest numbers representable by
1692 signed integer type TYPE. */
1695 get_signed_type_minmax (struct type
*type
, LONGEST
*min
, LONGEST
*max
)
1699 type
= check_typedef (type
);
1700 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_INT
&& !TYPE_UNSIGNED (type
));
1701 gdb_assert (TYPE_LENGTH (type
) <= sizeof (LONGEST
));
1703 n
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
1704 *min
= -((ULONGEST
) 1 << (n
- 1));
1705 *max
= ((ULONGEST
) 1 << (n
- 1)) - 1;
1708 /* Internal routine called by TYPE_VPTR_FIELDNO to return the value of
1709 cplus_stuff.vptr_fieldno.
1711 cplus_stuff is initialized to cplus_struct_default which does not
1712 set vptr_fieldno to -1 for portability reasons (IWBN to use C99
1713 designated initializers). We cope with that here. */
1716 internal_type_vptr_fieldno (struct type
*type
)
1718 type
= check_typedef (type
);
1719 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1720 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1721 if (!HAVE_CPLUS_STRUCT (type
))
1723 return TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_fieldno
;
1726 /* Set the value of cplus_stuff.vptr_fieldno. */
1729 set_type_vptr_fieldno (struct type
*type
, int fieldno
)
1731 type
= check_typedef (type
);
1732 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1733 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1734 if (!HAVE_CPLUS_STRUCT (type
))
1735 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1736 TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_fieldno
= fieldno
;
1739 /* Internal routine called by TYPE_VPTR_BASETYPE to return the value of
1740 cplus_stuff.vptr_basetype. */
1743 internal_type_vptr_basetype (struct type
*type
)
1745 type
= check_typedef (type
);
1746 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1747 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1748 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_CPLUS_STUFF
);
1749 return TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_basetype
;
1752 /* Set the value of cplus_stuff.vptr_basetype. */
1755 set_type_vptr_basetype (struct type
*type
, struct type
*basetype
)
1757 type
= check_typedef (type
);
1758 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1759 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1760 if (!HAVE_CPLUS_STRUCT (type
))
1761 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1762 TYPE_RAW_CPLUS_SPECIFIC (type
)->vptr_basetype
= basetype
;
1765 /* Lookup the vptr basetype/fieldno values for TYPE.
1766 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1767 vptr_fieldno. Also, if found and basetype is from the same objfile,
1769 If not found, return -1 and ignore BASETYPEP.
1770 Callers should be aware that in some cases (for example,
1771 the type or one of its baseclasses is a stub type and we are
1772 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1773 this function will not be able to find the
1774 virtual function table pointer, and vptr_fieldno will remain -1 and
1775 vptr_basetype will remain NULL or incomplete. */
1778 get_vptr_fieldno (struct type
*type
, struct type
**basetypep
)
1780 type
= check_typedef (type
);
1782 if (TYPE_VPTR_FIELDNO (type
) < 0)
1786 /* We must start at zero in case the first (and only) baseclass
1787 is virtual (and hence we cannot share the table pointer). */
1788 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1790 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1792 struct type
*basetype
;
1794 fieldno
= get_vptr_fieldno (baseclass
, &basetype
);
1797 /* If the type comes from a different objfile we can't cache
1798 it, it may have a different lifetime. PR 2384 */
1799 if (TYPE_OBJFILE (type
) == TYPE_OBJFILE (basetype
))
1801 set_type_vptr_fieldno (type
, fieldno
);
1802 set_type_vptr_basetype (type
, basetype
);
1805 *basetypep
= basetype
;
1816 *basetypep
= TYPE_VPTR_BASETYPE (type
);
1817 return TYPE_VPTR_FIELDNO (type
);
1822 stub_noname_complaint (void)
1824 complaint (&symfile_complaints
, _("stub type has NULL name"));
1827 /* Worker for is_dynamic_type. */
1830 is_dynamic_type_internal (struct type
*type
, int top_level
)
1832 type
= check_typedef (type
);
1834 /* We only want to recognize references at the outermost level. */
1835 if (top_level
&& TYPE_CODE (type
) == TYPE_CODE_REF
)
1836 type
= check_typedef (TYPE_TARGET_TYPE (type
));
1838 /* Types that have a dynamic TYPE_DATA_LOCATION are considered
1839 dynamic, even if the type itself is statically defined.
1840 From a user's point of view, this may appear counter-intuitive;
1841 but it makes sense in this context, because the point is to determine
1842 whether any part of the type needs to be resolved before it can
1844 if (TYPE_DATA_LOCATION (type
) != NULL
1845 && (TYPE_DATA_LOCATION_KIND (type
) == PROP_LOCEXPR
1846 || TYPE_DATA_LOCATION_KIND (type
) == PROP_LOCLIST
))
1849 if (TYPE_ASSOCIATED_PROP (type
))
1852 if (TYPE_ALLOCATED_PROP (type
))
1855 switch (TYPE_CODE (type
))
1857 case TYPE_CODE_RANGE
:
1859 /* A range type is obviously dynamic if it has at least one
1860 dynamic bound. But also consider the range type to be
1861 dynamic when its subtype is dynamic, even if the bounds
1862 of the range type are static. It allows us to assume that
1863 the subtype of a static range type is also static. */
1864 return (!has_static_range (TYPE_RANGE_DATA (type
))
1865 || is_dynamic_type_internal (TYPE_TARGET_TYPE (type
), 0));
1868 case TYPE_CODE_ARRAY
:
1870 gdb_assert (TYPE_NFIELDS (type
) == 1);
1872 /* The array is dynamic if either the bounds are dynamic,
1873 or the elements it contains have a dynamic contents. */
1874 if (is_dynamic_type_internal (TYPE_INDEX_TYPE (type
), 0))
1876 return is_dynamic_type_internal (TYPE_TARGET_TYPE (type
), 0);
1879 case TYPE_CODE_STRUCT
:
1880 case TYPE_CODE_UNION
:
1884 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
1885 if (!field_is_static (&TYPE_FIELD (type
, i
))
1886 && is_dynamic_type_internal (TYPE_FIELD_TYPE (type
, i
), 0))
1895 /* See gdbtypes.h. */
1898 is_dynamic_type (struct type
*type
)
1900 return is_dynamic_type_internal (type
, 1);
1903 static struct type
*resolve_dynamic_type_internal
1904 (struct type
*type
, struct property_addr_info
*addr_stack
, int top_level
);
1906 /* Given a dynamic range type (dyn_range_type) and a stack of
1907 struct property_addr_info elements, return a static version
1910 static struct type
*
1911 resolve_dynamic_range (struct type
*dyn_range_type
,
1912 struct property_addr_info
*addr_stack
)
1915 struct type
*static_range_type
, *static_target_type
;
1916 const struct dynamic_prop
*prop
;
1917 struct dynamic_prop low_bound
, high_bound
;
1919 gdb_assert (TYPE_CODE (dyn_range_type
) == TYPE_CODE_RANGE
);
1921 prop
= &TYPE_RANGE_DATA (dyn_range_type
)->low
;
1922 if (dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
1924 low_bound
.kind
= PROP_CONST
;
1925 low_bound
.data
.const_val
= value
;
1929 low_bound
.kind
= PROP_UNDEFINED
;
1930 low_bound
.data
.const_val
= 0;
1933 prop
= &TYPE_RANGE_DATA (dyn_range_type
)->high
;
1934 if (dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
1936 high_bound
.kind
= PROP_CONST
;
1937 high_bound
.data
.const_val
= value
;
1939 if (TYPE_RANGE_DATA (dyn_range_type
)->flag_upper_bound_is_count
)
1940 high_bound
.data
.const_val
1941 = low_bound
.data
.const_val
+ high_bound
.data
.const_val
- 1;
1945 high_bound
.kind
= PROP_UNDEFINED
;
1946 high_bound
.data
.const_val
= 0;
1950 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (dyn_range_type
),
1952 static_range_type
= create_range_type (copy_type (dyn_range_type
),
1954 &low_bound
, &high_bound
);
1955 TYPE_RANGE_DATA (static_range_type
)->flag_bound_evaluated
= 1;
1956 return static_range_type
;
1959 /* Resolves dynamic bound values of an array type TYPE to static ones.
1960 ADDR_STACK is a stack of struct property_addr_info to be used
1961 if needed during the dynamic resolution. */
1963 static struct type
*
1964 resolve_dynamic_array (struct type
*type
,
1965 struct property_addr_info
*addr_stack
)
1968 struct type
*elt_type
;
1969 struct type
*range_type
;
1970 struct type
*ary_dim
;
1971 struct dynamic_prop
*prop
;
1973 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_ARRAY
);
1975 type
= copy_type (type
);
1978 range_type
= check_typedef (TYPE_INDEX_TYPE (elt_type
));
1979 range_type
= resolve_dynamic_range (range_type
, addr_stack
);
1981 /* Resolve allocated/associated here before creating a new array type, which
1982 will update the length of the array accordingly. */
1983 prop
= TYPE_ALLOCATED_PROP (type
);
1984 if (prop
!= NULL
&& dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
1986 TYPE_DYN_PROP_ADDR (prop
) = value
;
1987 TYPE_DYN_PROP_KIND (prop
) = PROP_CONST
;
1989 prop
= TYPE_ASSOCIATED_PROP (type
);
1990 if (prop
!= NULL
&& dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
1992 TYPE_DYN_PROP_ADDR (prop
) = value
;
1993 TYPE_DYN_PROP_KIND (prop
) = PROP_CONST
;
1996 ary_dim
= check_typedef (TYPE_TARGET_TYPE (elt_type
));
1998 if (ary_dim
!= NULL
&& TYPE_CODE (ary_dim
) == TYPE_CODE_ARRAY
)
1999 elt_type
= resolve_dynamic_array (ary_dim
, addr_stack
);
2001 elt_type
= TYPE_TARGET_TYPE (type
);
2003 return create_array_type_with_stride (type
, elt_type
, range_type
,
2004 TYPE_FIELD_BITSIZE (type
, 0));
2007 /* Resolve dynamic bounds of members of the union TYPE to static
2008 bounds. ADDR_STACK is a stack of struct property_addr_info
2009 to be used if needed during the dynamic resolution. */
2011 static struct type
*
2012 resolve_dynamic_union (struct type
*type
,
2013 struct property_addr_info
*addr_stack
)
2015 struct type
*resolved_type
;
2017 unsigned int max_len
= 0;
2019 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_UNION
);
2021 resolved_type
= copy_type (type
);
2022 TYPE_FIELDS (resolved_type
)
2023 = (struct field
*) TYPE_ALLOC (resolved_type
,
2024 TYPE_NFIELDS (resolved_type
)
2025 * sizeof (struct field
));
2026 memcpy (TYPE_FIELDS (resolved_type
),
2028 TYPE_NFIELDS (resolved_type
) * sizeof (struct field
));
2029 for (i
= 0; i
< TYPE_NFIELDS (resolved_type
); ++i
)
2033 if (field_is_static (&TYPE_FIELD (type
, i
)))
2036 t
= resolve_dynamic_type_internal (TYPE_FIELD_TYPE (resolved_type
, i
),
2038 TYPE_FIELD_TYPE (resolved_type
, i
) = t
;
2039 if (TYPE_LENGTH (t
) > max_len
)
2040 max_len
= TYPE_LENGTH (t
);
2043 TYPE_LENGTH (resolved_type
) = max_len
;
2044 return resolved_type
;
2047 /* Resolve dynamic bounds of members of the struct TYPE to static
2048 bounds. ADDR_STACK is a stack of struct property_addr_info to
2049 be used if needed during the dynamic resolution. */
2051 static struct type
*
2052 resolve_dynamic_struct (struct type
*type
,
2053 struct property_addr_info
*addr_stack
)
2055 struct type
*resolved_type
;
2057 unsigned resolved_type_bit_length
= 0;
2059 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
);
2060 gdb_assert (TYPE_NFIELDS (type
) > 0);
2062 resolved_type
= copy_type (type
);
2063 TYPE_FIELDS (resolved_type
)
2064 = (struct field
*) TYPE_ALLOC (resolved_type
,
2065 TYPE_NFIELDS (resolved_type
)
2066 * sizeof (struct field
));
2067 memcpy (TYPE_FIELDS (resolved_type
),
2069 TYPE_NFIELDS (resolved_type
) * sizeof (struct field
));
2070 for (i
= 0; i
< TYPE_NFIELDS (resolved_type
); ++i
)
2072 unsigned new_bit_length
;
2073 struct property_addr_info pinfo
;
2075 if (field_is_static (&TYPE_FIELD (type
, i
)))
2078 /* As we know this field is not a static field, the field's
2079 field_loc_kind should be FIELD_LOC_KIND_BITPOS. Verify
2080 this is the case, but only trigger a simple error rather
2081 than an internal error if that fails. While failing
2082 that verification indicates a bug in our code, the error
2083 is not severe enough to suggest to the user he stops
2084 his debugging session because of it. */
2085 if (TYPE_FIELD_LOC_KIND (type
, i
) != FIELD_LOC_KIND_BITPOS
)
2086 error (_("Cannot determine struct field location"
2087 " (invalid location kind)"));
2089 pinfo
.type
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
2090 pinfo
.valaddr
= addr_stack
->valaddr
;
2093 + (TYPE_FIELD_BITPOS (resolved_type
, i
) / TARGET_CHAR_BIT
));
2094 pinfo
.next
= addr_stack
;
2096 TYPE_FIELD_TYPE (resolved_type
, i
)
2097 = resolve_dynamic_type_internal (TYPE_FIELD_TYPE (resolved_type
, i
),
2099 gdb_assert (TYPE_FIELD_LOC_KIND (resolved_type
, i
)
2100 == FIELD_LOC_KIND_BITPOS
);
2102 new_bit_length
= TYPE_FIELD_BITPOS (resolved_type
, i
);
2103 if (TYPE_FIELD_BITSIZE (resolved_type
, i
) != 0)
2104 new_bit_length
+= TYPE_FIELD_BITSIZE (resolved_type
, i
);
2106 new_bit_length
+= (TYPE_LENGTH (TYPE_FIELD_TYPE (resolved_type
, i
))
2109 /* Normally, we would use the position and size of the last field
2110 to determine the size of the enclosing structure. But GCC seems
2111 to be encoding the position of some fields incorrectly when
2112 the struct contains a dynamic field that is not placed last.
2113 So we compute the struct size based on the field that has
2114 the highest position + size - probably the best we can do. */
2115 if (new_bit_length
> resolved_type_bit_length
)
2116 resolved_type_bit_length
= new_bit_length
;
2119 /* The length of a type won't change for fortran, but it does for C and Ada.
2120 For fortran the size of dynamic fields might change over time but not the
2121 type length of the structure. If we adapt it, we run into problems
2122 when calculating the element offset for arrays of structs. */
2123 if (current_language
->la_language
!= language_fortran
)
2124 TYPE_LENGTH (resolved_type
)
2125 = (resolved_type_bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
2127 /* The Ada language uses this field as a cache for static fixed types: reset
2128 it as RESOLVED_TYPE must have its own static fixed type. */
2129 TYPE_TARGET_TYPE (resolved_type
) = NULL
;
2131 return resolved_type
;
2134 /* Worker for resolved_dynamic_type. */
2136 static struct type
*
2137 resolve_dynamic_type_internal (struct type
*type
,
2138 struct property_addr_info
*addr_stack
,
2141 struct type
*real_type
= check_typedef (type
);
2142 struct type
*resolved_type
= type
;
2143 struct dynamic_prop
*prop
;
2146 if (!is_dynamic_type_internal (real_type
, top_level
))
2149 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2151 resolved_type
= copy_type (type
);
2152 TYPE_TARGET_TYPE (resolved_type
)
2153 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type
), addr_stack
,
2158 /* Before trying to resolve TYPE, make sure it is not a stub. */
2161 switch (TYPE_CODE (type
))
2165 struct property_addr_info pinfo
;
2167 pinfo
.type
= check_typedef (TYPE_TARGET_TYPE (type
));
2168 pinfo
.valaddr
= NULL
;
2169 if (addr_stack
->valaddr
!= NULL
)
2170 pinfo
.addr
= extract_typed_address (addr_stack
->valaddr
, type
);
2172 pinfo
.addr
= read_memory_typed_address (addr_stack
->addr
, type
);
2173 pinfo
.next
= addr_stack
;
2175 resolved_type
= copy_type (type
);
2176 TYPE_TARGET_TYPE (resolved_type
)
2177 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type
),
2182 case TYPE_CODE_ARRAY
:
2183 resolved_type
= resolve_dynamic_array (type
, addr_stack
);
2186 case TYPE_CODE_RANGE
:
2187 resolved_type
= resolve_dynamic_range (type
, addr_stack
);
2190 case TYPE_CODE_UNION
:
2191 resolved_type
= resolve_dynamic_union (type
, addr_stack
);
2194 case TYPE_CODE_STRUCT
:
2195 resolved_type
= resolve_dynamic_struct (type
, addr_stack
);
2200 /* Resolve data_location attribute. */
2201 prop
= TYPE_DATA_LOCATION (resolved_type
);
2203 && dwarf2_evaluate_property (prop
, NULL
, addr_stack
, &value
))
2205 TYPE_DYN_PROP_ADDR (prop
) = value
;
2206 TYPE_DYN_PROP_KIND (prop
) = PROP_CONST
;
2209 return resolved_type
;
2212 /* See gdbtypes.h */
2215 resolve_dynamic_type (struct type
*type
, const gdb_byte
*valaddr
,
2218 struct property_addr_info pinfo
2219 = {check_typedef (type
), valaddr
, addr
, NULL
};
2221 return resolve_dynamic_type_internal (type
, &pinfo
, 1);
2224 /* See gdbtypes.h */
2226 struct dynamic_prop
*
2227 get_dyn_prop (enum dynamic_prop_node_kind prop_kind
, const struct type
*type
)
2229 struct dynamic_prop_list
*node
= TYPE_DYN_PROP_LIST (type
);
2231 while (node
!= NULL
)
2233 if (node
->prop_kind
== prop_kind
)
2240 /* See gdbtypes.h */
2243 add_dyn_prop (enum dynamic_prop_node_kind prop_kind
, struct dynamic_prop prop
,
2244 struct type
*type
, struct objfile
*objfile
)
2246 struct dynamic_prop_list
*temp
;
2248 gdb_assert (TYPE_OBJFILE_OWNED (type
));
2250 temp
= XOBNEW (&objfile
->objfile_obstack
, struct dynamic_prop_list
);
2251 temp
->prop_kind
= prop_kind
;
2253 temp
->next
= TYPE_DYN_PROP_LIST (type
);
2255 TYPE_DYN_PROP_LIST (type
) = temp
;
2258 /* Remove dynamic property from TYPE in case it exists. */
2261 remove_dyn_prop (enum dynamic_prop_node_kind prop_kind
,
2264 struct dynamic_prop_list
*prev_node
, *curr_node
;
2266 curr_node
= TYPE_DYN_PROP_LIST (type
);
2269 while (NULL
!= curr_node
)
2271 if (curr_node
->prop_kind
== prop_kind
)
2273 /* Update the linked list but don't free anything.
2274 The property was allocated on objstack and it is not known
2275 if we are on top of it. Nevertheless, everything is released
2276 when the complete objstack is freed. */
2277 if (NULL
== prev_node
)
2278 TYPE_DYN_PROP_LIST (type
) = curr_node
->next
;
2280 prev_node
->next
= curr_node
->next
;
2285 prev_node
= curr_node
;
2286 curr_node
= curr_node
->next
;
2290 /* Find the real type of TYPE. This function returns the real type,
2291 after removing all layers of typedefs, and completing opaque or stub
2292 types. Completion changes the TYPE argument, but stripping of
2295 Instance flags (e.g. const/volatile) are preserved as typedefs are
2296 stripped. If necessary a new qualified form of the underlying type
2299 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
2300 not been computed and we're either in the middle of reading symbols, or
2301 there was no name for the typedef in the debug info.
2303 NOTE: Lookup of opaque types can throw errors for invalid symbol files.
2304 QUITs in the symbol reading code can also throw.
2305 Thus this function can throw an exception.
2307 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
2310 If this is a stubbed struct (i.e. declared as struct foo *), see if
2311 we can find a full definition in some other file. If so, copy this
2312 definition, so we can use it in future. There used to be a comment
2313 (but not any code) that if we don't find a full definition, we'd
2314 set a flag so we don't spend time in the future checking the same
2315 type. That would be a mistake, though--we might load in more
2316 symbols which contain a full definition for the type. */
2319 check_typedef (struct type
*type
)
2321 struct type
*orig_type
= type
;
2322 /* While we're removing typedefs, we don't want to lose qualifiers.
2323 E.g., const/volatile. */
2324 int instance_flags
= TYPE_INSTANCE_FLAGS (type
);
2328 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2330 if (!TYPE_TARGET_TYPE (type
))
2335 /* It is dangerous to call lookup_symbol if we are currently
2336 reading a symtab. Infinite recursion is one danger. */
2337 if (currently_reading_symtab
)
2338 return make_qualified_type (type
, instance_flags
, NULL
);
2340 name
= type_name_no_tag (type
);
2341 /* FIXME: shouldn't we separately check the TYPE_NAME and
2342 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
2343 VAR_DOMAIN as appropriate? (this code was written before
2344 TYPE_NAME and TYPE_TAG_NAME were separate). */
2347 stub_noname_complaint ();
2348 return make_qualified_type (type
, instance_flags
, NULL
);
2350 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0).symbol
;
2352 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
2353 else /* TYPE_CODE_UNDEF */
2354 TYPE_TARGET_TYPE (type
) = alloc_type_arch (get_type_arch (type
));
2356 type
= TYPE_TARGET_TYPE (type
);
2358 /* Preserve the instance flags as we traverse down the typedef chain.
2360 Handling address spaces/classes is nasty, what do we do if there's a
2362 E.g., what if an outer typedef marks the type as class_1 and an inner
2363 typedef marks the type as class_2?
2364 This is the wrong place to do such error checking. We leave it to
2365 the code that created the typedef in the first place to flag the
2366 error. We just pick the outer address space (akin to letting the
2367 outer cast in a chain of casting win), instead of assuming
2368 "it can't happen". */
2370 const int ALL_SPACES
= (TYPE_INSTANCE_FLAG_CODE_SPACE
2371 | TYPE_INSTANCE_FLAG_DATA_SPACE
);
2372 const int ALL_CLASSES
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
;
2373 int new_instance_flags
= TYPE_INSTANCE_FLAGS (type
);
2375 /* Treat code vs data spaces and address classes separately. */
2376 if ((instance_flags
& ALL_SPACES
) != 0)
2377 new_instance_flags
&= ~ALL_SPACES
;
2378 if ((instance_flags
& ALL_CLASSES
) != 0)
2379 new_instance_flags
&= ~ALL_CLASSES
;
2381 instance_flags
|= new_instance_flags
;
2385 /* If this is a struct/class/union with no fields, then check
2386 whether a full definition exists somewhere else. This is for
2387 systems where a type definition with no fields is issued for such
2388 types, instead of identifying them as stub types in the first
2391 if (TYPE_IS_OPAQUE (type
)
2392 && opaque_type_resolution
2393 && !currently_reading_symtab
)
2395 const char *name
= type_name_no_tag (type
);
2396 struct type
*newtype
;
2400 stub_noname_complaint ();
2401 return make_qualified_type (type
, instance_flags
, NULL
);
2403 newtype
= lookup_transparent_type (name
);
2407 /* If the resolved type and the stub are in the same
2408 objfile, then replace the stub type with the real deal.
2409 But if they're in separate objfiles, leave the stub
2410 alone; we'll just look up the transparent type every time
2411 we call check_typedef. We can't create pointers between
2412 types allocated to different objfiles, since they may
2413 have different lifetimes. Trying to copy NEWTYPE over to
2414 TYPE's objfile is pointless, too, since you'll have to
2415 move over any other types NEWTYPE refers to, which could
2416 be an unbounded amount of stuff. */
2417 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
2418 type
= make_qualified_type (newtype
,
2419 TYPE_INSTANCE_FLAGS (type
),
2425 /* Otherwise, rely on the stub flag being set for opaque/stubbed
2427 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
2429 const char *name
= type_name_no_tag (type
);
2430 /* FIXME: shouldn't we separately check the TYPE_NAME and the
2431 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
2432 as appropriate? (this code was written before TYPE_NAME and
2433 TYPE_TAG_NAME were separate). */
2438 stub_noname_complaint ();
2439 return make_qualified_type (type
, instance_flags
, NULL
);
2441 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0).symbol
;
2444 /* Same as above for opaque types, we can replace the stub
2445 with the complete type only if they are in the same
2447 if (TYPE_OBJFILE (SYMBOL_TYPE(sym
)) == TYPE_OBJFILE (type
))
2448 type
= make_qualified_type (SYMBOL_TYPE (sym
),
2449 TYPE_INSTANCE_FLAGS (type
),
2452 type
= SYMBOL_TYPE (sym
);
2456 if (TYPE_TARGET_STUB (type
))
2458 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
2460 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
2462 /* Nothing we can do. */
2464 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
2466 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
2467 TYPE_TARGET_STUB (type
) = 0;
2471 type
= make_qualified_type (type
, instance_flags
, NULL
);
2473 /* Cache TYPE_LENGTH for future use. */
2474 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
2479 /* Parse a type expression in the string [P..P+LENGTH). If an error
2480 occurs, silently return a void type. */
2482 static struct type
*
2483 safe_parse_type (struct gdbarch
*gdbarch
, char *p
, int length
)
2485 struct ui_file
*saved_gdb_stderr
;
2486 struct type
*type
= NULL
; /* Initialize to keep gcc happy. */
2488 /* Suppress error messages. */
2489 saved_gdb_stderr
= gdb_stderr
;
2490 gdb_stderr
= &null_stream
;
2492 /* Call parse_and_eval_type() without fear of longjmp()s. */
2495 type
= parse_and_eval_type (p
, length
);
2497 CATCH (except
, RETURN_MASK_ERROR
)
2499 type
= builtin_type (gdbarch
)->builtin_void
;
2503 /* Stop suppressing error messages. */
2504 gdb_stderr
= saved_gdb_stderr
;
2509 /* Ugly hack to convert method stubs into method types.
2511 He ain't kiddin'. This demangles the name of the method into a
2512 string including argument types, parses out each argument type,
2513 generates a string casting a zero to that type, evaluates the
2514 string, and stuffs the resulting type into an argtype vector!!!
2515 Then it knows the type of the whole function (including argument
2516 types for overloading), which info used to be in the stab's but was
2517 removed to hack back the space required for them. */
2520 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
2522 struct gdbarch
*gdbarch
= get_type_arch (type
);
2524 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
2525 char *demangled_name
= gdb_demangle (mangled_name
,
2526 DMGL_PARAMS
| DMGL_ANSI
);
2527 char *argtypetext
, *p
;
2528 int depth
= 0, argcount
= 1;
2529 struct field
*argtypes
;
2532 /* Make sure we got back a function string that we can use. */
2534 p
= strchr (demangled_name
, '(');
2538 if (demangled_name
== NULL
|| p
== NULL
)
2539 error (_("Internal: Cannot demangle mangled name `%s'."),
2542 /* Now, read in the parameters that define this type. */
2547 if (*p
== '(' || *p
== '<')
2551 else if (*p
== ')' || *p
== '>')
2555 else if (*p
== ',' && depth
== 0)
2563 /* If we read one argument and it was ``void'', don't count it. */
2564 if (startswith (argtypetext
, "(void)"))
2567 /* We need one extra slot, for the THIS pointer. */
2569 argtypes
= (struct field
*)
2570 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
2573 /* Add THIS pointer for non-static methods. */
2574 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
2575 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
2579 argtypes
[0].type
= lookup_pointer_type (type
);
2583 if (*p
!= ')') /* () means no args, skip while. */
2588 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
2590 /* Avoid parsing of ellipsis, they will be handled below.
2591 Also avoid ``void'' as above. */
2592 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
2593 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
2595 argtypes
[argcount
].type
=
2596 safe_parse_type (gdbarch
, argtypetext
, p
- argtypetext
);
2599 argtypetext
= p
+ 1;
2602 if (*p
== '(' || *p
== '<')
2606 else if (*p
== ')' || *p
== '>')
2615 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
2617 /* Now update the old "stub" type into a real type. */
2618 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
2619 /* MTYPE may currently be a function (TYPE_CODE_FUNC).
2620 We want a method (TYPE_CODE_METHOD). */
2621 smash_to_method_type (mtype
, type
, TYPE_TARGET_TYPE (mtype
),
2622 argtypes
, argcount
, p
[-2] == '.');
2623 TYPE_STUB (mtype
) = 0;
2624 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
2626 xfree (demangled_name
);
2629 /* This is the external interface to check_stub_method, above. This
2630 function unstubs all of the signatures for TYPE's METHOD_ID method
2631 name. After calling this function TYPE_FN_FIELD_STUB will be
2632 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
2635 This function unfortunately can not die until stabs do. */
2638 check_stub_method_group (struct type
*type
, int method_id
)
2640 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
2641 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
2642 int j
, found_stub
= 0;
2644 for (j
= 0; j
< len
; j
++)
2645 if (TYPE_FN_FIELD_STUB (f
, j
))
2648 check_stub_method (type
, method_id
, j
);
2651 /* GNU v3 methods with incorrect names were corrected when we read
2652 in type information, because it was cheaper to do it then. The
2653 only GNU v2 methods with incorrect method names are operators and
2654 destructors; destructors were also corrected when we read in type
2657 Therefore the only thing we need to handle here are v2 operator
2659 if (found_stub
&& !startswith (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z"))
2662 char dem_opname
[256];
2664 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
2666 dem_opname
, DMGL_ANSI
);
2668 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
2672 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
2676 /* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */
2677 const struct cplus_struct_type cplus_struct_default
= { };
2680 allocate_cplus_struct_type (struct type
*type
)
2682 if (HAVE_CPLUS_STRUCT (type
))
2683 /* Structure was already allocated. Nothing more to do. */
2686 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_CPLUS_STUFF
;
2687 TYPE_RAW_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
2688 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
2689 *(TYPE_RAW_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
2690 set_type_vptr_fieldno (type
, -1);
2693 const struct gnat_aux_type gnat_aux_default
=
2696 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
2697 and allocate the associated gnat-specific data. The gnat-specific
2698 data is also initialized to gnat_aux_default. */
2701 allocate_gnat_aux_type (struct type
*type
)
2703 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_GNAT_STUFF
;
2704 TYPE_GNAT_SPECIFIC (type
) = (struct gnat_aux_type
*)
2705 TYPE_ALLOC (type
, sizeof (struct gnat_aux_type
));
2706 *(TYPE_GNAT_SPECIFIC (type
)) = gnat_aux_default
;
2709 /* Helper function to initialize a newly allocated type. Set type code
2710 to CODE and initialize the type-specific fields accordingly. */
2713 set_type_code (struct type
*type
, enum type_code code
)
2715 TYPE_CODE (type
) = code
;
2719 case TYPE_CODE_STRUCT
:
2720 case TYPE_CODE_UNION
:
2721 case TYPE_CODE_NAMESPACE
:
2722 INIT_CPLUS_SPECIFIC (type
);
2725 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_FLOATFORMAT
;
2727 case TYPE_CODE_FUNC
:
2728 INIT_FUNC_SPECIFIC (type
);
2733 /* Helper function to verify floating-point format and size.
2734 BIT is the type size in bits; if BIT equals -1, the size is
2735 determined by the floatformat. Returns size to be used. */
2738 verify_floatformat (int bit
, const struct floatformat
*floatformat
)
2740 gdb_assert (floatformat
!= NULL
);
2743 bit
= floatformat
->totalsize
;
2745 gdb_assert (bit
>= 0);
2746 gdb_assert (bit
>= floatformat
->totalsize
);
2751 /* Return the floating-point format for a floating-point variable of
2754 const struct floatformat
*
2755 floatformat_from_type (const struct type
*type
)
2757 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLT
);
2758 gdb_assert (TYPE_FLOATFORMAT (type
));
2759 return TYPE_FLOATFORMAT (type
);
2762 /* Helper function to initialize the standard scalar types.
2764 If NAME is non-NULL, then it is used to initialize the type name.
2765 Note that NAME is not copied; it is required to have a lifetime at
2766 least as long as OBJFILE. */
2769 init_type (struct objfile
*objfile
, enum type_code code
, int bit
,
2774 type
= alloc_type (objfile
);
2775 set_type_code (type
, code
);
2776 gdb_assert ((bit
% TARGET_CHAR_BIT
) == 0);
2777 TYPE_LENGTH (type
) = bit
/ TARGET_CHAR_BIT
;
2778 TYPE_NAME (type
) = name
;
2783 /* Allocate a TYPE_CODE_ERROR type structure associated with OBJFILE,
2784 to use with variables that have no debug info. NAME is the type
2787 static struct type
*
2788 init_nodebug_var_type (struct objfile
*objfile
, const char *name
)
2790 return init_type (objfile
, TYPE_CODE_ERROR
, 0, name
);
2793 /* Allocate a TYPE_CODE_INT type structure associated with OBJFILE.
2794 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
2795 the type's TYPE_UNSIGNED flag. NAME is the type name. */
2798 init_integer_type (struct objfile
*objfile
,
2799 int bit
, int unsigned_p
, const char *name
)
2803 t
= init_type (objfile
, TYPE_CODE_INT
, bit
, name
);
2805 TYPE_UNSIGNED (t
) = 1;
2810 /* Allocate a TYPE_CODE_CHAR type structure associated with OBJFILE.
2811 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
2812 the type's TYPE_UNSIGNED flag. NAME is the type name. */
2815 init_character_type (struct objfile
*objfile
,
2816 int bit
, int unsigned_p
, const char *name
)
2820 t
= init_type (objfile
, TYPE_CODE_CHAR
, bit
, name
);
2822 TYPE_UNSIGNED (t
) = 1;
2827 /* Allocate a TYPE_CODE_BOOL type structure associated with OBJFILE.
2828 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
2829 the type's TYPE_UNSIGNED flag. NAME is the type name. */
2832 init_boolean_type (struct objfile
*objfile
,
2833 int bit
, int unsigned_p
, const char *name
)
2837 t
= init_type (objfile
, TYPE_CODE_BOOL
, bit
, name
);
2839 TYPE_UNSIGNED (t
) = 1;
2844 /* Allocate a TYPE_CODE_FLT type structure associated with OBJFILE.
2845 BIT is the type size in bits; if BIT equals -1, the size is
2846 determined by the floatformat. NAME is the type name. Set the
2847 TYPE_FLOATFORMAT from FLOATFORMATS. */
2850 init_float_type (struct objfile
*objfile
,
2851 int bit
, const char *name
,
2852 const struct floatformat
**floatformats
)
2854 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2855 const struct floatformat
*fmt
= floatformats
[gdbarch_byte_order (gdbarch
)];
2858 bit
= verify_floatformat (bit
, fmt
);
2859 t
= init_type (objfile
, TYPE_CODE_FLT
, bit
, name
);
2860 TYPE_FLOATFORMAT (t
) = fmt
;
2865 /* Allocate a TYPE_CODE_DECFLOAT type structure associated with OBJFILE.
2866 BIT is the type size in bits. NAME is the type name. */
2869 init_decfloat_type (struct objfile
*objfile
, int bit
, const char *name
)
2873 t
= init_type (objfile
, TYPE_CODE_DECFLOAT
, bit
, name
);
2877 /* Allocate a TYPE_CODE_COMPLEX type structure associated with OBJFILE.
2878 NAME is the type name. TARGET_TYPE is the component float type. */
2881 init_complex_type (struct objfile
*objfile
,
2882 const char *name
, struct type
*target_type
)
2886 t
= init_type (objfile
, TYPE_CODE_COMPLEX
,
2887 2 * TYPE_LENGTH (target_type
) * TARGET_CHAR_BIT
, name
);
2888 TYPE_TARGET_TYPE (t
) = target_type
;
2892 /* Allocate a TYPE_CODE_PTR type structure associated with OBJFILE.
2893 BIT is the pointer type size in bits. NAME is the type name.
2894 TARGET_TYPE is the pointer target type. Always sets the pointer type's
2895 TYPE_UNSIGNED flag. */
2898 init_pointer_type (struct objfile
*objfile
,
2899 int bit
, const char *name
, struct type
*target_type
)
2903 t
= init_type (objfile
, TYPE_CODE_PTR
, bit
, name
);
2904 TYPE_TARGET_TYPE (t
) = target_type
;
2905 TYPE_UNSIGNED (t
) = 1;
2910 /* Queries on types. */
2913 can_dereference (struct type
*t
)
2915 /* FIXME: Should we return true for references as well as
2917 t
= check_typedef (t
);
2920 && TYPE_CODE (t
) == TYPE_CODE_PTR
2921 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
2925 is_integral_type (struct type
*t
)
2927 t
= check_typedef (t
);
2930 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
2931 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
2932 || (TYPE_CODE (t
) == TYPE_CODE_FLAGS
)
2933 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
2934 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
2935 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
2938 /* Return true if TYPE is scalar. */
2941 is_scalar_type (struct type
*type
)
2943 type
= check_typedef (type
);
2945 switch (TYPE_CODE (type
))
2947 case TYPE_CODE_ARRAY
:
2948 case TYPE_CODE_STRUCT
:
2949 case TYPE_CODE_UNION
:
2951 case TYPE_CODE_STRING
:
2958 /* Return true if T is scalar, or a composite type which in practice has
2959 the memory layout of a scalar type. E.g., an array or struct with only
2960 one scalar element inside it, or a union with only scalar elements. */
2963 is_scalar_type_recursive (struct type
*t
)
2965 t
= check_typedef (t
);
2967 if (is_scalar_type (t
))
2969 /* Are we dealing with an array or string of known dimensions? */
2970 else if ((TYPE_CODE (t
) == TYPE_CODE_ARRAY
2971 || TYPE_CODE (t
) == TYPE_CODE_STRING
) && TYPE_NFIELDS (t
) == 1
2972 && TYPE_CODE (TYPE_INDEX_TYPE (t
)) == TYPE_CODE_RANGE
)
2974 LONGEST low_bound
, high_bound
;
2975 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (t
));
2977 get_discrete_bounds (TYPE_INDEX_TYPE (t
), &low_bound
, &high_bound
);
2979 return high_bound
== low_bound
&& is_scalar_type_recursive (elt_type
);
2981 /* Are we dealing with a struct with one element? */
2982 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
&& TYPE_NFIELDS (t
) == 1)
2983 return is_scalar_type_recursive (TYPE_FIELD_TYPE (t
, 0));
2984 else if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
2986 int i
, n
= TYPE_NFIELDS (t
);
2988 /* If all elements of the union are scalar, then the union is scalar. */
2989 for (i
= 0; i
< n
; i
++)
2990 if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t
, i
)))
2999 /* Return true is T is a class or a union. False otherwise. */
3002 class_or_union_p (const struct type
*t
)
3004 return (TYPE_CODE (t
) == TYPE_CODE_STRUCT
3005 || TYPE_CODE (t
) == TYPE_CODE_UNION
);
3008 /* A helper function which returns true if types A and B represent the
3009 "same" class type. This is true if the types have the same main
3010 type, or the same name. */
3013 class_types_same_p (const struct type
*a
, const struct type
*b
)
3015 return (TYPE_MAIN_TYPE (a
) == TYPE_MAIN_TYPE (b
)
3016 || (TYPE_NAME (a
) && TYPE_NAME (b
)
3017 && !strcmp (TYPE_NAME (a
), TYPE_NAME (b
))));
3020 /* If BASE is an ancestor of DCLASS return the distance between them.
3021 otherwise return -1;
3025 class B: public A {};
3026 class C: public B {};
3029 distance_to_ancestor (A, A, 0) = 0
3030 distance_to_ancestor (A, B, 0) = 1
3031 distance_to_ancestor (A, C, 0) = 2
3032 distance_to_ancestor (A, D, 0) = 3
3034 If PUBLIC is 1 then only public ancestors are considered,
3035 and the function returns the distance only if BASE is a public ancestor
3039 distance_to_ancestor (A, D, 1) = -1. */
3042 distance_to_ancestor (struct type
*base
, struct type
*dclass
, int is_public
)
3047 base
= check_typedef (base
);
3048 dclass
= check_typedef (dclass
);
3050 if (class_types_same_p (base
, dclass
))
3053 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
3055 if (is_public
&& ! BASETYPE_VIA_PUBLIC (dclass
, i
))
3058 d
= distance_to_ancestor (base
, TYPE_BASECLASS (dclass
, i
), is_public
);
3066 /* Check whether BASE is an ancestor or base class or DCLASS
3067 Return 1 if so, and 0 if not.
3068 Note: If BASE and DCLASS are of the same type, this function
3069 will return 1. So for some class A, is_ancestor (A, A) will
3073 is_ancestor (struct type
*base
, struct type
*dclass
)
3075 return distance_to_ancestor (base
, dclass
, 0) >= 0;
3078 /* Like is_ancestor, but only returns true when BASE is a public
3079 ancestor of DCLASS. */
3082 is_public_ancestor (struct type
*base
, struct type
*dclass
)
3084 return distance_to_ancestor (base
, dclass
, 1) >= 0;
3087 /* A helper function for is_unique_ancestor. */
3090 is_unique_ancestor_worker (struct type
*base
, struct type
*dclass
,
3092 const gdb_byte
*valaddr
, int embedded_offset
,
3093 CORE_ADDR address
, struct value
*val
)
3097 base
= check_typedef (base
);
3098 dclass
= check_typedef (dclass
);
3100 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
) && count
< 2; ++i
)
3105 iter
= check_typedef (TYPE_BASECLASS (dclass
, i
));
3107 this_offset
= baseclass_offset (dclass
, i
, valaddr
, embedded_offset
,
3110 if (class_types_same_p (base
, iter
))
3112 /* If this is the first subclass, set *OFFSET and set count
3113 to 1. Otherwise, if this is at the same offset as
3114 previous instances, do nothing. Otherwise, increment
3118 *offset
= this_offset
;
3121 else if (this_offset
== *offset
)
3129 count
+= is_unique_ancestor_worker (base
, iter
, offset
,
3131 embedded_offset
+ this_offset
,
3138 /* Like is_ancestor, but only returns true if BASE is a unique base
3139 class of the type of VAL. */
3142 is_unique_ancestor (struct type
*base
, struct value
*val
)
3146 return is_unique_ancestor_worker (base
, value_type (val
), &offset
,
3147 value_contents_for_printing (val
),
3148 value_embedded_offset (val
),
3149 value_address (val
), val
) == 1;
3153 /* Overload resolution. */
3155 /* Return the sum of the rank of A with the rank of B. */
3158 sum_ranks (struct rank a
, struct rank b
)
3161 c
.rank
= a
.rank
+ b
.rank
;
3162 c
.subrank
= a
.subrank
+ b
.subrank
;
3166 /* Compare rank A and B and return:
3168 1 if a is better than b
3169 -1 if b is better than a. */
3172 compare_ranks (struct rank a
, struct rank b
)
3174 if (a
.rank
== b
.rank
)
3176 if (a
.subrank
== b
.subrank
)
3178 if (a
.subrank
< b
.subrank
)
3180 if (a
.subrank
> b
.subrank
)
3184 if (a
.rank
< b
.rank
)
3187 /* a.rank > b.rank */
3191 /* Functions for overload resolution begin here. */
3193 /* Compare two badness vectors A and B and return the result.
3194 0 => A and B are identical
3195 1 => A and B are incomparable
3196 2 => A is better than B
3197 3 => A is worse than B */
3200 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
3204 short found_pos
= 0; /* any positives in c? */
3205 short found_neg
= 0; /* any negatives in c? */
3207 /* differing lengths => incomparable */
3208 if (a
->length
!= b
->length
)
3211 /* Subtract b from a */
3212 for (i
= 0; i
< a
->length
; i
++)
3214 tmp
= compare_ranks (b
->rank
[i
], a
->rank
[i
]);
3224 return 1; /* incomparable */
3226 return 3; /* A > B */
3232 return 2; /* A < B */
3234 return 0; /* A == B */
3238 /* Rank a function by comparing its parameter types (PARMS, length
3239 NPARMS), to the types of an argument list (ARGS, length NARGS).
3240 Return a pointer to a badness vector. This has NARGS + 1
3243 struct badness_vector
*
3244 rank_function (struct type
**parms
, int nparms
,
3245 struct value
**args
, int nargs
)
3248 struct badness_vector
*bv
= XNEW (struct badness_vector
);
3249 int min_len
= nparms
< nargs
? nparms
: nargs
;
3251 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank. */
3252 bv
->rank
= XNEWVEC (struct rank
, nargs
+ 1);
3254 /* First compare the lengths of the supplied lists.
3255 If there is a mismatch, set it to a high value. */
3257 /* pai/1997-06-03 FIXME: when we have debug info about default
3258 arguments and ellipsis parameter lists, we should consider those
3259 and rank the length-match more finely. */
3261 LENGTH_MATCH (bv
) = (nargs
!= nparms
)
3262 ? LENGTH_MISMATCH_BADNESS
3263 : EXACT_MATCH_BADNESS
;
3265 /* Now rank all the parameters of the candidate function. */
3266 for (i
= 1; i
<= min_len
; i
++)
3267 bv
->rank
[i
] = rank_one_type (parms
[i
- 1], value_type (args
[i
- 1]),
3270 /* If more arguments than parameters, add dummy entries. */
3271 for (i
= min_len
+ 1; i
<= nargs
; i
++)
3272 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
3277 /* Compare the names of two integer types, assuming that any sign
3278 qualifiers have been checked already. We do it this way because
3279 there may be an "int" in the name of one of the types. */
3282 integer_types_same_name_p (const char *first
, const char *second
)
3284 int first_p
, second_p
;
3286 /* If both are shorts, return 1; if neither is a short, keep
3288 first_p
= (strstr (first
, "short") != NULL
);
3289 second_p
= (strstr (second
, "short") != NULL
);
3290 if (first_p
&& second_p
)
3292 if (first_p
|| second_p
)
3295 /* Likewise for long. */
3296 first_p
= (strstr (first
, "long") != NULL
);
3297 second_p
= (strstr (second
, "long") != NULL
);
3298 if (first_p
&& second_p
)
3300 if (first_p
|| second_p
)
3303 /* Likewise for char. */
3304 first_p
= (strstr (first
, "char") != NULL
);
3305 second_p
= (strstr (second
, "char") != NULL
);
3306 if (first_p
&& second_p
)
3308 if (first_p
|| second_p
)
3311 /* They must both be ints. */
3315 /* Compares type A to type B returns 1 if the represent the same type
3319 types_equal (struct type
*a
, struct type
*b
)
3321 /* Identical type pointers. */
3322 /* However, this still doesn't catch all cases of same type for b
3323 and a. The reason is that builtin types are different from
3324 the same ones constructed from the object. */
3328 /* Resolve typedefs */
3329 if (TYPE_CODE (a
) == TYPE_CODE_TYPEDEF
)
3330 a
= check_typedef (a
);
3331 if (TYPE_CODE (b
) == TYPE_CODE_TYPEDEF
)
3332 b
= check_typedef (b
);
3334 /* If after resolving typedefs a and b are not of the same type
3335 code then they are not equal. */
3336 if (TYPE_CODE (a
) != TYPE_CODE (b
))
3339 /* If a and b are both pointers types or both reference types then
3340 they are equal of the same type iff the objects they refer to are
3341 of the same type. */
3342 if (TYPE_CODE (a
) == TYPE_CODE_PTR
3343 || TYPE_CODE (a
) == TYPE_CODE_REF
)
3344 return types_equal (TYPE_TARGET_TYPE (a
),
3345 TYPE_TARGET_TYPE (b
));
3347 /* Well, damnit, if the names are exactly the same, I'll say they
3348 are exactly the same. This happens when we generate method
3349 stubs. The types won't point to the same address, but they
3350 really are the same. */
3352 if (TYPE_NAME (a
) && TYPE_NAME (b
)
3353 && strcmp (TYPE_NAME (a
), TYPE_NAME (b
)) == 0)
3356 /* Check if identical after resolving typedefs. */
3360 /* Two function types are equal if their argument and return types
3362 if (TYPE_CODE (a
) == TYPE_CODE_FUNC
)
3366 if (TYPE_NFIELDS (a
) != TYPE_NFIELDS (b
))
3369 if (!types_equal (TYPE_TARGET_TYPE (a
), TYPE_TARGET_TYPE (b
)))
3372 for (i
= 0; i
< TYPE_NFIELDS (a
); ++i
)
3373 if (!types_equal (TYPE_FIELD_TYPE (a
, i
), TYPE_FIELD_TYPE (b
, i
)))
3382 /* Deep comparison of types. */
3384 /* An entry in the type-equality bcache. */
3386 typedef struct type_equality_entry
3388 struct type
*type1
, *type2
;
3389 } type_equality_entry_d
;
3391 DEF_VEC_O (type_equality_entry_d
);
3393 /* A helper function to compare two strings. Returns 1 if they are
3394 the same, 0 otherwise. Handles NULLs properly. */
3397 compare_maybe_null_strings (const char *s
, const char *t
)
3399 if (s
== NULL
&& t
!= NULL
)
3401 else if (s
!= NULL
&& t
== NULL
)
3403 else if (s
== NULL
&& t
== NULL
)
3405 return strcmp (s
, t
) == 0;
3408 /* A helper function for check_types_worklist that checks two types for
3409 "deep" equality. Returns non-zero if the types are considered the
3410 same, zero otherwise. */
3413 check_types_equal (struct type
*type1
, struct type
*type2
,
3414 VEC (type_equality_entry_d
) **worklist
)
3416 type1
= check_typedef (type1
);
3417 type2
= check_typedef (type2
);
3422 if (TYPE_CODE (type1
) != TYPE_CODE (type2
)
3423 || TYPE_LENGTH (type1
) != TYPE_LENGTH (type2
)
3424 || TYPE_UNSIGNED (type1
) != TYPE_UNSIGNED (type2
)
3425 || TYPE_NOSIGN (type1
) != TYPE_NOSIGN (type2
)
3426 || TYPE_VARARGS (type1
) != TYPE_VARARGS (type2
)
3427 || TYPE_VECTOR (type1
) != TYPE_VECTOR (type2
)
3428 || TYPE_NOTTEXT (type1
) != TYPE_NOTTEXT (type2
)
3429 || TYPE_INSTANCE_FLAGS (type1
) != TYPE_INSTANCE_FLAGS (type2
)
3430 || TYPE_NFIELDS (type1
) != TYPE_NFIELDS (type2
))
3433 if (!compare_maybe_null_strings (TYPE_TAG_NAME (type1
),
3434 TYPE_TAG_NAME (type2
)))
3436 if (!compare_maybe_null_strings (TYPE_NAME (type1
), TYPE_NAME (type2
)))
3439 if (TYPE_CODE (type1
) == TYPE_CODE_RANGE
)
3441 if (memcmp (TYPE_RANGE_DATA (type1
), TYPE_RANGE_DATA (type2
),
3442 sizeof (*TYPE_RANGE_DATA (type1
))) != 0)
3449 for (i
= 0; i
< TYPE_NFIELDS (type1
); ++i
)
3451 const struct field
*field1
= &TYPE_FIELD (type1
, i
);
3452 const struct field
*field2
= &TYPE_FIELD (type2
, i
);
3453 struct type_equality_entry entry
;
3455 if (FIELD_ARTIFICIAL (*field1
) != FIELD_ARTIFICIAL (*field2
)
3456 || FIELD_BITSIZE (*field1
) != FIELD_BITSIZE (*field2
)
3457 || FIELD_LOC_KIND (*field1
) != FIELD_LOC_KIND (*field2
))
3459 if (!compare_maybe_null_strings (FIELD_NAME (*field1
),
3460 FIELD_NAME (*field2
)))
3462 switch (FIELD_LOC_KIND (*field1
))
3464 case FIELD_LOC_KIND_BITPOS
:
3465 if (FIELD_BITPOS (*field1
) != FIELD_BITPOS (*field2
))
3468 case FIELD_LOC_KIND_ENUMVAL
:
3469 if (FIELD_ENUMVAL (*field1
) != FIELD_ENUMVAL (*field2
))
3472 case FIELD_LOC_KIND_PHYSADDR
:
3473 if (FIELD_STATIC_PHYSADDR (*field1
)
3474 != FIELD_STATIC_PHYSADDR (*field2
))
3477 case FIELD_LOC_KIND_PHYSNAME
:
3478 if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1
),
3479 FIELD_STATIC_PHYSNAME (*field2
)))
3482 case FIELD_LOC_KIND_DWARF_BLOCK
:
3484 struct dwarf2_locexpr_baton
*block1
, *block2
;
3486 block1
= FIELD_DWARF_BLOCK (*field1
);
3487 block2
= FIELD_DWARF_BLOCK (*field2
);
3488 if (block1
->per_cu
!= block2
->per_cu
3489 || block1
->size
!= block2
->size
3490 || memcmp (block1
->data
, block2
->data
, block1
->size
) != 0)
3495 internal_error (__FILE__
, __LINE__
, _("Unsupported field kind "
3496 "%d by check_types_equal"),
3497 FIELD_LOC_KIND (*field1
));
3500 entry
.type1
= FIELD_TYPE (*field1
);
3501 entry
.type2
= FIELD_TYPE (*field2
);
3502 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
3506 if (TYPE_TARGET_TYPE (type1
) != NULL
)
3508 struct type_equality_entry entry
;
3510 if (TYPE_TARGET_TYPE (type2
) == NULL
)
3513 entry
.type1
= TYPE_TARGET_TYPE (type1
);
3514 entry
.type2
= TYPE_TARGET_TYPE (type2
);
3515 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
3517 else if (TYPE_TARGET_TYPE (type2
) != NULL
)
3523 /* Check types on a worklist for equality. Returns zero if any pair
3524 is not equal, non-zero if they are all considered equal. */
3527 check_types_worklist (VEC (type_equality_entry_d
) **worklist
,
3528 struct bcache
*cache
)
3530 while (!VEC_empty (type_equality_entry_d
, *worklist
))
3532 struct type_equality_entry entry
;
3535 entry
= *VEC_last (type_equality_entry_d
, *worklist
);
3536 VEC_pop (type_equality_entry_d
, *worklist
);
3538 /* If the type pair has already been visited, we know it is
3540 bcache_full (&entry
, sizeof (entry
), cache
, &added
);
3544 if (check_types_equal (entry
.type1
, entry
.type2
, worklist
) == 0)
3551 /* Return non-zero if types TYPE1 and TYPE2 are equal, as determined by a
3552 "deep comparison". Otherwise return zero. */
3555 types_deeply_equal (struct type
*type1
, struct type
*type2
)
3557 struct gdb_exception except
= exception_none
;
3559 struct bcache
*cache
;
3560 VEC (type_equality_entry_d
) *worklist
= NULL
;
3561 struct type_equality_entry entry
;
3563 gdb_assert (type1
!= NULL
&& type2
!= NULL
);
3565 /* Early exit for the simple case. */
3569 cache
= bcache_xmalloc (NULL
, NULL
);
3571 entry
.type1
= type1
;
3572 entry
.type2
= type2
;
3573 VEC_safe_push (type_equality_entry_d
, worklist
, &entry
);
3575 /* check_types_worklist calls several nested helper functions, some
3576 of which can raise a GDB exception, so we just check and rethrow
3577 here. If there is a GDB exception, a comparison is not capable
3578 (or trusted), so exit. */
3581 result
= check_types_worklist (&worklist
, cache
);
3583 CATCH (ex
, RETURN_MASK_ALL
)
3589 bcache_xfree (cache
);
3590 VEC_free (type_equality_entry_d
, worklist
);
3592 /* Rethrow if there was a problem. */
3593 if (except
.reason
< 0)
3594 throw_exception (except
);
3599 /* Allocated status of type TYPE. Return zero if type TYPE is allocated.
3600 Otherwise return one. */
3603 type_not_allocated (const struct type
*type
)
3605 struct dynamic_prop
*prop
= TYPE_ALLOCATED_PROP (type
);
3607 return (prop
&& TYPE_DYN_PROP_KIND (prop
) == PROP_CONST
3608 && !TYPE_DYN_PROP_ADDR (prop
));
3611 /* Associated status of type TYPE. Return zero if type TYPE is associated.
3612 Otherwise return one. */
3615 type_not_associated (const struct type
*type
)
3617 struct dynamic_prop
*prop
= TYPE_ASSOCIATED_PROP (type
);
3619 return (prop
&& TYPE_DYN_PROP_KIND (prop
) == PROP_CONST
3620 && !TYPE_DYN_PROP_ADDR (prop
));
3623 /* Compare one type (PARM) for compatibility with another (ARG).
3624 * PARM is intended to be the parameter type of a function; and
3625 * ARG is the supplied argument's type. This function tests if
3626 * the latter can be converted to the former.
3627 * VALUE is the argument's value or NULL if none (or called recursively)
3629 * Return 0 if they are identical types;
3630 * Otherwise, return an integer which corresponds to how compatible
3631 * PARM is to ARG. The higher the return value, the worse the match.
3632 * Generally the "bad" conversions are all uniformly assigned a 100. */
3635 rank_one_type (struct type
*parm
, struct type
*arg
, struct value
*value
)
3637 struct rank rank
= {0,0};
3639 /* Resolve typedefs */
3640 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
3641 parm
= check_typedef (parm
);
3642 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
3643 arg
= check_typedef (arg
);
3645 if (TYPE_IS_REFERENCE (parm
) && value
!= NULL
)
3647 if (VALUE_LVAL (value
) == not_lval
)
3649 /* Rvalues should preferably bind to rvalue references or const
3650 lvalue references. */
3651 if (TYPE_CODE (parm
) == TYPE_CODE_RVALUE_REF
)
3652 rank
.subrank
= REFERENCE_CONVERSION_RVALUE
;
3653 else if (TYPE_CONST (TYPE_TARGET_TYPE (parm
)))
3654 rank
.subrank
= REFERENCE_CONVERSION_CONST_LVALUE
;
3656 return INCOMPATIBLE_TYPE_BADNESS
;
3657 return sum_ranks (rank
, REFERENCE_CONVERSION_BADNESS
);
3661 /* Lvalues should prefer lvalue overloads. */
3662 if (TYPE_CODE (parm
) == TYPE_CODE_RVALUE_REF
)
3664 rank
.subrank
= REFERENCE_CONVERSION_RVALUE
;
3665 return sum_ranks (rank
, REFERENCE_CONVERSION_BADNESS
);
3670 if (types_equal (parm
, arg
))
3672 struct type
*t1
= parm
;
3673 struct type
*t2
= arg
;
3675 /* For pointers and references, compare target type. */
3676 if (TYPE_CODE (parm
) == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (parm
))
3678 t1
= TYPE_TARGET_TYPE (parm
);
3679 t2
= TYPE_TARGET_TYPE (arg
);
3682 /* Make sure they are CV equal, too. */
3683 if (TYPE_CONST (t1
) != TYPE_CONST (t2
))
3684 rank
.subrank
|= CV_CONVERSION_CONST
;
3685 if (TYPE_VOLATILE (t1
) != TYPE_VOLATILE (t2
))
3686 rank
.subrank
|= CV_CONVERSION_VOLATILE
;
3687 if (rank
.subrank
!= 0)
3688 return sum_ranks (CV_CONVERSION_BADNESS
, rank
);
3689 return EXACT_MATCH_BADNESS
;
3692 /* See through references, since we can almost make non-references
3695 if (TYPE_IS_REFERENCE (arg
))
3696 return (sum_ranks (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
),
3697 REFERENCE_CONVERSION_BADNESS
));
3698 if (TYPE_IS_REFERENCE (parm
))
3699 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
),
3700 REFERENCE_CONVERSION_BADNESS
));
3702 /* Debugging only. */
3703 fprintf_filtered (gdb_stderr
,
3704 "------ Arg is %s [%d], parm is %s [%d]\n",
3705 TYPE_NAME (arg
), TYPE_CODE (arg
),
3706 TYPE_NAME (parm
), TYPE_CODE (parm
));
3708 /* x -> y means arg of type x being supplied for parameter of type y. */
3710 switch (TYPE_CODE (parm
))
3713 switch (TYPE_CODE (arg
))
3717 /* Allowed pointer conversions are:
3718 (a) pointer to void-pointer conversion. */
3719 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
3720 return VOID_PTR_CONVERSION_BADNESS
;
3722 /* (b) pointer to ancestor-pointer conversion. */
3723 rank
.subrank
= distance_to_ancestor (TYPE_TARGET_TYPE (parm
),
3724 TYPE_TARGET_TYPE (arg
),
3726 if (rank
.subrank
>= 0)
3727 return sum_ranks (BASE_PTR_CONVERSION_BADNESS
, rank
);
3729 return INCOMPATIBLE_TYPE_BADNESS
;
3730 case TYPE_CODE_ARRAY
:
3732 struct type
*t1
= TYPE_TARGET_TYPE (parm
);
3733 struct type
*t2
= TYPE_TARGET_TYPE (arg
);
3735 if (types_equal (t1
, t2
))
3737 /* Make sure they are CV equal. */
3738 if (TYPE_CONST (t1
) != TYPE_CONST (t2
))
3739 rank
.subrank
|= CV_CONVERSION_CONST
;
3740 if (TYPE_VOLATILE (t1
) != TYPE_VOLATILE (t2
))
3741 rank
.subrank
|= CV_CONVERSION_VOLATILE
;
3742 if (rank
.subrank
!= 0)
3743 return sum_ranks (CV_CONVERSION_BADNESS
, rank
);
3744 return EXACT_MATCH_BADNESS
;
3746 return INCOMPATIBLE_TYPE_BADNESS
;
3748 case TYPE_CODE_FUNC
:
3749 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
);
3751 if (value
!= NULL
&& TYPE_CODE (value_type (value
)) == TYPE_CODE_INT
)
3753 if (value_as_long (value
) == 0)
3755 /* Null pointer conversion: allow it to be cast to a pointer.
3756 [4.10.1 of C++ standard draft n3290] */
3757 return NULL_POINTER_CONVERSION_BADNESS
;
3761 /* If type checking is disabled, allow the conversion. */
3762 if (!strict_type_checking
)
3763 return NS_INTEGER_POINTER_CONVERSION_BADNESS
;
3767 case TYPE_CODE_ENUM
:
3768 case TYPE_CODE_FLAGS
:
3769 case TYPE_CODE_CHAR
:
3770 case TYPE_CODE_RANGE
:
3771 case TYPE_CODE_BOOL
:
3773 return INCOMPATIBLE_TYPE_BADNESS
;
3775 case TYPE_CODE_ARRAY
:
3776 switch (TYPE_CODE (arg
))
3779 case TYPE_CODE_ARRAY
:
3780 return rank_one_type (TYPE_TARGET_TYPE (parm
),
3781 TYPE_TARGET_TYPE (arg
), NULL
);
3783 return INCOMPATIBLE_TYPE_BADNESS
;
3785 case TYPE_CODE_FUNC
:
3786 switch (TYPE_CODE (arg
))
3788 case TYPE_CODE_PTR
: /* funcptr -> func */
3789 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
);
3791 return INCOMPATIBLE_TYPE_BADNESS
;
3794 switch (TYPE_CODE (arg
))
3797 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
3799 /* Deal with signed, unsigned, and plain chars and
3800 signed and unsigned ints. */
3801 if (TYPE_NOSIGN (parm
))
3803 /* This case only for character types. */
3804 if (TYPE_NOSIGN (arg
))
3805 return EXACT_MATCH_BADNESS
; /* plain char -> plain char */
3806 else /* signed/unsigned char -> plain char */
3807 return INTEGER_CONVERSION_BADNESS
;
3809 else if (TYPE_UNSIGNED (parm
))
3811 if (TYPE_UNSIGNED (arg
))
3813 /* unsigned int -> unsigned int, or
3814 unsigned long -> unsigned long */
3815 if (integer_types_same_name_p (TYPE_NAME (parm
),
3817 return EXACT_MATCH_BADNESS
;
3818 else if (integer_types_same_name_p (TYPE_NAME (arg
),
3820 && integer_types_same_name_p (TYPE_NAME (parm
),
3822 /* unsigned int -> unsigned long */
3823 return INTEGER_PROMOTION_BADNESS
;
3825 /* unsigned long -> unsigned int */
3826 return INTEGER_CONVERSION_BADNESS
;
3830 if (integer_types_same_name_p (TYPE_NAME (arg
),
3832 && integer_types_same_name_p (TYPE_NAME (parm
),
3834 /* signed long -> unsigned int */
3835 return INTEGER_CONVERSION_BADNESS
;
3837 /* signed int/long -> unsigned int/long */
3838 return INTEGER_CONVERSION_BADNESS
;
3841 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
3843 if (integer_types_same_name_p (TYPE_NAME (parm
),
3845 return EXACT_MATCH_BADNESS
;
3846 else if (integer_types_same_name_p (TYPE_NAME (arg
),
3848 && integer_types_same_name_p (TYPE_NAME (parm
),
3850 return INTEGER_PROMOTION_BADNESS
;
3852 return INTEGER_CONVERSION_BADNESS
;
3855 return INTEGER_CONVERSION_BADNESS
;
3857 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
3858 return INTEGER_PROMOTION_BADNESS
;
3860 return INTEGER_CONVERSION_BADNESS
;
3861 case TYPE_CODE_ENUM
:
3862 case TYPE_CODE_FLAGS
:
3863 case TYPE_CODE_CHAR
:
3864 case TYPE_CODE_RANGE
:
3865 case TYPE_CODE_BOOL
:
3866 if (TYPE_DECLARED_CLASS (arg
))
3867 return INCOMPATIBLE_TYPE_BADNESS
;
3868 return INTEGER_PROMOTION_BADNESS
;
3870 return INT_FLOAT_CONVERSION_BADNESS
;
3872 return NS_POINTER_CONVERSION_BADNESS
;
3874 return INCOMPATIBLE_TYPE_BADNESS
;
3877 case TYPE_CODE_ENUM
:
3878 switch (TYPE_CODE (arg
))
3881 case TYPE_CODE_CHAR
:
3882 case TYPE_CODE_RANGE
:
3883 case TYPE_CODE_BOOL
:
3884 case TYPE_CODE_ENUM
:
3885 if (TYPE_DECLARED_CLASS (parm
) || TYPE_DECLARED_CLASS (arg
))
3886 return INCOMPATIBLE_TYPE_BADNESS
;
3887 return INTEGER_CONVERSION_BADNESS
;
3889 return INT_FLOAT_CONVERSION_BADNESS
;
3891 return INCOMPATIBLE_TYPE_BADNESS
;
3894 case TYPE_CODE_CHAR
:
3895 switch (TYPE_CODE (arg
))
3897 case TYPE_CODE_RANGE
:
3898 case TYPE_CODE_BOOL
:
3899 case TYPE_CODE_ENUM
:
3900 if (TYPE_DECLARED_CLASS (arg
))
3901 return INCOMPATIBLE_TYPE_BADNESS
;
3902 return INTEGER_CONVERSION_BADNESS
;
3904 return INT_FLOAT_CONVERSION_BADNESS
;
3906 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
3907 return INTEGER_CONVERSION_BADNESS
;
3908 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
3909 return INTEGER_PROMOTION_BADNESS
;
3910 /* >>> !! else fall through !! <<< */
3911 case TYPE_CODE_CHAR
:
3912 /* Deal with signed, unsigned, and plain chars for C++ and
3913 with int cases falling through from previous case. */
3914 if (TYPE_NOSIGN (parm
))
3916 if (TYPE_NOSIGN (arg
))
3917 return EXACT_MATCH_BADNESS
;
3919 return INTEGER_CONVERSION_BADNESS
;
3921 else if (TYPE_UNSIGNED (parm
))
3923 if (TYPE_UNSIGNED (arg
))
3924 return EXACT_MATCH_BADNESS
;
3926 return INTEGER_PROMOTION_BADNESS
;
3928 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
3929 return EXACT_MATCH_BADNESS
;
3931 return INTEGER_CONVERSION_BADNESS
;
3933 return INCOMPATIBLE_TYPE_BADNESS
;
3936 case TYPE_CODE_RANGE
:
3937 switch (TYPE_CODE (arg
))
3940 case TYPE_CODE_CHAR
:
3941 case TYPE_CODE_RANGE
:
3942 case TYPE_CODE_BOOL
:
3943 case TYPE_CODE_ENUM
:
3944 return INTEGER_CONVERSION_BADNESS
;
3946 return INT_FLOAT_CONVERSION_BADNESS
;
3948 return INCOMPATIBLE_TYPE_BADNESS
;
3951 case TYPE_CODE_BOOL
:
3952 switch (TYPE_CODE (arg
))
3954 /* n3290 draft, section 4.12.1 (conv.bool):
3956 "A prvalue of arithmetic, unscoped enumeration, pointer, or
3957 pointer to member type can be converted to a prvalue of type
3958 bool. A zero value, null pointer value, or null member pointer
3959 value is converted to false; any other value is converted to
3960 true. A prvalue of type std::nullptr_t can be converted to a
3961 prvalue of type bool; the resulting value is false." */
3963 case TYPE_CODE_CHAR
:
3964 case TYPE_CODE_ENUM
:
3966 case TYPE_CODE_MEMBERPTR
:
3968 return BOOL_CONVERSION_BADNESS
;
3969 case TYPE_CODE_RANGE
:
3970 return INCOMPATIBLE_TYPE_BADNESS
;
3971 case TYPE_CODE_BOOL
:
3972 return EXACT_MATCH_BADNESS
;
3974 return INCOMPATIBLE_TYPE_BADNESS
;
3978 switch (TYPE_CODE (arg
))
3981 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
3982 return FLOAT_PROMOTION_BADNESS
;
3983 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
3984 return EXACT_MATCH_BADNESS
;
3986 return FLOAT_CONVERSION_BADNESS
;
3988 case TYPE_CODE_BOOL
:
3989 case TYPE_CODE_ENUM
:
3990 case TYPE_CODE_RANGE
:
3991 case TYPE_CODE_CHAR
:
3992 return INT_FLOAT_CONVERSION_BADNESS
;
3994 return INCOMPATIBLE_TYPE_BADNESS
;
3997 case TYPE_CODE_COMPLEX
:
3998 switch (TYPE_CODE (arg
))
3999 { /* Strictly not needed for C++, but... */
4001 return FLOAT_PROMOTION_BADNESS
;
4002 case TYPE_CODE_COMPLEX
:
4003 return EXACT_MATCH_BADNESS
;
4005 return INCOMPATIBLE_TYPE_BADNESS
;
4008 case TYPE_CODE_STRUCT
:
4009 switch (TYPE_CODE (arg
))
4011 case TYPE_CODE_STRUCT
:
4012 /* Check for derivation */
4013 rank
.subrank
= distance_to_ancestor (parm
, arg
, 0);
4014 if (rank
.subrank
>= 0)
4015 return sum_ranks (BASE_CONVERSION_BADNESS
, rank
);
4016 /* else fall through */
4018 return INCOMPATIBLE_TYPE_BADNESS
;
4021 case TYPE_CODE_UNION
:
4022 switch (TYPE_CODE (arg
))
4024 case TYPE_CODE_UNION
:
4026 return INCOMPATIBLE_TYPE_BADNESS
;
4029 case TYPE_CODE_MEMBERPTR
:
4030 switch (TYPE_CODE (arg
))
4033 return INCOMPATIBLE_TYPE_BADNESS
;
4036 case TYPE_CODE_METHOD
:
4037 switch (TYPE_CODE (arg
))
4041 return INCOMPATIBLE_TYPE_BADNESS
;
4045 switch (TYPE_CODE (arg
))
4049 return INCOMPATIBLE_TYPE_BADNESS
;
4054 switch (TYPE_CODE (arg
))
4058 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0),
4059 TYPE_FIELD_TYPE (arg
, 0), NULL
);
4061 return INCOMPATIBLE_TYPE_BADNESS
;
4064 case TYPE_CODE_VOID
:
4066 return INCOMPATIBLE_TYPE_BADNESS
;
4067 } /* switch (TYPE_CODE (arg)) */
4070 /* End of functions for overload resolution. */
4072 /* Routines to pretty-print types. */
4075 print_bit_vector (B_TYPE
*bits
, int nbits
)
4079 for (bitno
= 0; bitno
< nbits
; bitno
++)
4081 if ((bitno
% 8) == 0)
4083 puts_filtered (" ");
4085 if (B_TST (bits
, bitno
))
4086 printf_filtered (("1"));
4088 printf_filtered (("0"));
4092 /* Note the first arg should be the "this" pointer, we may not want to
4093 include it since we may get into a infinitely recursive
4097 print_args (struct field
*args
, int nargs
, int spaces
)
4103 for (i
= 0; i
< nargs
; i
++)
4105 printfi_filtered (spaces
, "[%d] name '%s'\n", i
,
4106 args
[i
].name
!= NULL
? args
[i
].name
: "<NULL>");
4107 recursive_dump_type (args
[i
].type
, spaces
+ 2);
4113 field_is_static (struct field
*f
)
4115 /* "static" fields are the fields whose location is not relative
4116 to the address of the enclosing struct. It would be nice to
4117 have a dedicated flag that would be set for static fields when
4118 the type is being created. But in practice, checking the field
4119 loc_kind should give us an accurate answer. */
4120 return (FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSNAME
4121 || FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSADDR
);
4125 dump_fn_fieldlists (struct type
*type
, int spaces
)
4131 printfi_filtered (spaces
, "fn_fieldlists ");
4132 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
4133 printf_filtered ("\n");
4134 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
4136 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
4137 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
4139 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
4140 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
4142 printf_filtered (_(") length %d\n"),
4143 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
4144 for (overload_idx
= 0;
4145 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
4148 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
4150 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
4151 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
4153 printf_filtered (")\n");
4154 printfi_filtered (spaces
+ 8, "type ");
4155 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
4157 printf_filtered ("\n");
4159 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
4162 printfi_filtered (spaces
+ 8, "args ");
4163 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
4165 printf_filtered ("\n");
4166 print_args (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
4167 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
, overload_idx
)),
4169 printfi_filtered (spaces
+ 8, "fcontext ");
4170 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
4172 printf_filtered ("\n");
4174 printfi_filtered (spaces
+ 8, "is_const %d\n",
4175 TYPE_FN_FIELD_CONST (f
, overload_idx
));
4176 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
4177 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
4178 printfi_filtered (spaces
+ 8, "is_private %d\n",
4179 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
4180 printfi_filtered (spaces
+ 8, "is_protected %d\n",
4181 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
4182 printfi_filtered (spaces
+ 8, "is_stub %d\n",
4183 TYPE_FN_FIELD_STUB (f
, overload_idx
));
4184 printfi_filtered (spaces
+ 8, "voffset %u\n",
4185 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
4191 print_cplus_stuff (struct type
*type
, int spaces
)
4193 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
4194 printfi_filtered (spaces
, "vptr_basetype ");
4195 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
4196 puts_filtered ("\n");
4197 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
4198 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
4200 printfi_filtered (spaces
, "n_baseclasses %d\n",
4201 TYPE_N_BASECLASSES (type
));
4202 printfi_filtered (spaces
, "nfn_fields %d\n",
4203 TYPE_NFN_FIELDS (type
));
4204 if (TYPE_N_BASECLASSES (type
) > 0)
4206 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
4207 TYPE_N_BASECLASSES (type
));
4208 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
4210 printf_filtered (")");
4212 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
4213 TYPE_N_BASECLASSES (type
));
4214 puts_filtered ("\n");
4216 if (TYPE_NFIELDS (type
) > 0)
4218 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
4220 printfi_filtered (spaces
,
4221 "private_field_bits (%d bits at *",
4222 TYPE_NFIELDS (type
));
4223 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
4225 printf_filtered (")");
4226 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
4227 TYPE_NFIELDS (type
));
4228 puts_filtered ("\n");
4230 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
4232 printfi_filtered (spaces
,
4233 "protected_field_bits (%d bits at *",
4234 TYPE_NFIELDS (type
));
4235 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
4237 printf_filtered (")");
4238 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
4239 TYPE_NFIELDS (type
));
4240 puts_filtered ("\n");
4243 if (TYPE_NFN_FIELDS (type
) > 0)
4245 dump_fn_fieldlists (type
, spaces
);
4249 /* Print the contents of the TYPE's type_specific union, assuming that
4250 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
4253 print_gnat_stuff (struct type
*type
, int spaces
)
4255 struct type
*descriptive_type
= TYPE_DESCRIPTIVE_TYPE (type
);
4257 if (descriptive_type
== NULL
)
4258 printfi_filtered (spaces
+ 2, "no descriptive type\n");
4261 printfi_filtered (spaces
+ 2, "descriptive type\n");
4262 recursive_dump_type (descriptive_type
, spaces
+ 4);
4266 static struct obstack dont_print_type_obstack
;
4269 recursive_dump_type (struct type
*type
, int spaces
)
4274 obstack_begin (&dont_print_type_obstack
, 0);
4276 if (TYPE_NFIELDS (type
) > 0
4277 || (HAVE_CPLUS_STRUCT (type
) && TYPE_NFN_FIELDS (type
) > 0))
4279 struct type
**first_dont_print
4280 = (struct type
**) obstack_base (&dont_print_type_obstack
);
4282 int i
= (struct type
**)
4283 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
4287 if (type
== first_dont_print
[i
])
4289 printfi_filtered (spaces
, "type node ");
4290 gdb_print_host_address (type
, gdb_stdout
);
4291 printf_filtered (_(" <same as already seen type>\n"));
4296 obstack_ptr_grow (&dont_print_type_obstack
, type
);
4299 printfi_filtered (spaces
, "type node ");
4300 gdb_print_host_address (type
, gdb_stdout
);
4301 printf_filtered ("\n");
4302 printfi_filtered (spaces
, "name '%s' (",
4303 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
4304 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
4305 printf_filtered (")\n");
4306 printfi_filtered (spaces
, "tagname '%s' (",
4307 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
4308 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
4309 printf_filtered (")\n");
4310 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
4311 switch (TYPE_CODE (type
))
4313 case TYPE_CODE_UNDEF
:
4314 printf_filtered ("(TYPE_CODE_UNDEF)");
4317 printf_filtered ("(TYPE_CODE_PTR)");
4319 case TYPE_CODE_ARRAY
:
4320 printf_filtered ("(TYPE_CODE_ARRAY)");
4322 case TYPE_CODE_STRUCT
:
4323 printf_filtered ("(TYPE_CODE_STRUCT)");
4325 case TYPE_CODE_UNION
:
4326 printf_filtered ("(TYPE_CODE_UNION)");
4328 case TYPE_CODE_ENUM
:
4329 printf_filtered ("(TYPE_CODE_ENUM)");
4331 case TYPE_CODE_FLAGS
:
4332 printf_filtered ("(TYPE_CODE_FLAGS)");
4334 case TYPE_CODE_FUNC
:
4335 printf_filtered ("(TYPE_CODE_FUNC)");
4338 printf_filtered ("(TYPE_CODE_INT)");
4341 printf_filtered ("(TYPE_CODE_FLT)");
4343 case TYPE_CODE_VOID
:
4344 printf_filtered ("(TYPE_CODE_VOID)");
4347 printf_filtered ("(TYPE_CODE_SET)");
4349 case TYPE_CODE_RANGE
:
4350 printf_filtered ("(TYPE_CODE_RANGE)");
4352 case TYPE_CODE_STRING
:
4353 printf_filtered ("(TYPE_CODE_STRING)");
4355 case TYPE_CODE_ERROR
:
4356 printf_filtered ("(TYPE_CODE_ERROR)");
4358 case TYPE_CODE_MEMBERPTR
:
4359 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
4361 case TYPE_CODE_METHODPTR
:
4362 printf_filtered ("(TYPE_CODE_METHODPTR)");
4364 case TYPE_CODE_METHOD
:
4365 printf_filtered ("(TYPE_CODE_METHOD)");
4368 printf_filtered ("(TYPE_CODE_REF)");
4370 case TYPE_CODE_CHAR
:
4371 printf_filtered ("(TYPE_CODE_CHAR)");
4373 case TYPE_CODE_BOOL
:
4374 printf_filtered ("(TYPE_CODE_BOOL)");
4376 case TYPE_CODE_COMPLEX
:
4377 printf_filtered ("(TYPE_CODE_COMPLEX)");
4379 case TYPE_CODE_TYPEDEF
:
4380 printf_filtered ("(TYPE_CODE_TYPEDEF)");
4382 case TYPE_CODE_NAMESPACE
:
4383 printf_filtered ("(TYPE_CODE_NAMESPACE)");
4386 printf_filtered ("(UNKNOWN TYPE CODE)");
4389 puts_filtered ("\n");
4390 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
4391 if (TYPE_OBJFILE_OWNED (type
))
4393 printfi_filtered (spaces
, "objfile ");
4394 gdb_print_host_address (TYPE_OWNER (type
).objfile
, gdb_stdout
);
4398 printfi_filtered (spaces
, "gdbarch ");
4399 gdb_print_host_address (TYPE_OWNER (type
).gdbarch
, gdb_stdout
);
4401 printf_filtered ("\n");
4402 printfi_filtered (spaces
, "target_type ");
4403 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
4404 printf_filtered ("\n");
4405 if (TYPE_TARGET_TYPE (type
) != NULL
)
4407 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
4409 printfi_filtered (spaces
, "pointer_type ");
4410 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
4411 printf_filtered ("\n");
4412 printfi_filtered (spaces
, "reference_type ");
4413 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
4414 printf_filtered ("\n");
4415 printfi_filtered (spaces
, "type_chain ");
4416 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
4417 printf_filtered ("\n");
4418 printfi_filtered (spaces
, "instance_flags 0x%x",
4419 TYPE_INSTANCE_FLAGS (type
));
4420 if (TYPE_CONST (type
))
4422 puts_filtered (" TYPE_CONST");
4424 if (TYPE_VOLATILE (type
))
4426 puts_filtered (" TYPE_VOLATILE");
4428 if (TYPE_CODE_SPACE (type
))
4430 puts_filtered (" TYPE_CODE_SPACE");
4432 if (TYPE_DATA_SPACE (type
))
4434 puts_filtered (" TYPE_DATA_SPACE");
4436 if (TYPE_ADDRESS_CLASS_1 (type
))
4438 puts_filtered (" TYPE_ADDRESS_CLASS_1");
4440 if (TYPE_ADDRESS_CLASS_2 (type
))
4442 puts_filtered (" TYPE_ADDRESS_CLASS_2");
4444 if (TYPE_RESTRICT (type
))
4446 puts_filtered (" TYPE_RESTRICT");
4448 if (TYPE_ATOMIC (type
))
4450 puts_filtered (" TYPE_ATOMIC");
4452 puts_filtered ("\n");
4454 printfi_filtered (spaces
, "flags");
4455 if (TYPE_UNSIGNED (type
))
4457 puts_filtered (" TYPE_UNSIGNED");
4459 if (TYPE_NOSIGN (type
))
4461 puts_filtered (" TYPE_NOSIGN");
4463 if (TYPE_STUB (type
))
4465 puts_filtered (" TYPE_STUB");
4467 if (TYPE_TARGET_STUB (type
))
4469 puts_filtered (" TYPE_TARGET_STUB");
4471 if (TYPE_PROTOTYPED (type
))
4473 puts_filtered (" TYPE_PROTOTYPED");
4475 if (TYPE_INCOMPLETE (type
))
4477 puts_filtered (" TYPE_INCOMPLETE");
4479 if (TYPE_VARARGS (type
))
4481 puts_filtered (" TYPE_VARARGS");
4483 /* This is used for things like AltiVec registers on ppc. Gcc emits
4484 an attribute for the array type, which tells whether or not we
4485 have a vector, instead of a regular array. */
4486 if (TYPE_VECTOR (type
))
4488 puts_filtered (" TYPE_VECTOR");
4490 if (TYPE_FIXED_INSTANCE (type
))
4492 puts_filtered (" TYPE_FIXED_INSTANCE");
4494 if (TYPE_STUB_SUPPORTED (type
))
4496 puts_filtered (" TYPE_STUB_SUPPORTED");
4498 if (TYPE_NOTTEXT (type
))
4500 puts_filtered (" TYPE_NOTTEXT");
4502 puts_filtered ("\n");
4503 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
4504 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
4505 puts_filtered ("\n");
4506 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
4508 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
4509 printfi_filtered (spaces
+ 2,
4510 "[%d] enumval %s type ",
4511 idx
, plongest (TYPE_FIELD_ENUMVAL (type
, idx
)));
4513 printfi_filtered (spaces
+ 2,
4514 "[%d] bitpos %s bitsize %d type ",
4515 idx
, plongest (TYPE_FIELD_BITPOS (type
, idx
)),
4516 TYPE_FIELD_BITSIZE (type
, idx
));
4517 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
4518 printf_filtered (" name '%s' (",
4519 TYPE_FIELD_NAME (type
, idx
) != NULL
4520 ? TYPE_FIELD_NAME (type
, idx
)
4522 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
4523 printf_filtered (")\n");
4524 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
4526 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
4529 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
4531 printfi_filtered (spaces
, "low %s%s high %s%s\n",
4532 plongest (TYPE_LOW_BOUND (type
)),
4533 TYPE_LOW_BOUND_UNDEFINED (type
) ? " (undefined)" : "",
4534 plongest (TYPE_HIGH_BOUND (type
)),
4535 TYPE_HIGH_BOUND_UNDEFINED (type
)
4536 ? " (undefined)" : "");
4539 switch (TYPE_SPECIFIC_FIELD (type
))
4541 case TYPE_SPECIFIC_CPLUS_STUFF
:
4542 printfi_filtered (spaces
, "cplus_stuff ");
4543 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
),
4545 puts_filtered ("\n");
4546 print_cplus_stuff (type
, spaces
);
4549 case TYPE_SPECIFIC_GNAT_STUFF
:
4550 printfi_filtered (spaces
, "gnat_stuff ");
4551 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type
), gdb_stdout
);
4552 puts_filtered ("\n");
4553 print_gnat_stuff (type
, spaces
);
4556 case TYPE_SPECIFIC_FLOATFORMAT
:
4557 printfi_filtered (spaces
, "floatformat ");
4558 if (TYPE_FLOATFORMAT (type
) == NULL
4559 || TYPE_FLOATFORMAT (type
)->name
== NULL
)
4560 puts_filtered ("(null)");
4562 puts_filtered (TYPE_FLOATFORMAT (type
)->name
);
4563 puts_filtered ("\n");
4566 case TYPE_SPECIFIC_FUNC
:
4567 printfi_filtered (spaces
, "calling_convention %d\n",
4568 TYPE_CALLING_CONVENTION (type
));
4569 /* tail_call_list is not printed. */
4572 case TYPE_SPECIFIC_SELF_TYPE
:
4573 printfi_filtered (spaces
, "self_type ");
4574 gdb_print_host_address (TYPE_SELF_TYPE (type
), gdb_stdout
);
4575 puts_filtered ("\n");
4580 obstack_free (&dont_print_type_obstack
, NULL
);
4583 /* Trivial helpers for the libiberty hash table, for mapping one
4588 struct type
*old
, *newobj
;
4592 type_pair_hash (const void *item
)
4594 const struct type_pair
*pair
= (const struct type_pair
*) item
;
4596 return htab_hash_pointer (pair
->old
);
4600 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
4602 const struct type_pair
*lhs
= (const struct type_pair
*) item_lhs
;
4603 const struct type_pair
*rhs
= (const struct type_pair
*) item_rhs
;
4605 return lhs
->old
== rhs
->old
;
4608 /* Allocate the hash table used by copy_type_recursive to walk
4609 types without duplicates. We use OBJFILE's obstack, because
4610 OBJFILE is about to be deleted. */
4613 create_copied_types_hash (struct objfile
*objfile
)
4615 return htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
4616 NULL
, &objfile
->objfile_obstack
,
4617 hashtab_obstack_allocate
,
4618 dummy_obstack_deallocate
);
4621 /* Recursively copy (deep copy) a dynamic attribute list of a type. */
4623 static struct dynamic_prop_list
*
4624 copy_dynamic_prop_list (struct obstack
*objfile_obstack
,
4625 struct dynamic_prop_list
*list
)
4627 struct dynamic_prop_list
*copy
= list
;
4628 struct dynamic_prop_list
**node_ptr
= ©
;
4630 while (*node_ptr
!= NULL
)
4632 struct dynamic_prop_list
*node_copy
;
4634 node_copy
= ((struct dynamic_prop_list
*)
4635 obstack_copy (objfile_obstack
, *node_ptr
,
4636 sizeof (struct dynamic_prop_list
)));
4637 node_copy
->prop
= (*node_ptr
)->prop
;
4638 *node_ptr
= node_copy
;
4640 node_ptr
= &node_copy
->next
;
4646 /* Recursively copy (deep copy) TYPE, if it is associated with
4647 OBJFILE. Return a new type owned by the gdbarch associated with the type, a
4648 saved type if we have already visited TYPE (using COPIED_TYPES), or TYPE if
4649 it is not associated with OBJFILE. */
4652 copy_type_recursive (struct objfile
*objfile
,
4654 htab_t copied_types
)
4656 struct type_pair
*stored
, pair
;
4658 struct type
*new_type
;
4660 if (! TYPE_OBJFILE_OWNED (type
))
4663 /* This type shouldn't be pointing to any types in other objfiles;
4664 if it did, the type might disappear unexpectedly. */
4665 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
4668 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
4670 return ((struct type_pair
*) *slot
)->newobj
;
4672 new_type
= alloc_type_arch (get_type_arch (type
));
4674 /* We must add the new type to the hash table immediately, in case
4675 we encounter this type again during a recursive call below. */
4676 stored
= XOBNEW (&objfile
->objfile_obstack
, struct type_pair
);
4678 stored
->newobj
= new_type
;
4681 /* Copy the common fields of types. For the main type, we simply
4682 copy the entire thing and then update specific fields as needed. */
4683 *TYPE_MAIN_TYPE (new_type
) = *TYPE_MAIN_TYPE (type
);
4684 TYPE_OBJFILE_OWNED (new_type
) = 0;
4685 TYPE_OWNER (new_type
).gdbarch
= get_type_arch (type
);
4687 if (TYPE_NAME (type
))
4688 TYPE_NAME (new_type
) = xstrdup (TYPE_NAME (type
));
4689 if (TYPE_TAG_NAME (type
))
4690 TYPE_TAG_NAME (new_type
) = xstrdup (TYPE_TAG_NAME (type
));
4692 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
4693 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
4695 /* Copy the fields. */
4696 if (TYPE_NFIELDS (type
))
4700 nfields
= TYPE_NFIELDS (type
);
4701 TYPE_FIELDS (new_type
) = XCNEWVEC (struct field
, nfields
);
4702 for (i
= 0; i
< nfields
; i
++)
4704 TYPE_FIELD_ARTIFICIAL (new_type
, i
) =
4705 TYPE_FIELD_ARTIFICIAL (type
, i
);
4706 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
4707 if (TYPE_FIELD_TYPE (type
, i
))
4708 TYPE_FIELD_TYPE (new_type
, i
)
4709 = copy_type_recursive (objfile
, TYPE_FIELD_TYPE (type
, i
),
4711 if (TYPE_FIELD_NAME (type
, i
))
4712 TYPE_FIELD_NAME (new_type
, i
) =
4713 xstrdup (TYPE_FIELD_NAME (type
, i
));
4714 switch (TYPE_FIELD_LOC_KIND (type
, i
))
4716 case FIELD_LOC_KIND_BITPOS
:
4717 SET_FIELD_BITPOS (TYPE_FIELD (new_type
, i
),
4718 TYPE_FIELD_BITPOS (type
, i
));
4720 case FIELD_LOC_KIND_ENUMVAL
:
4721 SET_FIELD_ENUMVAL (TYPE_FIELD (new_type
, i
),
4722 TYPE_FIELD_ENUMVAL (type
, i
));
4724 case FIELD_LOC_KIND_PHYSADDR
:
4725 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type
, i
),
4726 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
4728 case FIELD_LOC_KIND_PHYSNAME
:
4729 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type
, i
),
4730 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
,
4734 internal_error (__FILE__
, __LINE__
,
4735 _("Unexpected type field location kind: %d"),
4736 TYPE_FIELD_LOC_KIND (type
, i
));
4741 /* For range types, copy the bounds information. */
4742 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
4744 TYPE_RANGE_DATA (new_type
) = XNEW (struct range_bounds
);
4745 *TYPE_RANGE_DATA (new_type
) = *TYPE_RANGE_DATA (type
);
4748 if (TYPE_DYN_PROP_LIST (type
) != NULL
)
4749 TYPE_DYN_PROP_LIST (new_type
)
4750 = copy_dynamic_prop_list (&objfile
->objfile_obstack
,
4751 TYPE_DYN_PROP_LIST (type
));
4754 /* Copy pointers to other types. */
4755 if (TYPE_TARGET_TYPE (type
))
4756 TYPE_TARGET_TYPE (new_type
) =
4757 copy_type_recursive (objfile
,
4758 TYPE_TARGET_TYPE (type
),
4761 /* Maybe copy the type_specific bits.
4763 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
4764 base classes and methods. There's no fundamental reason why we
4765 can't, but at the moment it is not needed. */
4767 switch (TYPE_SPECIFIC_FIELD (type
))
4769 case TYPE_SPECIFIC_NONE
:
4771 case TYPE_SPECIFIC_FUNC
:
4772 INIT_FUNC_SPECIFIC (new_type
);
4773 TYPE_CALLING_CONVENTION (new_type
) = TYPE_CALLING_CONVENTION (type
);
4774 TYPE_NO_RETURN (new_type
) = TYPE_NO_RETURN (type
);
4775 TYPE_TAIL_CALL_LIST (new_type
) = NULL
;
4777 case TYPE_SPECIFIC_FLOATFORMAT
:
4778 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
4780 case TYPE_SPECIFIC_CPLUS_STUFF
:
4781 INIT_CPLUS_SPECIFIC (new_type
);
4783 case TYPE_SPECIFIC_GNAT_STUFF
:
4784 INIT_GNAT_SPECIFIC (new_type
);
4786 case TYPE_SPECIFIC_SELF_TYPE
:
4787 set_type_self_type (new_type
,
4788 copy_type_recursive (objfile
, TYPE_SELF_TYPE (type
),
4792 gdb_assert_not_reached ("bad type_specific_kind");
4798 /* Make a copy of the given TYPE, except that the pointer & reference
4799 types are not preserved.
4801 This function assumes that the given type has an associated objfile.
4802 This objfile is used to allocate the new type. */
4805 copy_type (const struct type
*type
)
4807 struct type
*new_type
;
4809 gdb_assert (TYPE_OBJFILE_OWNED (type
));
4811 new_type
= alloc_type_copy (type
);
4812 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
4813 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
4814 memcpy (TYPE_MAIN_TYPE (new_type
), TYPE_MAIN_TYPE (type
),
4815 sizeof (struct main_type
));
4816 if (TYPE_DYN_PROP_LIST (type
) != NULL
)
4817 TYPE_DYN_PROP_LIST (new_type
)
4818 = copy_dynamic_prop_list (&TYPE_OBJFILE (type
) -> objfile_obstack
,
4819 TYPE_DYN_PROP_LIST (type
));
4824 /* Helper functions to initialize architecture-specific types. */
4826 /* Allocate a type structure associated with GDBARCH and set its
4827 CODE, LENGTH, and NAME fields. */
4830 arch_type (struct gdbarch
*gdbarch
,
4831 enum type_code code
, int bit
, const char *name
)
4835 type
= alloc_type_arch (gdbarch
);
4836 set_type_code (type
, code
);
4837 gdb_assert ((bit
% TARGET_CHAR_BIT
) == 0);
4838 TYPE_LENGTH (type
) = bit
/ TARGET_CHAR_BIT
;
4841 TYPE_NAME (type
) = gdbarch_obstack_strdup (gdbarch
, name
);
4846 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
4847 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
4848 the type's TYPE_UNSIGNED flag. NAME is the type name. */
4851 arch_integer_type (struct gdbarch
*gdbarch
,
4852 int bit
, int unsigned_p
, const char *name
)
4856 t
= arch_type (gdbarch
, TYPE_CODE_INT
, bit
, name
);
4858 TYPE_UNSIGNED (t
) = 1;
4863 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
4864 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
4865 the type's TYPE_UNSIGNED flag. NAME is the type name. */
4868 arch_character_type (struct gdbarch
*gdbarch
,
4869 int bit
, int unsigned_p
, const char *name
)
4873 t
= arch_type (gdbarch
, TYPE_CODE_CHAR
, bit
, name
);
4875 TYPE_UNSIGNED (t
) = 1;
4880 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
4881 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
4882 the type's TYPE_UNSIGNED flag. NAME is the type name. */
4885 arch_boolean_type (struct gdbarch
*gdbarch
,
4886 int bit
, int unsigned_p
, const char *name
)
4890 t
= arch_type (gdbarch
, TYPE_CODE_BOOL
, bit
, name
);
4892 TYPE_UNSIGNED (t
) = 1;
4897 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
4898 BIT is the type size in bits; if BIT equals -1, the size is
4899 determined by the floatformat. NAME is the type name. Set the
4900 TYPE_FLOATFORMAT from FLOATFORMATS. */
4903 arch_float_type (struct gdbarch
*gdbarch
,
4904 int bit
, const char *name
,
4905 const struct floatformat
**floatformats
)
4907 const struct floatformat
*fmt
= floatformats
[gdbarch_byte_order (gdbarch
)];
4910 bit
= verify_floatformat (bit
, fmt
);
4911 t
= arch_type (gdbarch
, TYPE_CODE_FLT
, bit
, name
);
4912 TYPE_FLOATFORMAT (t
) = fmt
;
4917 /* Allocate a TYPE_CODE_DECFLOAT type structure associated with GDBARCH.
4918 BIT is the type size in bits. NAME is the type name. */
4921 arch_decfloat_type (struct gdbarch
*gdbarch
, int bit
, const char *name
)
4925 t
= arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, bit
, name
);
4929 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
4930 NAME is the type name. TARGET_TYPE is the component float type. */
4933 arch_complex_type (struct gdbarch
*gdbarch
,
4934 const char *name
, struct type
*target_type
)
4938 t
= arch_type (gdbarch
, TYPE_CODE_COMPLEX
,
4939 2 * TYPE_LENGTH (target_type
) * TARGET_CHAR_BIT
, name
);
4940 TYPE_TARGET_TYPE (t
) = target_type
;
4944 /* Allocate a TYPE_CODE_PTR type structure associated with GDBARCH.
4945 BIT is the pointer type size in bits. NAME is the type name.
4946 TARGET_TYPE is the pointer target type. Always sets the pointer type's
4947 TYPE_UNSIGNED flag. */
4950 arch_pointer_type (struct gdbarch
*gdbarch
,
4951 int bit
, const char *name
, struct type
*target_type
)
4955 t
= arch_type (gdbarch
, TYPE_CODE_PTR
, bit
, name
);
4956 TYPE_TARGET_TYPE (t
) = target_type
;
4957 TYPE_UNSIGNED (t
) = 1;
4961 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
4962 NAME is the type name. BIT is the size of the flag word in bits. */
4965 arch_flags_type (struct gdbarch
*gdbarch
, const char *name
, int bit
)
4969 type
= arch_type (gdbarch
, TYPE_CODE_FLAGS
, bit
, name
);
4970 TYPE_UNSIGNED (type
) = 1;
4971 TYPE_NFIELDS (type
) = 0;
4972 /* Pre-allocate enough space assuming every field is one bit. */
4974 = (struct field
*) TYPE_ZALLOC (type
, bit
* sizeof (struct field
));
4979 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
4980 position BITPOS is called NAME. Pass NAME as "" for fields that
4981 should not be printed. */
4984 append_flags_type_field (struct type
*type
, int start_bitpos
, int nr_bits
,
4985 struct type
*field_type
, const char *name
)
4987 int type_bitsize
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
4988 int field_nr
= TYPE_NFIELDS (type
);
4990 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLAGS
);
4991 gdb_assert (TYPE_NFIELDS (type
) + 1 <= type_bitsize
);
4992 gdb_assert (start_bitpos
>= 0 && start_bitpos
< type_bitsize
);
4993 gdb_assert (nr_bits
>= 1 && nr_bits
<= type_bitsize
);
4994 gdb_assert (name
!= NULL
);
4996 TYPE_FIELD_NAME (type
, field_nr
) = xstrdup (name
);
4997 TYPE_FIELD_TYPE (type
, field_nr
) = field_type
;
4998 SET_FIELD_BITPOS (TYPE_FIELD (type
, field_nr
), start_bitpos
);
4999 TYPE_FIELD_BITSIZE (type
, field_nr
) = nr_bits
;
5000 ++TYPE_NFIELDS (type
);
5003 /* Special version of append_flags_type_field to add a flag field.
5004 Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
5005 position BITPOS is called NAME. */
5008 append_flags_type_flag (struct type
*type
, int bitpos
, const char *name
)
5010 struct gdbarch
*gdbarch
= get_type_arch (type
);
5012 append_flags_type_field (type
, bitpos
, 1,
5013 builtin_type (gdbarch
)->builtin_bool
,
5017 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
5018 specified by CODE) associated with GDBARCH. NAME is the type name. */
5021 arch_composite_type (struct gdbarch
*gdbarch
, const char *name
,
5022 enum type_code code
)
5026 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
5027 t
= arch_type (gdbarch
, code
, 0, NULL
);
5028 TYPE_TAG_NAME (t
) = name
;
5029 INIT_CPLUS_SPECIFIC (t
);
5033 /* Add new field with name NAME and type FIELD to composite type T.
5034 Do not set the field's position or adjust the type's length;
5035 the caller should do so. Return the new field. */
5038 append_composite_type_field_raw (struct type
*t
, const char *name
,
5043 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
5044 TYPE_FIELDS (t
) = XRESIZEVEC (struct field
, TYPE_FIELDS (t
),
5046 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
5047 memset (f
, 0, sizeof f
[0]);
5048 FIELD_TYPE (f
[0]) = field
;
5049 FIELD_NAME (f
[0]) = name
;
5053 /* Add new field with name NAME and type FIELD to composite type T.
5054 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
5057 append_composite_type_field_aligned (struct type
*t
, const char *name
,
5058 struct type
*field
, int alignment
)
5060 struct field
*f
= append_composite_type_field_raw (t
, name
, field
);
5062 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
5064 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
5065 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
5067 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
5069 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
5070 if (TYPE_NFIELDS (t
) > 1)
5072 SET_FIELD_BITPOS (f
[0],
5073 (FIELD_BITPOS (f
[-1])
5074 + (TYPE_LENGTH (FIELD_TYPE (f
[-1]))
5075 * TARGET_CHAR_BIT
)));
5081 alignment
*= TARGET_CHAR_BIT
;
5082 left
= FIELD_BITPOS (f
[0]) % alignment
;
5086 SET_FIELD_BITPOS (f
[0], FIELD_BITPOS (f
[0]) + (alignment
- left
));
5087 TYPE_LENGTH (t
) += (alignment
- left
) / TARGET_CHAR_BIT
;
5094 /* Add new field with name NAME and type FIELD to composite type T. */
5097 append_composite_type_field (struct type
*t
, const char *name
,
5100 append_composite_type_field_aligned (t
, name
, field
, 0);
5103 static struct gdbarch_data
*gdbtypes_data
;
5105 const struct builtin_type
*
5106 builtin_type (struct gdbarch
*gdbarch
)
5108 return (const struct builtin_type
*) gdbarch_data (gdbarch
, gdbtypes_data
);
5112 gdbtypes_post_init (struct gdbarch
*gdbarch
)
5114 struct builtin_type
*builtin_type
5115 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
5118 builtin_type
->builtin_void
5119 = arch_type (gdbarch
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, "void");
5120 builtin_type
->builtin_char
5121 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
5122 !gdbarch_char_signed (gdbarch
), "char");
5123 TYPE_NOSIGN (builtin_type
->builtin_char
) = 1;
5124 builtin_type
->builtin_signed_char
5125 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
5127 builtin_type
->builtin_unsigned_char
5128 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
5129 1, "unsigned char");
5130 builtin_type
->builtin_short
5131 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
5133 builtin_type
->builtin_unsigned_short
5134 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
5135 1, "unsigned short");
5136 builtin_type
->builtin_int
5137 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
5139 builtin_type
->builtin_unsigned_int
5140 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
5142 builtin_type
->builtin_long
5143 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
5145 builtin_type
->builtin_unsigned_long
5146 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
5147 1, "unsigned long");
5148 builtin_type
->builtin_long_long
5149 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
5151 builtin_type
->builtin_unsigned_long_long
5152 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
5153 1, "unsigned long long");
5154 builtin_type
->builtin_float
5155 = arch_float_type (gdbarch
, gdbarch_float_bit (gdbarch
),
5156 "float", gdbarch_float_format (gdbarch
));
5157 builtin_type
->builtin_double
5158 = arch_float_type (gdbarch
, gdbarch_double_bit (gdbarch
),
5159 "double", gdbarch_double_format (gdbarch
));
5160 builtin_type
->builtin_long_double
5161 = arch_float_type (gdbarch
, gdbarch_long_double_bit (gdbarch
),
5162 "long double", gdbarch_long_double_format (gdbarch
));
5163 builtin_type
->builtin_complex
5164 = arch_complex_type (gdbarch
, "complex",
5165 builtin_type
->builtin_float
);
5166 builtin_type
->builtin_double_complex
5167 = arch_complex_type (gdbarch
, "double complex",
5168 builtin_type
->builtin_double
);
5169 builtin_type
->builtin_string
5170 = arch_type (gdbarch
, TYPE_CODE_STRING
, TARGET_CHAR_BIT
, "string");
5171 builtin_type
->builtin_bool
5172 = arch_type (gdbarch
, TYPE_CODE_BOOL
, TARGET_CHAR_BIT
, "bool");
5174 /* The following three are about decimal floating point types, which
5175 are 32-bits, 64-bits and 128-bits respectively. */
5176 builtin_type
->builtin_decfloat
5177 = arch_decfloat_type (gdbarch
, 32, "_Decimal32");
5178 builtin_type
->builtin_decdouble
5179 = arch_decfloat_type (gdbarch
, 64, "_Decimal64");
5180 builtin_type
->builtin_declong
5181 = arch_decfloat_type (gdbarch
, 128, "_Decimal128");
5183 /* "True" character types. */
5184 builtin_type
->builtin_true_char
5185 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 0, "true character");
5186 builtin_type
->builtin_true_unsigned_char
5187 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 1, "true character");
5189 /* Fixed-size integer types. */
5190 builtin_type
->builtin_int0
5191 = arch_integer_type (gdbarch
, 0, 0, "int0_t");
5192 builtin_type
->builtin_int8
5193 = arch_integer_type (gdbarch
, 8, 0, "int8_t");
5194 builtin_type
->builtin_uint8
5195 = arch_integer_type (gdbarch
, 8, 1, "uint8_t");
5196 builtin_type
->builtin_int16
5197 = arch_integer_type (gdbarch
, 16, 0, "int16_t");
5198 builtin_type
->builtin_uint16
5199 = arch_integer_type (gdbarch
, 16, 1, "uint16_t");
5200 builtin_type
->builtin_int32
5201 = arch_integer_type (gdbarch
, 32, 0, "int32_t");
5202 builtin_type
->builtin_uint32
5203 = arch_integer_type (gdbarch
, 32, 1, "uint32_t");
5204 builtin_type
->builtin_int64
5205 = arch_integer_type (gdbarch
, 64, 0, "int64_t");
5206 builtin_type
->builtin_uint64
5207 = arch_integer_type (gdbarch
, 64, 1, "uint64_t");
5208 builtin_type
->builtin_int128
5209 = arch_integer_type (gdbarch
, 128, 0, "int128_t");
5210 builtin_type
->builtin_uint128
5211 = arch_integer_type (gdbarch
, 128, 1, "uint128_t");
5212 TYPE_INSTANCE_FLAGS (builtin_type
->builtin_int8
) |=
5213 TYPE_INSTANCE_FLAG_NOTTEXT
;
5214 TYPE_INSTANCE_FLAGS (builtin_type
->builtin_uint8
) |=
5215 TYPE_INSTANCE_FLAG_NOTTEXT
;
5217 /* Wide character types. */
5218 builtin_type
->builtin_char16
5219 = arch_integer_type (gdbarch
, 16, 1, "char16_t");
5220 builtin_type
->builtin_char32
5221 = arch_integer_type (gdbarch
, 32, 1, "char32_t");
5222 builtin_type
->builtin_wchar
5223 = arch_integer_type (gdbarch
, gdbarch_wchar_bit (gdbarch
),
5224 !gdbarch_wchar_signed (gdbarch
), "wchar_t");
5226 /* Default data/code pointer types. */
5227 builtin_type
->builtin_data_ptr
5228 = lookup_pointer_type (builtin_type
->builtin_void
);
5229 builtin_type
->builtin_func_ptr
5230 = lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
5231 builtin_type
->builtin_func_func
5232 = lookup_function_type (builtin_type
->builtin_func_ptr
);
5234 /* This type represents a GDB internal function. */
5235 builtin_type
->internal_fn
5236 = arch_type (gdbarch
, TYPE_CODE_INTERNAL_FUNCTION
, 0,
5237 "<internal function>");
5239 /* This type represents an xmethod. */
5240 builtin_type
->xmethod
5241 = arch_type (gdbarch
, TYPE_CODE_XMETHOD
, 0, "<xmethod>");
5243 return builtin_type
;
5246 /* This set of objfile-based types is intended to be used by symbol
5247 readers as basic types. */
5249 static const struct objfile_data
*objfile_type_data
;
5251 const struct objfile_type
*
5252 objfile_type (struct objfile
*objfile
)
5254 struct gdbarch
*gdbarch
;
5255 struct objfile_type
*objfile_type
5256 = (struct objfile_type
*) objfile_data (objfile
, objfile_type_data
);
5259 return objfile_type
;
5261 objfile_type
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
5262 1, struct objfile_type
);
5264 /* Use the objfile architecture to determine basic type properties. */
5265 gdbarch
= get_objfile_arch (objfile
);
5268 objfile_type
->builtin_void
5269 = init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, "void");
5270 objfile_type
->builtin_char
5271 = init_integer_type (objfile
, TARGET_CHAR_BIT
,
5272 !gdbarch_char_signed (gdbarch
), "char");
5273 TYPE_NOSIGN (objfile_type
->builtin_char
) = 1;
5274 objfile_type
->builtin_signed_char
5275 = init_integer_type (objfile
, TARGET_CHAR_BIT
,
5277 objfile_type
->builtin_unsigned_char
5278 = init_integer_type (objfile
, TARGET_CHAR_BIT
,
5279 1, "unsigned char");
5280 objfile_type
->builtin_short
5281 = init_integer_type (objfile
, gdbarch_short_bit (gdbarch
),
5283 objfile_type
->builtin_unsigned_short
5284 = init_integer_type (objfile
, gdbarch_short_bit (gdbarch
),
5285 1, "unsigned short");
5286 objfile_type
->builtin_int
5287 = init_integer_type (objfile
, gdbarch_int_bit (gdbarch
),
5289 objfile_type
->builtin_unsigned_int
5290 = init_integer_type (objfile
, gdbarch_int_bit (gdbarch
),
5292 objfile_type
->builtin_long
5293 = init_integer_type (objfile
, gdbarch_long_bit (gdbarch
),
5295 objfile_type
->builtin_unsigned_long
5296 = init_integer_type (objfile
, gdbarch_long_bit (gdbarch
),
5297 1, "unsigned long");
5298 objfile_type
->builtin_long_long
5299 = init_integer_type (objfile
, gdbarch_long_long_bit (gdbarch
),
5301 objfile_type
->builtin_unsigned_long_long
5302 = init_integer_type (objfile
, gdbarch_long_long_bit (gdbarch
),
5303 1, "unsigned long long");
5304 objfile_type
->builtin_float
5305 = init_float_type (objfile
, gdbarch_float_bit (gdbarch
),
5306 "float", gdbarch_float_format (gdbarch
));
5307 objfile_type
->builtin_double
5308 = init_float_type (objfile
, gdbarch_double_bit (gdbarch
),
5309 "double", gdbarch_double_format (gdbarch
));
5310 objfile_type
->builtin_long_double
5311 = init_float_type (objfile
, gdbarch_long_double_bit (gdbarch
),
5312 "long double", gdbarch_long_double_format (gdbarch
));
5314 /* This type represents a type that was unrecognized in symbol read-in. */
5315 objfile_type
->builtin_error
5316 = init_type (objfile
, TYPE_CODE_ERROR
, 0, "<unknown type>");
5318 /* The following set of types is used for symbols with no
5319 debug information. */
5320 objfile_type
->nodebug_text_symbol
5321 = init_type (objfile
, TYPE_CODE_FUNC
, TARGET_CHAR_BIT
,
5322 "<text variable, no debug info>");
5323 objfile_type
->nodebug_text_gnu_ifunc_symbol
5324 = init_type (objfile
, TYPE_CODE_FUNC
, TARGET_CHAR_BIT
,
5325 "<text gnu-indirect-function variable, no debug info>");
5326 /* Ifunc resolvers return a function address. */
5327 TYPE_TARGET_TYPE (objfile_type
->nodebug_text_gnu_ifunc_symbol
)
5328 = init_integer_type (objfile
, gdbarch_addr_bit (gdbarch
), 1,
5329 "__IFUNC_RESOLVER_RET");
5330 TYPE_GNU_IFUNC (objfile_type
->nodebug_text_gnu_ifunc_symbol
) = 1;
5331 objfile_type
->nodebug_got_plt_symbol
5332 = init_pointer_type (objfile
, gdbarch_addr_bit (gdbarch
),
5333 "<text from jump slot in .got.plt, no debug info>",
5334 objfile_type
->nodebug_text_symbol
);
5335 objfile_type
->nodebug_data_symbol
5336 = init_nodebug_var_type (objfile
, "<data variable, no debug info>");
5337 objfile_type
->nodebug_unknown_symbol
5338 = init_nodebug_var_type (objfile
, "<variable (not text or data), no debug info>");
5339 objfile_type
->nodebug_tls_symbol
5340 = init_nodebug_var_type (objfile
, "<thread local variable, no debug info>");
5342 /* NOTE: on some targets, addresses and pointers are not necessarily
5346 - gdb's `struct type' always describes the target's
5348 - gdb's `struct value' objects should always hold values in
5350 - gdb's CORE_ADDR values are addresses in the unified virtual
5351 address space that the assembler and linker work with. Thus,
5352 since target_read_memory takes a CORE_ADDR as an argument, it
5353 can access any memory on the target, even if the processor has
5354 separate code and data address spaces.
5356 In this context, objfile_type->builtin_core_addr is a bit odd:
5357 it's a target type for a value the target will never see. It's
5358 only used to hold the values of (typeless) linker symbols, which
5359 are indeed in the unified virtual address space. */
5361 objfile_type
->builtin_core_addr
5362 = init_integer_type (objfile
, gdbarch_addr_bit (gdbarch
), 1,
5365 set_objfile_data (objfile
, objfile_type_data
, objfile_type
);
5366 return objfile_type
;
5370 _initialize_gdbtypes (void)
5372 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
5373 objfile_type_data
= register_objfile_data ();
5375 add_setshow_zuinteger_cmd ("overload", no_class
, &overload_debug
,
5376 _("Set debugging of C++ overloading."),
5377 _("Show debugging of C++ overloading."),
5378 _("When enabled, ranking of the "
5379 "functions is displayed."),
5381 show_overload_debug
,
5382 &setdebuglist
, &showdebuglist
);
5384 /* Add user knob for controlling resolution of opaque types. */
5385 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
5386 &opaque_type_resolution
,
5387 _("Set resolution of opaque struct/class/union"
5388 " types (if set before loading symbols)."),
5389 _("Show resolution of opaque struct/class/union"
5390 " types (if set before loading symbols)."),
5392 show_opaque_type_resolution
,
5393 &setlist
, &showlist
);
5395 /* Add an option to permit non-strict type checking. */
5396 add_setshow_boolean_cmd ("type", class_support
,
5397 &strict_type_checking
,
5398 _("Set strict type checking."),
5399 _("Show strict type checking."),
5401 show_strict_type_checking
,
5402 &setchecklist
, &showchecklist
);