1 /* Support routines for manipulating internal types for GDB.
3 Copyright (C) 1992-2013 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/>. */
23 #include "gdb_string.h"
29 #include "expression.h"
34 #include "complaints.h"
37 #include "gdb_assert.h"
39 #include "exceptions.h"
40 #include "cp-support.h"
42 /* Initialize BADNESS constants. */
44 const struct rank LENGTH_MISMATCH_BADNESS
= {100,0};
46 const struct rank TOO_FEW_PARAMS_BADNESS
= {100,0};
47 const struct rank INCOMPATIBLE_TYPE_BADNESS
= {100,0};
49 const struct rank EXACT_MATCH_BADNESS
= {0,0};
51 const struct rank INTEGER_PROMOTION_BADNESS
= {1,0};
52 const struct rank FLOAT_PROMOTION_BADNESS
= {1,0};
53 const struct rank BASE_PTR_CONVERSION_BADNESS
= {1,0};
54 const struct rank INTEGER_CONVERSION_BADNESS
= {2,0};
55 const struct rank FLOAT_CONVERSION_BADNESS
= {2,0};
56 const struct rank INT_FLOAT_CONVERSION_BADNESS
= {2,0};
57 const struct rank VOID_PTR_CONVERSION_BADNESS
= {2,0};
58 const struct rank BOOL_CONVERSION_BADNESS
= {3,0};
59 const struct rank BASE_CONVERSION_BADNESS
= {2,0};
60 const struct rank REFERENCE_CONVERSION_BADNESS
= {2,0};
61 const struct rank NULL_POINTER_CONVERSION_BADNESS
= {2,0};
62 const struct rank NS_POINTER_CONVERSION_BADNESS
= {10,0};
63 const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS
= {3,0};
65 /* Floatformat pairs. */
66 const struct floatformat
*floatformats_ieee_half
[BFD_ENDIAN_UNKNOWN
] = {
67 &floatformat_ieee_half_big
,
68 &floatformat_ieee_half_little
70 const struct floatformat
*floatformats_ieee_single
[BFD_ENDIAN_UNKNOWN
] = {
71 &floatformat_ieee_single_big
,
72 &floatformat_ieee_single_little
74 const struct floatformat
*floatformats_ieee_double
[BFD_ENDIAN_UNKNOWN
] = {
75 &floatformat_ieee_double_big
,
76 &floatformat_ieee_double_little
78 const struct floatformat
*floatformats_ieee_double_littlebyte_bigword
[BFD_ENDIAN_UNKNOWN
] = {
79 &floatformat_ieee_double_big
,
80 &floatformat_ieee_double_littlebyte_bigword
82 const struct floatformat
*floatformats_i387_ext
[BFD_ENDIAN_UNKNOWN
] = {
83 &floatformat_i387_ext
,
86 const struct floatformat
*floatformats_m68881_ext
[BFD_ENDIAN_UNKNOWN
] = {
87 &floatformat_m68881_ext
,
88 &floatformat_m68881_ext
90 const struct floatformat
*floatformats_arm_ext
[BFD_ENDIAN_UNKNOWN
] = {
91 &floatformat_arm_ext_big
,
92 &floatformat_arm_ext_littlebyte_bigword
94 const struct floatformat
*floatformats_ia64_spill
[BFD_ENDIAN_UNKNOWN
] = {
95 &floatformat_ia64_spill_big
,
96 &floatformat_ia64_spill_little
98 const struct floatformat
*floatformats_ia64_quad
[BFD_ENDIAN_UNKNOWN
] = {
99 &floatformat_ia64_quad_big
,
100 &floatformat_ia64_quad_little
102 const struct floatformat
*floatformats_vax_f
[BFD_ENDIAN_UNKNOWN
] = {
106 const struct floatformat
*floatformats_vax_d
[BFD_ENDIAN_UNKNOWN
] = {
110 const struct floatformat
*floatformats_ibm_long_double
[BFD_ENDIAN_UNKNOWN
] = {
111 &floatformat_ibm_long_double_big
,
112 &floatformat_ibm_long_double_little
115 /* Should opaque types be resolved? */
117 static int opaque_type_resolution
= 1;
119 /* A flag to enable printing of debugging information of C++
122 unsigned int overload_debug
= 0;
124 /* A flag to enable strict type checking. */
126 static int strict_type_checking
= 1;
128 /* A function to show whether opaque types are resolved. */
131 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
132 struct cmd_list_element
*c
,
135 fprintf_filtered (file
, _("Resolution of opaque struct/class/union types "
136 "(if set before loading symbols) is %s.\n"),
140 /* A function to show whether C++ overload debugging is enabled. */
143 show_overload_debug (struct ui_file
*file
, int from_tty
,
144 struct cmd_list_element
*c
, const char *value
)
146 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"),
150 /* A function to show the status of strict type checking. */
153 show_strict_type_checking (struct ui_file
*file
, int from_tty
,
154 struct cmd_list_element
*c
, const char *value
)
156 fprintf_filtered (file
, _("Strict type checking is %s.\n"), value
);
160 /* Allocate a new OBJFILE-associated type structure and fill it
161 with some defaults. Space for the type structure is allocated
162 on the objfile's objfile_obstack. */
165 alloc_type (struct objfile
*objfile
)
169 gdb_assert (objfile
!= NULL
);
171 /* Alloc the structure and start off with all fields zeroed. */
172 type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct type
);
173 TYPE_MAIN_TYPE (type
) = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
175 OBJSTAT (objfile
, n_types
++);
177 TYPE_OBJFILE_OWNED (type
) = 1;
178 TYPE_OWNER (type
).objfile
= objfile
;
180 /* Initialize the fields that might not be zero. */
182 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
183 TYPE_VPTR_FIELDNO (type
) = -1;
184 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
189 /* Allocate a new GDBARCH-associated type structure and fill it
190 with some defaults. Space for the type structure is allocated
194 alloc_type_arch (struct gdbarch
*gdbarch
)
198 gdb_assert (gdbarch
!= NULL
);
200 /* Alloc the structure and start off with all fields zeroed. */
202 type
= XZALLOC (struct type
);
203 TYPE_MAIN_TYPE (type
) = XZALLOC (struct main_type
);
205 TYPE_OBJFILE_OWNED (type
) = 0;
206 TYPE_OWNER (type
).gdbarch
= gdbarch
;
208 /* Initialize the fields that might not be zero. */
210 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
211 TYPE_VPTR_FIELDNO (type
) = -1;
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 /* Alloc a new type instance structure, fill it with some defaults,
243 and point it at OLDTYPE. Allocate the new type instance from the
244 same place as OLDTYPE. */
247 alloc_type_instance (struct type
*oldtype
)
251 /* Allocate the structure. */
253 if (! TYPE_OBJFILE_OWNED (oldtype
))
254 type
= XZALLOC (struct type
);
256 type
= OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype
)->objfile_obstack
,
259 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
261 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
266 /* Clear all remnants of the previous type at TYPE, in preparation for
267 replacing it with something else. Preserve owner information. */
270 smash_type (struct type
*type
)
272 int objfile_owned
= TYPE_OBJFILE_OWNED (type
);
273 union type_owner owner
= TYPE_OWNER (type
);
275 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
277 /* Restore owner information. */
278 TYPE_OBJFILE_OWNED (type
) = objfile_owned
;
279 TYPE_OWNER (type
) = owner
;
281 /* For now, delete the rings. */
282 TYPE_CHAIN (type
) = type
;
284 /* For now, leave the pointer/reference types alone. */
287 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
288 to a pointer to memory where the pointer type should be stored.
289 If *TYPEPTR is zero, update it to point to the pointer type we return.
290 We allocate new memory if needed. */
293 make_pointer_type (struct type
*type
, struct type
**typeptr
)
295 struct type
*ntype
; /* New type */
298 ntype
= TYPE_POINTER_TYPE (type
);
303 return ntype
; /* Don't care about alloc,
304 and have new type. */
305 else if (*typeptr
== 0)
307 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
312 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
314 ntype
= alloc_type_copy (type
);
318 else /* We have storage, but need to reset it. */
321 chain
= TYPE_CHAIN (ntype
);
323 TYPE_CHAIN (ntype
) = chain
;
326 TYPE_TARGET_TYPE (ntype
) = type
;
327 TYPE_POINTER_TYPE (type
) = ntype
;
329 /* FIXME! Assumes the machine has only one representation for pointers! */
332 = gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
333 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
335 /* Mark pointers as unsigned. The target converts between pointers
336 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
337 gdbarch_address_to_pointer. */
338 TYPE_UNSIGNED (ntype
) = 1;
340 /* Update the length of all the other variants of this type. */
341 chain
= TYPE_CHAIN (ntype
);
342 while (chain
!= ntype
)
344 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
345 chain
= TYPE_CHAIN (chain
);
351 /* Given a type TYPE, return a type of pointers to that type.
352 May need to construct such a type if this is the first use. */
355 lookup_pointer_type (struct type
*type
)
357 return make_pointer_type (type
, (struct type
**) 0);
360 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
361 points to a pointer to memory where the reference type should be
362 stored. If *TYPEPTR is zero, update it to point to the reference
363 type we return. We allocate new memory if needed. */
366 make_reference_type (struct type
*type
, struct type
**typeptr
)
368 struct type
*ntype
; /* New type */
371 ntype
= TYPE_REFERENCE_TYPE (type
);
376 return ntype
; /* Don't care about alloc,
377 and have new type. */
378 else if (*typeptr
== 0)
380 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
385 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
387 ntype
= alloc_type_copy (type
);
391 else /* We have storage, but need to reset it. */
394 chain
= TYPE_CHAIN (ntype
);
396 TYPE_CHAIN (ntype
) = chain
;
399 TYPE_TARGET_TYPE (ntype
) = type
;
400 TYPE_REFERENCE_TYPE (type
) = ntype
;
402 /* FIXME! Assume the machine has only one representation for
403 references, and that it matches the (only) representation for
406 TYPE_LENGTH (ntype
) =
407 gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
408 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
410 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
411 TYPE_REFERENCE_TYPE (type
) = ntype
;
413 /* Update the length of all the other variants of this type. */
414 chain
= TYPE_CHAIN (ntype
);
415 while (chain
!= ntype
)
417 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
418 chain
= TYPE_CHAIN (chain
);
424 /* Same as above, but caller doesn't care about memory allocation
428 lookup_reference_type (struct type
*type
)
430 return make_reference_type (type
, (struct type
**) 0);
433 /* Lookup a function type that returns type TYPE. TYPEPTR, if
434 nonzero, points to a pointer to memory where the function type
435 should be stored. If *TYPEPTR is zero, update it to point to the
436 function type we return. We allocate new memory if needed. */
439 make_function_type (struct type
*type
, struct type
**typeptr
)
441 struct type
*ntype
; /* New type */
443 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
445 ntype
= alloc_type_copy (type
);
449 else /* We have storage, but need to reset it. */
455 TYPE_TARGET_TYPE (ntype
) = type
;
457 TYPE_LENGTH (ntype
) = 1;
458 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
460 INIT_FUNC_SPECIFIC (ntype
);
465 /* Given a type TYPE, return a type of functions that return that type.
466 May need to construct such a type if this is the first use. */
469 lookup_function_type (struct type
*type
)
471 return make_function_type (type
, (struct type
**) 0);
474 /* Given a type TYPE and argument types, return the appropriate
475 function type. If the final type in PARAM_TYPES is NULL, make a
479 lookup_function_type_with_arguments (struct type
*type
,
481 struct type
**param_types
)
483 struct type
*fn
= make_function_type (type
, (struct type
**) 0);
488 if (param_types
[nparams
- 1] == NULL
)
491 TYPE_VARARGS (fn
) = 1;
493 else if (TYPE_CODE (check_typedef (param_types
[nparams
- 1]))
497 /* Caller should have ensured this. */
498 gdb_assert (nparams
== 0);
499 TYPE_PROTOTYPED (fn
) = 1;
503 TYPE_NFIELDS (fn
) = nparams
;
504 TYPE_FIELDS (fn
) = TYPE_ZALLOC (fn
, nparams
* sizeof (struct field
));
505 for (i
= 0; i
< nparams
; ++i
)
506 TYPE_FIELD_TYPE (fn
, i
) = param_types
[i
];
511 /* Identify address space identifier by name --
512 return the integer flag defined in gdbtypes.h. */
515 address_space_name_to_int (struct gdbarch
*gdbarch
, char *space_identifier
)
519 /* Check for known address space delimiters. */
520 if (!strcmp (space_identifier
, "code"))
521 return TYPE_INSTANCE_FLAG_CODE_SPACE
;
522 else if (!strcmp (space_identifier
, "data"))
523 return TYPE_INSTANCE_FLAG_DATA_SPACE
;
524 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
525 && gdbarch_address_class_name_to_type_flags (gdbarch
,
530 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
533 /* Identify address space identifier by integer flag as defined in
534 gdbtypes.h -- return the string version of the adress space name. */
537 address_space_int_to_name (struct gdbarch
*gdbarch
, int space_flag
)
539 if (space_flag
& TYPE_INSTANCE_FLAG_CODE_SPACE
)
541 else if (space_flag
& TYPE_INSTANCE_FLAG_DATA_SPACE
)
543 else if ((space_flag
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
544 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
545 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
550 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
552 If STORAGE is non-NULL, create the new type instance there.
553 STORAGE must be in the same obstack as TYPE. */
556 make_qualified_type (struct type
*type
, int new_flags
,
557 struct type
*storage
)
564 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
566 ntype
= TYPE_CHAIN (ntype
);
568 while (ntype
!= type
);
570 /* Create a new type instance. */
572 ntype
= alloc_type_instance (type
);
575 /* If STORAGE was provided, it had better be in the same objfile
576 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
577 if one objfile is freed and the other kept, we'd have
578 dangling pointers. */
579 gdb_assert (TYPE_OBJFILE (type
) == TYPE_OBJFILE (storage
));
582 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
583 TYPE_CHAIN (ntype
) = ntype
;
586 /* Pointers or references to the original type are not relevant to
588 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
589 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
591 /* Chain the new qualified type to the old type. */
592 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
593 TYPE_CHAIN (type
) = ntype
;
595 /* Now set the instance flags and return the new type. */
596 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
598 /* Set length of new type to that of the original type. */
599 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
604 /* Make an address-space-delimited variant of a type -- a type that
605 is identical to the one supplied except that it has an address
606 space attribute attached to it (such as "code" or "data").
608 The space attributes "code" and "data" are for Harvard
609 architectures. The address space attributes are for architectures
610 which have alternately sized pointers or pointers with alternate
614 make_type_with_address_space (struct type
*type
, int space_flag
)
616 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
617 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
618 | TYPE_INSTANCE_FLAG_DATA_SPACE
619 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
))
622 return make_qualified_type (type
, new_flags
, NULL
);
625 /* Make a "c-v" variant of a type -- a type that is identical to the
626 one supplied except that it may have const or volatile attributes
627 CNST is a flag for setting the const attribute
628 VOLTL is a flag for setting the volatile attribute
629 TYPE is the base type whose variant we are creating.
631 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
632 storage to hold the new qualified type; *TYPEPTR and TYPE must be
633 in the same objfile. Otherwise, allocate fresh memory for the new
634 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
635 new type we construct. */
638 make_cv_type (int cnst
, int voltl
,
640 struct type
**typeptr
)
642 struct type
*ntype
; /* New type */
644 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
645 & ~(TYPE_INSTANCE_FLAG_CONST
646 | TYPE_INSTANCE_FLAG_VOLATILE
));
649 new_flags
|= TYPE_INSTANCE_FLAG_CONST
;
652 new_flags
|= TYPE_INSTANCE_FLAG_VOLATILE
;
654 if (typeptr
&& *typeptr
!= NULL
)
656 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
657 a C-V variant chain that threads across objfiles: if one
658 objfile gets freed, then the other has a broken C-V chain.
660 This code used to try to copy over the main type from TYPE to
661 *TYPEPTR if they were in different objfiles, but that's
662 wrong, too: TYPE may have a field list or member function
663 lists, which refer to types of their own, etc. etc. The
664 whole shebang would need to be copied over recursively; you
665 can't have inter-objfile pointers. The only thing to do is
666 to leave stub types as stub types, and look them up afresh by
667 name each time you encounter them. */
668 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
));
671 ntype
= make_qualified_type (type
, new_flags
,
672 typeptr
? *typeptr
: NULL
);
680 /* Make a 'restrict'-qualified version of TYPE. */
683 make_restrict_type (struct type
*type
)
685 return make_qualified_type (type
,
686 (TYPE_INSTANCE_FLAGS (type
)
687 | TYPE_INSTANCE_FLAG_RESTRICT
),
691 /* Replace the contents of ntype with the type *type. This changes the
692 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
693 the changes are propogated to all types in the TYPE_CHAIN.
695 In order to build recursive types, it's inevitable that we'll need
696 to update types in place --- but this sort of indiscriminate
697 smashing is ugly, and needs to be replaced with something more
698 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
699 clear if more steps are needed. */
702 replace_type (struct type
*ntype
, struct type
*type
)
706 /* These two types had better be in the same objfile. Otherwise,
707 the assignment of one type's main type structure to the other
708 will produce a type with references to objects (names; field
709 lists; etc.) allocated on an objfile other than its own. */
710 gdb_assert (TYPE_OBJFILE (ntype
) == TYPE_OBJFILE (ntype
));
712 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
714 /* The type length is not a part of the main type. Update it for
715 each type on the variant chain. */
719 /* Assert that this element of the chain has no address-class bits
720 set in its flags. Such type variants might have type lengths
721 which are supposed to be different from the non-address-class
722 variants. This assertion shouldn't ever be triggered because
723 symbol readers which do construct address-class variants don't
724 call replace_type(). */
725 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
727 TYPE_LENGTH (chain
) = TYPE_LENGTH (type
);
728 chain
= TYPE_CHAIN (chain
);
730 while (ntype
!= chain
);
732 /* Assert that the two types have equivalent instance qualifiers.
733 This should be true for at least all of our debug readers. */
734 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
737 /* Implement direct support for MEMBER_TYPE in GNU C++.
738 May need to construct such a type if this is the first use.
739 The TYPE is the type of the member. The DOMAIN is the type
740 of the aggregate that the member belongs to. */
743 lookup_memberptr_type (struct type
*type
, struct type
*domain
)
747 mtype
= alloc_type_copy (type
);
748 smash_to_memberptr_type (mtype
, domain
, type
);
752 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
755 lookup_methodptr_type (struct type
*to_type
)
759 mtype
= alloc_type_copy (to_type
);
760 smash_to_methodptr_type (mtype
, to_type
);
764 /* Allocate a stub method whose return type is TYPE. This apparently
765 happens for speed of symbol reading, since parsing out the
766 arguments to the method is cpu-intensive, the way we are doing it.
767 So, we will fill in arguments later. This always returns a fresh
771 allocate_stub_method (struct type
*type
)
775 mtype
= alloc_type_copy (type
);
776 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
777 TYPE_LENGTH (mtype
) = 1;
778 TYPE_STUB (mtype
) = 1;
779 TYPE_TARGET_TYPE (mtype
) = type
;
780 /* _DOMAIN_TYPE (mtype) = unknown yet */
784 /* Create a range type using either a blank type supplied in
785 RESULT_TYPE, or creating a new type, inheriting the objfile from
788 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
789 to HIGH_BOUND, inclusive.
791 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
792 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
795 create_range_type (struct type
*result_type
, struct type
*index_type
,
796 LONGEST low_bound
, LONGEST high_bound
)
798 if (result_type
== NULL
)
799 result_type
= alloc_type_copy (index_type
);
800 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
801 TYPE_TARGET_TYPE (result_type
) = index_type
;
802 if (TYPE_STUB (index_type
))
803 TYPE_TARGET_STUB (result_type
) = 1;
805 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
806 TYPE_RANGE_DATA (result_type
) = (struct range_bounds
*)
807 TYPE_ZALLOC (result_type
, sizeof (struct range_bounds
));
808 TYPE_LOW_BOUND (result_type
) = low_bound
;
809 TYPE_HIGH_BOUND (result_type
) = high_bound
;
812 TYPE_UNSIGNED (result_type
) = 1;
817 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
818 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
819 bounds will fit in LONGEST), or -1 otherwise. */
822 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
824 CHECK_TYPEDEF (type
);
825 switch (TYPE_CODE (type
))
827 case TYPE_CODE_RANGE
:
828 *lowp
= TYPE_LOW_BOUND (type
);
829 *highp
= TYPE_HIGH_BOUND (type
);
832 if (TYPE_NFIELDS (type
) > 0)
834 /* The enums may not be sorted by value, so search all
838 *lowp
= *highp
= TYPE_FIELD_ENUMVAL (type
, 0);
839 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
841 if (TYPE_FIELD_ENUMVAL (type
, i
) < *lowp
)
842 *lowp
= TYPE_FIELD_ENUMVAL (type
, i
);
843 if (TYPE_FIELD_ENUMVAL (type
, i
) > *highp
)
844 *highp
= TYPE_FIELD_ENUMVAL (type
, i
);
847 /* Set unsigned indicator if warranted. */
850 TYPE_UNSIGNED (type
) = 1;
864 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
866 if (!TYPE_UNSIGNED (type
))
868 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
872 /* ... fall through for unsigned ints ... */
875 /* This round-about calculation is to avoid shifting by
876 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
877 if TYPE_LENGTH (type) == sizeof (LONGEST). */
878 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
879 *highp
= (*highp
- 1) | *highp
;
886 /* Assuming TYPE is a simple, non-empty array type, compute its upper
887 and lower bound. Save the low bound into LOW_BOUND if not NULL.
888 Save the high bound into HIGH_BOUND if not NULL.
890 Return 1 if the operation was successful. Return zero otherwise,
891 in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
893 We now simply use get_discrete_bounds call to get the values
894 of the low and high bounds.
895 get_discrete_bounds can return three values:
896 1, meaning that index is a range,
897 0, meaning that index is a discrete type,
898 or -1 for failure. */
901 get_array_bounds (struct type
*type
, LONGEST
*low_bound
, LONGEST
*high_bound
)
903 struct type
*index
= TYPE_INDEX_TYPE (type
);
911 res
= get_discrete_bounds (index
, &low
, &high
);
915 /* Check if the array bounds are undefined. */
917 && ((low_bound
&& TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type
))
918 || (high_bound
&& TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))))
930 /* Create an array type using either a blank type supplied in
931 RESULT_TYPE, or creating a new type, inheriting the objfile from
934 Elements will be of type ELEMENT_TYPE, the indices will be of type
937 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
938 sure it is TYPE_CODE_UNDEF before we bash it into an array
942 create_array_type (struct type
*result_type
,
943 struct type
*element_type
,
944 struct type
*range_type
)
946 LONGEST low_bound
, high_bound
;
948 if (result_type
== NULL
)
949 result_type
= alloc_type_copy (range_type
);
951 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
952 TYPE_TARGET_TYPE (result_type
) = element_type
;
953 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
954 low_bound
= high_bound
= 0;
955 CHECK_TYPEDEF (element_type
);
956 /* Be careful when setting the array length. Ada arrays can be
957 empty arrays with the high_bound being smaller than the low_bound.
958 In such cases, the array length should be zero. */
959 if (high_bound
< low_bound
)
960 TYPE_LENGTH (result_type
) = 0;
962 TYPE_LENGTH (result_type
) =
963 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
964 TYPE_NFIELDS (result_type
) = 1;
965 TYPE_FIELDS (result_type
) =
966 (struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
));
967 TYPE_INDEX_TYPE (result_type
) = range_type
;
968 TYPE_VPTR_FIELDNO (result_type
) = -1;
970 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays. */
971 if (TYPE_LENGTH (result_type
) == 0)
972 TYPE_TARGET_STUB (result_type
) = 1;
978 lookup_array_range_type (struct type
*element_type
,
979 LONGEST low_bound
, LONGEST high_bound
)
981 struct gdbarch
*gdbarch
= get_type_arch (element_type
);
982 struct type
*index_type
= builtin_type (gdbarch
)->builtin_int
;
983 struct type
*range_type
984 = create_range_type (NULL
, index_type
, low_bound
, high_bound
);
986 return create_array_type (NULL
, element_type
, range_type
);
989 /* Create a string type using either a blank type supplied in
990 RESULT_TYPE, or creating a new type. String types are similar
991 enough to array of char types that we can use create_array_type to
992 build the basic type and then bash it into a string type.
994 For fixed length strings, the range type contains 0 as the lower
995 bound and the length of the string minus one as the upper bound.
997 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
998 sure it is TYPE_CODE_UNDEF before we bash it into a string
1002 create_string_type (struct type
*result_type
,
1003 struct type
*string_char_type
,
1004 struct type
*range_type
)
1006 result_type
= create_array_type (result_type
,
1009 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
1014 lookup_string_range_type (struct type
*string_char_type
,
1015 LONGEST low_bound
, LONGEST high_bound
)
1017 struct type
*result_type
;
1019 result_type
= lookup_array_range_type (string_char_type
,
1020 low_bound
, high_bound
);
1021 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
1026 create_set_type (struct type
*result_type
, struct type
*domain_type
)
1028 if (result_type
== NULL
)
1029 result_type
= alloc_type_copy (domain_type
);
1031 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
1032 TYPE_NFIELDS (result_type
) = 1;
1033 TYPE_FIELDS (result_type
) = TYPE_ZALLOC (result_type
, sizeof (struct field
));
1035 if (!TYPE_STUB (domain_type
))
1037 LONGEST low_bound
, high_bound
, bit_length
;
1039 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
1040 low_bound
= high_bound
= 0;
1041 bit_length
= high_bound
- low_bound
+ 1;
1042 TYPE_LENGTH (result_type
)
1043 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
1045 TYPE_UNSIGNED (result_type
) = 1;
1047 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
1052 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
1053 and any array types nested inside it. */
1056 make_vector_type (struct type
*array_type
)
1058 struct type
*inner_array
, *elt_type
;
1061 /* Find the innermost array type, in case the array is
1062 multi-dimensional. */
1063 inner_array
= array_type
;
1064 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
1065 inner_array
= TYPE_TARGET_TYPE (inner_array
);
1067 elt_type
= TYPE_TARGET_TYPE (inner_array
);
1068 if (TYPE_CODE (elt_type
) == TYPE_CODE_INT
)
1070 flags
= TYPE_INSTANCE_FLAGS (elt_type
) | TYPE_INSTANCE_FLAG_NOTTEXT
;
1071 elt_type
= make_qualified_type (elt_type
, flags
, NULL
);
1072 TYPE_TARGET_TYPE (inner_array
) = elt_type
;
1075 TYPE_VECTOR (array_type
) = 1;
1079 init_vector_type (struct type
*elt_type
, int n
)
1081 struct type
*array_type
;
1083 array_type
= lookup_array_range_type (elt_type
, 0, n
- 1);
1084 make_vector_type (array_type
);
1088 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
1089 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1090 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1091 TYPE doesn't include the offset (that's the value of the MEMBER
1092 itself), but does include the structure type into which it points
1095 When "smashing" the type, we preserve the objfile that the old type
1096 pointed to, since we aren't changing where the type is actually
1100 smash_to_memberptr_type (struct type
*type
, struct type
*domain
,
1101 struct type
*to_type
)
1104 TYPE_TARGET_TYPE (type
) = to_type
;
1105 TYPE_DOMAIN_TYPE (type
) = domain
;
1106 /* Assume that a data member pointer is the same size as a normal
1109 = gdbarch_ptr_bit (get_type_arch (to_type
)) / TARGET_CHAR_BIT
;
1110 TYPE_CODE (type
) = TYPE_CODE_MEMBERPTR
;
1113 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1115 When "smashing" the type, we preserve the objfile that the old type
1116 pointed to, since we aren't changing where the type is actually
1120 smash_to_methodptr_type (struct type
*type
, struct type
*to_type
)
1123 TYPE_TARGET_TYPE (type
) = to_type
;
1124 TYPE_DOMAIN_TYPE (type
) = TYPE_DOMAIN_TYPE (to_type
);
1125 TYPE_LENGTH (type
) = cplus_method_ptr_size (to_type
);
1126 TYPE_CODE (type
) = TYPE_CODE_METHODPTR
;
1129 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
1130 METHOD just means `function that gets an extra "this" argument'.
1132 When "smashing" the type, we preserve the objfile that the old type
1133 pointed to, since we aren't changing where the type is actually
1137 smash_to_method_type (struct type
*type
, struct type
*domain
,
1138 struct type
*to_type
, struct field
*args
,
1139 int nargs
, int varargs
)
1142 TYPE_TARGET_TYPE (type
) = to_type
;
1143 TYPE_DOMAIN_TYPE (type
) = domain
;
1144 TYPE_FIELDS (type
) = args
;
1145 TYPE_NFIELDS (type
) = nargs
;
1147 TYPE_VARARGS (type
) = 1;
1148 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1149 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
1152 /* Return a typename for a struct/union/enum type without "struct ",
1153 "union ", or "enum ". If the type has a NULL name, return NULL. */
1156 type_name_no_tag (const struct type
*type
)
1158 if (TYPE_TAG_NAME (type
) != NULL
)
1159 return TYPE_TAG_NAME (type
);
1161 /* Is there code which expects this to return the name if there is
1162 no tag name? My guess is that this is mainly used for C++ in
1163 cases where the two will always be the same. */
1164 return TYPE_NAME (type
);
1167 /* A wrapper of type_name_no_tag which calls error if the type is anonymous.
1168 Since GCC PR debug/47510 DWARF provides associated information to detect the
1169 anonymous class linkage name from its typedef.
1171 Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
1175 type_name_no_tag_or_error (struct type
*type
)
1177 struct type
*saved_type
= type
;
1179 struct objfile
*objfile
;
1181 CHECK_TYPEDEF (type
);
1183 name
= type_name_no_tag (type
);
1187 name
= type_name_no_tag (saved_type
);
1188 objfile
= TYPE_OBJFILE (saved_type
);
1189 error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
1190 name
? name
: "<anonymous>",
1191 objfile
? objfile_name (objfile
) : "<arch>");
1194 /* Lookup a typedef or primitive type named NAME, visible in lexical
1195 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1196 suitably defined. */
1199 lookup_typename (const struct language_defn
*language
,
1200 struct gdbarch
*gdbarch
, const char *name
,
1201 const struct block
*block
, int noerr
)
1206 sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, 0);
1207 if (sym
!= NULL
&& SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
1208 return SYMBOL_TYPE (sym
);
1210 type
= language_lookup_primitive_type_by_name (language
, gdbarch
, name
);
1216 error (_("No type named %s."), name
);
1220 lookup_unsigned_typename (const struct language_defn
*language
,
1221 struct gdbarch
*gdbarch
, const char *name
)
1223 char *uns
= alloca (strlen (name
) + 10);
1225 strcpy (uns
, "unsigned ");
1226 strcpy (uns
+ 9, name
);
1227 return lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 0);
1231 lookup_signed_typename (const struct language_defn
*language
,
1232 struct gdbarch
*gdbarch
, const char *name
)
1235 char *uns
= alloca (strlen (name
) + 8);
1237 strcpy (uns
, "signed ");
1238 strcpy (uns
+ 7, name
);
1239 t
= lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 1);
1240 /* If we don't find "signed FOO" just try again with plain "FOO". */
1243 return lookup_typename (language
, gdbarch
, name
, (struct block
*) NULL
, 0);
1246 /* Lookup a structure type named "struct NAME",
1247 visible in lexical block BLOCK. */
1250 lookup_struct (const char *name
, const struct block
*block
)
1254 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1258 error (_("No struct type named %s."), name
);
1260 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1262 error (_("This context has class, union or enum %s, not a struct."),
1265 return (SYMBOL_TYPE (sym
));
1268 /* Lookup a union type named "union NAME",
1269 visible in lexical block BLOCK. */
1272 lookup_union (const char *name
, const struct block
*block
)
1277 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1280 error (_("No union type named %s."), name
);
1282 t
= SYMBOL_TYPE (sym
);
1284 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1287 /* If we get here, it's not a union. */
1288 error (_("This context has class, struct or enum %s, not a union."),
1292 /* Lookup an enum type named "enum NAME",
1293 visible in lexical block BLOCK. */
1296 lookup_enum (const char *name
, const struct block
*block
)
1300 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1303 error (_("No enum type named %s."), name
);
1305 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1307 error (_("This context has class, struct or union %s, not an enum."),
1310 return (SYMBOL_TYPE (sym
));
1313 /* Lookup a template type named "template NAME<TYPE>",
1314 visible in lexical block BLOCK. */
1317 lookup_template_type (char *name
, struct type
*type
,
1318 const struct block
*block
)
1321 char *nam
= (char *)
1322 alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1326 strcat (nam
, TYPE_NAME (type
));
1327 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1329 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0);
1333 error (_("No template type named %s."), name
);
1335 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1337 error (_("This context has class, union or enum %s, not a struct."),
1340 return (SYMBOL_TYPE (sym
));
1343 /* Given a type TYPE, lookup the type of the component of type named
1346 TYPE can be either a struct or union, or a pointer or reference to
1347 a struct or union. If it is a pointer or reference, its target
1348 type is automatically used. Thus '.' and '->' are interchangable,
1349 as specified for the definitions of the expression element types
1350 STRUCTOP_STRUCT and STRUCTOP_PTR.
1352 If NOERR is nonzero, return zero if NAME is not suitably defined.
1353 If NAME is the name of a baseclass type, return that type. */
1356 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
1363 CHECK_TYPEDEF (type
);
1364 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1365 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1367 type
= TYPE_TARGET_TYPE (type
);
1370 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1371 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1373 typename
= type_to_string (type
);
1374 make_cleanup (xfree
, typename
);
1375 error (_("Type %s is not a structure or union type."), typename
);
1379 /* FIXME: This change put in by Michael seems incorrect for the case
1380 where the structure tag name is the same as the member name.
1381 I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
1382 foo; } bell;" Disabled by fnf. */
1386 typename
= type_name_no_tag (type
);
1387 if (typename
!= NULL
&& strcmp (typename
, name
) == 0)
1392 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1394 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1396 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1398 return TYPE_FIELD_TYPE (type
, i
);
1400 else if (!t_field_name
|| *t_field_name
== '\0')
1402 struct type
*subtype
1403 = lookup_struct_elt_type (TYPE_FIELD_TYPE (type
, i
), name
, 1);
1405 if (subtype
!= NULL
)
1410 /* OK, it's not in this class. Recursively check the baseclasses. */
1411 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1415 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, 1);
1427 typename
= type_to_string (type
);
1428 make_cleanup (xfree
, typename
);
1429 error (_("Type %s has no component named %s."), typename
, name
);
1432 /* Lookup the vptr basetype/fieldno values for TYPE.
1433 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1434 vptr_fieldno. Also, if found and basetype is from the same objfile,
1436 If not found, return -1 and ignore BASETYPEP.
1437 Callers should be aware that in some cases (for example,
1438 the type or one of its baseclasses is a stub type and we are
1439 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1440 this function will not be able to find the
1441 virtual function table pointer, and vptr_fieldno will remain -1 and
1442 vptr_basetype will remain NULL or incomplete. */
1445 get_vptr_fieldno (struct type
*type
, struct type
**basetypep
)
1447 CHECK_TYPEDEF (type
);
1449 if (TYPE_VPTR_FIELDNO (type
) < 0)
1453 /* We must start at zero in case the first (and only) baseclass
1454 is virtual (and hence we cannot share the table pointer). */
1455 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1457 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1459 struct type
*basetype
;
1461 fieldno
= get_vptr_fieldno (baseclass
, &basetype
);
1464 /* If the type comes from a different objfile we can't cache
1465 it, it may have a different lifetime. PR 2384 */
1466 if (TYPE_OBJFILE (type
) == TYPE_OBJFILE (basetype
))
1468 TYPE_VPTR_FIELDNO (type
) = fieldno
;
1469 TYPE_VPTR_BASETYPE (type
) = basetype
;
1472 *basetypep
= basetype
;
1483 *basetypep
= TYPE_VPTR_BASETYPE (type
);
1484 return TYPE_VPTR_FIELDNO (type
);
1489 stub_noname_complaint (void)
1491 complaint (&symfile_complaints
, _("stub type has NULL name"));
1494 /* Find the real type of TYPE. This function returns the real type,
1495 after removing all layers of typedefs, and completing opaque or stub
1496 types. Completion changes the TYPE argument, but stripping of
1499 Instance flags (e.g. const/volatile) are preserved as typedefs are
1500 stripped. If necessary a new qualified form of the underlying type
1503 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
1504 not been computed and we're either in the middle of reading symbols, or
1505 there was no name for the typedef in the debug info.
1507 NOTE: Lookup of opaque types can throw errors for invalid symbol files.
1508 QUITs in the symbol reading code can also throw.
1509 Thus this function can throw an exception.
1511 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
1514 If this is a stubbed struct (i.e. declared as struct foo *), see if
1515 we can find a full definition in some other file. If so, copy this
1516 definition, so we can use it in future. There used to be a comment
1517 (but not any code) that if we don't find a full definition, we'd
1518 set a flag so we don't spend time in the future checking the same
1519 type. That would be a mistake, though--we might load in more
1520 symbols which contain a full definition for the type. */
1523 check_typedef (struct type
*type
)
1525 struct type
*orig_type
= type
;
1526 /* While we're removing typedefs, we don't want to lose qualifiers.
1527 E.g., const/volatile. */
1528 int instance_flags
= TYPE_INSTANCE_FLAGS (type
);
1532 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1534 if (!TYPE_TARGET_TYPE (type
))
1539 /* It is dangerous to call lookup_symbol if we are currently
1540 reading a symtab. Infinite recursion is one danger. */
1541 if (currently_reading_symtab
)
1542 return make_qualified_type (type
, instance_flags
, NULL
);
1544 name
= type_name_no_tag (type
);
1545 /* FIXME: shouldn't we separately check the TYPE_NAME and
1546 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1547 VAR_DOMAIN as appropriate? (this code was written before
1548 TYPE_NAME and TYPE_TAG_NAME were separate). */
1551 stub_noname_complaint ();
1552 return make_qualified_type (type
, instance_flags
, NULL
);
1554 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1556 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1557 else /* TYPE_CODE_UNDEF */
1558 TYPE_TARGET_TYPE (type
) = alloc_type_arch (get_type_arch (type
));
1560 type
= TYPE_TARGET_TYPE (type
);
1562 /* Preserve the instance flags as we traverse down the typedef chain.
1564 Handling address spaces/classes is nasty, what do we do if there's a
1566 E.g., what if an outer typedef marks the type as class_1 and an inner
1567 typedef marks the type as class_2?
1568 This is the wrong place to do such error checking. We leave it to
1569 the code that created the typedef in the first place to flag the
1570 error. We just pick the outer address space (akin to letting the
1571 outer cast in a chain of casting win), instead of assuming
1572 "it can't happen". */
1574 const int ALL_SPACES
= (TYPE_INSTANCE_FLAG_CODE_SPACE
1575 | TYPE_INSTANCE_FLAG_DATA_SPACE
);
1576 const int ALL_CLASSES
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
;
1577 int new_instance_flags
= TYPE_INSTANCE_FLAGS (type
);
1579 /* Treat code vs data spaces and address classes separately. */
1580 if ((instance_flags
& ALL_SPACES
) != 0)
1581 new_instance_flags
&= ~ALL_SPACES
;
1582 if ((instance_flags
& ALL_CLASSES
) != 0)
1583 new_instance_flags
&= ~ALL_CLASSES
;
1585 instance_flags
|= new_instance_flags
;
1589 /* If this is a struct/class/union with no fields, then check
1590 whether a full definition exists somewhere else. This is for
1591 systems where a type definition with no fields is issued for such
1592 types, instead of identifying them as stub types in the first
1595 if (TYPE_IS_OPAQUE (type
)
1596 && opaque_type_resolution
1597 && !currently_reading_symtab
)
1599 const char *name
= type_name_no_tag (type
);
1600 struct type
*newtype
;
1604 stub_noname_complaint ();
1605 return make_qualified_type (type
, instance_flags
, NULL
);
1607 newtype
= lookup_transparent_type (name
);
1611 /* If the resolved type and the stub are in the same
1612 objfile, then replace the stub type with the real deal.
1613 But if they're in separate objfiles, leave the stub
1614 alone; we'll just look up the transparent type every time
1615 we call check_typedef. We can't create pointers between
1616 types allocated to different objfiles, since they may
1617 have different lifetimes. Trying to copy NEWTYPE over to
1618 TYPE's objfile is pointless, too, since you'll have to
1619 move over any other types NEWTYPE refers to, which could
1620 be an unbounded amount of stuff. */
1621 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
1622 type
= make_qualified_type (newtype
,
1623 TYPE_INSTANCE_FLAGS (type
),
1629 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1631 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1633 const char *name
= type_name_no_tag (type
);
1634 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1635 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1636 as appropriate? (this code was written before TYPE_NAME and
1637 TYPE_TAG_NAME were separate). */
1642 stub_noname_complaint ();
1643 return make_qualified_type (type
, instance_flags
, NULL
);
1645 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1648 /* Same as above for opaque types, we can replace the stub
1649 with the complete type only if they are in the same
1651 if (TYPE_OBJFILE (SYMBOL_TYPE(sym
)) == TYPE_OBJFILE (type
))
1652 type
= make_qualified_type (SYMBOL_TYPE (sym
),
1653 TYPE_INSTANCE_FLAGS (type
),
1656 type
= SYMBOL_TYPE (sym
);
1660 if (TYPE_TARGET_STUB (type
))
1662 struct type
*range_type
;
1663 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1665 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1667 /* Nothing we can do. */
1669 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1670 && TYPE_NFIELDS (type
) == 1
1671 && (TYPE_CODE (range_type
= TYPE_INDEX_TYPE (type
))
1672 == TYPE_CODE_RANGE
))
1674 /* Now recompute the length of the array type, based on its
1675 number of elements and the target type's length.
1676 Watch out for Ada null Ada arrays where the high bound
1677 is smaller than the low bound. */
1678 const LONGEST low_bound
= TYPE_LOW_BOUND (range_type
);
1679 const LONGEST high_bound
= TYPE_HIGH_BOUND (range_type
);
1682 if (high_bound
< low_bound
)
1686 /* For now, we conservatively take the array length to be 0
1687 if its length exceeds UINT_MAX. The code below assumes
1688 that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
1689 which is technically not guaranteed by C, but is usually true
1690 (because it would be true if x were unsigned with its
1691 high-order bit on). It uses the fact that
1692 high_bound-low_bound is always representable in
1693 ULONGEST and that if high_bound-low_bound+1 overflows,
1694 it overflows to 0. We must change these tests if we
1695 decide to increase the representation of TYPE_LENGTH
1696 from unsigned int to ULONGEST. */
1697 ULONGEST ulow
= low_bound
, uhigh
= high_bound
;
1698 ULONGEST tlen
= TYPE_LENGTH (target_type
);
1700 len
= tlen
* (uhigh
- ulow
+ 1);
1701 if (tlen
== 0 || (len
/ tlen
- 1 + ulow
) != uhigh
1705 TYPE_LENGTH (type
) = len
;
1706 TYPE_TARGET_STUB (type
) = 0;
1708 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1710 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1711 TYPE_TARGET_STUB (type
) = 0;
1715 type
= make_qualified_type (type
, instance_flags
, NULL
);
1717 /* Cache TYPE_LENGTH for future use. */
1718 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1723 /* Parse a type expression in the string [P..P+LENGTH). If an error
1724 occurs, silently return a void type. */
1726 static struct type
*
1727 safe_parse_type (struct gdbarch
*gdbarch
, char *p
, int length
)
1729 struct ui_file
*saved_gdb_stderr
;
1730 struct type
*type
= NULL
; /* Initialize to keep gcc happy. */
1731 volatile struct gdb_exception except
;
1733 /* Suppress error messages. */
1734 saved_gdb_stderr
= gdb_stderr
;
1735 gdb_stderr
= ui_file_new ();
1737 /* Call parse_and_eval_type() without fear of longjmp()s. */
1738 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1740 type
= parse_and_eval_type (p
, length
);
1743 if (except
.reason
< 0)
1744 type
= builtin_type (gdbarch
)->builtin_void
;
1746 /* Stop suppressing error messages. */
1747 ui_file_delete (gdb_stderr
);
1748 gdb_stderr
= saved_gdb_stderr
;
1753 /* Ugly hack to convert method stubs into method types.
1755 He ain't kiddin'. This demangles the name of the method into a
1756 string including argument types, parses out each argument type,
1757 generates a string casting a zero to that type, evaluates the
1758 string, and stuffs the resulting type into an argtype vector!!!
1759 Then it knows the type of the whole function (including argument
1760 types for overloading), which info used to be in the stab's but was
1761 removed to hack back the space required for them. */
1764 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1766 struct gdbarch
*gdbarch
= get_type_arch (type
);
1768 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1769 char *demangled_name
= gdb_demangle (mangled_name
,
1770 DMGL_PARAMS
| DMGL_ANSI
);
1771 char *argtypetext
, *p
;
1772 int depth
= 0, argcount
= 1;
1773 struct field
*argtypes
;
1776 /* Make sure we got back a function string that we can use. */
1778 p
= strchr (demangled_name
, '(');
1782 if (demangled_name
== NULL
|| p
== NULL
)
1783 error (_("Internal: Cannot demangle mangled name `%s'."),
1786 /* Now, read in the parameters that define this type. */
1791 if (*p
== '(' || *p
== '<')
1795 else if (*p
== ')' || *p
== '>')
1799 else if (*p
== ',' && depth
== 0)
1807 /* If we read one argument and it was ``void'', don't count it. */
1808 if (strncmp (argtypetext
, "(void)", 6) == 0)
1811 /* We need one extra slot, for the THIS pointer. */
1813 argtypes
= (struct field
*)
1814 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
1817 /* Add THIS pointer for non-static methods. */
1818 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1819 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
1823 argtypes
[0].type
= lookup_pointer_type (type
);
1827 if (*p
!= ')') /* () means no args, skip while. */
1832 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1834 /* Avoid parsing of ellipsis, they will be handled below.
1835 Also avoid ``void'' as above. */
1836 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
1837 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
1839 argtypes
[argcount
].type
=
1840 safe_parse_type (gdbarch
, argtypetext
, p
- argtypetext
);
1843 argtypetext
= p
+ 1;
1846 if (*p
== '(' || *p
== '<')
1850 else if (*p
== ')' || *p
== '>')
1859 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1861 /* Now update the old "stub" type into a real type. */
1862 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1863 TYPE_DOMAIN_TYPE (mtype
) = type
;
1864 TYPE_FIELDS (mtype
) = argtypes
;
1865 TYPE_NFIELDS (mtype
) = argcount
;
1866 TYPE_STUB (mtype
) = 0;
1867 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1869 TYPE_VARARGS (mtype
) = 1;
1871 xfree (demangled_name
);
1874 /* This is the external interface to check_stub_method, above. This
1875 function unstubs all of the signatures for TYPE's METHOD_ID method
1876 name. After calling this function TYPE_FN_FIELD_STUB will be
1877 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1880 This function unfortunately can not die until stabs do. */
1883 check_stub_method_group (struct type
*type
, int method_id
)
1885 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
1886 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1887 int j
, found_stub
= 0;
1889 for (j
= 0; j
< len
; j
++)
1890 if (TYPE_FN_FIELD_STUB (f
, j
))
1893 check_stub_method (type
, method_id
, j
);
1896 /* GNU v3 methods with incorrect names were corrected when we read
1897 in type information, because it was cheaper to do it then. The
1898 only GNU v2 methods with incorrect method names are operators and
1899 destructors; destructors were also corrected when we read in type
1902 Therefore the only thing we need to handle here are v2 operator
1904 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
1907 char dem_opname
[256];
1909 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1911 dem_opname
, DMGL_ANSI
);
1913 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1917 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
1921 /* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */
1922 const struct cplus_struct_type cplus_struct_default
= { };
1925 allocate_cplus_struct_type (struct type
*type
)
1927 if (HAVE_CPLUS_STRUCT (type
))
1928 /* Structure was already allocated. Nothing more to do. */
1931 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_CPLUS_STUFF
;
1932 TYPE_RAW_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1933 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1934 *(TYPE_RAW_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1937 const struct gnat_aux_type gnat_aux_default
=
1940 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
1941 and allocate the associated gnat-specific data. The gnat-specific
1942 data is also initialized to gnat_aux_default. */
1945 allocate_gnat_aux_type (struct type
*type
)
1947 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_GNAT_STUFF
;
1948 TYPE_GNAT_SPECIFIC (type
) = (struct gnat_aux_type
*)
1949 TYPE_ALLOC (type
, sizeof (struct gnat_aux_type
));
1950 *(TYPE_GNAT_SPECIFIC (type
)) = gnat_aux_default
;
1953 /* Helper function to initialize the standard scalar types.
1955 If NAME is non-NULL, then it is used to initialize the type name.
1956 Note that NAME is not copied; it is required to have a lifetime at
1957 least as long as OBJFILE. */
1960 init_type (enum type_code code
, int length
, int flags
,
1961 const char *name
, struct objfile
*objfile
)
1965 type
= alloc_type (objfile
);
1966 TYPE_CODE (type
) = code
;
1967 TYPE_LENGTH (type
) = length
;
1969 gdb_assert (!(flags
& (TYPE_FLAG_MIN
- 1)));
1970 if (flags
& TYPE_FLAG_UNSIGNED
)
1971 TYPE_UNSIGNED (type
) = 1;
1972 if (flags
& TYPE_FLAG_NOSIGN
)
1973 TYPE_NOSIGN (type
) = 1;
1974 if (flags
& TYPE_FLAG_STUB
)
1975 TYPE_STUB (type
) = 1;
1976 if (flags
& TYPE_FLAG_TARGET_STUB
)
1977 TYPE_TARGET_STUB (type
) = 1;
1978 if (flags
& TYPE_FLAG_STATIC
)
1979 TYPE_STATIC (type
) = 1;
1980 if (flags
& TYPE_FLAG_PROTOTYPED
)
1981 TYPE_PROTOTYPED (type
) = 1;
1982 if (flags
& TYPE_FLAG_INCOMPLETE
)
1983 TYPE_INCOMPLETE (type
) = 1;
1984 if (flags
& TYPE_FLAG_VARARGS
)
1985 TYPE_VARARGS (type
) = 1;
1986 if (flags
& TYPE_FLAG_VECTOR
)
1987 TYPE_VECTOR (type
) = 1;
1988 if (flags
& TYPE_FLAG_STUB_SUPPORTED
)
1989 TYPE_STUB_SUPPORTED (type
) = 1;
1990 if (flags
& TYPE_FLAG_FIXED_INSTANCE
)
1991 TYPE_FIXED_INSTANCE (type
) = 1;
1992 if (flags
& TYPE_FLAG_GNU_IFUNC
)
1993 TYPE_GNU_IFUNC (type
) = 1;
1995 TYPE_NAME (type
) = name
;
1999 if (name
&& strcmp (name
, "char") == 0)
2000 TYPE_NOSIGN (type
) = 1;
2004 case TYPE_CODE_STRUCT
:
2005 case TYPE_CODE_UNION
:
2006 case TYPE_CODE_NAMESPACE
:
2007 INIT_CPLUS_SPECIFIC (type
);
2010 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_FLOATFORMAT
;
2012 case TYPE_CODE_FUNC
:
2013 INIT_FUNC_SPECIFIC (type
);
2019 /* Queries on types. */
2022 can_dereference (struct type
*t
)
2024 /* FIXME: Should we return true for references as well as
2029 && TYPE_CODE (t
) == TYPE_CODE_PTR
2030 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
2034 is_integral_type (struct type
*t
)
2039 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
2040 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
2041 || (TYPE_CODE (t
) == TYPE_CODE_FLAGS
)
2042 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
2043 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
2044 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
2047 /* Return true if TYPE is scalar. */
2050 is_scalar_type (struct type
*type
)
2052 CHECK_TYPEDEF (type
);
2054 switch (TYPE_CODE (type
))
2056 case TYPE_CODE_ARRAY
:
2057 case TYPE_CODE_STRUCT
:
2058 case TYPE_CODE_UNION
:
2060 case TYPE_CODE_STRING
:
2067 /* Return true if T is scalar, or a composite type which in practice has
2068 the memory layout of a scalar type. E.g., an array or struct with only
2069 one scalar element inside it, or a union with only scalar elements. */
2072 is_scalar_type_recursive (struct type
*t
)
2076 if (is_scalar_type (t
))
2078 /* Are we dealing with an array or string of known dimensions? */
2079 else if ((TYPE_CODE (t
) == TYPE_CODE_ARRAY
2080 || TYPE_CODE (t
) == TYPE_CODE_STRING
) && TYPE_NFIELDS (t
) == 1
2081 && TYPE_CODE (TYPE_INDEX_TYPE (t
)) == TYPE_CODE_RANGE
)
2083 LONGEST low_bound
, high_bound
;
2084 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (t
));
2086 get_discrete_bounds (TYPE_INDEX_TYPE (t
), &low_bound
, &high_bound
);
2088 return high_bound
== low_bound
&& is_scalar_type_recursive (elt_type
);
2090 /* Are we dealing with a struct with one element? */
2091 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
&& TYPE_NFIELDS (t
) == 1)
2092 return is_scalar_type_recursive (TYPE_FIELD_TYPE (t
, 0));
2093 else if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
2095 int i
, n
= TYPE_NFIELDS (t
);
2097 /* If all elements of the union are scalar, then the union is scalar. */
2098 for (i
= 0; i
< n
; i
++)
2099 if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t
, i
)))
2108 /* A helper function which returns true if types A and B represent the
2109 "same" class type. This is true if the types have the same main
2110 type, or the same name. */
2113 class_types_same_p (const struct type
*a
, const struct type
*b
)
2115 return (TYPE_MAIN_TYPE (a
) == TYPE_MAIN_TYPE (b
)
2116 || (TYPE_NAME (a
) && TYPE_NAME (b
)
2117 && !strcmp (TYPE_NAME (a
), TYPE_NAME (b
))));
2120 /* If BASE is an ancestor of DCLASS return the distance between them.
2121 otherwise return -1;
2125 class B: public A {};
2126 class C: public B {};
2129 distance_to_ancestor (A, A, 0) = 0
2130 distance_to_ancestor (A, B, 0) = 1
2131 distance_to_ancestor (A, C, 0) = 2
2132 distance_to_ancestor (A, D, 0) = 3
2134 If PUBLIC is 1 then only public ancestors are considered,
2135 and the function returns the distance only if BASE is a public ancestor
2139 distance_to_ancestor (A, D, 1) = -1. */
2142 distance_to_ancestor (struct type
*base
, struct type
*dclass
, int public)
2147 CHECK_TYPEDEF (base
);
2148 CHECK_TYPEDEF (dclass
);
2150 if (class_types_same_p (base
, dclass
))
2153 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2155 if (public && ! BASETYPE_VIA_PUBLIC (dclass
, i
))
2158 d
= distance_to_ancestor (base
, TYPE_BASECLASS (dclass
, i
), public);
2166 /* Check whether BASE is an ancestor or base class or DCLASS
2167 Return 1 if so, and 0 if not.
2168 Note: If BASE and DCLASS are of the same type, this function
2169 will return 1. So for some class A, is_ancestor (A, A) will
2173 is_ancestor (struct type
*base
, struct type
*dclass
)
2175 return distance_to_ancestor (base
, dclass
, 0) >= 0;
2178 /* Like is_ancestor, but only returns true when BASE is a public
2179 ancestor of DCLASS. */
2182 is_public_ancestor (struct type
*base
, struct type
*dclass
)
2184 return distance_to_ancestor (base
, dclass
, 1) >= 0;
2187 /* A helper function for is_unique_ancestor. */
2190 is_unique_ancestor_worker (struct type
*base
, struct type
*dclass
,
2192 const gdb_byte
*valaddr
, int embedded_offset
,
2193 CORE_ADDR address
, struct value
*val
)
2197 CHECK_TYPEDEF (base
);
2198 CHECK_TYPEDEF (dclass
);
2200 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
) && count
< 2; ++i
)
2205 iter
= check_typedef (TYPE_BASECLASS (dclass
, i
));
2207 this_offset
= baseclass_offset (dclass
, i
, valaddr
, embedded_offset
,
2210 if (class_types_same_p (base
, iter
))
2212 /* If this is the first subclass, set *OFFSET and set count
2213 to 1. Otherwise, if this is at the same offset as
2214 previous instances, do nothing. Otherwise, increment
2218 *offset
= this_offset
;
2221 else if (this_offset
== *offset
)
2229 count
+= is_unique_ancestor_worker (base
, iter
, offset
,
2231 embedded_offset
+ this_offset
,
2238 /* Like is_ancestor, but only returns true if BASE is a unique base
2239 class of the type of VAL. */
2242 is_unique_ancestor (struct type
*base
, struct value
*val
)
2246 return is_unique_ancestor_worker (base
, value_type (val
), &offset
,
2247 value_contents_for_printing (val
),
2248 value_embedded_offset (val
),
2249 value_address (val
), val
) == 1;
2253 /* Overload resolution. */
2255 /* Return the sum of the rank of A with the rank of B. */
2258 sum_ranks (struct rank a
, struct rank b
)
2261 c
.rank
= a
.rank
+ b
.rank
;
2262 c
.subrank
= a
.subrank
+ b
.subrank
;
2266 /* Compare rank A and B and return:
2268 1 if a is better than b
2269 -1 if b is better than a. */
2272 compare_ranks (struct rank a
, struct rank b
)
2274 if (a
.rank
== b
.rank
)
2276 if (a
.subrank
== b
.subrank
)
2278 if (a
.subrank
< b
.subrank
)
2280 if (a
.subrank
> b
.subrank
)
2284 if (a
.rank
< b
.rank
)
2287 /* a.rank > b.rank */
2291 /* Functions for overload resolution begin here. */
2293 /* Compare two badness vectors A and B and return the result.
2294 0 => A and B are identical
2295 1 => A and B are incomparable
2296 2 => A is better than B
2297 3 => A is worse than B */
2300 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
2304 short found_pos
= 0; /* any positives in c? */
2305 short found_neg
= 0; /* any negatives in c? */
2307 /* differing lengths => incomparable */
2308 if (a
->length
!= b
->length
)
2311 /* Subtract b from a */
2312 for (i
= 0; i
< a
->length
; i
++)
2314 tmp
= compare_ranks (b
->rank
[i
], a
->rank
[i
]);
2324 return 1; /* incomparable */
2326 return 3; /* A > B */
2332 return 2; /* A < B */
2334 return 0; /* A == B */
2338 /* Rank a function by comparing its parameter types (PARMS, length
2339 NPARMS), to the types of an argument list (ARGS, length NARGS).
2340 Return a pointer to a badness vector. This has NARGS + 1
2343 struct badness_vector
*
2344 rank_function (struct type
**parms
, int nparms
,
2345 struct value
**args
, int nargs
)
2348 struct badness_vector
*bv
;
2349 int min_len
= nparms
< nargs
? nparms
: nargs
;
2351 bv
= xmalloc (sizeof (struct badness_vector
));
2352 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank. */
2353 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
2355 /* First compare the lengths of the supplied lists.
2356 If there is a mismatch, set it to a high value. */
2358 /* pai/1997-06-03 FIXME: when we have debug info about default
2359 arguments and ellipsis parameter lists, we should consider those
2360 and rank the length-match more finely. */
2362 LENGTH_MATCH (bv
) = (nargs
!= nparms
)
2363 ? LENGTH_MISMATCH_BADNESS
2364 : EXACT_MATCH_BADNESS
;
2366 /* Now rank all the parameters of the candidate function. */
2367 for (i
= 1; i
<= min_len
; i
++)
2368 bv
->rank
[i
] = rank_one_type (parms
[i
- 1], value_type (args
[i
- 1]),
2371 /* If more arguments than parameters, add dummy entries. */
2372 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2373 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2378 /* Compare the names of two integer types, assuming that any sign
2379 qualifiers have been checked already. We do it this way because
2380 there may be an "int" in the name of one of the types. */
2383 integer_types_same_name_p (const char *first
, const char *second
)
2385 int first_p
, second_p
;
2387 /* If both are shorts, return 1; if neither is a short, keep
2389 first_p
= (strstr (first
, "short") != NULL
);
2390 second_p
= (strstr (second
, "short") != NULL
);
2391 if (first_p
&& second_p
)
2393 if (first_p
|| second_p
)
2396 /* Likewise for long. */
2397 first_p
= (strstr (first
, "long") != NULL
);
2398 second_p
= (strstr (second
, "long") != NULL
);
2399 if (first_p
&& second_p
)
2401 if (first_p
|| second_p
)
2404 /* Likewise for char. */
2405 first_p
= (strstr (first
, "char") != NULL
);
2406 second_p
= (strstr (second
, "char") != NULL
);
2407 if (first_p
&& second_p
)
2409 if (first_p
|| second_p
)
2412 /* They must both be ints. */
2416 /* Compares type A to type B returns 1 if the represent the same type
2420 types_equal (struct type
*a
, struct type
*b
)
2422 /* Identical type pointers. */
2423 /* However, this still doesn't catch all cases of same type for b
2424 and a. The reason is that builtin types are different from
2425 the same ones constructed from the object. */
2429 /* Resolve typedefs */
2430 if (TYPE_CODE (a
) == TYPE_CODE_TYPEDEF
)
2431 a
= check_typedef (a
);
2432 if (TYPE_CODE (b
) == TYPE_CODE_TYPEDEF
)
2433 b
= check_typedef (b
);
2435 /* If after resolving typedefs a and b are not of the same type
2436 code then they are not equal. */
2437 if (TYPE_CODE (a
) != TYPE_CODE (b
))
2440 /* If a and b are both pointers types or both reference types then
2441 they are equal of the same type iff the objects they refer to are
2442 of the same type. */
2443 if (TYPE_CODE (a
) == TYPE_CODE_PTR
2444 || TYPE_CODE (a
) == TYPE_CODE_REF
)
2445 return types_equal (TYPE_TARGET_TYPE (a
),
2446 TYPE_TARGET_TYPE (b
));
2448 /* Well, damnit, if the names are exactly the same, I'll say they
2449 are exactly the same. This happens when we generate method
2450 stubs. The types won't point to the same address, but they
2451 really are the same. */
2453 if (TYPE_NAME (a
) && TYPE_NAME (b
)
2454 && strcmp (TYPE_NAME (a
), TYPE_NAME (b
)) == 0)
2457 /* Check if identical after resolving typedefs. */
2461 /* Two function types are equal if their argument and return types
2463 if (TYPE_CODE (a
) == TYPE_CODE_FUNC
)
2467 if (TYPE_NFIELDS (a
) != TYPE_NFIELDS (b
))
2470 if (!types_equal (TYPE_TARGET_TYPE (a
), TYPE_TARGET_TYPE (b
)))
2473 for (i
= 0; i
< TYPE_NFIELDS (a
); ++i
)
2474 if (!types_equal (TYPE_FIELD_TYPE (a
, i
), TYPE_FIELD_TYPE (b
, i
)))
2483 /* Compare one type (PARM) for compatibility with another (ARG).
2484 * PARM is intended to be the parameter type of a function; and
2485 * ARG is the supplied argument's type. This function tests if
2486 * the latter can be converted to the former.
2487 * VALUE is the argument's value or NULL if none (or called recursively)
2489 * Return 0 if they are identical types;
2490 * Otherwise, return an integer which corresponds to how compatible
2491 * PARM is to ARG. The higher the return value, the worse the match.
2492 * Generally the "bad" conversions are all uniformly assigned a 100. */
2495 rank_one_type (struct type
*parm
, struct type
*arg
, struct value
*value
)
2497 struct rank rank
= {0,0};
2499 if (types_equal (parm
, arg
))
2500 return EXACT_MATCH_BADNESS
;
2502 /* Resolve typedefs */
2503 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2504 parm
= check_typedef (parm
);
2505 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2506 arg
= check_typedef (arg
);
2508 /* See through references, since we can almost make non-references
2510 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2511 return (sum_ranks (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
),
2512 REFERENCE_CONVERSION_BADNESS
));
2513 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2514 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
),
2515 REFERENCE_CONVERSION_BADNESS
));
2517 /* Debugging only. */
2518 fprintf_filtered (gdb_stderr
,
2519 "------ Arg is %s [%d], parm is %s [%d]\n",
2520 TYPE_NAME (arg
), TYPE_CODE (arg
),
2521 TYPE_NAME (parm
), TYPE_CODE (parm
));
2523 /* x -> y means arg of type x being supplied for parameter of type y. */
2525 switch (TYPE_CODE (parm
))
2528 switch (TYPE_CODE (arg
))
2532 /* Allowed pointer conversions are:
2533 (a) pointer to void-pointer conversion. */
2534 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2535 return VOID_PTR_CONVERSION_BADNESS
;
2537 /* (b) pointer to ancestor-pointer conversion. */
2538 rank
.subrank
= distance_to_ancestor (TYPE_TARGET_TYPE (parm
),
2539 TYPE_TARGET_TYPE (arg
),
2541 if (rank
.subrank
>= 0)
2542 return sum_ranks (BASE_PTR_CONVERSION_BADNESS
, rank
);
2544 return INCOMPATIBLE_TYPE_BADNESS
;
2545 case TYPE_CODE_ARRAY
:
2546 if (types_equal (TYPE_TARGET_TYPE (parm
),
2547 TYPE_TARGET_TYPE (arg
)))
2548 return EXACT_MATCH_BADNESS
;
2549 return INCOMPATIBLE_TYPE_BADNESS
;
2550 case TYPE_CODE_FUNC
:
2551 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
);
2553 if (value
!= NULL
&& TYPE_CODE (value_type (value
)) == TYPE_CODE_INT
)
2555 if (value_as_long (value
) == 0)
2557 /* Null pointer conversion: allow it to be cast to a pointer.
2558 [4.10.1 of C++ standard draft n3290] */
2559 return NULL_POINTER_CONVERSION_BADNESS
;
2563 /* If type checking is disabled, allow the conversion. */
2564 if (!strict_type_checking
)
2565 return NS_INTEGER_POINTER_CONVERSION_BADNESS
;
2569 case TYPE_CODE_ENUM
:
2570 case TYPE_CODE_FLAGS
:
2571 case TYPE_CODE_CHAR
:
2572 case TYPE_CODE_RANGE
:
2573 case TYPE_CODE_BOOL
:
2575 return INCOMPATIBLE_TYPE_BADNESS
;
2577 case TYPE_CODE_ARRAY
:
2578 switch (TYPE_CODE (arg
))
2581 case TYPE_CODE_ARRAY
:
2582 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2583 TYPE_TARGET_TYPE (arg
), NULL
);
2585 return INCOMPATIBLE_TYPE_BADNESS
;
2587 case TYPE_CODE_FUNC
:
2588 switch (TYPE_CODE (arg
))
2590 case TYPE_CODE_PTR
: /* funcptr -> func */
2591 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
);
2593 return INCOMPATIBLE_TYPE_BADNESS
;
2596 switch (TYPE_CODE (arg
))
2599 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2601 /* Deal with signed, unsigned, and plain chars and
2602 signed and unsigned ints. */
2603 if (TYPE_NOSIGN (parm
))
2605 /* This case only for character types. */
2606 if (TYPE_NOSIGN (arg
))
2607 return EXACT_MATCH_BADNESS
; /* plain char -> plain char */
2608 else /* signed/unsigned char -> plain char */
2609 return INTEGER_CONVERSION_BADNESS
;
2611 else if (TYPE_UNSIGNED (parm
))
2613 if (TYPE_UNSIGNED (arg
))
2615 /* unsigned int -> unsigned int, or
2616 unsigned long -> unsigned long */
2617 if (integer_types_same_name_p (TYPE_NAME (parm
),
2619 return EXACT_MATCH_BADNESS
;
2620 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2622 && integer_types_same_name_p (TYPE_NAME (parm
),
2624 /* unsigned int -> unsigned long */
2625 return INTEGER_PROMOTION_BADNESS
;
2627 /* unsigned long -> unsigned int */
2628 return INTEGER_CONVERSION_BADNESS
;
2632 if (integer_types_same_name_p (TYPE_NAME (arg
),
2634 && integer_types_same_name_p (TYPE_NAME (parm
),
2636 /* signed long -> unsigned int */
2637 return INTEGER_CONVERSION_BADNESS
;
2639 /* signed int/long -> unsigned int/long */
2640 return INTEGER_CONVERSION_BADNESS
;
2643 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2645 if (integer_types_same_name_p (TYPE_NAME (parm
),
2647 return EXACT_MATCH_BADNESS
;
2648 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2650 && integer_types_same_name_p (TYPE_NAME (parm
),
2652 return INTEGER_PROMOTION_BADNESS
;
2654 return INTEGER_CONVERSION_BADNESS
;
2657 return INTEGER_CONVERSION_BADNESS
;
2659 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2660 return INTEGER_PROMOTION_BADNESS
;
2662 return INTEGER_CONVERSION_BADNESS
;
2663 case TYPE_CODE_ENUM
:
2664 case TYPE_CODE_FLAGS
:
2665 case TYPE_CODE_CHAR
:
2666 case TYPE_CODE_RANGE
:
2667 case TYPE_CODE_BOOL
:
2668 return INTEGER_PROMOTION_BADNESS
;
2670 return INT_FLOAT_CONVERSION_BADNESS
;
2672 return NS_POINTER_CONVERSION_BADNESS
;
2674 return INCOMPATIBLE_TYPE_BADNESS
;
2677 case TYPE_CODE_ENUM
:
2678 switch (TYPE_CODE (arg
))
2681 case TYPE_CODE_CHAR
:
2682 case TYPE_CODE_RANGE
:
2683 case TYPE_CODE_BOOL
:
2684 case TYPE_CODE_ENUM
:
2685 return INTEGER_CONVERSION_BADNESS
;
2687 return INT_FLOAT_CONVERSION_BADNESS
;
2689 return INCOMPATIBLE_TYPE_BADNESS
;
2692 case TYPE_CODE_CHAR
:
2693 switch (TYPE_CODE (arg
))
2695 case TYPE_CODE_RANGE
:
2696 case TYPE_CODE_BOOL
:
2697 case TYPE_CODE_ENUM
:
2698 return INTEGER_CONVERSION_BADNESS
;
2700 return INT_FLOAT_CONVERSION_BADNESS
;
2702 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2703 return INTEGER_CONVERSION_BADNESS
;
2704 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2705 return INTEGER_PROMOTION_BADNESS
;
2706 /* >>> !! else fall through !! <<< */
2707 case TYPE_CODE_CHAR
:
2708 /* Deal with signed, unsigned, and plain chars for C++ and
2709 with int cases falling through from previous case. */
2710 if (TYPE_NOSIGN (parm
))
2712 if (TYPE_NOSIGN (arg
))
2713 return EXACT_MATCH_BADNESS
;
2715 return INTEGER_CONVERSION_BADNESS
;
2717 else if (TYPE_UNSIGNED (parm
))
2719 if (TYPE_UNSIGNED (arg
))
2720 return EXACT_MATCH_BADNESS
;
2722 return INTEGER_PROMOTION_BADNESS
;
2724 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2725 return EXACT_MATCH_BADNESS
;
2727 return INTEGER_CONVERSION_BADNESS
;
2729 return INCOMPATIBLE_TYPE_BADNESS
;
2732 case TYPE_CODE_RANGE
:
2733 switch (TYPE_CODE (arg
))
2736 case TYPE_CODE_CHAR
:
2737 case TYPE_CODE_RANGE
:
2738 case TYPE_CODE_BOOL
:
2739 case TYPE_CODE_ENUM
:
2740 return INTEGER_CONVERSION_BADNESS
;
2742 return INT_FLOAT_CONVERSION_BADNESS
;
2744 return INCOMPATIBLE_TYPE_BADNESS
;
2747 case TYPE_CODE_BOOL
:
2748 switch (TYPE_CODE (arg
))
2750 /* n3290 draft, section 4.12.1 (conv.bool):
2752 "A prvalue of arithmetic, unscoped enumeration, pointer, or
2753 pointer to member type can be converted to a prvalue of type
2754 bool. A zero value, null pointer value, or null member pointer
2755 value is converted to false; any other value is converted to
2756 true. A prvalue of type std::nullptr_t can be converted to a
2757 prvalue of type bool; the resulting value is false." */
2759 case TYPE_CODE_CHAR
:
2760 case TYPE_CODE_ENUM
:
2762 case TYPE_CODE_MEMBERPTR
:
2764 return BOOL_CONVERSION_BADNESS
;
2765 case TYPE_CODE_RANGE
:
2766 return INCOMPATIBLE_TYPE_BADNESS
;
2767 case TYPE_CODE_BOOL
:
2768 return EXACT_MATCH_BADNESS
;
2770 return INCOMPATIBLE_TYPE_BADNESS
;
2774 switch (TYPE_CODE (arg
))
2777 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2778 return FLOAT_PROMOTION_BADNESS
;
2779 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2780 return EXACT_MATCH_BADNESS
;
2782 return FLOAT_CONVERSION_BADNESS
;
2784 case TYPE_CODE_BOOL
:
2785 case TYPE_CODE_ENUM
:
2786 case TYPE_CODE_RANGE
:
2787 case TYPE_CODE_CHAR
:
2788 return INT_FLOAT_CONVERSION_BADNESS
;
2790 return INCOMPATIBLE_TYPE_BADNESS
;
2793 case TYPE_CODE_COMPLEX
:
2794 switch (TYPE_CODE (arg
))
2795 { /* Strictly not needed for C++, but... */
2797 return FLOAT_PROMOTION_BADNESS
;
2798 case TYPE_CODE_COMPLEX
:
2799 return EXACT_MATCH_BADNESS
;
2801 return INCOMPATIBLE_TYPE_BADNESS
;
2804 case TYPE_CODE_STRUCT
:
2805 /* currently same as TYPE_CODE_CLASS. */
2806 switch (TYPE_CODE (arg
))
2808 case TYPE_CODE_STRUCT
:
2809 /* Check for derivation */
2810 rank
.subrank
= distance_to_ancestor (parm
, arg
, 0);
2811 if (rank
.subrank
>= 0)
2812 return sum_ranks (BASE_CONVERSION_BADNESS
, rank
);
2813 /* else fall through */
2815 return INCOMPATIBLE_TYPE_BADNESS
;
2818 case TYPE_CODE_UNION
:
2819 switch (TYPE_CODE (arg
))
2821 case TYPE_CODE_UNION
:
2823 return INCOMPATIBLE_TYPE_BADNESS
;
2826 case TYPE_CODE_MEMBERPTR
:
2827 switch (TYPE_CODE (arg
))
2830 return INCOMPATIBLE_TYPE_BADNESS
;
2833 case TYPE_CODE_METHOD
:
2834 switch (TYPE_CODE (arg
))
2838 return INCOMPATIBLE_TYPE_BADNESS
;
2842 switch (TYPE_CODE (arg
))
2846 return INCOMPATIBLE_TYPE_BADNESS
;
2851 switch (TYPE_CODE (arg
))
2855 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0),
2856 TYPE_FIELD_TYPE (arg
, 0), NULL
);
2858 return INCOMPATIBLE_TYPE_BADNESS
;
2861 case TYPE_CODE_VOID
:
2863 return INCOMPATIBLE_TYPE_BADNESS
;
2864 } /* switch (TYPE_CODE (arg)) */
2867 /* End of functions for overload resolution. */
2869 /* Routines to pretty-print types. */
2872 print_bit_vector (B_TYPE
*bits
, int nbits
)
2876 for (bitno
= 0; bitno
< nbits
; bitno
++)
2878 if ((bitno
% 8) == 0)
2880 puts_filtered (" ");
2882 if (B_TST (bits
, bitno
))
2883 printf_filtered (("1"));
2885 printf_filtered (("0"));
2889 /* Note the first arg should be the "this" pointer, we may not want to
2890 include it since we may get into a infinitely recursive
2894 print_arg_types (struct field
*args
, int nargs
, int spaces
)
2900 for (i
= 0; i
< nargs
; i
++)
2901 recursive_dump_type (args
[i
].type
, spaces
+ 2);
2906 field_is_static (struct field
*f
)
2908 /* "static" fields are the fields whose location is not relative
2909 to the address of the enclosing struct. It would be nice to
2910 have a dedicated flag that would be set for static fields when
2911 the type is being created. But in practice, checking the field
2912 loc_kind should give us an accurate answer. */
2913 return (FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSNAME
2914 || FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSADDR
);
2918 dump_fn_fieldlists (struct type
*type
, int spaces
)
2924 printfi_filtered (spaces
, "fn_fieldlists ");
2925 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2926 printf_filtered ("\n");
2927 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2929 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2930 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2932 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2933 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2935 printf_filtered (_(") length %d\n"),
2936 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2937 for (overload_idx
= 0;
2938 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2941 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2943 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2944 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2946 printf_filtered (")\n");
2947 printfi_filtered (spaces
+ 8, "type ");
2948 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2950 printf_filtered ("\n");
2952 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2955 printfi_filtered (spaces
+ 8, "args ");
2956 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2958 printf_filtered ("\n");
2960 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2961 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
,
2964 printfi_filtered (spaces
+ 8, "fcontext ");
2965 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2967 printf_filtered ("\n");
2969 printfi_filtered (spaces
+ 8, "is_const %d\n",
2970 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2971 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2972 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2973 printfi_filtered (spaces
+ 8, "is_private %d\n",
2974 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2975 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2976 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2977 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2978 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2979 printfi_filtered (spaces
+ 8, "voffset %u\n",
2980 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2986 print_cplus_stuff (struct type
*type
, int spaces
)
2988 printfi_filtered (spaces
, "n_baseclasses %d\n",
2989 TYPE_N_BASECLASSES (type
));
2990 printfi_filtered (spaces
, "nfn_fields %d\n",
2991 TYPE_NFN_FIELDS (type
));
2992 if (TYPE_N_BASECLASSES (type
) > 0)
2994 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2995 TYPE_N_BASECLASSES (type
));
2996 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
2998 printf_filtered (")");
3000 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
3001 TYPE_N_BASECLASSES (type
));
3002 puts_filtered ("\n");
3004 if (TYPE_NFIELDS (type
) > 0)
3006 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
3008 printfi_filtered (spaces
,
3009 "private_field_bits (%d bits at *",
3010 TYPE_NFIELDS (type
));
3011 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
3013 printf_filtered (")");
3014 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
3015 TYPE_NFIELDS (type
));
3016 puts_filtered ("\n");
3018 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
3020 printfi_filtered (spaces
,
3021 "protected_field_bits (%d bits at *",
3022 TYPE_NFIELDS (type
));
3023 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
3025 printf_filtered (")");
3026 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
3027 TYPE_NFIELDS (type
));
3028 puts_filtered ("\n");
3031 if (TYPE_NFN_FIELDS (type
) > 0)
3033 dump_fn_fieldlists (type
, spaces
);
3037 /* Print the contents of the TYPE's type_specific union, assuming that
3038 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
3041 print_gnat_stuff (struct type
*type
, int spaces
)
3043 struct type
*descriptive_type
= TYPE_DESCRIPTIVE_TYPE (type
);
3045 recursive_dump_type (descriptive_type
, spaces
+ 2);
3048 static struct obstack dont_print_type_obstack
;
3051 recursive_dump_type (struct type
*type
, int spaces
)
3056 obstack_begin (&dont_print_type_obstack
, 0);
3058 if (TYPE_NFIELDS (type
) > 0
3059 || (HAVE_CPLUS_STRUCT (type
) && TYPE_NFN_FIELDS (type
) > 0))
3061 struct type
**first_dont_print
3062 = (struct type
**) obstack_base (&dont_print_type_obstack
);
3064 int i
= (struct type
**)
3065 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
3069 if (type
== first_dont_print
[i
])
3071 printfi_filtered (spaces
, "type node ");
3072 gdb_print_host_address (type
, gdb_stdout
);
3073 printf_filtered (_(" <same as already seen type>\n"));
3078 obstack_ptr_grow (&dont_print_type_obstack
, type
);
3081 printfi_filtered (spaces
, "type node ");
3082 gdb_print_host_address (type
, gdb_stdout
);
3083 printf_filtered ("\n");
3084 printfi_filtered (spaces
, "name '%s' (",
3085 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
3086 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
3087 printf_filtered (")\n");
3088 printfi_filtered (spaces
, "tagname '%s' (",
3089 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
3090 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
3091 printf_filtered (")\n");
3092 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
3093 switch (TYPE_CODE (type
))
3095 case TYPE_CODE_UNDEF
:
3096 printf_filtered ("(TYPE_CODE_UNDEF)");
3099 printf_filtered ("(TYPE_CODE_PTR)");
3101 case TYPE_CODE_ARRAY
:
3102 printf_filtered ("(TYPE_CODE_ARRAY)");
3104 case TYPE_CODE_STRUCT
:
3105 printf_filtered ("(TYPE_CODE_STRUCT)");
3107 case TYPE_CODE_UNION
:
3108 printf_filtered ("(TYPE_CODE_UNION)");
3110 case TYPE_CODE_ENUM
:
3111 printf_filtered ("(TYPE_CODE_ENUM)");
3113 case TYPE_CODE_FLAGS
:
3114 printf_filtered ("(TYPE_CODE_FLAGS)");
3116 case TYPE_CODE_FUNC
:
3117 printf_filtered ("(TYPE_CODE_FUNC)");
3120 printf_filtered ("(TYPE_CODE_INT)");
3123 printf_filtered ("(TYPE_CODE_FLT)");
3125 case TYPE_CODE_VOID
:
3126 printf_filtered ("(TYPE_CODE_VOID)");
3129 printf_filtered ("(TYPE_CODE_SET)");
3131 case TYPE_CODE_RANGE
:
3132 printf_filtered ("(TYPE_CODE_RANGE)");
3134 case TYPE_CODE_STRING
:
3135 printf_filtered ("(TYPE_CODE_STRING)");
3137 case TYPE_CODE_ERROR
:
3138 printf_filtered ("(TYPE_CODE_ERROR)");
3140 case TYPE_CODE_MEMBERPTR
:
3141 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
3143 case TYPE_CODE_METHODPTR
:
3144 printf_filtered ("(TYPE_CODE_METHODPTR)");
3146 case TYPE_CODE_METHOD
:
3147 printf_filtered ("(TYPE_CODE_METHOD)");
3150 printf_filtered ("(TYPE_CODE_REF)");
3152 case TYPE_CODE_CHAR
:
3153 printf_filtered ("(TYPE_CODE_CHAR)");
3155 case TYPE_CODE_BOOL
:
3156 printf_filtered ("(TYPE_CODE_BOOL)");
3158 case TYPE_CODE_COMPLEX
:
3159 printf_filtered ("(TYPE_CODE_COMPLEX)");
3161 case TYPE_CODE_TYPEDEF
:
3162 printf_filtered ("(TYPE_CODE_TYPEDEF)");
3164 case TYPE_CODE_NAMESPACE
:
3165 printf_filtered ("(TYPE_CODE_NAMESPACE)");
3168 printf_filtered ("(UNKNOWN TYPE CODE)");
3171 puts_filtered ("\n");
3172 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
3173 if (TYPE_OBJFILE_OWNED (type
))
3175 printfi_filtered (spaces
, "objfile ");
3176 gdb_print_host_address (TYPE_OWNER (type
).objfile
, gdb_stdout
);
3180 printfi_filtered (spaces
, "gdbarch ");
3181 gdb_print_host_address (TYPE_OWNER (type
).gdbarch
, gdb_stdout
);
3183 printf_filtered ("\n");
3184 printfi_filtered (spaces
, "target_type ");
3185 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
3186 printf_filtered ("\n");
3187 if (TYPE_TARGET_TYPE (type
) != NULL
)
3189 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
3191 printfi_filtered (spaces
, "pointer_type ");
3192 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
3193 printf_filtered ("\n");
3194 printfi_filtered (spaces
, "reference_type ");
3195 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
3196 printf_filtered ("\n");
3197 printfi_filtered (spaces
, "type_chain ");
3198 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
3199 printf_filtered ("\n");
3200 printfi_filtered (spaces
, "instance_flags 0x%x",
3201 TYPE_INSTANCE_FLAGS (type
));
3202 if (TYPE_CONST (type
))
3204 puts_filtered (" TYPE_FLAG_CONST");
3206 if (TYPE_VOLATILE (type
))
3208 puts_filtered (" TYPE_FLAG_VOLATILE");
3210 if (TYPE_CODE_SPACE (type
))
3212 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3214 if (TYPE_DATA_SPACE (type
))
3216 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3218 if (TYPE_ADDRESS_CLASS_1 (type
))
3220 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3222 if (TYPE_ADDRESS_CLASS_2 (type
))
3224 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3226 if (TYPE_RESTRICT (type
))
3228 puts_filtered (" TYPE_FLAG_RESTRICT");
3230 puts_filtered ("\n");
3232 printfi_filtered (spaces
, "flags");
3233 if (TYPE_UNSIGNED (type
))
3235 puts_filtered (" TYPE_FLAG_UNSIGNED");
3237 if (TYPE_NOSIGN (type
))
3239 puts_filtered (" TYPE_FLAG_NOSIGN");
3241 if (TYPE_STUB (type
))
3243 puts_filtered (" TYPE_FLAG_STUB");
3245 if (TYPE_TARGET_STUB (type
))
3247 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3249 if (TYPE_STATIC (type
))
3251 puts_filtered (" TYPE_FLAG_STATIC");
3253 if (TYPE_PROTOTYPED (type
))
3255 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3257 if (TYPE_INCOMPLETE (type
))
3259 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3261 if (TYPE_VARARGS (type
))
3263 puts_filtered (" TYPE_FLAG_VARARGS");
3265 /* This is used for things like AltiVec registers on ppc. Gcc emits
3266 an attribute for the array type, which tells whether or not we
3267 have a vector, instead of a regular array. */
3268 if (TYPE_VECTOR (type
))
3270 puts_filtered (" TYPE_FLAG_VECTOR");
3272 if (TYPE_FIXED_INSTANCE (type
))
3274 puts_filtered (" TYPE_FIXED_INSTANCE");
3276 if (TYPE_STUB_SUPPORTED (type
))
3278 puts_filtered (" TYPE_STUB_SUPPORTED");
3280 if (TYPE_NOTTEXT (type
))
3282 puts_filtered (" TYPE_NOTTEXT");
3284 puts_filtered ("\n");
3285 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
3286 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
3287 puts_filtered ("\n");
3288 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
3290 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
3291 printfi_filtered (spaces
+ 2,
3292 "[%d] enumval %s type ",
3293 idx
, plongest (TYPE_FIELD_ENUMVAL (type
, idx
)));
3295 printfi_filtered (spaces
+ 2,
3296 "[%d] bitpos %d bitsize %d type ",
3297 idx
, TYPE_FIELD_BITPOS (type
, idx
),
3298 TYPE_FIELD_BITSIZE (type
, idx
));
3299 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
3300 printf_filtered (" name '%s' (",
3301 TYPE_FIELD_NAME (type
, idx
) != NULL
3302 ? TYPE_FIELD_NAME (type
, idx
)
3304 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
3305 printf_filtered (")\n");
3306 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
3308 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
3311 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
3313 printfi_filtered (spaces
, "low %s%s high %s%s\n",
3314 plongest (TYPE_LOW_BOUND (type
)),
3315 TYPE_LOW_BOUND_UNDEFINED (type
) ? " (undefined)" : "",
3316 plongest (TYPE_HIGH_BOUND (type
)),
3317 TYPE_HIGH_BOUND_UNDEFINED (type
)
3318 ? " (undefined)" : "");
3320 printfi_filtered (spaces
, "vptr_basetype ");
3321 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
3322 puts_filtered ("\n");
3323 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
3325 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
3327 printfi_filtered (spaces
, "vptr_fieldno %d\n",
3328 TYPE_VPTR_FIELDNO (type
));
3330 switch (TYPE_SPECIFIC_FIELD (type
))
3332 case TYPE_SPECIFIC_CPLUS_STUFF
:
3333 printfi_filtered (spaces
, "cplus_stuff ");
3334 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
),
3336 puts_filtered ("\n");
3337 print_cplus_stuff (type
, spaces
);
3340 case TYPE_SPECIFIC_GNAT_STUFF
:
3341 printfi_filtered (spaces
, "gnat_stuff ");
3342 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type
), gdb_stdout
);
3343 puts_filtered ("\n");
3344 print_gnat_stuff (type
, spaces
);
3347 case TYPE_SPECIFIC_FLOATFORMAT
:
3348 printfi_filtered (spaces
, "floatformat ");
3349 if (TYPE_FLOATFORMAT (type
) == NULL
)
3350 puts_filtered ("(null)");
3353 puts_filtered ("{ ");
3354 if (TYPE_FLOATFORMAT (type
)[0] == NULL
3355 || TYPE_FLOATFORMAT (type
)[0]->name
== NULL
)
3356 puts_filtered ("(null)");
3358 puts_filtered (TYPE_FLOATFORMAT (type
)[0]->name
);
3360 puts_filtered (", ");
3361 if (TYPE_FLOATFORMAT (type
)[1] == NULL
3362 || TYPE_FLOATFORMAT (type
)[1]->name
== NULL
)
3363 puts_filtered ("(null)");
3365 puts_filtered (TYPE_FLOATFORMAT (type
)[1]->name
);
3367 puts_filtered (" }");
3369 puts_filtered ("\n");
3372 case TYPE_SPECIFIC_FUNC
:
3373 printfi_filtered (spaces
, "calling_convention %d\n",
3374 TYPE_CALLING_CONVENTION (type
));
3375 /* tail_call_list is not printed. */
3380 obstack_free (&dont_print_type_obstack
, NULL
);
3383 /* Trivial helpers for the libiberty hash table, for mapping one
3388 struct type
*old
, *new;
3392 type_pair_hash (const void *item
)
3394 const struct type_pair
*pair
= item
;
3396 return htab_hash_pointer (pair
->old
);
3400 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
3402 const struct type_pair
*lhs
= item_lhs
, *rhs
= item_rhs
;
3404 return lhs
->old
== rhs
->old
;
3407 /* Allocate the hash table used by copy_type_recursive to walk
3408 types without duplicates. We use OBJFILE's obstack, because
3409 OBJFILE is about to be deleted. */
3412 create_copied_types_hash (struct objfile
*objfile
)
3414 return htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
3415 NULL
, &objfile
->objfile_obstack
,
3416 hashtab_obstack_allocate
,
3417 dummy_obstack_deallocate
);
3420 /* Recursively copy (deep copy) TYPE, if it is associated with
3421 OBJFILE. Return a new type allocated using malloc, a saved type if
3422 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
3423 not associated with OBJFILE. */
3426 copy_type_recursive (struct objfile
*objfile
,
3428 htab_t copied_types
)
3430 struct type_pair
*stored
, pair
;
3432 struct type
*new_type
;
3434 if (! TYPE_OBJFILE_OWNED (type
))
3437 /* This type shouldn't be pointing to any types in other objfiles;
3438 if it did, the type might disappear unexpectedly. */
3439 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
3442 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
3444 return ((struct type_pair
*) *slot
)->new;
3446 new_type
= alloc_type_arch (get_type_arch (type
));
3448 /* We must add the new type to the hash table immediately, in case
3449 we encounter this type again during a recursive call below. */
3451 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct type_pair
));
3453 stored
->new = new_type
;
3456 /* Copy the common fields of types. For the main type, we simply
3457 copy the entire thing and then update specific fields as needed. */
3458 *TYPE_MAIN_TYPE (new_type
) = *TYPE_MAIN_TYPE (type
);
3459 TYPE_OBJFILE_OWNED (new_type
) = 0;
3460 TYPE_OWNER (new_type
).gdbarch
= get_type_arch (type
);
3462 if (TYPE_NAME (type
))
3463 TYPE_NAME (new_type
) = xstrdup (TYPE_NAME (type
));
3464 if (TYPE_TAG_NAME (type
))
3465 TYPE_TAG_NAME (new_type
) = xstrdup (TYPE_TAG_NAME (type
));
3467 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
3468 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
3470 /* Copy the fields. */
3471 if (TYPE_NFIELDS (type
))
3475 nfields
= TYPE_NFIELDS (type
);
3476 TYPE_FIELDS (new_type
) = XCALLOC (nfields
, struct field
);
3477 for (i
= 0; i
< nfields
; i
++)
3479 TYPE_FIELD_ARTIFICIAL (new_type
, i
) =
3480 TYPE_FIELD_ARTIFICIAL (type
, i
);
3481 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
3482 if (TYPE_FIELD_TYPE (type
, i
))
3483 TYPE_FIELD_TYPE (new_type
, i
)
3484 = copy_type_recursive (objfile
, TYPE_FIELD_TYPE (type
, i
),
3486 if (TYPE_FIELD_NAME (type
, i
))
3487 TYPE_FIELD_NAME (new_type
, i
) =
3488 xstrdup (TYPE_FIELD_NAME (type
, i
));
3489 switch (TYPE_FIELD_LOC_KIND (type
, i
))
3491 case FIELD_LOC_KIND_BITPOS
:
3492 SET_FIELD_BITPOS (TYPE_FIELD (new_type
, i
),
3493 TYPE_FIELD_BITPOS (type
, i
));
3495 case FIELD_LOC_KIND_ENUMVAL
:
3496 SET_FIELD_ENUMVAL (TYPE_FIELD (new_type
, i
),
3497 TYPE_FIELD_ENUMVAL (type
, i
));
3499 case FIELD_LOC_KIND_PHYSADDR
:
3500 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type
, i
),
3501 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
3503 case FIELD_LOC_KIND_PHYSNAME
:
3504 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type
, i
),
3505 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
,
3509 internal_error (__FILE__
, __LINE__
,
3510 _("Unexpected type field location kind: %d"),
3511 TYPE_FIELD_LOC_KIND (type
, i
));
3516 /* For range types, copy the bounds information. */
3517 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
3519 TYPE_RANGE_DATA (new_type
) = xmalloc (sizeof (struct range_bounds
));
3520 *TYPE_RANGE_DATA (new_type
) = *TYPE_RANGE_DATA (type
);
3523 /* Copy pointers to other types. */
3524 if (TYPE_TARGET_TYPE (type
))
3525 TYPE_TARGET_TYPE (new_type
) =
3526 copy_type_recursive (objfile
,
3527 TYPE_TARGET_TYPE (type
),
3529 if (TYPE_VPTR_BASETYPE (type
))
3530 TYPE_VPTR_BASETYPE (new_type
) =
3531 copy_type_recursive (objfile
,
3532 TYPE_VPTR_BASETYPE (type
),
3534 /* Maybe copy the type_specific bits.
3536 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3537 base classes and methods. There's no fundamental reason why we
3538 can't, but at the moment it is not needed. */
3540 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
3541 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
3542 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3543 || TYPE_CODE (type
) == TYPE_CODE_UNION
3544 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
3545 INIT_CPLUS_SPECIFIC (new_type
);
3550 /* Make a copy of the given TYPE, except that the pointer & reference
3551 types are not preserved.
3553 This function assumes that the given type has an associated objfile.
3554 This objfile is used to allocate the new type. */
3557 copy_type (const struct type
*type
)
3559 struct type
*new_type
;
3561 gdb_assert (TYPE_OBJFILE_OWNED (type
));
3563 new_type
= alloc_type_copy (type
);
3564 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
3565 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
3566 memcpy (TYPE_MAIN_TYPE (new_type
), TYPE_MAIN_TYPE (type
),
3567 sizeof (struct main_type
));
3572 /* Helper functions to initialize architecture-specific types. */
3574 /* Allocate a type structure associated with GDBARCH and set its
3575 CODE, LENGTH, and NAME fields. */
3578 arch_type (struct gdbarch
*gdbarch
,
3579 enum type_code code
, int length
, char *name
)
3583 type
= alloc_type_arch (gdbarch
);
3584 TYPE_CODE (type
) = code
;
3585 TYPE_LENGTH (type
) = length
;
3588 TYPE_NAME (type
) = xstrdup (name
);
3593 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
3594 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3595 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3598 arch_integer_type (struct gdbarch
*gdbarch
,
3599 int bit
, int unsigned_p
, char *name
)
3603 t
= arch_type (gdbarch
, TYPE_CODE_INT
, bit
/ TARGET_CHAR_BIT
, name
);
3605 TYPE_UNSIGNED (t
) = 1;
3606 if (name
&& strcmp (name
, "char") == 0)
3607 TYPE_NOSIGN (t
) = 1;
3612 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
3613 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3614 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3617 arch_character_type (struct gdbarch
*gdbarch
,
3618 int bit
, int unsigned_p
, char *name
)
3622 t
= arch_type (gdbarch
, TYPE_CODE_CHAR
, bit
/ TARGET_CHAR_BIT
, name
);
3624 TYPE_UNSIGNED (t
) = 1;
3629 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
3630 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3631 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3634 arch_boolean_type (struct gdbarch
*gdbarch
,
3635 int bit
, int unsigned_p
, char *name
)
3639 t
= arch_type (gdbarch
, TYPE_CODE_BOOL
, bit
/ TARGET_CHAR_BIT
, name
);
3641 TYPE_UNSIGNED (t
) = 1;
3646 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
3647 BIT is the type size in bits; if BIT equals -1, the size is
3648 determined by the floatformat. NAME is the type name. Set the
3649 TYPE_FLOATFORMAT from FLOATFORMATS. */
3652 arch_float_type (struct gdbarch
*gdbarch
,
3653 int bit
, char *name
, const struct floatformat
**floatformats
)
3659 gdb_assert (floatformats
!= NULL
);
3660 gdb_assert (floatformats
[0] != NULL
&& floatformats
[1] != NULL
);
3661 bit
= floatformats
[0]->totalsize
;
3663 gdb_assert (bit
>= 0);
3665 t
= arch_type (gdbarch
, TYPE_CODE_FLT
, bit
/ TARGET_CHAR_BIT
, name
);
3666 TYPE_FLOATFORMAT (t
) = floatformats
;
3670 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
3671 NAME is the type name. TARGET_TYPE is the component float type. */
3674 arch_complex_type (struct gdbarch
*gdbarch
,
3675 char *name
, struct type
*target_type
)
3679 t
= arch_type (gdbarch
, TYPE_CODE_COMPLEX
,
3680 2 * TYPE_LENGTH (target_type
), name
);
3681 TYPE_TARGET_TYPE (t
) = target_type
;
3685 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
3686 NAME is the type name. LENGTH is the size of the flag word in bytes. */
3689 arch_flags_type (struct gdbarch
*gdbarch
, char *name
, int length
)
3691 int nfields
= length
* TARGET_CHAR_BIT
;
3694 type
= arch_type (gdbarch
, TYPE_CODE_FLAGS
, length
, name
);
3695 TYPE_UNSIGNED (type
) = 1;
3696 TYPE_NFIELDS (type
) = nfields
;
3697 TYPE_FIELDS (type
) = TYPE_ZALLOC (type
, nfields
* sizeof (struct field
));
3702 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
3703 position BITPOS is called NAME. */
3706 append_flags_type_flag (struct type
*type
, int bitpos
, char *name
)
3708 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLAGS
);
3709 gdb_assert (bitpos
< TYPE_NFIELDS (type
));
3710 gdb_assert (bitpos
>= 0);
3714 TYPE_FIELD_NAME (type
, bitpos
) = xstrdup (name
);
3715 SET_FIELD_BITPOS (TYPE_FIELD (type
, bitpos
), bitpos
);
3719 /* Don't show this field to the user. */
3720 SET_FIELD_BITPOS (TYPE_FIELD (type
, bitpos
), -1);
3724 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
3725 specified by CODE) associated with GDBARCH. NAME is the type name. */
3728 arch_composite_type (struct gdbarch
*gdbarch
, char *name
, enum type_code code
)
3732 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
3733 t
= arch_type (gdbarch
, code
, 0, NULL
);
3734 TYPE_TAG_NAME (t
) = name
;
3735 INIT_CPLUS_SPECIFIC (t
);
3739 /* Add new field with name NAME and type FIELD to composite type T.
3740 Do not set the field's position or adjust the type's length;
3741 the caller should do so. Return the new field. */
3744 append_composite_type_field_raw (struct type
*t
, char *name
,
3749 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
3750 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
3751 sizeof (struct field
) * TYPE_NFIELDS (t
));
3752 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
3753 memset (f
, 0, sizeof f
[0]);
3754 FIELD_TYPE (f
[0]) = field
;
3755 FIELD_NAME (f
[0]) = name
;
3759 /* Add new field with name NAME and type FIELD to composite type T.
3760 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
3763 append_composite_type_field_aligned (struct type
*t
, char *name
,
3764 struct type
*field
, int alignment
)
3766 struct field
*f
= append_composite_type_field_raw (t
, name
, field
);
3768 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
3770 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
3771 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
3773 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
3775 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
3776 if (TYPE_NFIELDS (t
) > 1)
3778 SET_FIELD_BITPOS (f
[0],
3779 (FIELD_BITPOS (f
[-1])
3780 + (TYPE_LENGTH (FIELD_TYPE (f
[-1]))
3781 * TARGET_CHAR_BIT
)));
3787 alignment
*= TARGET_CHAR_BIT
;
3788 left
= FIELD_BITPOS (f
[0]) % alignment
;
3792 SET_FIELD_BITPOS (f
[0], FIELD_BITPOS (f
[0]) + (alignment
- left
));
3793 TYPE_LENGTH (t
) += (alignment
- left
) / TARGET_CHAR_BIT
;
3800 /* Add new field with name NAME and type FIELD to composite type T. */
3803 append_composite_type_field (struct type
*t
, char *name
,
3806 append_composite_type_field_aligned (t
, name
, field
, 0);
3809 static struct gdbarch_data
*gdbtypes_data
;
3811 const struct builtin_type
*
3812 builtin_type (struct gdbarch
*gdbarch
)
3814 return gdbarch_data (gdbarch
, gdbtypes_data
);
3818 gdbtypes_post_init (struct gdbarch
*gdbarch
)
3820 struct builtin_type
*builtin_type
3821 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
3824 builtin_type
->builtin_void
3825 = arch_type (gdbarch
, TYPE_CODE_VOID
, 1, "void");
3826 builtin_type
->builtin_char
3827 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3828 !gdbarch_char_signed (gdbarch
), "char");
3829 builtin_type
->builtin_signed_char
3830 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3832 builtin_type
->builtin_unsigned_char
3833 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3834 1, "unsigned char");
3835 builtin_type
->builtin_short
3836 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
3838 builtin_type
->builtin_unsigned_short
3839 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
3840 1, "unsigned short");
3841 builtin_type
->builtin_int
3842 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
3844 builtin_type
->builtin_unsigned_int
3845 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
3847 builtin_type
->builtin_long
3848 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
3850 builtin_type
->builtin_unsigned_long
3851 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
3852 1, "unsigned long");
3853 builtin_type
->builtin_long_long
3854 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
3856 builtin_type
->builtin_unsigned_long_long
3857 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
3858 1, "unsigned long long");
3859 builtin_type
->builtin_float
3860 = arch_float_type (gdbarch
, gdbarch_float_bit (gdbarch
),
3861 "float", gdbarch_float_format (gdbarch
));
3862 builtin_type
->builtin_double
3863 = arch_float_type (gdbarch
, gdbarch_double_bit (gdbarch
),
3864 "double", gdbarch_double_format (gdbarch
));
3865 builtin_type
->builtin_long_double
3866 = arch_float_type (gdbarch
, gdbarch_long_double_bit (gdbarch
),
3867 "long double", gdbarch_long_double_format (gdbarch
));
3868 builtin_type
->builtin_complex
3869 = arch_complex_type (gdbarch
, "complex",
3870 builtin_type
->builtin_float
);
3871 builtin_type
->builtin_double_complex
3872 = arch_complex_type (gdbarch
, "double complex",
3873 builtin_type
->builtin_double
);
3874 builtin_type
->builtin_string
3875 = arch_type (gdbarch
, TYPE_CODE_STRING
, 1, "string");
3876 builtin_type
->builtin_bool
3877 = arch_type (gdbarch
, TYPE_CODE_BOOL
, 1, "bool");
3879 /* The following three are about decimal floating point types, which
3880 are 32-bits, 64-bits and 128-bits respectively. */
3881 builtin_type
->builtin_decfloat
3882 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 32 / 8, "_Decimal32");
3883 builtin_type
->builtin_decdouble
3884 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 64 / 8, "_Decimal64");
3885 builtin_type
->builtin_declong
3886 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 128 / 8, "_Decimal128");
3888 /* "True" character types. */
3889 builtin_type
->builtin_true_char
3890 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 0, "true character");
3891 builtin_type
->builtin_true_unsigned_char
3892 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 1, "true character");
3894 /* Fixed-size integer types. */
3895 builtin_type
->builtin_int0
3896 = arch_integer_type (gdbarch
, 0, 0, "int0_t");
3897 builtin_type
->builtin_int8
3898 = arch_integer_type (gdbarch
, 8, 0, "int8_t");
3899 builtin_type
->builtin_uint8
3900 = arch_integer_type (gdbarch
, 8, 1, "uint8_t");
3901 builtin_type
->builtin_int16
3902 = arch_integer_type (gdbarch
, 16, 0, "int16_t");
3903 builtin_type
->builtin_uint16
3904 = arch_integer_type (gdbarch
, 16, 1, "uint16_t");
3905 builtin_type
->builtin_int32
3906 = arch_integer_type (gdbarch
, 32, 0, "int32_t");
3907 builtin_type
->builtin_uint32
3908 = arch_integer_type (gdbarch
, 32, 1, "uint32_t");
3909 builtin_type
->builtin_int64
3910 = arch_integer_type (gdbarch
, 64, 0, "int64_t");
3911 builtin_type
->builtin_uint64
3912 = arch_integer_type (gdbarch
, 64, 1, "uint64_t");
3913 builtin_type
->builtin_int128
3914 = arch_integer_type (gdbarch
, 128, 0, "int128_t");
3915 builtin_type
->builtin_uint128
3916 = arch_integer_type (gdbarch
, 128, 1, "uint128_t");
3917 TYPE_INSTANCE_FLAGS (builtin_type
->builtin_int8
) |=
3918 TYPE_INSTANCE_FLAG_NOTTEXT
;
3919 TYPE_INSTANCE_FLAGS (builtin_type
->builtin_uint8
) |=
3920 TYPE_INSTANCE_FLAG_NOTTEXT
;
3922 /* Wide character types. */
3923 builtin_type
->builtin_char16
3924 = arch_integer_type (gdbarch
, 16, 0, "char16_t");
3925 builtin_type
->builtin_char32
3926 = arch_integer_type (gdbarch
, 32, 0, "char32_t");
3929 /* Default data/code pointer types. */
3930 builtin_type
->builtin_data_ptr
3931 = lookup_pointer_type (builtin_type
->builtin_void
);
3932 builtin_type
->builtin_func_ptr
3933 = lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
3934 builtin_type
->builtin_func_func
3935 = lookup_function_type (builtin_type
->builtin_func_ptr
);
3937 /* This type represents a GDB internal function. */
3938 builtin_type
->internal_fn
3939 = arch_type (gdbarch
, TYPE_CODE_INTERNAL_FUNCTION
, 0,
3940 "<internal function>");
3942 return builtin_type
;
3945 /* This set of objfile-based types is intended to be used by symbol
3946 readers as basic types. */
3948 static const struct objfile_data
*objfile_type_data
;
3950 const struct objfile_type
*
3951 objfile_type (struct objfile
*objfile
)
3953 struct gdbarch
*gdbarch
;
3954 struct objfile_type
*objfile_type
3955 = objfile_data (objfile
, objfile_type_data
);
3958 return objfile_type
;
3960 objfile_type
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
3961 1, struct objfile_type
);
3963 /* Use the objfile architecture to determine basic type properties. */
3964 gdbarch
= get_objfile_arch (objfile
);
3967 objfile_type
->builtin_void
3968 = init_type (TYPE_CODE_VOID
, 1,
3972 objfile_type
->builtin_char
3973 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3975 | (gdbarch_char_signed (gdbarch
) ? 0 : TYPE_FLAG_UNSIGNED
)),
3977 objfile_type
->builtin_signed_char
3978 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3980 "signed char", objfile
);
3981 objfile_type
->builtin_unsigned_char
3982 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3984 "unsigned char", objfile
);
3985 objfile_type
->builtin_short
3986 = init_type (TYPE_CODE_INT
,
3987 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3988 0, "short", objfile
);
3989 objfile_type
->builtin_unsigned_short
3990 = init_type (TYPE_CODE_INT
,
3991 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3992 TYPE_FLAG_UNSIGNED
, "unsigned short", objfile
);
3993 objfile_type
->builtin_int
3994 = init_type (TYPE_CODE_INT
,
3995 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3997 objfile_type
->builtin_unsigned_int
3998 = init_type (TYPE_CODE_INT
,
3999 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
4000 TYPE_FLAG_UNSIGNED
, "unsigned int", objfile
);
4001 objfile_type
->builtin_long
4002 = init_type (TYPE_CODE_INT
,
4003 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
4004 0, "long", objfile
);
4005 objfile_type
->builtin_unsigned_long
4006 = init_type (TYPE_CODE_INT
,
4007 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
4008 TYPE_FLAG_UNSIGNED
, "unsigned long", objfile
);
4009 objfile_type
->builtin_long_long
4010 = init_type (TYPE_CODE_INT
,
4011 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
4012 0, "long long", objfile
);
4013 objfile_type
->builtin_unsigned_long_long
4014 = init_type (TYPE_CODE_INT
,
4015 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
4016 TYPE_FLAG_UNSIGNED
, "unsigned long long", objfile
);
4018 objfile_type
->builtin_float
4019 = init_type (TYPE_CODE_FLT
,
4020 gdbarch_float_bit (gdbarch
) / TARGET_CHAR_BIT
,
4021 0, "float", objfile
);
4022 TYPE_FLOATFORMAT (objfile_type
->builtin_float
)
4023 = gdbarch_float_format (gdbarch
);
4024 objfile_type
->builtin_double
4025 = init_type (TYPE_CODE_FLT
,
4026 gdbarch_double_bit (gdbarch
) / TARGET_CHAR_BIT
,
4027 0, "double", objfile
);
4028 TYPE_FLOATFORMAT (objfile_type
->builtin_double
)
4029 = gdbarch_double_format (gdbarch
);
4030 objfile_type
->builtin_long_double
4031 = init_type (TYPE_CODE_FLT
,
4032 gdbarch_long_double_bit (gdbarch
) / TARGET_CHAR_BIT
,
4033 0, "long double", objfile
);
4034 TYPE_FLOATFORMAT (objfile_type
->builtin_long_double
)
4035 = gdbarch_long_double_format (gdbarch
);
4037 /* This type represents a type that was unrecognized in symbol read-in. */
4038 objfile_type
->builtin_error
4039 = init_type (TYPE_CODE_ERROR
, 0, 0, "<unknown type>", objfile
);
4041 /* The following set of types is used for symbols with no
4042 debug information. */
4043 objfile_type
->nodebug_text_symbol
4044 = init_type (TYPE_CODE_FUNC
, 1, 0,
4045 "<text variable, no debug info>", objfile
);
4046 TYPE_TARGET_TYPE (objfile_type
->nodebug_text_symbol
)
4047 = objfile_type
->builtin_int
;
4048 objfile_type
->nodebug_text_gnu_ifunc_symbol
4049 = init_type (TYPE_CODE_FUNC
, 1, TYPE_FLAG_GNU_IFUNC
,
4050 "<text gnu-indirect-function variable, no debug info>",
4052 TYPE_TARGET_TYPE (objfile_type
->nodebug_text_gnu_ifunc_symbol
)
4053 = objfile_type
->nodebug_text_symbol
;
4054 objfile_type
->nodebug_got_plt_symbol
4055 = init_type (TYPE_CODE_PTR
, gdbarch_addr_bit (gdbarch
) / 8, 0,
4056 "<text from jump slot in .got.plt, no debug info>",
4058 TYPE_TARGET_TYPE (objfile_type
->nodebug_got_plt_symbol
)
4059 = objfile_type
->nodebug_text_symbol
;
4060 objfile_type
->nodebug_data_symbol
4061 = init_type (TYPE_CODE_INT
,
4062 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
4063 "<data variable, no debug info>", objfile
);
4064 objfile_type
->nodebug_unknown_symbol
4065 = init_type (TYPE_CODE_INT
, 1, 0,
4066 "<variable (not text or data), no debug info>", objfile
);
4067 objfile_type
->nodebug_tls_symbol
4068 = init_type (TYPE_CODE_INT
,
4069 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
4070 "<thread local variable, no debug info>", objfile
);
4072 /* NOTE: on some targets, addresses and pointers are not necessarily
4076 - gdb's `struct type' always describes the target's
4078 - gdb's `struct value' objects should always hold values in
4080 - gdb's CORE_ADDR values are addresses in the unified virtual
4081 address space that the assembler and linker work with. Thus,
4082 since target_read_memory takes a CORE_ADDR as an argument, it
4083 can access any memory on the target, even if the processor has
4084 separate code and data address spaces.
4086 In this context, objfile_type->builtin_core_addr is a bit odd:
4087 it's a target type for a value the target will never see. It's
4088 only used to hold the values of (typeless) linker symbols, which
4089 are indeed in the unified virtual address space. */
4091 objfile_type
->builtin_core_addr
4092 = init_type (TYPE_CODE_INT
,
4093 gdbarch_addr_bit (gdbarch
) / 8,
4094 TYPE_FLAG_UNSIGNED
, "__CORE_ADDR", objfile
);
4096 set_objfile_data (objfile
, objfile_type_data
, objfile_type
);
4097 return objfile_type
;
4100 extern initialize_file_ftype _initialize_gdbtypes
;
4103 _initialize_gdbtypes (void)
4105 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
4106 objfile_type_data
= register_objfile_data ();
4108 add_setshow_zuinteger_cmd ("overload", no_class
, &overload_debug
,
4109 _("Set debugging of C++ overloading."),
4110 _("Show debugging of C++ overloading."),
4111 _("When enabled, ranking of the "
4112 "functions is displayed."),
4114 show_overload_debug
,
4115 &setdebuglist
, &showdebuglist
);
4117 /* Add user knob for controlling resolution of opaque types. */
4118 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
4119 &opaque_type_resolution
,
4120 _("Set resolution of opaque struct/class/union"
4121 " types (if set before loading symbols)."),
4122 _("Show resolution of opaque struct/class/union"
4123 " types (if set before loading symbols)."),
4125 show_opaque_type_resolution
,
4126 &setlist
, &showlist
);
4128 /* Add an option to permit non-strict type checking. */
4129 add_setshow_boolean_cmd ("type", class_support
,
4130 &strict_type_checking
,
4131 _("Set strict type checking."),
4132 _("Show strict type checking."),
4134 show_strict_type_checking
,
4135 &setchecklist
, &showchecklist
);