1 /* Support routines for manipulating internal types for GDB.
3 Copyright (C) 1992-2014 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/>. */
29 #include "expression.h"
34 #include "complaints.h"
37 #include "gdb_assert.h"
39 #include "exceptions.h"
40 #include "cp-support.h"
42 #include "dwarf2loc.h"
44 /* Initialize BADNESS constants. */
46 const struct rank LENGTH_MISMATCH_BADNESS
= {100,0};
48 const struct rank TOO_FEW_PARAMS_BADNESS
= {100,0};
49 const struct rank INCOMPATIBLE_TYPE_BADNESS
= {100,0};
51 const struct rank EXACT_MATCH_BADNESS
= {0,0};
53 const struct rank INTEGER_PROMOTION_BADNESS
= {1,0};
54 const struct rank FLOAT_PROMOTION_BADNESS
= {1,0};
55 const struct rank BASE_PTR_CONVERSION_BADNESS
= {1,0};
56 const struct rank INTEGER_CONVERSION_BADNESS
= {2,0};
57 const struct rank FLOAT_CONVERSION_BADNESS
= {2,0};
58 const struct rank INT_FLOAT_CONVERSION_BADNESS
= {2,0};
59 const struct rank VOID_PTR_CONVERSION_BADNESS
= {2,0};
60 const struct rank BOOL_CONVERSION_BADNESS
= {3,0};
61 const struct rank BASE_CONVERSION_BADNESS
= {2,0};
62 const struct rank REFERENCE_CONVERSION_BADNESS
= {2,0};
63 const struct rank NULL_POINTER_CONVERSION_BADNESS
= {2,0};
64 const struct rank NS_POINTER_CONVERSION_BADNESS
= {10,0};
65 const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS
= {3,0};
67 /* Floatformat pairs. */
68 const struct floatformat
*floatformats_ieee_half
[BFD_ENDIAN_UNKNOWN
] = {
69 &floatformat_ieee_half_big
,
70 &floatformat_ieee_half_little
72 const struct floatformat
*floatformats_ieee_single
[BFD_ENDIAN_UNKNOWN
] = {
73 &floatformat_ieee_single_big
,
74 &floatformat_ieee_single_little
76 const struct floatformat
*floatformats_ieee_double
[BFD_ENDIAN_UNKNOWN
] = {
77 &floatformat_ieee_double_big
,
78 &floatformat_ieee_double_little
80 const struct floatformat
*floatformats_ieee_double_littlebyte_bigword
[BFD_ENDIAN_UNKNOWN
] = {
81 &floatformat_ieee_double_big
,
82 &floatformat_ieee_double_littlebyte_bigword
84 const struct floatformat
*floatformats_i387_ext
[BFD_ENDIAN_UNKNOWN
] = {
85 &floatformat_i387_ext
,
88 const struct floatformat
*floatformats_m68881_ext
[BFD_ENDIAN_UNKNOWN
] = {
89 &floatformat_m68881_ext
,
90 &floatformat_m68881_ext
92 const struct floatformat
*floatformats_arm_ext
[BFD_ENDIAN_UNKNOWN
] = {
93 &floatformat_arm_ext_big
,
94 &floatformat_arm_ext_littlebyte_bigword
96 const struct floatformat
*floatformats_ia64_spill
[BFD_ENDIAN_UNKNOWN
] = {
97 &floatformat_ia64_spill_big
,
98 &floatformat_ia64_spill_little
100 const struct floatformat
*floatformats_ia64_quad
[BFD_ENDIAN_UNKNOWN
] = {
101 &floatformat_ia64_quad_big
,
102 &floatformat_ia64_quad_little
104 const struct floatformat
*floatformats_vax_f
[BFD_ENDIAN_UNKNOWN
] = {
108 const struct floatformat
*floatformats_vax_d
[BFD_ENDIAN_UNKNOWN
] = {
112 const struct floatformat
*floatformats_ibm_long_double
[BFD_ENDIAN_UNKNOWN
] = {
113 &floatformat_ibm_long_double_big
,
114 &floatformat_ibm_long_double_little
117 /* Should opaque types be resolved? */
119 static int opaque_type_resolution
= 1;
121 /* A flag to enable printing of debugging information of C++
124 unsigned int overload_debug
= 0;
126 /* A flag to enable strict type checking. */
128 static int strict_type_checking
= 1;
130 /* A function to show whether opaque types are resolved. */
133 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
134 struct cmd_list_element
*c
,
137 fprintf_filtered (file
, _("Resolution of opaque struct/class/union types "
138 "(if set before loading symbols) is %s.\n"),
142 /* A function to show whether C++ overload debugging is enabled. */
145 show_overload_debug (struct ui_file
*file
, int from_tty
,
146 struct cmd_list_element
*c
, const char *value
)
148 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"),
152 /* A function to show the status of strict type checking. */
155 show_strict_type_checking (struct ui_file
*file
, int from_tty
,
156 struct cmd_list_element
*c
, const char *value
)
158 fprintf_filtered (file
, _("Strict type checking is %s.\n"), value
);
162 /* Allocate a new OBJFILE-associated type structure and fill it
163 with some defaults. Space for the type structure is allocated
164 on the objfile's objfile_obstack. */
167 alloc_type (struct objfile
*objfile
)
171 gdb_assert (objfile
!= NULL
);
173 /* Alloc the structure and start off with all fields zeroed. */
174 type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct type
);
175 TYPE_MAIN_TYPE (type
) = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
177 OBJSTAT (objfile
, n_types
++);
179 TYPE_OBJFILE_OWNED (type
) = 1;
180 TYPE_OWNER (type
).objfile
= objfile
;
182 /* Initialize the fields that might not be zero. */
184 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
185 TYPE_VPTR_FIELDNO (type
) = -1;
186 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
191 /* Allocate a new GDBARCH-associated type structure and fill it
192 with some defaults. Space for the type structure is allocated
196 alloc_type_arch (struct gdbarch
*gdbarch
)
200 gdb_assert (gdbarch
!= NULL
);
202 /* Alloc the structure and start off with all fields zeroed. */
204 type
= XCNEW (struct type
);
205 TYPE_MAIN_TYPE (type
) = XCNEW (struct main_type
);
207 TYPE_OBJFILE_OWNED (type
) = 0;
208 TYPE_OWNER (type
).gdbarch
= gdbarch
;
210 /* Initialize the fields that might not be zero. */
212 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
213 TYPE_VPTR_FIELDNO (type
) = -1;
214 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
219 /* If TYPE is objfile-associated, allocate a new type structure
220 associated with the same objfile. If TYPE is gdbarch-associated,
221 allocate a new type structure associated with the same gdbarch. */
224 alloc_type_copy (const struct type
*type
)
226 if (TYPE_OBJFILE_OWNED (type
))
227 return alloc_type (TYPE_OWNER (type
).objfile
);
229 return alloc_type_arch (TYPE_OWNER (type
).gdbarch
);
232 /* If TYPE is gdbarch-associated, return that architecture.
233 If TYPE is objfile-associated, return that objfile's architecture. */
236 get_type_arch (const struct type
*type
)
238 if (TYPE_OBJFILE_OWNED (type
))
239 return get_objfile_arch (TYPE_OWNER (type
).objfile
);
241 return TYPE_OWNER (type
).gdbarch
;
244 /* See gdbtypes.h. */
247 get_target_type (struct type
*type
)
251 type
= TYPE_TARGET_TYPE (type
);
253 type
= check_typedef (type
);
259 /* Alloc a new type instance structure, fill it with some defaults,
260 and point it at OLDTYPE. Allocate the new type instance from the
261 same place as OLDTYPE. */
264 alloc_type_instance (struct type
*oldtype
)
268 /* Allocate the structure. */
270 if (! TYPE_OBJFILE_OWNED (oldtype
))
271 type
= XCNEW (struct type
);
273 type
= OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype
)->objfile_obstack
,
276 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
278 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
283 /* Clear all remnants of the previous type at TYPE, in preparation for
284 replacing it with something else. Preserve owner information. */
287 smash_type (struct type
*type
)
289 int objfile_owned
= TYPE_OBJFILE_OWNED (type
);
290 union type_owner owner
= TYPE_OWNER (type
);
292 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
294 /* Restore owner information. */
295 TYPE_OBJFILE_OWNED (type
) = objfile_owned
;
296 TYPE_OWNER (type
) = owner
;
298 /* For now, delete the rings. */
299 TYPE_CHAIN (type
) = type
;
301 /* For now, leave the pointer/reference types alone. */
304 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
305 to a pointer to memory where the pointer type should be stored.
306 If *TYPEPTR is zero, update it to point to the pointer type we return.
307 We allocate new memory if needed. */
310 make_pointer_type (struct type
*type
, struct type
**typeptr
)
312 struct type
*ntype
; /* New type */
315 ntype
= TYPE_POINTER_TYPE (type
);
320 return ntype
; /* Don't care about alloc,
321 and have new type. */
322 else if (*typeptr
== 0)
324 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
329 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
331 ntype
= alloc_type_copy (type
);
335 else /* We have storage, but need to reset it. */
338 chain
= TYPE_CHAIN (ntype
);
340 TYPE_CHAIN (ntype
) = chain
;
343 TYPE_TARGET_TYPE (ntype
) = type
;
344 TYPE_POINTER_TYPE (type
) = ntype
;
346 /* FIXME! Assumes the machine has only one representation for pointers! */
349 = gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
350 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
352 /* Mark pointers as unsigned. The target converts between pointers
353 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
354 gdbarch_address_to_pointer. */
355 TYPE_UNSIGNED (ntype
) = 1;
357 /* Update the length of all the other variants of this type. */
358 chain
= TYPE_CHAIN (ntype
);
359 while (chain
!= ntype
)
361 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
362 chain
= TYPE_CHAIN (chain
);
368 /* Given a type TYPE, return a type of pointers to that type.
369 May need to construct such a type if this is the first use. */
372 lookup_pointer_type (struct type
*type
)
374 return make_pointer_type (type
, (struct type
**) 0);
377 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
378 points to a pointer to memory where the reference type should be
379 stored. If *TYPEPTR is zero, update it to point to the reference
380 type we return. We allocate new memory if needed. */
383 make_reference_type (struct type
*type
, struct type
**typeptr
)
385 struct type
*ntype
; /* New type */
388 ntype
= TYPE_REFERENCE_TYPE (type
);
393 return ntype
; /* Don't care about alloc,
394 and have new type. */
395 else if (*typeptr
== 0)
397 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
402 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
404 ntype
= alloc_type_copy (type
);
408 else /* We have storage, but need to reset it. */
411 chain
= TYPE_CHAIN (ntype
);
413 TYPE_CHAIN (ntype
) = chain
;
416 TYPE_TARGET_TYPE (ntype
) = type
;
417 TYPE_REFERENCE_TYPE (type
) = ntype
;
419 /* FIXME! Assume the machine has only one representation for
420 references, and that it matches the (only) representation for
423 TYPE_LENGTH (ntype
) =
424 gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
425 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
427 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
428 TYPE_REFERENCE_TYPE (type
) = ntype
;
430 /* Update the length of all the other variants of this type. */
431 chain
= TYPE_CHAIN (ntype
);
432 while (chain
!= ntype
)
434 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
435 chain
= TYPE_CHAIN (chain
);
441 /* Same as above, but caller doesn't care about memory allocation
445 lookup_reference_type (struct type
*type
)
447 return make_reference_type (type
, (struct type
**) 0);
450 /* Lookup a function type that returns type TYPE. TYPEPTR, if
451 nonzero, points to a pointer to memory where the function type
452 should be stored. If *TYPEPTR is zero, update it to point to the
453 function type we return. We allocate new memory if needed. */
456 make_function_type (struct type
*type
, struct type
**typeptr
)
458 struct type
*ntype
; /* New type */
460 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
462 ntype
= alloc_type_copy (type
);
466 else /* We have storage, but need to reset it. */
472 TYPE_TARGET_TYPE (ntype
) = type
;
474 TYPE_LENGTH (ntype
) = 1;
475 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
477 INIT_FUNC_SPECIFIC (ntype
);
482 /* Given a type TYPE, return a type of functions that return that type.
483 May need to construct such a type if this is the first use. */
486 lookup_function_type (struct type
*type
)
488 return make_function_type (type
, (struct type
**) 0);
491 /* Given a type TYPE and argument types, return the appropriate
492 function type. If the final type in PARAM_TYPES is NULL, make a
496 lookup_function_type_with_arguments (struct type
*type
,
498 struct type
**param_types
)
500 struct type
*fn
= make_function_type (type
, (struct type
**) 0);
505 if (param_types
[nparams
- 1] == NULL
)
508 TYPE_VARARGS (fn
) = 1;
510 else if (TYPE_CODE (check_typedef (param_types
[nparams
- 1]))
514 /* Caller should have ensured this. */
515 gdb_assert (nparams
== 0);
516 TYPE_PROTOTYPED (fn
) = 1;
520 TYPE_NFIELDS (fn
) = nparams
;
521 TYPE_FIELDS (fn
) = TYPE_ZALLOC (fn
, nparams
* sizeof (struct field
));
522 for (i
= 0; i
< nparams
; ++i
)
523 TYPE_FIELD_TYPE (fn
, i
) = param_types
[i
];
528 /* Identify address space identifier by name --
529 return the integer flag defined in gdbtypes.h. */
532 address_space_name_to_int (struct gdbarch
*gdbarch
, char *space_identifier
)
536 /* Check for known address space delimiters. */
537 if (!strcmp (space_identifier
, "code"))
538 return TYPE_INSTANCE_FLAG_CODE_SPACE
;
539 else if (!strcmp (space_identifier
, "data"))
540 return TYPE_INSTANCE_FLAG_DATA_SPACE
;
541 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
542 && gdbarch_address_class_name_to_type_flags (gdbarch
,
547 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
550 /* Identify address space identifier by integer flag as defined in
551 gdbtypes.h -- return the string version of the adress space name. */
554 address_space_int_to_name (struct gdbarch
*gdbarch
, int space_flag
)
556 if (space_flag
& TYPE_INSTANCE_FLAG_CODE_SPACE
)
558 else if (space_flag
& TYPE_INSTANCE_FLAG_DATA_SPACE
)
560 else if ((space_flag
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
561 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
562 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
567 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
569 If STORAGE is non-NULL, create the new type instance there.
570 STORAGE must be in the same obstack as TYPE. */
573 make_qualified_type (struct type
*type
, int new_flags
,
574 struct type
*storage
)
581 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
583 ntype
= TYPE_CHAIN (ntype
);
585 while (ntype
!= type
);
587 /* Create a new type instance. */
589 ntype
= alloc_type_instance (type
);
592 /* If STORAGE was provided, it had better be in the same objfile
593 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
594 if one objfile is freed and the other kept, we'd have
595 dangling pointers. */
596 gdb_assert (TYPE_OBJFILE (type
) == TYPE_OBJFILE (storage
));
599 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
600 TYPE_CHAIN (ntype
) = ntype
;
603 /* Pointers or references to the original type are not relevant to
605 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
606 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
608 /* Chain the new qualified type to the old type. */
609 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
610 TYPE_CHAIN (type
) = ntype
;
612 /* Now set the instance flags and return the new type. */
613 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
615 /* Set length of new type to that of the original type. */
616 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
621 /* Make an address-space-delimited variant of a type -- a type that
622 is identical to the one supplied except that it has an address
623 space attribute attached to it (such as "code" or "data").
625 The space attributes "code" and "data" are for Harvard
626 architectures. The address space attributes are for architectures
627 which have alternately sized pointers or pointers with alternate
631 make_type_with_address_space (struct type
*type
, int space_flag
)
633 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
634 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
635 | TYPE_INSTANCE_FLAG_DATA_SPACE
636 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
))
639 return make_qualified_type (type
, new_flags
, NULL
);
642 /* Make a "c-v" variant of a type -- a type that is identical to the
643 one supplied except that it may have const or volatile attributes
644 CNST is a flag for setting the const attribute
645 VOLTL is a flag for setting the volatile attribute
646 TYPE is the base type whose variant we are creating.
648 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
649 storage to hold the new qualified type; *TYPEPTR and TYPE must be
650 in the same objfile. Otherwise, allocate fresh memory for the new
651 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
652 new type we construct. */
655 make_cv_type (int cnst
, int voltl
,
657 struct type
**typeptr
)
659 struct type
*ntype
; /* New type */
661 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
662 & ~(TYPE_INSTANCE_FLAG_CONST
663 | TYPE_INSTANCE_FLAG_VOLATILE
));
666 new_flags
|= TYPE_INSTANCE_FLAG_CONST
;
669 new_flags
|= TYPE_INSTANCE_FLAG_VOLATILE
;
671 if (typeptr
&& *typeptr
!= NULL
)
673 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
674 a C-V variant chain that threads across objfiles: if one
675 objfile gets freed, then the other has a broken C-V chain.
677 This code used to try to copy over the main type from TYPE to
678 *TYPEPTR if they were in different objfiles, but that's
679 wrong, too: TYPE may have a field list or member function
680 lists, which refer to types of their own, etc. etc. The
681 whole shebang would need to be copied over recursively; you
682 can't have inter-objfile pointers. The only thing to do is
683 to leave stub types as stub types, and look them up afresh by
684 name each time you encounter them. */
685 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
));
688 ntype
= make_qualified_type (type
, new_flags
,
689 typeptr
? *typeptr
: NULL
);
697 /* Make a 'restrict'-qualified version of TYPE. */
700 make_restrict_type (struct type
*type
)
702 return make_qualified_type (type
,
703 (TYPE_INSTANCE_FLAGS (type
)
704 | TYPE_INSTANCE_FLAG_RESTRICT
),
708 /* Replace the contents of ntype with the type *type. This changes the
709 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
710 the changes are propogated to all types in the TYPE_CHAIN.
712 In order to build recursive types, it's inevitable that we'll need
713 to update types in place --- but this sort of indiscriminate
714 smashing is ugly, and needs to be replaced with something more
715 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
716 clear if more steps are needed. */
719 replace_type (struct type
*ntype
, struct type
*type
)
723 /* These two types had better be in the same objfile. Otherwise,
724 the assignment of one type's main type structure to the other
725 will produce a type with references to objects (names; field
726 lists; etc.) allocated on an objfile other than its own. */
727 gdb_assert (TYPE_OBJFILE (ntype
) == TYPE_OBJFILE (ntype
));
729 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
731 /* The type length is not a part of the main type. Update it for
732 each type on the variant chain. */
736 /* Assert that this element of the chain has no address-class bits
737 set in its flags. Such type variants might have type lengths
738 which are supposed to be different from the non-address-class
739 variants. This assertion shouldn't ever be triggered because
740 symbol readers which do construct address-class variants don't
741 call replace_type(). */
742 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
744 TYPE_LENGTH (chain
) = TYPE_LENGTH (type
);
745 chain
= TYPE_CHAIN (chain
);
747 while (ntype
!= chain
);
749 /* Assert that the two types have equivalent instance qualifiers.
750 This should be true for at least all of our debug readers. */
751 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
754 /* Implement direct support for MEMBER_TYPE in GNU C++.
755 May need to construct such a type if this is the first use.
756 The TYPE is the type of the member. The DOMAIN is the type
757 of the aggregate that the member belongs to. */
760 lookup_memberptr_type (struct type
*type
, struct type
*domain
)
764 mtype
= alloc_type_copy (type
);
765 smash_to_memberptr_type (mtype
, domain
, type
);
769 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
772 lookup_methodptr_type (struct type
*to_type
)
776 mtype
= alloc_type_copy (to_type
);
777 smash_to_methodptr_type (mtype
, to_type
);
781 /* Allocate a stub method whose return type is TYPE. This apparently
782 happens for speed of symbol reading, since parsing out the
783 arguments to the method is cpu-intensive, the way we are doing it.
784 So, we will fill in arguments later. This always returns a fresh
788 allocate_stub_method (struct type
*type
)
792 mtype
= alloc_type_copy (type
);
793 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
794 TYPE_LENGTH (mtype
) = 1;
795 TYPE_STUB (mtype
) = 1;
796 TYPE_TARGET_TYPE (mtype
) = type
;
797 /* _DOMAIN_TYPE (mtype) = unknown yet */
801 /* Create a range type using either a blank type supplied in
802 RESULT_TYPE, or creating a new type, inheriting the objfile from
805 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
806 to HIGH_BOUND, inclusive.
808 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
809 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
812 create_range_type (struct type
*result_type
, struct type
*index_type
,
813 LONGEST low_bound
, LONGEST high_bound
)
815 if (result_type
== NULL
)
816 result_type
= alloc_type_copy (index_type
);
817 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
818 TYPE_TARGET_TYPE (result_type
) = index_type
;
819 if (TYPE_STUB (index_type
))
820 TYPE_TARGET_STUB (result_type
) = 1;
822 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
823 TYPE_RANGE_DATA (result_type
) = (struct range_bounds
*)
824 TYPE_ZALLOC (result_type
, sizeof (struct range_bounds
));
825 TYPE_LOW_BOUND (result_type
) = low_bound
;
826 TYPE_HIGH_BOUND (result_type
) = high_bound
;
829 TYPE_UNSIGNED (result_type
) = 1;
834 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
835 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
836 bounds will fit in LONGEST), or -1 otherwise. */
839 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
841 CHECK_TYPEDEF (type
);
842 switch (TYPE_CODE (type
))
844 case TYPE_CODE_RANGE
:
845 *lowp
= TYPE_LOW_BOUND (type
);
846 *highp
= TYPE_HIGH_BOUND (type
);
849 if (TYPE_NFIELDS (type
) > 0)
851 /* The enums may not be sorted by value, so search all
855 *lowp
= *highp
= TYPE_FIELD_ENUMVAL (type
, 0);
856 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
858 if (TYPE_FIELD_ENUMVAL (type
, i
) < *lowp
)
859 *lowp
= TYPE_FIELD_ENUMVAL (type
, i
);
860 if (TYPE_FIELD_ENUMVAL (type
, i
) > *highp
)
861 *highp
= TYPE_FIELD_ENUMVAL (type
, i
);
864 /* Set unsigned indicator if warranted. */
867 TYPE_UNSIGNED (type
) = 1;
881 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
883 if (!TYPE_UNSIGNED (type
))
885 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
889 /* ... fall through for unsigned ints ... */
892 /* This round-about calculation is to avoid shifting by
893 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
894 if TYPE_LENGTH (type) == sizeof (LONGEST). */
895 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
896 *highp
= (*highp
- 1) | *highp
;
903 /* Assuming TYPE is a simple, non-empty array type, compute its upper
904 and lower bound. Save the low bound into LOW_BOUND if not NULL.
905 Save the high bound into HIGH_BOUND if not NULL.
907 Return 1 if the operation was successful. Return zero otherwise,
908 in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
910 We now simply use get_discrete_bounds call to get the values
911 of the low and high bounds.
912 get_discrete_bounds can return three values:
913 1, meaning that index is a range,
914 0, meaning that index is a discrete type,
915 or -1 for failure. */
918 get_array_bounds (struct type
*type
, LONGEST
*low_bound
, LONGEST
*high_bound
)
920 struct type
*index
= TYPE_INDEX_TYPE (type
);
928 res
= get_discrete_bounds (index
, &low
, &high
);
932 /* Check if the array bounds are undefined. */
934 && ((low_bound
&& TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type
))
935 || (high_bound
&& TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))))
947 /* Create an array type using either a blank type supplied in
948 RESULT_TYPE, or creating a new type, inheriting the objfile from
951 Elements will be of type ELEMENT_TYPE, the indices will be of type
954 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
955 sure it is TYPE_CODE_UNDEF before we bash it into an array
959 create_array_type (struct type
*result_type
,
960 struct type
*element_type
,
961 struct type
*range_type
)
963 LONGEST low_bound
, high_bound
;
965 if (result_type
== NULL
)
966 result_type
= alloc_type_copy (range_type
);
968 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
969 TYPE_TARGET_TYPE (result_type
) = element_type
;
970 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
971 low_bound
= high_bound
= 0;
972 CHECK_TYPEDEF (element_type
);
973 /* Be careful when setting the array length. Ada arrays can be
974 empty arrays with the high_bound being smaller than the low_bound.
975 In such cases, the array length should be zero. */
976 if (high_bound
< low_bound
)
977 TYPE_LENGTH (result_type
) = 0;
979 TYPE_LENGTH (result_type
) =
980 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
981 TYPE_NFIELDS (result_type
) = 1;
982 TYPE_FIELDS (result_type
) =
983 (struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
));
984 TYPE_INDEX_TYPE (result_type
) = range_type
;
985 TYPE_VPTR_FIELDNO (result_type
) = -1;
987 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays. */
988 if (TYPE_LENGTH (result_type
) == 0)
989 TYPE_TARGET_STUB (result_type
) = 1;
995 lookup_array_range_type (struct type
*element_type
,
996 LONGEST low_bound
, LONGEST high_bound
)
998 struct gdbarch
*gdbarch
= get_type_arch (element_type
);
999 struct type
*index_type
= builtin_type (gdbarch
)->builtin_int
;
1000 struct type
*range_type
1001 = create_range_type (NULL
, index_type
, low_bound
, high_bound
);
1003 return create_array_type (NULL
, element_type
, range_type
);
1006 /* Create a string type using either a blank type supplied in
1007 RESULT_TYPE, or creating a new type. String types are similar
1008 enough to array of char types that we can use create_array_type to
1009 build the basic type and then bash it into a string type.
1011 For fixed length strings, the range type contains 0 as the lower
1012 bound and the length of the string minus one as the upper bound.
1014 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1015 sure it is TYPE_CODE_UNDEF before we bash it into a string
1019 create_string_type (struct type
*result_type
,
1020 struct type
*string_char_type
,
1021 struct type
*range_type
)
1023 result_type
= create_array_type (result_type
,
1026 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
1031 lookup_string_range_type (struct type
*string_char_type
,
1032 LONGEST low_bound
, LONGEST high_bound
)
1034 struct type
*result_type
;
1036 result_type
= lookup_array_range_type (string_char_type
,
1037 low_bound
, high_bound
);
1038 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
1043 create_set_type (struct type
*result_type
, struct type
*domain_type
)
1045 if (result_type
== NULL
)
1046 result_type
= alloc_type_copy (domain_type
);
1048 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
1049 TYPE_NFIELDS (result_type
) = 1;
1050 TYPE_FIELDS (result_type
) = TYPE_ZALLOC (result_type
, sizeof (struct field
));
1052 if (!TYPE_STUB (domain_type
))
1054 LONGEST low_bound
, high_bound
, bit_length
;
1056 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
1057 low_bound
= high_bound
= 0;
1058 bit_length
= high_bound
- low_bound
+ 1;
1059 TYPE_LENGTH (result_type
)
1060 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
1062 TYPE_UNSIGNED (result_type
) = 1;
1064 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
1069 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
1070 and any array types nested inside it. */
1073 make_vector_type (struct type
*array_type
)
1075 struct type
*inner_array
, *elt_type
;
1078 /* Find the innermost array type, in case the array is
1079 multi-dimensional. */
1080 inner_array
= array_type
;
1081 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
1082 inner_array
= TYPE_TARGET_TYPE (inner_array
);
1084 elt_type
= TYPE_TARGET_TYPE (inner_array
);
1085 if (TYPE_CODE (elt_type
) == TYPE_CODE_INT
)
1087 flags
= TYPE_INSTANCE_FLAGS (elt_type
) | TYPE_INSTANCE_FLAG_NOTTEXT
;
1088 elt_type
= make_qualified_type (elt_type
, flags
, NULL
);
1089 TYPE_TARGET_TYPE (inner_array
) = elt_type
;
1092 TYPE_VECTOR (array_type
) = 1;
1096 init_vector_type (struct type
*elt_type
, int n
)
1098 struct type
*array_type
;
1100 array_type
= lookup_array_range_type (elt_type
, 0, n
- 1);
1101 make_vector_type (array_type
);
1105 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
1106 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1107 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1108 TYPE doesn't include the offset (that's the value of the MEMBER
1109 itself), but does include the structure type into which it points
1112 When "smashing" the type, we preserve the objfile that the old type
1113 pointed to, since we aren't changing where the type is actually
1117 smash_to_memberptr_type (struct type
*type
, struct type
*domain
,
1118 struct type
*to_type
)
1121 TYPE_TARGET_TYPE (type
) = to_type
;
1122 TYPE_DOMAIN_TYPE (type
) = domain
;
1123 /* Assume that a data member pointer is the same size as a normal
1126 = gdbarch_ptr_bit (get_type_arch (to_type
)) / TARGET_CHAR_BIT
;
1127 TYPE_CODE (type
) = TYPE_CODE_MEMBERPTR
;
1130 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
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_methodptr_type (struct type
*type
, struct type
*to_type
)
1140 TYPE_TARGET_TYPE (type
) = to_type
;
1141 TYPE_DOMAIN_TYPE (type
) = TYPE_DOMAIN_TYPE (to_type
);
1142 TYPE_LENGTH (type
) = cplus_method_ptr_size (to_type
);
1143 TYPE_CODE (type
) = TYPE_CODE_METHODPTR
;
1146 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
1147 METHOD just means `function that gets an extra "this" argument'.
1149 When "smashing" the type, we preserve the objfile that the old type
1150 pointed to, since we aren't changing where the type is actually
1154 smash_to_method_type (struct type
*type
, struct type
*domain
,
1155 struct type
*to_type
, struct field
*args
,
1156 int nargs
, int varargs
)
1159 TYPE_TARGET_TYPE (type
) = to_type
;
1160 TYPE_DOMAIN_TYPE (type
) = domain
;
1161 TYPE_FIELDS (type
) = args
;
1162 TYPE_NFIELDS (type
) = nargs
;
1164 TYPE_VARARGS (type
) = 1;
1165 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1166 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
1169 /* Return a typename for a struct/union/enum type without "struct ",
1170 "union ", or "enum ". If the type has a NULL name, return NULL. */
1173 type_name_no_tag (const struct type
*type
)
1175 if (TYPE_TAG_NAME (type
) != NULL
)
1176 return TYPE_TAG_NAME (type
);
1178 /* Is there code which expects this to return the name if there is
1179 no tag name? My guess is that this is mainly used for C++ in
1180 cases where the two will always be the same. */
1181 return TYPE_NAME (type
);
1184 /* A wrapper of type_name_no_tag which calls error if the type is anonymous.
1185 Since GCC PR debug/47510 DWARF provides associated information to detect the
1186 anonymous class linkage name from its typedef.
1188 Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
1192 type_name_no_tag_or_error (struct type
*type
)
1194 struct type
*saved_type
= type
;
1196 struct objfile
*objfile
;
1198 CHECK_TYPEDEF (type
);
1200 name
= type_name_no_tag (type
);
1204 name
= type_name_no_tag (saved_type
);
1205 objfile
= TYPE_OBJFILE (saved_type
);
1206 error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
1207 name
? name
: "<anonymous>",
1208 objfile
? objfile_name (objfile
) : "<arch>");
1211 /* Lookup a typedef or primitive type named NAME, visible in lexical
1212 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1213 suitably defined. */
1216 lookup_typename (const struct language_defn
*language
,
1217 struct gdbarch
*gdbarch
, const char *name
,
1218 const struct block
*block
, int noerr
)
1223 sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, 0);
1224 if (sym
!= NULL
&& SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
1225 return SYMBOL_TYPE (sym
);
1227 type
= language_lookup_primitive_type_by_name (language
, gdbarch
, name
);
1233 error (_("No type named %s."), name
);
1237 lookup_unsigned_typename (const struct language_defn
*language
,
1238 struct gdbarch
*gdbarch
, const char *name
)
1240 char *uns
= alloca (strlen (name
) + 10);
1242 strcpy (uns
, "unsigned ");
1243 strcpy (uns
+ 9, name
);
1244 return lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 0);
1248 lookup_signed_typename (const struct language_defn
*language
,
1249 struct gdbarch
*gdbarch
, const char *name
)
1252 char *uns
= alloca (strlen (name
) + 8);
1254 strcpy (uns
, "signed ");
1255 strcpy (uns
+ 7, name
);
1256 t
= lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 1);
1257 /* If we don't find "signed FOO" just try again with plain "FOO". */
1260 return lookup_typename (language
, gdbarch
, name
, (struct block
*) NULL
, 0);
1263 /* Lookup a structure type named "struct NAME",
1264 visible in lexical block BLOCK. */
1267 lookup_struct (const char *name
, const struct block
*block
)
1271 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1275 error (_("No struct type named %s."), name
);
1277 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1279 error (_("This context has class, union or enum %s, not a struct."),
1282 return (SYMBOL_TYPE (sym
));
1285 /* Lookup a union type named "union NAME",
1286 visible in lexical block BLOCK. */
1289 lookup_union (const char *name
, const struct block
*block
)
1294 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1297 error (_("No union type named %s."), name
);
1299 t
= SYMBOL_TYPE (sym
);
1301 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1304 /* If we get here, it's not a union. */
1305 error (_("This context has class, struct or enum %s, not a union."),
1309 /* Lookup an enum type named "enum NAME",
1310 visible in lexical block BLOCK. */
1313 lookup_enum (const char *name
, const struct block
*block
)
1317 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1320 error (_("No enum type named %s."), name
);
1322 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1324 error (_("This context has class, struct or union %s, not an enum."),
1327 return (SYMBOL_TYPE (sym
));
1330 /* Lookup a template type named "template NAME<TYPE>",
1331 visible in lexical block BLOCK. */
1334 lookup_template_type (char *name
, struct type
*type
,
1335 const struct block
*block
)
1338 char *nam
= (char *)
1339 alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1343 strcat (nam
, TYPE_NAME (type
));
1344 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1346 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0);
1350 error (_("No template type named %s."), name
);
1352 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1354 error (_("This context has class, union or enum %s, not a struct."),
1357 return (SYMBOL_TYPE (sym
));
1360 /* Given a type TYPE, lookup the type of the component of type named
1363 TYPE can be either a struct or union, or a pointer or reference to
1364 a struct or union. If it is a pointer or reference, its target
1365 type is automatically used. Thus '.' and '->' are interchangable,
1366 as specified for the definitions of the expression element types
1367 STRUCTOP_STRUCT and STRUCTOP_PTR.
1369 If NOERR is nonzero, return zero if NAME is not suitably defined.
1370 If NAME is the name of a baseclass type, return that type. */
1373 lookup_struct_elt_type (struct type
*type
, const char *name
, int noerr
)
1380 CHECK_TYPEDEF (type
);
1381 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1382 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1384 type
= TYPE_TARGET_TYPE (type
);
1387 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1388 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1390 typename
= type_to_string (type
);
1391 make_cleanup (xfree
, typename
);
1392 error (_("Type %s is not a structure or union type."), typename
);
1396 /* FIXME: This change put in by Michael seems incorrect for the case
1397 where the structure tag name is the same as the member name.
1398 I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
1399 foo; } bell;" Disabled by fnf. */
1403 typename
= type_name_no_tag (type
);
1404 if (typename
!= NULL
&& strcmp (typename
, name
) == 0)
1409 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1411 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1413 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1415 return TYPE_FIELD_TYPE (type
, i
);
1417 else if (!t_field_name
|| *t_field_name
== '\0')
1419 struct type
*subtype
1420 = lookup_struct_elt_type (TYPE_FIELD_TYPE (type
, i
), name
, 1);
1422 if (subtype
!= NULL
)
1427 /* OK, it's not in this class. Recursively check the baseclasses. */
1428 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1432 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, 1);
1444 typename
= type_to_string (type
);
1445 make_cleanup (xfree
, typename
);
1446 error (_("Type %s has no component named %s."), typename
, name
);
1449 /* Store in *MAX the largest number representable by unsigned integer type
1453 get_unsigned_type_max (struct type
*type
, ULONGEST
*max
)
1457 CHECK_TYPEDEF (type
);
1458 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_INT
&& TYPE_UNSIGNED (type
));
1459 gdb_assert (TYPE_LENGTH (type
) <= sizeof (ULONGEST
));
1461 /* Written this way to avoid overflow. */
1462 n
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
1463 *max
= ((((ULONGEST
) 1 << (n
- 1)) - 1) << 1) | 1;
1466 /* Store in *MIN, *MAX the smallest and largest numbers representable by
1467 signed integer type TYPE. */
1470 get_signed_type_minmax (struct type
*type
, LONGEST
*min
, LONGEST
*max
)
1474 CHECK_TYPEDEF (type
);
1475 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_INT
&& !TYPE_UNSIGNED (type
));
1476 gdb_assert (TYPE_LENGTH (type
) <= sizeof (LONGEST
));
1478 n
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
1479 *min
= -((ULONGEST
) 1 << (n
- 1));
1480 *max
= ((ULONGEST
) 1 << (n
- 1)) - 1;
1483 /* Lookup the vptr basetype/fieldno values for TYPE.
1484 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1485 vptr_fieldno. Also, if found and basetype is from the same objfile,
1487 If not found, return -1 and ignore BASETYPEP.
1488 Callers should be aware that in some cases (for example,
1489 the type or one of its baseclasses is a stub type and we are
1490 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1491 this function will not be able to find the
1492 virtual function table pointer, and vptr_fieldno will remain -1 and
1493 vptr_basetype will remain NULL or incomplete. */
1496 get_vptr_fieldno (struct type
*type
, struct type
**basetypep
)
1498 CHECK_TYPEDEF (type
);
1500 if (TYPE_VPTR_FIELDNO (type
) < 0)
1504 /* We must start at zero in case the first (and only) baseclass
1505 is virtual (and hence we cannot share the table pointer). */
1506 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1508 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1510 struct type
*basetype
;
1512 fieldno
= get_vptr_fieldno (baseclass
, &basetype
);
1515 /* If the type comes from a different objfile we can't cache
1516 it, it may have a different lifetime. PR 2384 */
1517 if (TYPE_OBJFILE (type
) == TYPE_OBJFILE (basetype
))
1519 TYPE_VPTR_FIELDNO (type
) = fieldno
;
1520 TYPE_VPTR_BASETYPE (type
) = basetype
;
1523 *basetypep
= basetype
;
1534 *basetypep
= TYPE_VPTR_BASETYPE (type
);
1535 return TYPE_VPTR_FIELDNO (type
);
1540 stub_noname_complaint (void)
1542 complaint (&symfile_complaints
, _("stub type has NULL name"));
1545 /* Find the real type of TYPE. This function returns the real type,
1546 after removing all layers of typedefs, and completing opaque or stub
1547 types. Completion changes the TYPE argument, but stripping of
1550 Instance flags (e.g. const/volatile) are preserved as typedefs are
1551 stripped. If necessary a new qualified form of the underlying type
1554 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
1555 not been computed and we're either in the middle of reading symbols, or
1556 there was no name for the typedef in the debug info.
1558 NOTE: Lookup of opaque types can throw errors for invalid symbol files.
1559 QUITs in the symbol reading code can also throw.
1560 Thus this function can throw an exception.
1562 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
1565 If this is a stubbed struct (i.e. declared as struct foo *), see if
1566 we can find a full definition in some other file. If so, copy this
1567 definition, so we can use it in future. There used to be a comment
1568 (but not any code) that if we don't find a full definition, we'd
1569 set a flag so we don't spend time in the future checking the same
1570 type. That would be a mistake, though--we might load in more
1571 symbols which contain a full definition for the type. */
1574 check_typedef (struct type
*type
)
1576 struct type
*orig_type
= type
;
1577 /* While we're removing typedefs, we don't want to lose qualifiers.
1578 E.g., const/volatile. */
1579 int instance_flags
= TYPE_INSTANCE_FLAGS (type
);
1583 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1585 if (!TYPE_TARGET_TYPE (type
))
1590 /* It is dangerous to call lookup_symbol if we are currently
1591 reading a symtab. Infinite recursion is one danger. */
1592 if (currently_reading_symtab
)
1593 return make_qualified_type (type
, instance_flags
, NULL
);
1595 name
= type_name_no_tag (type
);
1596 /* FIXME: shouldn't we separately check the TYPE_NAME and
1597 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1598 VAR_DOMAIN as appropriate? (this code was written before
1599 TYPE_NAME and TYPE_TAG_NAME were separate). */
1602 stub_noname_complaint ();
1603 return make_qualified_type (type
, instance_flags
, NULL
);
1605 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1607 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1608 else /* TYPE_CODE_UNDEF */
1609 TYPE_TARGET_TYPE (type
) = alloc_type_arch (get_type_arch (type
));
1611 type
= TYPE_TARGET_TYPE (type
);
1613 /* Preserve the instance flags as we traverse down the typedef chain.
1615 Handling address spaces/classes is nasty, what do we do if there's a
1617 E.g., what if an outer typedef marks the type as class_1 and an inner
1618 typedef marks the type as class_2?
1619 This is the wrong place to do such error checking. We leave it to
1620 the code that created the typedef in the first place to flag the
1621 error. We just pick the outer address space (akin to letting the
1622 outer cast in a chain of casting win), instead of assuming
1623 "it can't happen". */
1625 const int ALL_SPACES
= (TYPE_INSTANCE_FLAG_CODE_SPACE
1626 | TYPE_INSTANCE_FLAG_DATA_SPACE
);
1627 const int ALL_CLASSES
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
;
1628 int new_instance_flags
= TYPE_INSTANCE_FLAGS (type
);
1630 /* Treat code vs data spaces and address classes separately. */
1631 if ((instance_flags
& ALL_SPACES
) != 0)
1632 new_instance_flags
&= ~ALL_SPACES
;
1633 if ((instance_flags
& ALL_CLASSES
) != 0)
1634 new_instance_flags
&= ~ALL_CLASSES
;
1636 instance_flags
|= new_instance_flags
;
1640 /* If this is a struct/class/union with no fields, then check
1641 whether a full definition exists somewhere else. This is for
1642 systems where a type definition with no fields is issued for such
1643 types, instead of identifying them as stub types in the first
1646 if (TYPE_IS_OPAQUE (type
)
1647 && opaque_type_resolution
1648 && !currently_reading_symtab
)
1650 const char *name
= type_name_no_tag (type
);
1651 struct type
*newtype
;
1655 stub_noname_complaint ();
1656 return make_qualified_type (type
, instance_flags
, NULL
);
1658 newtype
= lookup_transparent_type (name
);
1662 /* If the resolved type and the stub are in the same
1663 objfile, then replace the stub type with the real deal.
1664 But if they're in separate objfiles, leave the stub
1665 alone; we'll just look up the transparent type every time
1666 we call check_typedef. We can't create pointers between
1667 types allocated to different objfiles, since they may
1668 have different lifetimes. Trying to copy NEWTYPE over to
1669 TYPE's objfile is pointless, too, since you'll have to
1670 move over any other types NEWTYPE refers to, which could
1671 be an unbounded amount of stuff. */
1672 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
1673 type
= make_qualified_type (newtype
,
1674 TYPE_INSTANCE_FLAGS (type
),
1680 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1682 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1684 const char *name
= type_name_no_tag (type
);
1685 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1686 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1687 as appropriate? (this code was written before TYPE_NAME and
1688 TYPE_TAG_NAME were separate). */
1693 stub_noname_complaint ();
1694 return make_qualified_type (type
, instance_flags
, NULL
);
1696 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1699 /* Same as above for opaque types, we can replace the stub
1700 with the complete type only if they are in the same
1702 if (TYPE_OBJFILE (SYMBOL_TYPE(sym
)) == TYPE_OBJFILE (type
))
1703 type
= make_qualified_type (SYMBOL_TYPE (sym
),
1704 TYPE_INSTANCE_FLAGS (type
),
1707 type
= SYMBOL_TYPE (sym
);
1711 if (TYPE_TARGET_STUB (type
))
1713 struct type
*range_type
;
1714 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1716 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1718 /* Nothing we can do. */
1720 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1721 && TYPE_NFIELDS (type
) == 1
1722 && (TYPE_CODE (range_type
= TYPE_INDEX_TYPE (type
))
1723 == TYPE_CODE_RANGE
))
1725 /* Now recompute the length of the array type, based on its
1726 number of elements and the target type's length.
1727 Watch out for Ada null Ada arrays where the high bound
1728 is smaller than the low bound. */
1729 const LONGEST low_bound
= TYPE_LOW_BOUND (range_type
);
1730 const LONGEST high_bound
= TYPE_HIGH_BOUND (range_type
);
1733 if (high_bound
< low_bound
)
1737 /* For now, we conservatively take the array length to be 0
1738 if its length exceeds UINT_MAX. The code below assumes
1739 that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
1740 which is technically not guaranteed by C, but is usually true
1741 (because it would be true if x were unsigned with its
1742 high-order bit on). It uses the fact that
1743 high_bound-low_bound is always representable in
1744 ULONGEST and that if high_bound-low_bound+1 overflows,
1745 it overflows to 0. We must change these tests if we
1746 decide to increase the representation of TYPE_LENGTH
1747 from unsigned int to ULONGEST. */
1748 ULONGEST ulow
= low_bound
, uhigh
= high_bound
;
1749 ULONGEST tlen
= TYPE_LENGTH (target_type
);
1751 len
= tlen
* (uhigh
- ulow
+ 1);
1752 if (tlen
== 0 || (len
/ tlen
- 1 + ulow
) != uhigh
1756 TYPE_LENGTH (type
) = len
;
1757 TYPE_TARGET_STUB (type
) = 0;
1759 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1761 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1762 TYPE_TARGET_STUB (type
) = 0;
1766 type
= make_qualified_type (type
, instance_flags
, NULL
);
1768 /* Cache TYPE_LENGTH for future use. */
1769 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1774 /* Parse a type expression in the string [P..P+LENGTH). If an error
1775 occurs, silently return a void type. */
1777 static struct type
*
1778 safe_parse_type (struct gdbarch
*gdbarch
, char *p
, int length
)
1780 struct ui_file
*saved_gdb_stderr
;
1781 struct type
*type
= NULL
; /* Initialize to keep gcc happy. */
1782 volatile struct gdb_exception except
;
1784 /* Suppress error messages. */
1785 saved_gdb_stderr
= gdb_stderr
;
1786 gdb_stderr
= ui_file_new ();
1788 /* Call parse_and_eval_type() without fear of longjmp()s. */
1789 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1791 type
= parse_and_eval_type (p
, length
);
1794 if (except
.reason
< 0)
1795 type
= builtin_type (gdbarch
)->builtin_void
;
1797 /* Stop suppressing error messages. */
1798 ui_file_delete (gdb_stderr
);
1799 gdb_stderr
= saved_gdb_stderr
;
1804 /* Ugly hack to convert method stubs into method types.
1806 He ain't kiddin'. This demangles the name of the method into a
1807 string including argument types, parses out each argument type,
1808 generates a string casting a zero to that type, evaluates the
1809 string, and stuffs the resulting type into an argtype vector!!!
1810 Then it knows the type of the whole function (including argument
1811 types for overloading), which info used to be in the stab's but was
1812 removed to hack back the space required for them. */
1815 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1817 struct gdbarch
*gdbarch
= get_type_arch (type
);
1819 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1820 char *demangled_name
= gdb_demangle (mangled_name
,
1821 DMGL_PARAMS
| DMGL_ANSI
);
1822 char *argtypetext
, *p
;
1823 int depth
= 0, argcount
= 1;
1824 struct field
*argtypes
;
1827 /* Make sure we got back a function string that we can use. */
1829 p
= strchr (demangled_name
, '(');
1833 if (demangled_name
== NULL
|| p
== NULL
)
1834 error (_("Internal: Cannot demangle mangled name `%s'."),
1837 /* Now, read in the parameters that define this type. */
1842 if (*p
== '(' || *p
== '<')
1846 else if (*p
== ')' || *p
== '>')
1850 else if (*p
== ',' && depth
== 0)
1858 /* If we read one argument and it was ``void'', don't count it. */
1859 if (strncmp (argtypetext
, "(void)", 6) == 0)
1862 /* We need one extra slot, for the THIS pointer. */
1864 argtypes
= (struct field
*)
1865 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
1868 /* Add THIS pointer for non-static methods. */
1869 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1870 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
1874 argtypes
[0].type
= lookup_pointer_type (type
);
1878 if (*p
!= ')') /* () means no args, skip while. */
1883 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1885 /* Avoid parsing of ellipsis, they will be handled below.
1886 Also avoid ``void'' as above. */
1887 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
1888 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
1890 argtypes
[argcount
].type
=
1891 safe_parse_type (gdbarch
, argtypetext
, p
- argtypetext
);
1894 argtypetext
= p
+ 1;
1897 if (*p
== '(' || *p
== '<')
1901 else if (*p
== ')' || *p
== '>')
1910 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1912 /* Now update the old "stub" type into a real type. */
1913 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1914 TYPE_DOMAIN_TYPE (mtype
) = type
;
1915 TYPE_FIELDS (mtype
) = argtypes
;
1916 TYPE_NFIELDS (mtype
) = argcount
;
1917 TYPE_STUB (mtype
) = 0;
1918 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1920 TYPE_VARARGS (mtype
) = 1;
1922 xfree (demangled_name
);
1925 /* This is the external interface to check_stub_method, above. This
1926 function unstubs all of the signatures for TYPE's METHOD_ID method
1927 name. After calling this function TYPE_FN_FIELD_STUB will be
1928 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1931 This function unfortunately can not die until stabs do. */
1934 check_stub_method_group (struct type
*type
, int method_id
)
1936 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
1937 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1938 int j
, found_stub
= 0;
1940 for (j
= 0; j
< len
; j
++)
1941 if (TYPE_FN_FIELD_STUB (f
, j
))
1944 check_stub_method (type
, method_id
, j
);
1947 /* GNU v3 methods with incorrect names were corrected when we read
1948 in type information, because it was cheaper to do it then. The
1949 only GNU v2 methods with incorrect method names are operators and
1950 destructors; destructors were also corrected when we read in type
1953 Therefore the only thing we need to handle here are v2 operator
1955 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
1958 char dem_opname
[256];
1960 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1962 dem_opname
, DMGL_ANSI
);
1964 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1968 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
1972 /* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */
1973 const struct cplus_struct_type cplus_struct_default
= { };
1976 allocate_cplus_struct_type (struct type
*type
)
1978 if (HAVE_CPLUS_STRUCT (type
))
1979 /* Structure was already allocated. Nothing more to do. */
1982 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_CPLUS_STUFF
;
1983 TYPE_RAW_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1984 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1985 *(TYPE_RAW_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1988 const struct gnat_aux_type gnat_aux_default
=
1991 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
1992 and allocate the associated gnat-specific data. The gnat-specific
1993 data is also initialized to gnat_aux_default. */
1996 allocate_gnat_aux_type (struct type
*type
)
1998 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_GNAT_STUFF
;
1999 TYPE_GNAT_SPECIFIC (type
) = (struct gnat_aux_type
*)
2000 TYPE_ALLOC (type
, sizeof (struct gnat_aux_type
));
2001 *(TYPE_GNAT_SPECIFIC (type
)) = gnat_aux_default
;
2004 /* Helper function to initialize the standard scalar types.
2006 If NAME is non-NULL, then it is used to initialize the type name.
2007 Note that NAME is not copied; it is required to have a lifetime at
2008 least as long as OBJFILE. */
2011 init_type (enum type_code code
, int length
, int flags
,
2012 const char *name
, struct objfile
*objfile
)
2016 type
= alloc_type (objfile
);
2017 TYPE_CODE (type
) = code
;
2018 TYPE_LENGTH (type
) = length
;
2020 gdb_assert (!(flags
& (TYPE_FLAG_MIN
- 1)));
2021 if (flags
& TYPE_FLAG_UNSIGNED
)
2022 TYPE_UNSIGNED (type
) = 1;
2023 if (flags
& TYPE_FLAG_NOSIGN
)
2024 TYPE_NOSIGN (type
) = 1;
2025 if (flags
& TYPE_FLAG_STUB
)
2026 TYPE_STUB (type
) = 1;
2027 if (flags
& TYPE_FLAG_TARGET_STUB
)
2028 TYPE_TARGET_STUB (type
) = 1;
2029 if (flags
& TYPE_FLAG_STATIC
)
2030 TYPE_STATIC (type
) = 1;
2031 if (flags
& TYPE_FLAG_PROTOTYPED
)
2032 TYPE_PROTOTYPED (type
) = 1;
2033 if (flags
& TYPE_FLAG_INCOMPLETE
)
2034 TYPE_INCOMPLETE (type
) = 1;
2035 if (flags
& TYPE_FLAG_VARARGS
)
2036 TYPE_VARARGS (type
) = 1;
2037 if (flags
& TYPE_FLAG_VECTOR
)
2038 TYPE_VECTOR (type
) = 1;
2039 if (flags
& TYPE_FLAG_STUB_SUPPORTED
)
2040 TYPE_STUB_SUPPORTED (type
) = 1;
2041 if (flags
& TYPE_FLAG_FIXED_INSTANCE
)
2042 TYPE_FIXED_INSTANCE (type
) = 1;
2043 if (flags
& TYPE_FLAG_GNU_IFUNC
)
2044 TYPE_GNU_IFUNC (type
) = 1;
2046 TYPE_NAME (type
) = name
;
2050 if (name
&& strcmp (name
, "char") == 0)
2051 TYPE_NOSIGN (type
) = 1;
2055 case TYPE_CODE_STRUCT
:
2056 case TYPE_CODE_UNION
:
2057 case TYPE_CODE_NAMESPACE
:
2058 INIT_CPLUS_SPECIFIC (type
);
2061 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_FLOATFORMAT
;
2063 case TYPE_CODE_FUNC
:
2064 INIT_FUNC_SPECIFIC (type
);
2070 /* Queries on types. */
2073 can_dereference (struct type
*t
)
2075 /* FIXME: Should we return true for references as well as
2080 && TYPE_CODE (t
) == TYPE_CODE_PTR
2081 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
2085 is_integral_type (struct type
*t
)
2090 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
2091 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
2092 || (TYPE_CODE (t
) == TYPE_CODE_FLAGS
)
2093 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
2094 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
2095 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
2098 /* Return true if TYPE is scalar. */
2101 is_scalar_type (struct type
*type
)
2103 CHECK_TYPEDEF (type
);
2105 switch (TYPE_CODE (type
))
2107 case TYPE_CODE_ARRAY
:
2108 case TYPE_CODE_STRUCT
:
2109 case TYPE_CODE_UNION
:
2111 case TYPE_CODE_STRING
:
2118 /* Return true if T is scalar, or a composite type which in practice has
2119 the memory layout of a scalar type. E.g., an array or struct with only
2120 one scalar element inside it, or a union with only scalar elements. */
2123 is_scalar_type_recursive (struct type
*t
)
2127 if (is_scalar_type (t
))
2129 /* Are we dealing with an array or string of known dimensions? */
2130 else if ((TYPE_CODE (t
) == TYPE_CODE_ARRAY
2131 || TYPE_CODE (t
) == TYPE_CODE_STRING
) && TYPE_NFIELDS (t
) == 1
2132 && TYPE_CODE (TYPE_INDEX_TYPE (t
)) == TYPE_CODE_RANGE
)
2134 LONGEST low_bound
, high_bound
;
2135 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (t
));
2137 get_discrete_bounds (TYPE_INDEX_TYPE (t
), &low_bound
, &high_bound
);
2139 return high_bound
== low_bound
&& is_scalar_type_recursive (elt_type
);
2141 /* Are we dealing with a struct with one element? */
2142 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
&& TYPE_NFIELDS (t
) == 1)
2143 return is_scalar_type_recursive (TYPE_FIELD_TYPE (t
, 0));
2144 else if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
2146 int i
, n
= TYPE_NFIELDS (t
);
2148 /* If all elements of the union are scalar, then the union is scalar. */
2149 for (i
= 0; i
< n
; i
++)
2150 if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t
, i
)))
2159 /* A helper function which returns true if types A and B represent the
2160 "same" class type. This is true if the types have the same main
2161 type, or the same name. */
2164 class_types_same_p (const struct type
*a
, const struct type
*b
)
2166 return (TYPE_MAIN_TYPE (a
) == TYPE_MAIN_TYPE (b
)
2167 || (TYPE_NAME (a
) && TYPE_NAME (b
)
2168 && !strcmp (TYPE_NAME (a
), TYPE_NAME (b
))));
2171 /* If BASE is an ancestor of DCLASS return the distance between them.
2172 otherwise return -1;
2176 class B: public A {};
2177 class C: public B {};
2180 distance_to_ancestor (A, A, 0) = 0
2181 distance_to_ancestor (A, B, 0) = 1
2182 distance_to_ancestor (A, C, 0) = 2
2183 distance_to_ancestor (A, D, 0) = 3
2185 If PUBLIC is 1 then only public ancestors are considered,
2186 and the function returns the distance only if BASE is a public ancestor
2190 distance_to_ancestor (A, D, 1) = -1. */
2193 distance_to_ancestor (struct type
*base
, struct type
*dclass
, int public)
2198 CHECK_TYPEDEF (base
);
2199 CHECK_TYPEDEF (dclass
);
2201 if (class_types_same_p (base
, dclass
))
2204 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2206 if (public && ! BASETYPE_VIA_PUBLIC (dclass
, i
))
2209 d
= distance_to_ancestor (base
, TYPE_BASECLASS (dclass
, i
), public);
2217 /* Check whether BASE is an ancestor or base class or DCLASS
2218 Return 1 if so, and 0 if not.
2219 Note: If BASE and DCLASS are of the same type, this function
2220 will return 1. So for some class A, is_ancestor (A, A) will
2224 is_ancestor (struct type
*base
, struct type
*dclass
)
2226 return distance_to_ancestor (base
, dclass
, 0) >= 0;
2229 /* Like is_ancestor, but only returns true when BASE is a public
2230 ancestor of DCLASS. */
2233 is_public_ancestor (struct type
*base
, struct type
*dclass
)
2235 return distance_to_ancestor (base
, dclass
, 1) >= 0;
2238 /* A helper function for is_unique_ancestor. */
2241 is_unique_ancestor_worker (struct type
*base
, struct type
*dclass
,
2243 const gdb_byte
*valaddr
, int embedded_offset
,
2244 CORE_ADDR address
, struct value
*val
)
2248 CHECK_TYPEDEF (base
);
2249 CHECK_TYPEDEF (dclass
);
2251 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
) && count
< 2; ++i
)
2256 iter
= check_typedef (TYPE_BASECLASS (dclass
, i
));
2258 this_offset
= baseclass_offset (dclass
, i
, valaddr
, embedded_offset
,
2261 if (class_types_same_p (base
, iter
))
2263 /* If this is the first subclass, set *OFFSET and set count
2264 to 1. Otherwise, if this is at the same offset as
2265 previous instances, do nothing. Otherwise, increment
2269 *offset
= this_offset
;
2272 else if (this_offset
== *offset
)
2280 count
+= is_unique_ancestor_worker (base
, iter
, offset
,
2282 embedded_offset
+ this_offset
,
2289 /* Like is_ancestor, but only returns true if BASE is a unique base
2290 class of the type of VAL. */
2293 is_unique_ancestor (struct type
*base
, struct value
*val
)
2297 return is_unique_ancestor_worker (base
, value_type (val
), &offset
,
2298 value_contents_for_printing (val
),
2299 value_embedded_offset (val
),
2300 value_address (val
), val
) == 1;
2304 /* Overload resolution. */
2306 /* Return the sum of the rank of A with the rank of B. */
2309 sum_ranks (struct rank a
, struct rank b
)
2312 c
.rank
= a
.rank
+ b
.rank
;
2313 c
.subrank
= a
.subrank
+ b
.subrank
;
2317 /* Compare rank A and B and return:
2319 1 if a is better than b
2320 -1 if b is better than a. */
2323 compare_ranks (struct rank a
, struct rank b
)
2325 if (a
.rank
== b
.rank
)
2327 if (a
.subrank
== b
.subrank
)
2329 if (a
.subrank
< b
.subrank
)
2331 if (a
.subrank
> b
.subrank
)
2335 if (a
.rank
< b
.rank
)
2338 /* a.rank > b.rank */
2342 /* Functions for overload resolution begin here. */
2344 /* Compare two badness vectors A and B and return the result.
2345 0 => A and B are identical
2346 1 => A and B are incomparable
2347 2 => A is better than B
2348 3 => A is worse than B */
2351 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
2355 short found_pos
= 0; /* any positives in c? */
2356 short found_neg
= 0; /* any negatives in c? */
2358 /* differing lengths => incomparable */
2359 if (a
->length
!= b
->length
)
2362 /* Subtract b from a */
2363 for (i
= 0; i
< a
->length
; i
++)
2365 tmp
= compare_ranks (b
->rank
[i
], a
->rank
[i
]);
2375 return 1; /* incomparable */
2377 return 3; /* A > B */
2383 return 2; /* A < B */
2385 return 0; /* A == B */
2389 /* Rank a function by comparing its parameter types (PARMS, length
2390 NPARMS), to the types of an argument list (ARGS, length NARGS).
2391 Return a pointer to a badness vector. This has NARGS + 1
2394 struct badness_vector
*
2395 rank_function (struct type
**parms
, int nparms
,
2396 struct value
**args
, int nargs
)
2399 struct badness_vector
*bv
;
2400 int min_len
= nparms
< nargs
? nparms
: nargs
;
2402 bv
= xmalloc (sizeof (struct badness_vector
));
2403 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank. */
2404 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
2406 /* First compare the lengths of the supplied lists.
2407 If there is a mismatch, set it to a high value. */
2409 /* pai/1997-06-03 FIXME: when we have debug info about default
2410 arguments and ellipsis parameter lists, we should consider those
2411 and rank the length-match more finely. */
2413 LENGTH_MATCH (bv
) = (nargs
!= nparms
)
2414 ? LENGTH_MISMATCH_BADNESS
2415 : EXACT_MATCH_BADNESS
;
2417 /* Now rank all the parameters of the candidate function. */
2418 for (i
= 1; i
<= min_len
; i
++)
2419 bv
->rank
[i
] = rank_one_type (parms
[i
- 1], value_type (args
[i
- 1]),
2422 /* If more arguments than parameters, add dummy entries. */
2423 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2424 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2429 /* Compare the names of two integer types, assuming that any sign
2430 qualifiers have been checked already. We do it this way because
2431 there may be an "int" in the name of one of the types. */
2434 integer_types_same_name_p (const char *first
, const char *second
)
2436 int first_p
, second_p
;
2438 /* If both are shorts, return 1; if neither is a short, keep
2440 first_p
= (strstr (first
, "short") != NULL
);
2441 second_p
= (strstr (second
, "short") != NULL
);
2442 if (first_p
&& second_p
)
2444 if (first_p
|| second_p
)
2447 /* Likewise for long. */
2448 first_p
= (strstr (first
, "long") != NULL
);
2449 second_p
= (strstr (second
, "long") != NULL
);
2450 if (first_p
&& second_p
)
2452 if (first_p
|| second_p
)
2455 /* Likewise for char. */
2456 first_p
= (strstr (first
, "char") != NULL
);
2457 second_p
= (strstr (second
, "char") != NULL
);
2458 if (first_p
&& second_p
)
2460 if (first_p
|| second_p
)
2463 /* They must both be ints. */
2467 /* Compares type A to type B returns 1 if the represent the same type
2471 types_equal (struct type
*a
, struct type
*b
)
2473 /* Identical type pointers. */
2474 /* However, this still doesn't catch all cases of same type for b
2475 and a. The reason is that builtin types are different from
2476 the same ones constructed from the object. */
2480 /* Resolve typedefs */
2481 if (TYPE_CODE (a
) == TYPE_CODE_TYPEDEF
)
2482 a
= check_typedef (a
);
2483 if (TYPE_CODE (b
) == TYPE_CODE_TYPEDEF
)
2484 b
= check_typedef (b
);
2486 /* If after resolving typedefs a and b are not of the same type
2487 code then they are not equal. */
2488 if (TYPE_CODE (a
) != TYPE_CODE (b
))
2491 /* If a and b are both pointers types or both reference types then
2492 they are equal of the same type iff the objects they refer to are
2493 of the same type. */
2494 if (TYPE_CODE (a
) == TYPE_CODE_PTR
2495 || TYPE_CODE (a
) == TYPE_CODE_REF
)
2496 return types_equal (TYPE_TARGET_TYPE (a
),
2497 TYPE_TARGET_TYPE (b
));
2499 /* Well, damnit, if the names are exactly the same, I'll say they
2500 are exactly the same. This happens when we generate method
2501 stubs. The types won't point to the same address, but they
2502 really are the same. */
2504 if (TYPE_NAME (a
) && TYPE_NAME (b
)
2505 && strcmp (TYPE_NAME (a
), TYPE_NAME (b
)) == 0)
2508 /* Check if identical after resolving typedefs. */
2512 /* Two function types are equal if their argument and return types
2514 if (TYPE_CODE (a
) == TYPE_CODE_FUNC
)
2518 if (TYPE_NFIELDS (a
) != TYPE_NFIELDS (b
))
2521 if (!types_equal (TYPE_TARGET_TYPE (a
), TYPE_TARGET_TYPE (b
)))
2524 for (i
= 0; i
< TYPE_NFIELDS (a
); ++i
)
2525 if (!types_equal (TYPE_FIELD_TYPE (a
, i
), TYPE_FIELD_TYPE (b
, i
)))
2534 /* Deep comparison of types. */
2536 /* An entry in the type-equality bcache. */
2538 typedef struct type_equality_entry
2540 struct type
*type1
, *type2
;
2541 } type_equality_entry_d
;
2543 DEF_VEC_O (type_equality_entry_d
);
2545 /* A helper function to compare two strings. Returns 1 if they are
2546 the same, 0 otherwise. Handles NULLs properly. */
2549 compare_maybe_null_strings (const char *s
, const char *t
)
2551 if (s
== NULL
&& t
!= NULL
)
2553 else if (s
!= NULL
&& t
== NULL
)
2555 else if (s
== NULL
&& t
== NULL
)
2557 return strcmp (s
, t
) == 0;
2560 /* A helper function for check_types_worklist that checks two types for
2561 "deep" equality. Returns non-zero if the types are considered the
2562 same, zero otherwise. */
2565 check_types_equal (struct type
*type1
, struct type
*type2
,
2566 VEC (type_equality_entry_d
) **worklist
)
2568 CHECK_TYPEDEF (type1
);
2569 CHECK_TYPEDEF (type2
);
2574 if (TYPE_CODE (type1
) != TYPE_CODE (type2
)
2575 || TYPE_LENGTH (type1
) != TYPE_LENGTH (type2
)
2576 || TYPE_UNSIGNED (type1
) != TYPE_UNSIGNED (type2
)
2577 || TYPE_NOSIGN (type1
) != TYPE_NOSIGN (type2
)
2578 || TYPE_VARARGS (type1
) != TYPE_VARARGS (type2
)
2579 || TYPE_VECTOR (type1
) != TYPE_VECTOR (type2
)
2580 || TYPE_NOTTEXT (type1
) != TYPE_NOTTEXT (type2
)
2581 || TYPE_INSTANCE_FLAGS (type1
) != TYPE_INSTANCE_FLAGS (type2
)
2582 || TYPE_NFIELDS (type1
) != TYPE_NFIELDS (type2
))
2585 if (!compare_maybe_null_strings (TYPE_TAG_NAME (type1
),
2586 TYPE_TAG_NAME (type2
)))
2588 if (!compare_maybe_null_strings (TYPE_NAME (type1
), TYPE_NAME (type2
)))
2591 if (TYPE_CODE (type1
) == TYPE_CODE_RANGE
)
2593 if (memcmp (TYPE_RANGE_DATA (type1
), TYPE_RANGE_DATA (type2
),
2594 sizeof (*TYPE_RANGE_DATA (type1
))) != 0)
2601 for (i
= 0; i
< TYPE_NFIELDS (type1
); ++i
)
2603 const struct field
*field1
= &TYPE_FIELD (type1
, i
);
2604 const struct field
*field2
= &TYPE_FIELD (type2
, i
);
2605 struct type_equality_entry entry
;
2607 if (FIELD_ARTIFICIAL (*field1
) != FIELD_ARTIFICIAL (*field2
)
2608 || FIELD_BITSIZE (*field1
) != FIELD_BITSIZE (*field2
)
2609 || FIELD_LOC_KIND (*field1
) != FIELD_LOC_KIND (*field2
))
2611 if (!compare_maybe_null_strings (FIELD_NAME (*field1
),
2612 FIELD_NAME (*field2
)))
2614 switch (FIELD_LOC_KIND (*field1
))
2616 case FIELD_LOC_KIND_BITPOS
:
2617 if (FIELD_BITPOS (*field1
) != FIELD_BITPOS (*field2
))
2620 case FIELD_LOC_KIND_ENUMVAL
:
2621 if (FIELD_ENUMVAL (*field1
) != FIELD_ENUMVAL (*field2
))
2624 case FIELD_LOC_KIND_PHYSADDR
:
2625 if (FIELD_STATIC_PHYSADDR (*field1
)
2626 != FIELD_STATIC_PHYSADDR (*field2
))
2629 case FIELD_LOC_KIND_PHYSNAME
:
2630 if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1
),
2631 FIELD_STATIC_PHYSNAME (*field2
)))
2634 case FIELD_LOC_KIND_DWARF_BLOCK
:
2636 struct dwarf2_locexpr_baton
*block1
, *block2
;
2638 block1
= FIELD_DWARF_BLOCK (*field1
);
2639 block2
= FIELD_DWARF_BLOCK (*field2
);
2640 if (block1
->per_cu
!= block2
->per_cu
2641 || block1
->size
!= block2
->size
2642 || memcmp (block1
->data
, block2
->data
, block1
->size
) != 0)
2647 internal_error (__FILE__
, __LINE__
, _("Unsupported field kind "
2648 "%d by check_types_equal"),
2649 FIELD_LOC_KIND (*field1
));
2652 entry
.type1
= FIELD_TYPE (*field1
);
2653 entry
.type2
= FIELD_TYPE (*field2
);
2654 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
2658 if (TYPE_TARGET_TYPE (type1
) != NULL
)
2660 struct type_equality_entry entry
;
2662 if (TYPE_TARGET_TYPE (type2
) == NULL
)
2665 entry
.type1
= TYPE_TARGET_TYPE (type1
);
2666 entry
.type2
= TYPE_TARGET_TYPE (type2
);
2667 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
2669 else if (TYPE_TARGET_TYPE (type2
) != NULL
)
2675 /* Check types on a worklist for equality. Returns zero if any pair
2676 is not equal, non-zero if they are all considered equal. */
2679 check_types_worklist (VEC (type_equality_entry_d
) **worklist
,
2680 struct bcache
*cache
)
2682 while (!VEC_empty (type_equality_entry_d
, *worklist
))
2684 struct type_equality_entry entry
;
2687 entry
= *VEC_last (type_equality_entry_d
, *worklist
);
2688 VEC_pop (type_equality_entry_d
, *worklist
);
2690 /* If the type pair has already been visited, we know it is
2692 bcache_full (&entry
, sizeof (entry
), cache
, &added
);
2696 if (check_types_equal (entry
.type1
, entry
.type2
, worklist
) == 0)
2703 /* Return non-zero if types TYPE1 and TYPE2 are equal, as determined by a
2704 "deep comparison". Otherwise return zero. */
2707 types_deeply_equal (struct type
*type1
, struct type
*type2
)
2709 volatile struct gdb_exception except
;
2711 struct bcache
*cache
;
2712 VEC (type_equality_entry_d
) *worklist
= NULL
;
2713 struct type_equality_entry entry
;
2715 gdb_assert (type1
!= NULL
&& type2
!= NULL
);
2717 /* Early exit for the simple case. */
2721 cache
= bcache_xmalloc (NULL
, NULL
);
2723 entry
.type1
= type1
;
2724 entry
.type2
= type2
;
2725 VEC_safe_push (type_equality_entry_d
, worklist
, &entry
);
2727 TRY_CATCH (except
, RETURN_MASK_ALL
)
2729 result
= check_types_worklist (&worklist
, cache
);
2731 /* check_types_worklist calls several nested helper functions,
2732 some of which can raise a GDB Exception, so we just check
2733 and rethrow here. If there is a GDB exception, a comparison
2734 is not capable (or trusted), so exit. */
2735 bcache_xfree (cache
);
2736 VEC_free (type_equality_entry_d
, worklist
);
2737 /* Rethrow if there was a problem. */
2738 if (except
.reason
< 0)
2739 throw_exception (except
);
2744 /* Compare one type (PARM) for compatibility with another (ARG).
2745 * PARM is intended to be the parameter type of a function; and
2746 * ARG is the supplied argument's type. This function tests if
2747 * the latter can be converted to the former.
2748 * VALUE is the argument's value or NULL if none (or called recursively)
2750 * Return 0 if they are identical types;
2751 * Otherwise, return an integer which corresponds to how compatible
2752 * PARM is to ARG. The higher the return value, the worse the match.
2753 * Generally the "bad" conversions are all uniformly assigned a 100. */
2756 rank_one_type (struct type
*parm
, struct type
*arg
, struct value
*value
)
2758 struct rank rank
= {0,0};
2760 if (types_equal (parm
, arg
))
2761 return EXACT_MATCH_BADNESS
;
2763 /* Resolve typedefs */
2764 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2765 parm
= check_typedef (parm
);
2766 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2767 arg
= check_typedef (arg
);
2769 /* See through references, since we can almost make non-references
2771 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2772 return (sum_ranks (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
),
2773 REFERENCE_CONVERSION_BADNESS
));
2774 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2775 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
),
2776 REFERENCE_CONVERSION_BADNESS
));
2778 /* Debugging only. */
2779 fprintf_filtered (gdb_stderr
,
2780 "------ Arg is %s [%d], parm is %s [%d]\n",
2781 TYPE_NAME (arg
), TYPE_CODE (arg
),
2782 TYPE_NAME (parm
), TYPE_CODE (parm
));
2784 /* x -> y means arg of type x being supplied for parameter of type y. */
2786 switch (TYPE_CODE (parm
))
2789 switch (TYPE_CODE (arg
))
2793 /* Allowed pointer conversions are:
2794 (a) pointer to void-pointer conversion. */
2795 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2796 return VOID_PTR_CONVERSION_BADNESS
;
2798 /* (b) pointer to ancestor-pointer conversion. */
2799 rank
.subrank
= distance_to_ancestor (TYPE_TARGET_TYPE (parm
),
2800 TYPE_TARGET_TYPE (arg
),
2802 if (rank
.subrank
>= 0)
2803 return sum_ranks (BASE_PTR_CONVERSION_BADNESS
, rank
);
2805 return INCOMPATIBLE_TYPE_BADNESS
;
2806 case TYPE_CODE_ARRAY
:
2807 if (types_equal (TYPE_TARGET_TYPE (parm
),
2808 TYPE_TARGET_TYPE (arg
)))
2809 return EXACT_MATCH_BADNESS
;
2810 return INCOMPATIBLE_TYPE_BADNESS
;
2811 case TYPE_CODE_FUNC
:
2812 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
);
2814 if (value
!= NULL
&& TYPE_CODE (value_type (value
)) == TYPE_CODE_INT
)
2816 if (value_as_long (value
) == 0)
2818 /* Null pointer conversion: allow it to be cast to a pointer.
2819 [4.10.1 of C++ standard draft n3290] */
2820 return NULL_POINTER_CONVERSION_BADNESS
;
2824 /* If type checking is disabled, allow the conversion. */
2825 if (!strict_type_checking
)
2826 return NS_INTEGER_POINTER_CONVERSION_BADNESS
;
2830 case TYPE_CODE_ENUM
:
2831 case TYPE_CODE_FLAGS
:
2832 case TYPE_CODE_CHAR
:
2833 case TYPE_CODE_RANGE
:
2834 case TYPE_CODE_BOOL
:
2836 return INCOMPATIBLE_TYPE_BADNESS
;
2838 case TYPE_CODE_ARRAY
:
2839 switch (TYPE_CODE (arg
))
2842 case TYPE_CODE_ARRAY
:
2843 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2844 TYPE_TARGET_TYPE (arg
), NULL
);
2846 return INCOMPATIBLE_TYPE_BADNESS
;
2848 case TYPE_CODE_FUNC
:
2849 switch (TYPE_CODE (arg
))
2851 case TYPE_CODE_PTR
: /* funcptr -> func */
2852 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
);
2854 return INCOMPATIBLE_TYPE_BADNESS
;
2857 switch (TYPE_CODE (arg
))
2860 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2862 /* Deal with signed, unsigned, and plain chars and
2863 signed and unsigned ints. */
2864 if (TYPE_NOSIGN (parm
))
2866 /* This case only for character types. */
2867 if (TYPE_NOSIGN (arg
))
2868 return EXACT_MATCH_BADNESS
; /* plain char -> plain char */
2869 else /* signed/unsigned char -> plain char */
2870 return INTEGER_CONVERSION_BADNESS
;
2872 else if (TYPE_UNSIGNED (parm
))
2874 if (TYPE_UNSIGNED (arg
))
2876 /* unsigned int -> unsigned int, or
2877 unsigned long -> unsigned long */
2878 if (integer_types_same_name_p (TYPE_NAME (parm
),
2880 return EXACT_MATCH_BADNESS
;
2881 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2883 && integer_types_same_name_p (TYPE_NAME (parm
),
2885 /* unsigned int -> unsigned long */
2886 return INTEGER_PROMOTION_BADNESS
;
2888 /* unsigned long -> unsigned int */
2889 return INTEGER_CONVERSION_BADNESS
;
2893 if (integer_types_same_name_p (TYPE_NAME (arg
),
2895 && integer_types_same_name_p (TYPE_NAME (parm
),
2897 /* signed long -> unsigned int */
2898 return INTEGER_CONVERSION_BADNESS
;
2900 /* signed int/long -> unsigned int/long */
2901 return INTEGER_CONVERSION_BADNESS
;
2904 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2906 if (integer_types_same_name_p (TYPE_NAME (parm
),
2908 return EXACT_MATCH_BADNESS
;
2909 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2911 && integer_types_same_name_p (TYPE_NAME (parm
),
2913 return INTEGER_PROMOTION_BADNESS
;
2915 return INTEGER_CONVERSION_BADNESS
;
2918 return INTEGER_CONVERSION_BADNESS
;
2920 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2921 return INTEGER_PROMOTION_BADNESS
;
2923 return INTEGER_CONVERSION_BADNESS
;
2924 case TYPE_CODE_ENUM
:
2925 case TYPE_CODE_FLAGS
:
2926 case TYPE_CODE_CHAR
:
2927 case TYPE_CODE_RANGE
:
2928 case TYPE_CODE_BOOL
:
2929 return INTEGER_PROMOTION_BADNESS
;
2931 return INT_FLOAT_CONVERSION_BADNESS
;
2933 return NS_POINTER_CONVERSION_BADNESS
;
2935 return INCOMPATIBLE_TYPE_BADNESS
;
2938 case TYPE_CODE_ENUM
:
2939 switch (TYPE_CODE (arg
))
2942 case TYPE_CODE_CHAR
:
2943 case TYPE_CODE_RANGE
:
2944 case TYPE_CODE_BOOL
:
2945 case TYPE_CODE_ENUM
:
2946 return INTEGER_CONVERSION_BADNESS
;
2948 return INT_FLOAT_CONVERSION_BADNESS
;
2950 return INCOMPATIBLE_TYPE_BADNESS
;
2953 case TYPE_CODE_CHAR
:
2954 switch (TYPE_CODE (arg
))
2956 case TYPE_CODE_RANGE
:
2957 case TYPE_CODE_BOOL
:
2958 case TYPE_CODE_ENUM
:
2959 return INTEGER_CONVERSION_BADNESS
;
2961 return INT_FLOAT_CONVERSION_BADNESS
;
2963 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2964 return INTEGER_CONVERSION_BADNESS
;
2965 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2966 return INTEGER_PROMOTION_BADNESS
;
2967 /* >>> !! else fall through !! <<< */
2968 case TYPE_CODE_CHAR
:
2969 /* Deal with signed, unsigned, and plain chars for C++ and
2970 with int cases falling through from previous case. */
2971 if (TYPE_NOSIGN (parm
))
2973 if (TYPE_NOSIGN (arg
))
2974 return EXACT_MATCH_BADNESS
;
2976 return INTEGER_CONVERSION_BADNESS
;
2978 else if (TYPE_UNSIGNED (parm
))
2980 if (TYPE_UNSIGNED (arg
))
2981 return EXACT_MATCH_BADNESS
;
2983 return INTEGER_PROMOTION_BADNESS
;
2985 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2986 return EXACT_MATCH_BADNESS
;
2988 return INTEGER_CONVERSION_BADNESS
;
2990 return INCOMPATIBLE_TYPE_BADNESS
;
2993 case TYPE_CODE_RANGE
:
2994 switch (TYPE_CODE (arg
))
2997 case TYPE_CODE_CHAR
:
2998 case TYPE_CODE_RANGE
:
2999 case TYPE_CODE_BOOL
:
3000 case TYPE_CODE_ENUM
:
3001 return INTEGER_CONVERSION_BADNESS
;
3003 return INT_FLOAT_CONVERSION_BADNESS
;
3005 return INCOMPATIBLE_TYPE_BADNESS
;
3008 case TYPE_CODE_BOOL
:
3009 switch (TYPE_CODE (arg
))
3011 /* n3290 draft, section 4.12.1 (conv.bool):
3013 "A prvalue of arithmetic, unscoped enumeration, pointer, or
3014 pointer to member type can be converted to a prvalue of type
3015 bool. A zero value, null pointer value, or null member pointer
3016 value is converted to false; any other value is converted to
3017 true. A prvalue of type std::nullptr_t can be converted to a
3018 prvalue of type bool; the resulting value is false." */
3020 case TYPE_CODE_CHAR
:
3021 case TYPE_CODE_ENUM
:
3023 case TYPE_CODE_MEMBERPTR
:
3025 return BOOL_CONVERSION_BADNESS
;
3026 case TYPE_CODE_RANGE
:
3027 return INCOMPATIBLE_TYPE_BADNESS
;
3028 case TYPE_CODE_BOOL
:
3029 return EXACT_MATCH_BADNESS
;
3031 return INCOMPATIBLE_TYPE_BADNESS
;
3035 switch (TYPE_CODE (arg
))
3038 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
3039 return FLOAT_PROMOTION_BADNESS
;
3040 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
3041 return EXACT_MATCH_BADNESS
;
3043 return FLOAT_CONVERSION_BADNESS
;
3045 case TYPE_CODE_BOOL
:
3046 case TYPE_CODE_ENUM
:
3047 case TYPE_CODE_RANGE
:
3048 case TYPE_CODE_CHAR
:
3049 return INT_FLOAT_CONVERSION_BADNESS
;
3051 return INCOMPATIBLE_TYPE_BADNESS
;
3054 case TYPE_CODE_COMPLEX
:
3055 switch (TYPE_CODE (arg
))
3056 { /* Strictly not needed for C++, but... */
3058 return FLOAT_PROMOTION_BADNESS
;
3059 case TYPE_CODE_COMPLEX
:
3060 return EXACT_MATCH_BADNESS
;
3062 return INCOMPATIBLE_TYPE_BADNESS
;
3065 case TYPE_CODE_STRUCT
:
3066 /* currently same as TYPE_CODE_CLASS. */
3067 switch (TYPE_CODE (arg
))
3069 case TYPE_CODE_STRUCT
:
3070 /* Check for derivation */
3071 rank
.subrank
= distance_to_ancestor (parm
, arg
, 0);
3072 if (rank
.subrank
>= 0)
3073 return sum_ranks (BASE_CONVERSION_BADNESS
, rank
);
3074 /* else fall through */
3076 return INCOMPATIBLE_TYPE_BADNESS
;
3079 case TYPE_CODE_UNION
:
3080 switch (TYPE_CODE (arg
))
3082 case TYPE_CODE_UNION
:
3084 return INCOMPATIBLE_TYPE_BADNESS
;
3087 case TYPE_CODE_MEMBERPTR
:
3088 switch (TYPE_CODE (arg
))
3091 return INCOMPATIBLE_TYPE_BADNESS
;
3094 case TYPE_CODE_METHOD
:
3095 switch (TYPE_CODE (arg
))
3099 return INCOMPATIBLE_TYPE_BADNESS
;
3103 switch (TYPE_CODE (arg
))
3107 return INCOMPATIBLE_TYPE_BADNESS
;
3112 switch (TYPE_CODE (arg
))
3116 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0),
3117 TYPE_FIELD_TYPE (arg
, 0), NULL
);
3119 return INCOMPATIBLE_TYPE_BADNESS
;
3122 case TYPE_CODE_VOID
:
3124 return INCOMPATIBLE_TYPE_BADNESS
;
3125 } /* switch (TYPE_CODE (arg)) */
3128 /* End of functions for overload resolution. */
3130 /* Routines to pretty-print types. */
3133 print_bit_vector (B_TYPE
*bits
, int nbits
)
3137 for (bitno
= 0; bitno
< nbits
; bitno
++)
3139 if ((bitno
% 8) == 0)
3141 puts_filtered (" ");
3143 if (B_TST (bits
, bitno
))
3144 printf_filtered (("1"));
3146 printf_filtered (("0"));
3150 /* Note the first arg should be the "this" pointer, we may not want to
3151 include it since we may get into a infinitely recursive
3155 print_arg_types (struct field
*args
, int nargs
, int spaces
)
3161 for (i
= 0; i
< nargs
; i
++)
3162 recursive_dump_type (args
[i
].type
, spaces
+ 2);
3167 field_is_static (struct field
*f
)
3169 /* "static" fields are the fields whose location is not relative
3170 to the address of the enclosing struct. It would be nice to
3171 have a dedicated flag that would be set for static fields when
3172 the type is being created. But in practice, checking the field
3173 loc_kind should give us an accurate answer. */
3174 return (FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSNAME
3175 || FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSADDR
);
3179 dump_fn_fieldlists (struct type
*type
, int spaces
)
3185 printfi_filtered (spaces
, "fn_fieldlists ");
3186 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
3187 printf_filtered ("\n");
3188 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
3190 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
3191 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
3193 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
3194 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
3196 printf_filtered (_(") length %d\n"),
3197 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
3198 for (overload_idx
= 0;
3199 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
3202 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
3204 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
3205 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
3207 printf_filtered (")\n");
3208 printfi_filtered (spaces
+ 8, "type ");
3209 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
3211 printf_filtered ("\n");
3213 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
3216 printfi_filtered (spaces
+ 8, "args ");
3217 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
3219 printf_filtered ("\n");
3221 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
3222 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
,
3225 printfi_filtered (spaces
+ 8, "fcontext ");
3226 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
3228 printf_filtered ("\n");
3230 printfi_filtered (spaces
+ 8, "is_const %d\n",
3231 TYPE_FN_FIELD_CONST (f
, overload_idx
));
3232 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
3233 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
3234 printfi_filtered (spaces
+ 8, "is_private %d\n",
3235 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
3236 printfi_filtered (spaces
+ 8, "is_protected %d\n",
3237 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
3238 printfi_filtered (spaces
+ 8, "is_stub %d\n",
3239 TYPE_FN_FIELD_STUB (f
, overload_idx
));
3240 printfi_filtered (spaces
+ 8, "voffset %u\n",
3241 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
3247 print_cplus_stuff (struct type
*type
, int spaces
)
3249 printfi_filtered (spaces
, "n_baseclasses %d\n",
3250 TYPE_N_BASECLASSES (type
));
3251 printfi_filtered (spaces
, "nfn_fields %d\n",
3252 TYPE_NFN_FIELDS (type
));
3253 if (TYPE_N_BASECLASSES (type
) > 0)
3255 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
3256 TYPE_N_BASECLASSES (type
));
3257 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
3259 printf_filtered (")");
3261 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
3262 TYPE_N_BASECLASSES (type
));
3263 puts_filtered ("\n");
3265 if (TYPE_NFIELDS (type
) > 0)
3267 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
3269 printfi_filtered (spaces
,
3270 "private_field_bits (%d bits at *",
3271 TYPE_NFIELDS (type
));
3272 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
3274 printf_filtered (")");
3275 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
3276 TYPE_NFIELDS (type
));
3277 puts_filtered ("\n");
3279 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
3281 printfi_filtered (spaces
,
3282 "protected_field_bits (%d bits at *",
3283 TYPE_NFIELDS (type
));
3284 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
3286 printf_filtered (")");
3287 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
3288 TYPE_NFIELDS (type
));
3289 puts_filtered ("\n");
3292 if (TYPE_NFN_FIELDS (type
) > 0)
3294 dump_fn_fieldlists (type
, spaces
);
3298 /* Print the contents of the TYPE's type_specific union, assuming that
3299 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
3302 print_gnat_stuff (struct type
*type
, int spaces
)
3304 struct type
*descriptive_type
= TYPE_DESCRIPTIVE_TYPE (type
);
3306 recursive_dump_type (descriptive_type
, spaces
+ 2);
3309 static struct obstack dont_print_type_obstack
;
3312 recursive_dump_type (struct type
*type
, int spaces
)
3317 obstack_begin (&dont_print_type_obstack
, 0);
3319 if (TYPE_NFIELDS (type
) > 0
3320 || (HAVE_CPLUS_STRUCT (type
) && TYPE_NFN_FIELDS (type
) > 0))
3322 struct type
**first_dont_print
3323 = (struct type
**) obstack_base (&dont_print_type_obstack
);
3325 int i
= (struct type
**)
3326 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
3330 if (type
== first_dont_print
[i
])
3332 printfi_filtered (spaces
, "type node ");
3333 gdb_print_host_address (type
, gdb_stdout
);
3334 printf_filtered (_(" <same as already seen type>\n"));
3339 obstack_ptr_grow (&dont_print_type_obstack
, type
);
3342 printfi_filtered (spaces
, "type node ");
3343 gdb_print_host_address (type
, gdb_stdout
);
3344 printf_filtered ("\n");
3345 printfi_filtered (spaces
, "name '%s' (",
3346 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
3347 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
3348 printf_filtered (")\n");
3349 printfi_filtered (spaces
, "tagname '%s' (",
3350 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
3351 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
3352 printf_filtered (")\n");
3353 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
3354 switch (TYPE_CODE (type
))
3356 case TYPE_CODE_UNDEF
:
3357 printf_filtered ("(TYPE_CODE_UNDEF)");
3360 printf_filtered ("(TYPE_CODE_PTR)");
3362 case TYPE_CODE_ARRAY
:
3363 printf_filtered ("(TYPE_CODE_ARRAY)");
3365 case TYPE_CODE_STRUCT
:
3366 printf_filtered ("(TYPE_CODE_STRUCT)");
3368 case TYPE_CODE_UNION
:
3369 printf_filtered ("(TYPE_CODE_UNION)");
3371 case TYPE_CODE_ENUM
:
3372 printf_filtered ("(TYPE_CODE_ENUM)");
3374 case TYPE_CODE_FLAGS
:
3375 printf_filtered ("(TYPE_CODE_FLAGS)");
3377 case TYPE_CODE_FUNC
:
3378 printf_filtered ("(TYPE_CODE_FUNC)");
3381 printf_filtered ("(TYPE_CODE_INT)");
3384 printf_filtered ("(TYPE_CODE_FLT)");
3386 case TYPE_CODE_VOID
:
3387 printf_filtered ("(TYPE_CODE_VOID)");
3390 printf_filtered ("(TYPE_CODE_SET)");
3392 case TYPE_CODE_RANGE
:
3393 printf_filtered ("(TYPE_CODE_RANGE)");
3395 case TYPE_CODE_STRING
:
3396 printf_filtered ("(TYPE_CODE_STRING)");
3398 case TYPE_CODE_ERROR
:
3399 printf_filtered ("(TYPE_CODE_ERROR)");
3401 case TYPE_CODE_MEMBERPTR
:
3402 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
3404 case TYPE_CODE_METHODPTR
:
3405 printf_filtered ("(TYPE_CODE_METHODPTR)");
3407 case TYPE_CODE_METHOD
:
3408 printf_filtered ("(TYPE_CODE_METHOD)");
3411 printf_filtered ("(TYPE_CODE_REF)");
3413 case TYPE_CODE_CHAR
:
3414 printf_filtered ("(TYPE_CODE_CHAR)");
3416 case TYPE_CODE_BOOL
:
3417 printf_filtered ("(TYPE_CODE_BOOL)");
3419 case TYPE_CODE_COMPLEX
:
3420 printf_filtered ("(TYPE_CODE_COMPLEX)");
3422 case TYPE_CODE_TYPEDEF
:
3423 printf_filtered ("(TYPE_CODE_TYPEDEF)");
3425 case TYPE_CODE_NAMESPACE
:
3426 printf_filtered ("(TYPE_CODE_NAMESPACE)");
3429 printf_filtered ("(UNKNOWN TYPE CODE)");
3432 puts_filtered ("\n");
3433 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
3434 if (TYPE_OBJFILE_OWNED (type
))
3436 printfi_filtered (spaces
, "objfile ");
3437 gdb_print_host_address (TYPE_OWNER (type
).objfile
, gdb_stdout
);
3441 printfi_filtered (spaces
, "gdbarch ");
3442 gdb_print_host_address (TYPE_OWNER (type
).gdbarch
, gdb_stdout
);
3444 printf_filtered ("\n");
3445 printfi_filtered (spaces
, "target_type ");
3446 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
3447 printf_filtered ("\n");
3448 if (TYPE_TARGET_TYPE (type
) != NULL
)
3450 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
3452 printfi_filtered (spaces
, "pointer_type ");
3453 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
3454 printf_filtered ("\n");
3455 printfi_filtered (spaces
, "reference_type ");
3456 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
3457 printf_filtered ("\n");
3458 printfi_filtered (spaces
, "type_chain ");
3459 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
3460 printf_filtered ("\n");
3461 printfi_filtered (spaces
, "instance_flags 0x%x",
3462 TYPE_INSTANCE_FLAGS (type
));
3463 if (TYPE_CONST (type
))
3465 puts_filtered (" TYPE_FLAG_CONST");
3467 if (TYPE_VOLATILE (type
))
3469 puts_filtered (" TYPE_FLAG_VOLATILE");
3471 if (TYPE_CODE_SPACE (type
))
3473 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3475 if (TYPE_DATA_SPACE (type
))
3477 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3479 if (TYPE_ADDRESS_CLASS_1 (type
))
3481 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3483 if (TYPE_ADDRESS_CLASS_2 (type
))
3485 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3487 if (TYPE_RESTRICT (type
))
3489 puts_filtered (" TYPE_FLAG_RESTRICT");
3491 puts_filtered ("\n");
3493 printfi_filtered (spaces
, "flags");
3494 if (TYPE_UNSIGNED (type
))
3496 puts_filtered (" TYPE_FLAG_UNSIGNED");
3498 if (TYPE_NOSIGN (type
))
3500 puts_filtered (" TYPE_FLAG_NOSIGN");
3502 if (TYPE_STUB (type
))
3504 puts_filtered (" TYPE_FLAG_STUB");
3506 if (TYPE_TARGET_STUB (type
))
3508 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3510 if (TYPE_STATIC (type
))
3512 puts_filtered (" TYPE_FLAG_STATIC");
3514 if (TYPE_PROTOTYPED (type
))
3516 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3518 if (TYPE_INCOMPLETE (type
))
3520 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3522 if (TYPE_VARARGS (type
))
3524 puts_filtered (" TYPE_FLAG_VARARGS");
3526 /* This is used for things like AltiVec registers on ppc. Gcc emits
3527 an attribute for the array type, which tells whether or not we
3528 have a vector, instead of a regular array. */
3529 if (TYPE_VECTOR (type
))
3531 puts_filtered (" TYPE_FLAG_VECTOR");
3533 if (TYPE_FIXED_INSTANCE (type
))
3535 puts_filtered (" TYPE_FIXED_INSTANCE");
3537 if (TYPE_STUB_SUPPORTED (type
))
3539 puts_filtered (" TYPE_STUB_SUPPORTED");
3541 if (TYPE_NOTTEXT (type
))
3543 puts_filtered (" TYPE_NOTTEXT");
3545 puts_filtered ("\n");
3546 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
3547 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
3548 puts_filtered ("\n");
3549 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
3551 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
3552 printfi_filtered (spaces
+ 2,
3553 "[%d] enumval %s type ",
3554 idx
, plongest (TYPE_FIELD_ENUMVAL (type
, idx
)));
3556 printfi_filtered (spaces
+ 2,
3557 "[%d] bitpos %d bitsize %d type ",
3558 idx
, TYPE_FIELD_BITPOS (type
, idx
),
3559 TYPE_FIELD_BITSIZE (type
, idx
));
3560 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
3561 printf_filtered (" name '%s' (",
3562 TYPE_FIELD_NAME (type
, idx
) != NULL
3563 ? TYPE_FIELD_NAME (type
, idx
)
3565 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
3566 printf_filtered (")\n");
3567 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
3569 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
3572 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
3574 printfi_filtered (spaces
, "low %s%s high %s%s\n",
3575 plongest (TYPE_LOW_BOUND (type
)),
3576 TYPE_LOW_BOUND_UNDEFINED (type
) ? " (undefined)" : "",
3577 plongest (TYPE_HIGH_BOUND (type
)),
3578 TYPE_HIGH_BOUND_UNDEFINED (type
)
3579 ? " (undefined)" : "");
3581 printfi_filtered (spaces
, "vptr_basetype ");
3582 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
3583 puts_filtered ("\n");
3584 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
3586 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
3588 printfi_filtered (spaces
, "vptr_fieldno %d\n",
3589 TYPE_VPTR_FIELDNO (type
));
3591 switch (TYPE_SPECIFIC_FIELD (type
))
3593 case TYPE_SPECIFIC_CPLUS_STUFF
:
3594 printfi_filtered (spaces
, "cplus_stuff ");
3595 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
),
3597 puts_filtered ("\n");
3598 print_cplus_stuff (type
, spaces
);
3601 case TYPE_SPECIFIC_GNAT_STUFF
:
3602 printfi_filtered (spaces
, "gnat_stuff ");
3603 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type
), gdb_stdout
);
3604 puts_filtered ("\n");
3605 print_gnat_stuff (type
, spaces
);
3608 case TYPE_SPECIFIC_FLOATFORMAT
:
3609 printfi_filtered (spaces
, "floatformat ");
3610 if (TYPE_FLOATFORMAT (type
) == NULL
)
3611 puts_filtered ("(null)");
3614 puts_filtered ("{ ");
3615 if (TYPE_FLOATFORMAT (type
)[0] == NULL
3616 || TYPE_FLOATFORMAT (type
)[0]->name
== NULL
)
3617 puts_filtered ("(null)");
3619 puts_filtered (TYPE_FLOATFORMAT (type
)[0]->name
);
3621 puts_filtered (", ");
3622 if (TYPE_FLOATFORMAT (type
)[1] == NULL
3623 || TYPE_FLOATFORMAT (type
)[1]->name
== NULL
)
3624 puts_filtered ("(null)");
3626 puts_filtered (TYPE_FLOATFORMAT (type
)[1]->name
);
3628 puts_filtered (" }");
3630 puts_filtered ("\n");
3633 case TYPE_SPECIFIC_FUNC
:
3634 printfi_filtered (spaces
, "calling_convention %d\n",
3635 TYPE_CALLING_CONVENTION (type
));
3636 /* tail_call_list is not printed. */
3641 obstack_free (&dont_print_type_obstack
, NULL
);
3644 /* Trivial helpers for the libiberty hash table, for mapping one
3649 struct type
*old
, *new;
3653 type_pair_hash (const void *item
)
3655 const struct type_pair
*pair
= item
;
3657 return htab_hash_pointer (pair
->old
);
3661 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
3663 const struct type_pair
*lhs
= item_lhs
, *rhs
= item_rhs
;
3665 return lhs
->old
== rhs
->old
;
3668 /* Allocate the hash table used by copy_type_recursive to walk
3669 types without duplicates. We use OBJFILE's obstack, because
3670 OBJFILE is about to be deleted. */
3673 create_copied_types_hash (struct objfile
*objfile
)
3675 return htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
3676 NULL
, &objfile
->objfile_obstack
,
3677 hashtab_obstack_allocate
,
3678 dummy_obstack_deallocate
);
3681 /* Recursively copy (deep copy) TYPE, if it is associated with
3682 OBJFILE. Return a new type allocated using malloc, a saved type if
3683 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
3684 not associated with OBJFILE. */
3687 copy_type_recursive (struct objfile
*objfile
,
3689 htab_t copied_types
)
3691 struct type_pair
*stored
, pair
;
3693 struct type
*new_type
;
3695 if (! TYPE_OBJFILE_OWNED (type
))
3698 /* This type shouldn't be pointing to any types in other objfiles;
3699 if it did, the type might disappear unexpectedly. */
3700 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
3703 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
3705 return ((struct type_pair
*) *slot
)->new;
3707 new_type
= alloc_type_arch (get_type_arch (type
));
3709 /* We must add the new type to the hash table immediately, in case
3710 we encounter this type again during a recursive call below. */
3712 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct type_pair
));
3714 stored
->new = new_type
;
3717 /* Copy the common fields of types. For the main type, we simply
3718 copy the entire thing and then update specific fields as needed. */
3719 *TYPE_MAIN_TYPE (new_type
) = *TYPE_MAIN_TYPE (type
);
3720 TYPE_OBJFILE_OWNED (new_type
) = 0;
3721 TYPE_OWNER (new_type
).gdbarch
= get_type_arch (type
);
3723 if (TYPE_NAME (type
))
3724 TYPE_NAME (new_type
) = xstrdup (TYPE_NAME (type
));
3725 if (TYPE_TAG_NAME (type
))
3726 TYPE_TAG_NAME (new_type
) = xstrdup (TYPE_TAG_NAME (type
));
3728 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
3729 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
3731 /* Copy the fields. */
3732 if (TYPE_NFIELDS (type
))
3736 nfields
= TYPE_NFIELDS (type
);
3737 TYPE_FIELDS (new_type
) = XCNEWVEC (struct field
, nfields
);
3738 for (i
= 0; i
< nfields
; i
++)
3740 TYPE_FIELD_ARTIFICIAL (new_type
, i
) =
3741 TYPE_FIELD_ARTIFICIAL (type
, i
);
3742 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
3743 if (TYPE_FIELD_TYPE (type
, i
))
3744 TYPE_FIELD_TYPE (new_type
, i
)
3745 = copy_type_recursive (objfile
, TYPE_FIELD_TYPE (type
, i
),
3747 if (TYPE_FIELD_NAME (type
, i
))
3748 TYPE_FIELD_NAME (new_type
, i
) =
3749 xstrdup (TYPE_FIELD_NAME (type
, i
));
3750 switch (TYPE_FIELD_LOC_KIND (type
, i
))
3752 case FIELD_LOC_KIND_BITPOS
:
3753 SET_FIELD_BITPOS (TYPE_FIELD (new_type
, i
),
3754 TYPE_FIELD_BITPOS (type
, i
));
3756 case FIELD_LOC_KIND_ENUMVAL
:
3757 SET_FIELD_ENUMVAL (TYPE_FIELD (new_type
, i
),
3758 TYPE_FIELD_ENUMVAL (type
, i
));
3760 case FIELD_LOC_KIND_PHYSADDR
:
3761 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type
, i
),
3762 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
3764 case FIELD_LOC_KIND_PHYSNAME
:
3765 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type
, i
),
3766 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
,
3770 internal_error (__FILE__
, __LINE__
,
3771 _("Unexpected type field location kind: %d"),
3772 TYPE_FIELD_LOC_KIND (type
, i
));
3777 /* For range types, copy the bounds information. */
3778 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
3780 TYPE_RANGE_DATA (new_type
) = xmalloc (sizeof (struct range_bounds
));
3781 *TYPE_RANGE_DATA (new_type
) = *TYPE_RANGE_DATA (type
);
3784 /* Copy pointers to other types. */
3785 if (TYPE_TARGET_TYPE (type
))
3786 TYPE_TARGET_TYPE (new_type
) =
3787 copy_type_recursive (objfile
,
3788 TYPE_TARGET_TYPE (type
),
3790 if (TYPE_VPTR_BASETYPE (type
))
3791 TYPE_VPTR_BASETYPE (new_type
) =
3792 copy_type_recursive (objfile
,
3793 TYPE_VPTR_BASETYPE (type
),
3795 /* Maybe copy the type_specific bits.
3797 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3798 base classes and methods. There's no fundamental reason why we
3799 can't, but at the moment it is not needed. */
3801 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
3802 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
3803 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3804 || TYPE_CODE (type
) == TYPE_CODE_UNION
3805 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
3806 INIT_CPLUS_SPECIFIC (new_type
);
3811 /* Make a copy of the given TYPE, except that the pointer & reference
3812 types are not preserved.
3814 This function assumes that the given type has an associated objfile.
3815 This objfile is used to allocate the new type. */
3818 copy_type (const struct type
*type
)
3820 struct type
*new_type
;
3822 gdb_assert (TYPE_OBJFILE_OWNED (type
));
3824 new_type
= alloc_type_copy (type
);
3825 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
3826 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
3827 memcpy (TYPE_MAIN_TYPE (new_type
), TYPE_MAIN_TYPE (type
),
3828 sizeof (struct main_type
));
3833 /* Helper functions to initialize architecture-specific types. */
3835 /* Allocate a type structure associated with GDBARCH and set its
3836 CODE, LENGTH, and NAME fields. */
3839 arch_type (struct gdbarch
*gdbarch
,
3840 enum type_code code
, int length
, char *name
)
3844 type
= alloc_type_arch (gdbarch
);
3845 TYPE_CODE (type
) = code
;
3846 TYPE_LENGTH (type
) = length
;
3849 TYPE_NAME (type
) = xstrdup (name
);
3854 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
3855 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3856 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3859 arch_integer_type (struct gdbarch
*gdbarch
,
3860 int bit
, int unsigned_p
, char *name
)
3864 t
= arch_type (gdbarch
, TYPE_CODE_INT
, bit
/ TARGET_CHAR_BIT
, name
);
3866 TYPE_UNSIGNED (t
) = 1;
3867 if (name
&& strcmp (name
, "char") == 0)
3868 TYPE_NOSIGN (t
) = 1;
3873 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
3874 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3875 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3878 arch_character_type (struct gdbarch
*gdbarch
,
3879 int bit
, int unsigned_p
, char *name
)
3883 t
= arch_type (gdbarch
, TYPE_CODE_CHAR
, bit
/ TARGET_CHAR_BIT
, name
);
3885 TYPE_UNSIGNED (t
) = 1;
3890 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
3891 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3892 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3895 arch_boolean_type (struct gdbarch
*gdbarch
,
3896 int bit
, int unsigned_p
, char *name
)
3900 t
= arch_type (gdbarch
, TYPE_CODE_BOOL
, bit
/ TARGET_CHAR_BIT
, name
);
3902 TYPE_UNSIGNED (t
) = 1;
3907 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
3908 BIT is the type size in bits; if BIT equals -1, the size is
3909 determined by the floatformat. NAME is the type name. Set the
3910 TYPE_FLOATFORMAT from FLOATFORMATS. */
3913 arch_float_type (struct gdbarch
*gdbarch
,
3914 int bit
, char *name
, const struct floatformat
**floatformats
)
3920 gdb_assert (floatformats
!= NULL
);
3921 gdb_assert (floatformats
[0] != NULL
&& floatformats
[1] != NULL
);
3922 bit
= floatformats
[0]->totalsize
;
3924 gdb_assert (bit
>= 0);
3926 t
= arch_type (gdbarch
, TYPE_CODE_FLT
, bit
/ TARGET_CHAR_BIT
, name
);
3927 TYPE_FLOATFORMAT (t
) = floatformats
;
3931 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
3932 NAME is the type name. TARGET_TYPE is the component float type. */
3935 arch_complex_type (struct gdbarch
*gdbarch
,
3936 char *name
, struct type
*target_type
)
3940 t
= arch_type (gdbarch
, TYPE_CODE_COMPLEX
,
3941 2 * TYPE_LENGTH (target_type
), name
);
3942 TYPE_TARGET_TYPE (t
) = target_type
;
3946 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
3947 NAME is the type name. LENGTH is the size of the flag word in bytes. */
3950 arch_flags_type (struct gdbarch
*gdbarch
, char *name
, int length
)
3952 int nfields
= length
* TARGET_CHAR_BIT
;
3955 type
= arch_type (gdbarch
, TYPE_CODE_FLAGS
, length
, name
);
3956 TYPE_UNSIGNED (type
) = 1;
3957 TYPE_NFIELDS (type
) = nfields
;
3958 TYPE_FIELDS (type
) = TYPE_ZALLOC (type
, nfields
* sizeof (struct field
));
3963 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
3964 position BITPOS is called NAME. */
3967 append_flags_type_flag (struct type
*type
, int bitpos
, char *name
)
3969 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLAGS
);
3970 gdb_assert (bitpos
< TYPE_NFIELDS (type
));
3971 gdb_assert (bitpos
>= 0);
3975 TYPE_FIELD_NAME (type
, bitpos
) = xstrdup (name
);
3976 SET_FIELD_BITPOS (TYPE_FIELD (type
, bitpos
), bitpos
);
3980 /* Don't show this field to the user. */
3981 SET_FIELD_BITPOS (TYPE_FIELD (type
, bitpos
), -1);
3985 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
3986 specified by CODE) associated with GDBARCH. NAME is the type name. */
3989 arch_composite_type (struct gdbarch
*gdbarch
, char *name
, enum type_code code
)
3993 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
3994 t
= arch_type (gdbarch
, code
, 0, NULL
);
3995 TYPE_TAG_NAME (t
) = name
;
3996 INIT_CPLUS_SPECIFIC (t
);
4000 /* Add new field with name NAME and type FIELD to composite type T.
4001 Do not set the field's position or adjust the type's length;
4002 the caller should do so. Return the new field. */
4005 append_composite_type_field_raw (struct type
*t
, char *name
,
4010 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
4011 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
4012 sizeof (struct field
) * TYPE_NFIELDS (t
));
4013 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
4014 memset (f
, 0, sizeof f
[0]);
4015 FIELD_TYPE (f
[0]) = field
;
4016 FIELD_NAME (f
[0]) = name
;
4020 /* Add new field with name NAME and type FIELD to composite type T.
4021 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
4024 append_composite_type_field_aligned (struct type
*t
, char *name
,
4025 struct type
*field
, int alignment
)
4027 struct field
*f
= append_composite_type_field_raw (t
, name
, field
);
4029 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
4031 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
4032 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
4034 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
4036 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
4037 if (TYPE_NFIELDS (t
) > 1)
4039 SET_FIELD_BITPOS (f
[0],
4040 (FIELD_BITPOS (f
[-1])
4041 + (TYPE_LENGTH (FIELD_TYPE (f
[-1]))
4042 * TARGET_CHAR_BIT
)));
4048 alignment
*= TARGET_CHAR_BIT
;
4049 left
= FIELD_BITPOS (f
[0]) % alignment
;
4053 SET_FIELD_BITPOS (f
[0], FIELD_BITPOS (f
[0]) + (alignment
- left
));
4054 TYPE_LENGTH (t
) += (alignment
- left
) / TARGET_CHAR_BIT
;
4061 /* Add new field with name NAME and type FIELD to composite type T. */
4064 append_composite_type_field (struct type
*t
, char *name
,
4067 append_composite_type_field_aligned (t
, name
, field
, 0);
4070 static struct gdbarch_data
*gdbtypes_data
;
4072 const struct builtin_type
*
4073 builtin_type (struct gdbarch
*gdbarch
)
4075 return gdbarch_data (gdbarch
, gdbtypes_data
);
4079 gdbtypes_post_init (struct gdbarch
*gdbarch
)
4081 struct builtin_type
*builtin_type
4082 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
4085 builtin_type
->builtin_void
4086 = arch_type (gdbarch
, TYPE_CODE_VOID
, 1, "void");
4087 builtin_type
->builtin_char
4088 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
4089 !gdbarch_char_signed (gdbarch
), "char");
4090 builtin_type
->builtin_signed_char
4091 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
4093 builtin_type
->builtin_unsigned_char
4094 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
4095 1, "unsigned char");
4096 builtin_type
->builtin_short
4097 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
4099 builtin_type
->builtin_unsigned_short
4100 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
4101 1, "unsigned short");
4102 builtin_type
->builtin_int
4103 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
4105 builtin_type
->builtin_unsigned_int
4106 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
4108 builtin_type
->builtin_long
4109 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
4111 builtin_type
->builtin_unsigned_long
4112 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
4113 1, "unsigned long");
4114 builtin_type
->builtin_long_long
4115 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
4117 builtin_type
->builtin_unsigned_long_long
4118 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
4119 1, "unsigned long long");
4120 builtin_type
->builtin_float
4121 = arch_float_type (gdbarch
, gdbarch_float_bit (gdbarch
),
4122 "float", gdbarch_float_format (gdbarch
));
4123 builtin_type
->builtin_double
4124 = arch_float_type (gdbarch
, gdbarch_double_bit (gdbarch
),
4125 "double", gdbarch_double_format (gdbarch
));
4126 builtin_type
->builtin_long_double
4127 = arch_float_type (gdbarch
, gdbarch_long_double_bit (gdbarch
),
4128 "long double", gdbarch_long_double_format (gdbarch
));
4129 builtin_type
->builtin_complex
4130 = arch_complex_type (gdbarch
, "complex",
4131 builtin_type
->builtin_float
);
4132 builtin_type
->builtin_double_complex
4133 = arch_complex_type (gdbarch
, "double complex",
4134 builtin_type
->builtin_double
);
4135 builtin_type
->builtin_string
4136 = arch_type (gdbarch
, TYPE_CODE_STRING
, 1, "string");
4137 builtin_type
->builtin_bool
4138 = arch_type (gdbarch
, TYPE_CODE_BOOL
, 1, "bool");
4140 /* The following three are about decimal floating point types, which
4141 are 32-bits, 64-bits and 128-bits respectively. */
4142 builtin_type
->builtin_decfloat
4143 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 32 / 8, "_Decimal32");
4144 builtin_type
->builtin_decdouble
4145 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 64 / 8, "_Decimal64");
4146 builtin_type
->builtin_declong
4147 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 128 / 8, "_Decimal128");
4149 /* "True" character types. */
4150 builtin_type
->builtin_true_char
4151 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 0, "true character");
4152 builtin_type
->builtin_true_unsigned_char
4153 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 1, "true character");
4155 /* Fixed-size integer types. */
4156 builtin_type
->builtin_int0
4157 = arch_integer_type (gdbarch
, 0, 0, "int0_t");
4158 builtin_type
->builtin_int8
4159 = arch_integer_type (gdbarch
, 8, 0, "int8_t");
4160 builtin_type
->builtin_uint8
4161 = arch_integer_type (gdbarch
, 8, 1, "uint8_t");
4162 builtin_type
->builtin_int16
4163 = arch_integer_type (gdbarch
, 16, 0, "int16_t");
4164 builtin_type
->builtin_uint16
4165 = arch_integer_type (gdbarch
, 16, 1, "uint16_t");
4166 builtin_type
->builtin_int32
4167 = arch_integer_type (gdbarch
, 32, 0, "int32_t");
4168 builtin_type
->builtin_uint32
4169 = arch_integer_type (gdbarch
, 32, 1, "uint32_t");
4170 builtin_type
->builtin_int64
4171 = arch_integer_type (gdbarch
, 64, 0, "int64_t");
4172 builtin_type
->builtin_uint64
4173 = arch_integer_type (gdbarch
, 64, 1, "uint64_t");
4174 builtin_type
->builtin_int128
4175 = arch_integer_type (gdbarch
, 128, 0, "int128_t");
4176 builtin_type
->builtin_uint128
4177 = arch_integer_type (gdbarch
, 128, 1, "uint128_t");
4178 TYPE_INSTANCE_FLAGS (builtin_type
->builtin_int8
) |=
4179 TYPE_INSTANCE_FLAG_NOTTEXT
;
4180 TYPE_INSTANCE_FLAGS (builtin_type
->builtin_uint8
) |=
4181 TYPE_INSTANCE_FLAG_NOTTEXT
;
4183 /* Wide character types. */
4184 builtin_type
->builtin_char16
4185 = arch_integer_type (gdbarch
, 16, 0, "char16_t");
4186 builtin_type
->builtin_char32
4187 = arch_integer_type (gdbarch
, 32, 0, "char32_t");
4190 /* Default data/code pointer types. */
4191 builtin_type
->builtin_data_ptr
4192 = lookup_pointer_type (builtin_type
->builtin_void
);
4193 builtin_type
->builtin_func_ptr
4194 = lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
4195 builtin_type
->builtin_func_func
4196 = lookup_function_type (builtin_type
->builtin_func_ptr
);
4198 /* This type represents a GDB internal function. */
4199 builtin_type
->internal_fn
4200 = arch_type (gdbarch
, TYPE_CODE_INTERNAL_FUNCTION
, 0,
4201 "<internal function>");
4203 return builtin_type
;
4206 /* This set of objfile-based types is intended to be used by symbol
4207 readers as basic types. */
4209 static const struct objfile_data
*objfile_type_data
;
4211 const struct objfile_type
*
4212 objfile_type (struct objfile
*objfile
)
4214 struct gdbarch
*gdbarch
;
4215 struct objfile_type
*objfile_type
4216 = objfile_data (objfile
, objfile_type_data
);
4219 return objfile_type
;
4221 objfile_type
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
4222 1, struct objfile_type
);
4224 /* Use the objfile architecture to determine basic type properties. */
4225 gdbarch
= get_objfile_arch (objfile
);
4228 objfile_type
->builtin_void
4229 = init_type (TYPE_CODE_VOID
, 1,
4233 objfile_type
->builtin_char
4234 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
4236 | (gdbarch_char_signed (gdbarch
) ? 0 : TYPE_FLAG_UNSIGNED
)),
4238 objfile_type
->builtin_signed_char
4239 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
4241 "signed char", objfile
);
4242 objfile_type
->builtin_unsigned_char
4243 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
4245 "unsigned char", objfile
);
4246 objfile_type
->builtin_short
4247 = init_type (TYPE_CODE_INT
,
4248 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
4249 0, "short", objfile
);
4250 objfile_type
->builtin_unsigned_short
4251 = init_type (TYPE_CODE_INT
,
4252 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
4253 TYPE_FLAG_UNSIGNED
, "unsigned short", objfile
);
4254 objfile_type
->builtin_int
4255 = init_type (TYPE_CODE_INT
,
4256 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
4258 objfile_type
->builtin_unsigned_int
4259 = init_type (TYPE_CODE_INT
,
4260 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
4261 TYPE_FLAG_UNSIGNED
, "unsigned int", objfile
);
4262 objfile_type
->builtin_long
4263 = init_type (TYPE_CODE_INT
,
4264 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
4265 0, "long", objfile
);
4266 objfile_type
->builtin_unsigned_long
4267 = init_type (TYPE_CODE_INT
,
4268 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
4269 TYPE_FLAG_UNSIGNED
, "unsigned long", objfile
);
4270 objfile_type
->builtin_long_long
4271 = init_type (TYPE_CODE_INT
,
4272 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
4273 0, "long long", objfile
);
4274 objfile_type
->builtin_unsigned_long_long
4275 = init_type (TYPE_CODE_INT
,
4276 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
4277 TYPE_FLAG_UNSIGNED
, "unsigned long long", objfile
);
4279 objfile_type
->builtin_float
4280 = init_type (TYPE_CODE_FLT
,
4281 gdbarch_float_bit (gdbarch
) / TARGET_CHAR_BIT
,
4282 0, "float", objfile
);
4283 TYPE_FLOATFORMAT (objfile_type
->builtin_float
)
4284 = gdbarch_float_format (gdbarch
);
4285 objfile_type
->builtin_double
4286 = init_type (TYPE_CODE_FLT
,
4287 gdbarch_double_bit (gdbarch
) / TARGET_CHAR_BIT
,
4288 0, "double", objfile
);
4289 TYPE_FLOATFORMAT (objfile_type
->builtin_double
)
4290 = gdbarch_double_format (gdbarch
);
4291 objfile_type
->builtin_long_double
4292 = init_type (TYPE_CODE_FLT
,
4293 gdbarch_long_double_bit (gdbarch
) / TARGET_CHAR_BIT
,
4294 0, "long double", objfile
);
4295 TYPE_FLOATFORMAT (objfile_type
->builtin_long_double
)
4296 = gdbarch_long_double_format (gdbarch
);
4298 /* This type represents a type that was unrecognized in symbol read-in. */
4299 objfile_type
->builtin_error
4300 = init_type (TYPE_CODE_ERROR
, 0, 0, "<unknown type>", objfile
);
4302 /* The following set of types is used for symbols with no
4303 debug information. */
4304 objfile_type
->nodebug_text_symbol
4305 = init_type (TYPE_CODE_FUNC
, 1, 0,
4306 "<text variable, no debug info>", objfile
);
4307 TYPE_TARGET_TYPE (objfile_type
->nodebug_text_symbol
)
4308 = objfile_type
->builtin_int
;
4309 objfile_type
->nodebug_text_gnu_ifunc_symbol
4310 = init_type (TYPE_CODE_FUNC
, 1, TYPE_FLAG_GNU_IFUNC
,
4311 "<text gnu-indirect-function variable, no debug info>",
4313 TYPE_TARGET_TYPE (objfile_type
->nodebug_text_gnu_ifunc_symbol
)
4314 = objfile_type
->nodebug_text_symbol
;
4315 objfile_type
->nodebug_got_plt_symbol
4316 = init_type (TYPE_CODE_PTR
, gdbarch_addr_bit (gdbarch
) / 8, 0,
4317 "<text from jump slot in .got.plt, no debug info>",
4319 TYPE_TARGET_TYPE (objfile_type
->nodebug_got_plt_symbol
)
4320 = objfile_type
->nodebug_text_symbol
;
4321 objfile_type
->nodebug_data_symbol
4322 = init_type (TYPE_CODE_INT
,
4323 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
4324 "<data variable, no debug info>", objfile
);
4325 objfile_type
->nodebug_unknown_symbol
4326 = init_type (TYPE_CODE_INT
, 1, 0,
4327 "<variable (not text or data), no debug info>", objfile
);
4328 objfile_type
->nodebug_tls_symbol
4329 = init_type (TYPE_CODE_INT
,
4330 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
4331 "<thread local variable, no debug info>", objfile
);
4333 /* NOTE: on some targets, addresses and pointers are not necessarily
4337 - gdb's `struct type' always describes the target's
4339 - gdb's `struct value' objects should always hold values in
4341 - gdb's CORE_ADDR values are addresses in the unified virtual
4342 address space that the assembler and linker work with. Thus,
4343 since target_read_memory takes a CORE_ADDR as an argument, it
4344 can access any memory on the target, even if the processor has
4345 separate code and data address spaces.
4347 In this context, objfile_type->builtin_core_addr is a bit odd:
4348 it's a target type for a value the target will never see. It's
4349 only used to hold the values of (typeless) linker symbols, which
4350 are indeed in the unified virtual address space. */
4352 objfile_type
->builtin_core_addr
4353 = init_type (TYPE_CODE_INT
,
4354 gdbarch_addr_bit (gdbarch
) / 8,
4355 TYPE_FLAG_UNSIGNED
, "__CORE_ADDR", objfile
);
4357 set_objfile_data (objfile
, objfile_type_data
, objfile_type
);
4358 return objfile_type
;
4361 extern initialize_file_ftype _initialize_gdbtypes
;
4364 _initialize_gdbtypes (void)
4366 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
4367 objfile_type_data
= register_objfile_data ();
4369 add_setshow_zuinteger_cmd ("overload", no_class
, &overload_debug
,
4370 _("Set debugging of C++ overloading."),
4371 _("Show debugging of C++ overloading."),
4372 _("When enabled, ranking of the "
4373 "functions is displayed."),
4375 show_overload_debug
,
4376 &setdebuglist
, &showdebuglist
);
4378 /* Add user knob for controlling resolution of opaque types. */
4379 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
4380 &opaque_type_resolution
,
4381 _("Set resolution of opaque struct/class/union"
4382 " types (if set before loading symbols)."),
4383 _("Show resolution of opaque struct/class/union"
4384 " types (if set before loading symbols)."),
4386 show_opaque_type_resolution
,
4387 &setlist
, &showlist
);
4389 /* Add an option to permit non-strict type checking. */
4390 add_setshow_boolean_cmd ("type", class_support
,
4391 &strict_type_checking
,
4392 _("Set strict type checking."),
4393 _("Show strict type checking."),
4395 show_strict_type_checking
,
4396 &setchecklist
, &showchecklist
);