1 /* Support routines for manipulating internal types for GDB.
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
4 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
7 Contributed by Cygnus Support, using pieces from other GDB modules.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "gdb_string.h"
31 #include "expression.h"
36 #include "complaints.h"
40 #include "gdb_assert.h"
44 /* Floatformat pairs. */
45 const struct floatformat
*floatformats_ieee_half
[BFD_ENDIAN_UNKNOWN
] = {
46 &floatformat_ieee_half_big
,
47 &floatformat_ieee_half_little
49 const struct floatformat
*floatformats_ieee_single
[BFD_ENDIAN_UNKNOWN
] = {
50 &floatformat_ieee_single_big
,
51 &floatformat_ieee_single_little
53 const struct floatformat
*floatformats_ieee_double
[BFD_ENDIAN_UNKNOWN
] = {
54 &floatformat_ieee_double_big
,
55 &floatformat_ieee_double_little
57 const struct floatformat
*floatformats_ieee_double_littlebyte_bigword
[BFD_ENDIAN_UNKNOWN
] = {
58 &floatformat_ieee_double_big
,
59 &floatformat_ieee_double_littlebyte_bigword
61 const struct floatformat
*floatformats_i387_ext
[BFD_ENDIAN_UNKNOWN
] = {
62 &floatformat_i387_ext
,
65 const struct floatformat
*floatformats_m68881_ext
[BFD_ENDIAN_UNKNOWN
] = {
66 &floatformat_m68881_ext
,
67 &floatformat_m68881_ext
69 const struct floatformat
*floatformats_arm_ext
[BFD_ENDIAN_UNKNOWN
] = {
70 &floatformat_arm_ext_big
,
71 &floatformat_arm_ext_littlebyte_bigword
73 const struct floatformat
*floatformats_ia64_spill
[BFD_ENDIAN_UNKNOWN
] = {
74 &floatformat_ia64_spill_big
,
75 &floatformat_ia64_spill_little
77 const struct floatformat
*floatformats_ia64_quad
[BFD_ENDIAN_UNKNOWN
] = {
78 &floatformat_ia64_quad_big
,
79 &floatformat_ia64_quad_little
81 const struct floatformat
*floatformats_vax_f
[BFD_ENDIAN_UNKNOWN
] = {
85 const struct floatformat
*floatformats_vax_d
[BFD_ENDIAN_UNKNOWN
] = {
89 const struct floatformat
*floatformats_ibm_long_double
[BFD_ENDIAN_UNKNOWN
] = {
90 &floatformat_ibm_long_double
,
91 &floatformat_ibm_long_double
95 int opaque_type_resolution
= 1;
97 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
98 struct cmd_list_element
*c
,
101 fprintf_filtered (file
, _("\
102 Resolution of opaque struct/class/union types (if set before loading symbols) is %s.\n"),
106 int overload_debug
= 0;
108 show_overload_debug (struct ui_file
*file
, int from_tty
,
109 struct cmd_list_element
*c
, const char *value
)
111 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"),
119 }; /* Maximum extension is 128! FIXME */
121 static void print_bit_vector (B_TYPE
*, int);
122 static void print_arg_types (struct field
*, int, int);
123 static void dump_fn_fieldlists (struct type
*, int);
124 static void print_cplus_stuff (struct type
*, int);
127 /* Allocate a new OBJFILE-associated type structure and fill it
128 with some defaults. Space for the type structure is allocated
129 on the objfile's objfile_obstack. */
132 alloc_type (struct objfile
*objfile
)
136 gdb_assert (objfile
!= NULL
);
138 /* Alloc the structure and start off with all fields zeroed. */
139 type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct type
);
140 TYPE_MAIN_TYPE (type
) = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
142 OBJSTAT (objfile
, n_types
++);
144 TYPE_OBJFILE_OWNED (type
) = 1;
145 TYPE_OWNER (type
).objfile
= objfile
;
147 /* Initialize the fields that might not be zero. */
149 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
150 TYPE_VPTR_FIELDNO (type
) = -1;
151 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
156 /* Allocate a new GDBARCH-associated type structure and fill it
157 with some defaults. Space for the type structure is allocated
161 alloc_type_arch (struct gdbarch
*gdbarch
)
165 gdb_assert (gdbarch
!= NULL
);
167 /* Alloc the structure and start off with all fields zeroed. */
169 type
= XZALLOC (struct type
);
170 TYPE_MAIN_TYPE (type
) = XZALLOC (struct main_type
);
172 TYPE_OBJFILE_OWNED (type
) = 0;
173 TYPE_OWNER (type
).gdbarch
= gdbarch
;
175 /* Initialize the fields that might not be zero. */
177 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
178 TYPE_VPTR_FIELDNO (type
) = -1;
179 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
184 /* If TYPE is objfile-associated, allocate a new type structure
185 associated with the same objfile. If TYPE is gdbarch-associated,
186 allocate a new type structure associated with the same gdbarch. */
189 alloc_type_copy (const struct type
*type
)
191 if (TYPE_OBJFILE_OWNED (type
))
192 return alloc_type (TYPE_OWNER (type
).objfile
);
194 return alloc_type_arch (TYPE_OWNER (type
).gdbarch
);
197 /* If TYPE is gdbarch-associated, return that architecture.
198 If TYPE is objfile-associated, return that objfile's architecture. */
201 get_type_arch (const struct type
*type
)
203 if (TYPE_OBJFILE_OWNED (type
))
204 return get_objfile_arch (TYPE_OWNER (type
).objfile
);
206 return TYPE_OWNER (type
).gdbarch
;
210 /* Alloc a new type instance structure, fill it with some defaults,
211 and point it at OLDTYPE. Allocate the new type instance from the
212 same place as OLDTYPE. */
215 alloc_type_instance (struct type
*oldtype
)
219 /* Allocate the structure. */
221 if (! TYPE_OBJFILE_OWNED (oldtype
))
222 type
= XZALLOC (struct type
);
224 type
= OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype
)->objfile_obstack
,
227 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
229 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
234 /* Clear all remnants of the previous type at TYPE, in preparation for
235 replacing it with something else. Preserve owner information. */
237 smash_type (struct type
*type
)
239 int objfile_owned
= TYPE_OBJFILE_OWNED (type
);
240 union type_owner owner
= TYPE_OWNER (type
);
242 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
244 /* Restore owner information. */
245 TYPE_OBJFILE_OWNED (type
) = objfile_owned
;
246 TYPE_OWNER (type
) = owner
;
248 /* For now, delete the rings. */
249 TYPE_CHAIN (type
) = type
;
251 /* For now, leave the pointer/reference types alone. */
254 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
255 to a pointer to memory where the pointer type should be stored.
256 If *TYPEPTR is zero, update it to point to the pointer type we return.
257 We allocate new memory if needed. */
260 make_pointer_type (struct type
*type
, struct type
**typeptr
)
262 struct type
*ntype
; /* New type */
265 ntype
= TYPE_POINTER_TYPE (type
);
270 return ntype
; /* Don't care about alloc,
271 and have new type. */
272 else if (*typeptr
== 0)
274 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
279 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
281 ntype
= alloc_type_copy (type
);
285 else /* We have storage, but need to reset it. */
288 chain
= TYPE_CHAIN (ntype
);
290 TYPE_CHAIN (ntype
) = chain
;
293 TYPE_TARGET_TYPE (ntype
) = type
;
294 TYPE_POINTER_TYPE (type
) = ntype
;
296 /* FIXME! Assume the machine has only one representation for
300 = gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
301 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
303 /* Mark pointers as unsigned. The target converts between pointers
304 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
305 gdbarch_address_to_pointer. */
306 TYPE_UNSIGNED (ntype
) = 1;
308 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
309 TYPE_POINTER_TYPE (type
) = ntype
;
311 /* Update the length of all the other variants of this type. */
312 chain
= TYPE_CHAIN (ntype
);
313 while (chain
!= ntype
)
315 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
316 chain
= TYPE_CHAIN (chain
);
322 /* Given a type TYPE, return a type of pointers to that type.
323 May need to construct such a type if this is the first use. */
326 lookup_pointer_type (struct type
*type
)
328 return make_pointer_type (type
, (struct type
**) 0);
331 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
332 points to a pointer to memory where the reference type should be
333 stored. If *TYPEPTR is zero, update it to point to the reference
334 type we return. We allocate new memory if needed. */
337 make_reference_type (struct type
*type
, struct type
**typeptr
)
339 struct type
*ntype
; /* New type */
342 ntype
= TYPE_REFERENCE_TYPE (type
);
347 return ntype
; /* Don't care about alloc,
348 and have new type. */
349 else if (*typeptr
== 0)
351 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
356 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
358 ntype
= alloc_type_copy (type
);
362 else /* We have storage, but need to reset it. */
365 chain
= TYPE_CHAIN (ntype
);
367 TYPE_CHAIN (ntype
) = chain
;
370 TYPE_TARGET_TYPE (ntype
) = type
;
371 TYPE_REFERENCE_TYPE (type
) = ntype
;
373 /* FIXME! Assume the machine has only one representation for
374 references, and that it matches the (only) representation for
377 TYPE_LENGTH (ntype
) =
378 gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
379 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
381 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
382 TYPE_REFERENCE_TYPE (type
) = ntype
;
384 /* Update the length of all the other variants of this type. */
385 chain
= TYPE_CHAIN (ntype
);
386 while (chain
!= ntype
)
388 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
389 chain
= TYPE_CHAIN (chain
);
395 /* Same as above, but caller doesn't care about memory allocation
399 lookup_reference_type (struct type
*type
)
401 return make_reference_type (type
, (struct type
**) 0);
404 /* Lookup a function type that returns type TYPE. TYPEPTR, if
405 nonzero, points to a pointer to memory where the function type
406 should be stored. If *TYPEPTR is zero, update it to point to the
407 function type we return. We allocate new memory if needed. */
410 make_function_type (struct type
*type
, struct type
**typeptr
)
412 struct type
*ntype
; /* New type */
414 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
416 ntype
= alloc_type_copy (type
);
420 else /* We have storage, but need to reset it. */
426 TYPE_TARGET_TYPE (ntype
) = type
;
428 TYPE_LENGTH (ntype
) = 1;
429 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
435 /* Given a type TYPE, return a type of functions that return that type.
436 May need to construct such a type if this is the first use. */
439 lookup_function_type (struct type
*type
)
441 return make_function_type (type
, (struct type
**) 0);
444 /* Identify address space identifier by name --
445 return the integer flag defined in gdbtypes.h. */
447 address_space_name_to_int (struct gdbarch
*gdbarch
, char *space_identifier
)
451 /* Check for known address space delimiters. */
452 if (!strcmp (space_identifier
, "code"))
453 return TYPE_INSTANCE_FLAG_CODE_SPACE
;
454 else if (!strcmp (space_identifier
, "data"))
455 return TYPE_INSTANCE_FLAG_DATA_SPACE
;
456 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
457 && gdbarch_address_class_name_to_type_flags (gdbarch
,
462 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
465 /* Identify address space identifier by integer flag as defined in
466 gdbtypes.h -- return the string version of the adress space name. */
469 address_space_int_to_name (struct gdbarch
*gdbarch
, int space_flag
)
471 if (space_flag
& TYPE_INSTANCE_FLAG_CODE_SPACE
)
473 else if (space_flag
& TYPE_INSTANCE_FLAG_DATA_SPACE
)
475 else if ((space_flag
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
476 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
477 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
482 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
484 If STORAGE is non-NULL, create the new type instance there.
485 STORAGE must be in the same obstack as TYPE. */
488 make_qualified_type (struct type
*type
, int new_flags
,
489 struct type
*storage
)
496 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
498 ntype
= TYPE_CHAIN (ntype
);
500 while (ntype
!= type
);
502 /* Create a new type instance. */
504 ntype
= alloc_type_instance (type
);
507 /* If STORAGE was provided, it had better be in the same objfile
508 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
509 if one objfile is freed and the other kept, we'd have
510 dangling pointers. */
511 gdb_assert (TYPE_OBJFILE (type
) == TYPE_OBJFILE (storage
));
514 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
515 TYPE_CHAIN (ntype
) = ntype
;
518 /* Pointers or references to the original type are not relevant to
520 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
521 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
523 /* Chain the new qualified type to the old type. */
524 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
525 TYPE_CHAIN (type
) = ntype
;
527 /* Now set the instance flags and return the new type. */
528 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
530 /* Set length of new type to that of the original type. */
531 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
536 /* Make an address-space-delimited variant of a type -- a type that
537 is identical to the one supplied except that it has an address
538 space attribute attached to it (such as "code" or "data").
540 The space attributes "code" and "data" are for Harvard
541 architectures. The address space attributes are for architectures
542 which have alternately sized pointers or pointers with alternate
546 make_type_with_address_space (struct type
*type
, int space_flag
)
548 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
549 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
550 | TYPE_INSTANCE_FLAG_DATA_SPACE
551 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
))
554 return make_qualified_type (type
, new_flags
, NULL
);
557 /* Make a "c-v" variant of a type -- a type that is identical to the
558 one supplied except that it may have const or volatile attributes
559 CNST is a flag for setting the const attribute
560 VOLTL is a flag for setting the volatile attribute
561 TYPE is the base type whose variant we are creating.
563 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
564 storage to hold the new qualified type; *TYPEPTR and TYPE must be
565 in the same objfile. Otherwise, allocate fresh memory for the new
566 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
567 new type we construct. */
569 make_cv_type (int cnst
, int voltl
,
571 struct type
**typeptr
)
573 struct type
*ntype
; /* New type */
575 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
576 & ~(TYPE_INSTANCE_FLAG_CONST
577 | TYPE_INSTANCE_FLAG_VOLATILE
));
580 new_flags
|= TYPE_INSTANCE_FLAG_CONST
;
583 new_flags
|= TYPE_INSTANCE_FLAG_VOLATILE
;
585 if (typeptr
&& *typeptr
!= NULL
)
587 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
588 a C-V variant chain that threads across objfiles: if one
589 objfile gets freed, then the other has a broken C-V chain.
591 This code used to try to copy over the main type from TYPE to
592 *TYPEPTR if they were in different objfiles, but that's
593 wrong, too: TYPE may have a field list or member function
594 lists, which refer to types of their own, etc. etc. The
595 whole shebang would need to be copied over recursively; you
596 can't have inter-objfile pointers. The only thing to do is
597 to leave stub types as stub types, and look them up afresh by
598 name each time you encounter them. */
599 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
));
602 ntype
= make_qualified_type (type
, new_flags
,
603 typeptr
? *typeptr
: NULL
);
611 /* Replace the contents of ntype with the type *type. This changes the
612 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
613 the changes are propogated to all types in the TYPE_CHAIN.
615 In order to build recursive types, it's inevitable that we'll need
616 to update types in place --- but this sort of indiscriminate
617 smashing is ugly, and needs to be replaced with something more
618 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
619 clear if more steps are needed. */
621 replace_type (struct type
*ntype
, struct type
*type
)
625 /* These two types had better be in the same objfile. Otherwise,
626 the assignment of one type's main type structure to the other
627 will produce a type with references to objects (names; field
628 lists; etc.) allocated on an objfile other than its own. */
629 gdb_assert (TYPE_OBJFILE (ntype
) == TYPE_OBJFILE (ntype
));
631 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
633 /* The type length is not a part of the main type. Update it for
634 each type on the variant chain. */
638 /* Assert that this element of the chain has no address-class bits
639 set in its flags. Such type variants might have type lengths
640 which are supposed to be different from the non-address-class
641 variants. This assertion shouldn't ever be triggered because
642 symbol readers which do construct address-class variants don't
643 call replace_type(). */
644 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
646 TYPE_LENGTH (chain
) = TYPE_LENGTH (type
);
647 chain
= TYPE_CHAIN (chain
);
649 while (ntype
!= chain
);
651 /* Assert that the two types have equivalent instance qualifiers.
652 This should be true for at least all of our debug readers. */
653 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
656 /* Implement direct support for MEMBER_TYPE in GNU C++.
657 May need to construct such a type if this is the first use.
658 The TYPE is the type of the member. The DOMAIN is the type
659 of the aggregate that the member belongs to. */
662 lookup_memberptr_type (struct type
*type
, struct type
*domain
)
666 mtype
= alloc_type_copy (type
);
667 smash_to_memberptr_type (mtype
, domain
, type
);
671 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
674 lookup_methodptr_type (struct type
*to_type
)
678 mtype
= alloc_type_copy (to_type
);
679 smash_to_methodptr_type (mtype
, to_type
);
683 /* Allocate a stub method whose return type is TYPE. This apparently
684 happens for speed of symbol reading, since parsing out the
685 arguments to the method is cpu-intensive, the way we are doing it.
686 So, we will fill in arguments later. This always returns a fresh
690 allocate_stub_method (struct type
*type
)
694 mtype
= alloc_type_copy (type
);
695 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
696 TYPE_LENGTH (mtype
) = 1;
697 TYPE_STUB (mtype
) = 1;
698 TYPE_TARGET_TYPE (mtype
) = type
;
699 /* _DOMAIN_TYPE (mtype) = unknown yet */
703 /* Create a range type using either a blank type supplied in
704 RESULT_TYPE, or creating a new type, inheriting the objfile from
707 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
708 to HIGH_BOUND, inclusive.
710 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
711 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
714 create_range_type (struct type
*result_type
, struct type
*index_type
,
715 LONGEST low_bound
, LONGEST high_bound
)
717 if (result_type
== NULL
)
718 result_type
= alloc_type_copy (index_type
);
719 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
720 TYPE_TARGET_TYPE (result_type
) = index_type
;
721 if (TYPE_STUB (index_type
))
722 TYPE_TARGET_STUB (result_type
) = 1;
724 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
725 TYPE_RANGE_DATA (result_type
) = (struct range_bounds
*)
726 TYPE_ZALLOC (result_type
, sizeof (struct range_bounds
));
727 TYPE_LOW_BOUND (result_type
) = low_bound
;
728 TYPE_HIGH_BOUND (result_type
) = high_bound
;
731 TYPE_UNSIGNED (result_type
) = 1;
736 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
737 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
738 bounds will fit in LONGEST), or -1 otherwise. */
741 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
743 CHECK_TYPEDEF (type
);
744 switch (TYPE_CODE (type
))
746 case TYPE_CODE_RANGE
:
747 *lowp
= TYPE_LOW_BOUND (type
);
748 *highp
= TYPE_HIGH_BOUND (type
);
751 if (TYPE_NFIELDS (type
) > 0)
753 /* The enums may not be sorted by value, so search all
757 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
758 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
760 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
761 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
762 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
763 *highp
= TYPE_FIELD_BITPOS (type
, i
);
766 /* Set unsigned indicator if warranted. */
769 TYPE_UNSIGNED (type
) = 1;
783 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
785 if (!TYPE_UNSIGNED (type
))
787 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
791 /* ... fall through for unsigned ints ... */
794 /* This round-about calculation is to avoid shifting by
795 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
796 if TYPE_LENGTH (type) == sizeof (LONGEST). */
797 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
798 *highp
= (*highp
- 1) | *highp
;
805 /* Assuming TYPE is a simple, non-empty array type, compute its upper
806 and lower bound. Save the low bound into LOW_BOUND if not NULL.
807 Save the high bound into HIGH_BOUND if not NULL.
809 Return 1 if the operation was successful. Return zero otherwise,
810 in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
812 We now simply use get_discrete_bounds call to get the values
813 of the low and high bounds.
814 get_discrete_bounds can return three values:
815 1, meaning that index is a range,
816 0, meaning that index is a discrete type,
817 or -1 for failure. */
820 get_array_bounds (struct type
*type
, LONGEST
*low_bound
, LONGEST
*high_bound
)
822 struct type
*index
= TYPE_INDEX_TYPE (type
);
830 res
= get_discrete_bounds (index
, &low
, &high
);
834 /* Check if the array bounds are undefined. */
836 && ((low_bound
&& TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type
))
837 || (high_bound
&& TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))))
849 /* Create an array type using either a blank type supplied in
850 RESULT_TYPE, or creating a new type, inheriting the objfile from
853 Elements will be of type ELEMENT_TYPE, the indices will be of type
856 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
857 sure it is TYPE_CODE_UNDEF before we bash it into an array
861 create_array_type (struct type
*result_type
,
862 struct type
*element_type
,
863 struct type
*range_type
)
865 LONGEST low_bound
, high_bound
;
867 if (result_type
== NULL
)
868 result_type
= alloc_type_copy (range_type
);
870 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
871 TYPE_TARGET_TYPE (result_type
) = element_type
;
872 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
873 low_bound
= high_bound
= 0;
874 CHECK_TYPEDEF (element_type
);
875 /* Be careful when setting the array length. Ada arrays can be
876 empty arrays with the high_bound being smaller than the low_bound.
877 In such cases, the array length should be zero. */
878 if (high_bound
< low_bound
)
879 TYPE_LENGTH (result_type
) = 0;
881 TYPE_LENGTH (result_type
) =
882 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
883 TYPE_NFIELDS (result_type
) = 1;
884 TYPE_FIELDS (result_type
) =
885 (struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
));
886 TYPE_INDEX_TYPE (result_type
) = range_type
;
887 TYPE_VPTR_FIELDNO (result_type
) = -1;
889 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
890 if (TYPE_LENGTH (result_type
) == 0)
891 TYPE_TARGET_STUB (result_type
) = 1;
897 lookup_array_range_type (struct type
*element_type
,
898 int low_bound
, int high_bound
)
900 struct gdbarch
*gdbarch
= get_type_arch (element_type
);
901 struct type
*index_type
= builtin_type (gdbarch
)->builtin_int
;
902 struct type
*range_type
903 = create_range_type (NULL
, index_type
, low_bound
, high_bound
);
905 return create_array_type (NULL
, element_type
, range_type
);
908 /* Create a string type using either a blank type supplied in
909 RESULT_TYPE, or creating a new type. String types are similar
910 enough to array of char types that we can use create_array_type to
911 build the basic type and then bash it into a string type.
913 For fixed length strings, the range type contains 0 as the lower
914 bound and the length of the string minus one as the upper bound.
916 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
917 sure it is TYPE_CODE_UNDEF before we bash it into a string
921 create_string_type (struct type
*result_type
,
922 struct type
*string_char_type
,
923 struct type
*range_type
)
925 result_type
= create_array_type (result_type
,
928 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
933 lookup_string_range_type (struct type
*string_char_type
,
934 int low_bound
, int high_bound
)
936 struct type
*result_type
;
938 result_type
= lookup_array_range_type (string_char_type
,
939 low_bound
, high_bound
);
940 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
945 create_set_type (struct type
*result_type
, struct type
*domain_type
)
947 if (result_type
== NULL
)
948 result_type
= alloc_type_copy (domain_type
);
950 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
951 TYPE_NFIELDS (result_type
) = 1;
952 TYPE_FIELDS (result_type
) = TYPE_ZALLOC (result_type
, sizeof (struct field
));
954 if (!TYPE_STUB (domain_type
))
956 LONGEST low_bound
, high_bound
, bit_length
;
958 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
959 low_bound
= high_bound
= 0;
960 bit_length
= high_bound
- low_bound
+ 1;
961 TYPE_LENGTH (result_type
)
962 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
964 TYPE_UNSIGNED (result_type
) = 1;
966 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
971 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
972 and any array types nested inside it. */
975 make_vector_type (struct type
*array_type
)
977 struct type
*inner_array
, *elt_type
;
980 /* Find the innermost array type, in case the array is
981 multi-dimensional. */
982 inner_array
= array_type
;
983 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
984 inner_array
= TYPE_TARGET_TYPE (inner_array
);
986 elt_type
= TYPE_TARGET_TYPE (inner_array
);
987 if (TYPE_CODE (elt_type
) == TYPE_CODE_INT
)
989 flags
= TYPE_INSTANCE_FLAGS (elt_type
) | TYPE_INSTANCE_FLAG_NOTTEXT
;
990 elt_type
= make_qualified_type (elt_type
, flags
, NULL
);
991 TYPE_TARGET_TYPE (inner_array
) = elt_type
;
994 TYPE_VECTOR (array_type
) = 1;
998 init_vector_type (struct type
*elt_type
, int n
)
1000 struct type
*array_type
;
1002 array_type
= lookup_array_range_type (elt_type
, 0, n
- 1);
1003 make_vector_type (array_type
);
1007 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
1008 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1009 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1010 TYPE doesn't include the offset (that's the value of the MEMBER
1011 itself), but does include the structure type into which it points
1014 When "smashing" the type, we preserve the objfile that the old type
1015 pointed to, since we aren't changing where the type is actually
1019 smash_to_memberptr_type (struct type
*type
, struct type
*domain
,
1020 struct type
*to_type
)
1023 TYPE_TARGET_TYPE (type
) = to_type
;
1024 TYPE_DOMAIN_TYPE (type
) = domain
;
1025 /* Assume that a data member pointer is the same size as a normal
1028 = gdbarch_ptr_bit (get_type_arch (to_type
)) / TARGET_CHAR_BIT
;
1029 TYPE_CODE (type
) = TYPE_CODE_MEMBERPTR
;
1032 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1034 When "smashing" the type, we preserve the objfile that the old type
1035 pointed to, since we aren't changing where the type is actually
1039 smash_to_methodptr_type (struct type
*type
, struct type
*to_type
)
1042 TYPE_TARGET_TYPE (type
) = to_type
;
1043 TYPE_DOMAIN_TYPE (type
) = TYPE_DOMAIN_TYPE (to_type
);
1044 TYPE_LENGTH (type
) = cplus_method_ptr_size (to_type
);
1045 TYPE_CODE (type
) = TYPE_CODE_METHODPTR
;
1048 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
1049 METHOD just means `function that gets an extra "this" argument'.
1051 When "smashing" the type, we preserve the objfile that the old type
1052 pointed to, since we aren't changing where the type is actually
1056 smash_to_method_type (struct type
*type
, struct type
*domain
,
1057 struct type
*to_type
, struct field
*args
,
1058 int nargs
, int varargs
)
1061 TYPE_TARGET_TYPE (type
) = to_type
;
1062 TYPE_DOMAIN_TYPE (type
) = domain
;
1063 TYPE_FIELDS (type
) = args
;
1064 TYPE_NFIELDS (type
) = nargs
;
1066 TYPE_VARARGS (type
) = 1;
1067 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1068 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
1071 /* Return a typename for a struct/union/enum type without "struct ",
1072 "union ", or "enum ". If the type has a NULL name, return NULL. */
1075 type_name_no_tag (const struct type
*type
)
1077 if (TYPE_TAG_NAME (type
) != NULL
)
1078 return TYPE_TAG_NAME (type
);
1080 /* Is there code which expects this to return the name if there is
1081 no tag name? My guess is that this is mainly used for C++ in
1082 cases where the two will always be the same. */
1083 return TYPE_NAME (type
);
1086 /* Lookup a typedef or primitive type named NAME, visible in lexical
1087 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1088 suitably defined. */
1091 lookup_typename (const struct language_defn
*language
,
1092 struct gdbarch
*gdbarch
, char *name
,
1093 const struct block
*block
, int noerr
)
1098 sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, 0);
1099 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1101 tmp
= language_lookup_primitive_type_by_name (language
, gdbarch
, name
);
1106 else if (!tmp
&& noerr
)
1112 error (_("No type named %s."), name
);
1115 return (SYMBOL_TYPE (sym
));
1119 lookup_unsigned_typename (const struct language_defn
*language
,
1120 struct gdbarch
*gdbarch
, char *name
)
1122 char *uns
= alloca (strlen (name
) + 10);
1124 strcpy (uns
, "unsigned ");
1125 strcpy (uns
+ 9, name
);
1126 return lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 0);
1130 lookup_signed_typename (const struct language_defn
*language
,
1131 struct gdbarch
*gdbarch
, char *name
)
1134 char *uns
= alloca (strlen (name
) + 8);
1136 strcpy (uns
, "signed ");
1137 strcpy (uns
+ 7, name
);
1138 t
= lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 1);
1139 /* If we don't find "signed FOO" just try again with plain "FOO". */
1142 return lookup_typename (language
, gdbarch
, name
, (struct block
*) NULL
, 0);
1145 /* Lookup a structure type named "struct NAME",
1146 visible in lexical block BLOCK. */
1149 lookup_struct (char *name
, struct block
*block
)
1153 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1157 error (_("No struct type named %s."), name
);
1159 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1161 error (_("This context has class, union or enum %s, not a struct."),
1164 return (SYMBOL_TYPE (sym
));
1167 /* Lookup a union type named "union NAME",
1168 visible in lexical block BLOCK. */
1171 lookup_union (char *name
, struct block
*block
)
1176 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1179 error (_("No union type named %s."), name
);
1181 t
= SYMBOL_TYPE (sym
);
1183 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1186 /* If we get here, it's not a union. */
1187 error (_("This context has class, struct or enum %s, not a union."),
1192 /* Lookup an enum type named "enum NAME",
1193 visible in lexical block BLOCK. */
1196 lookup_enum (char *name
, struct block
*block
)
1200 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1203 error (_("No enum type named %s."), name
);
1205 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1207 error (_("This context has class, struct or union %s, not an enum."),
1210 return (SYMBOL_TYPE (sym
));
1213 /* Lookup a template type named "template NAME<TYPE>",
1214 visible in lexical block BLOCK. */
1217 lookup_template_type (char *name
, struct type
*type
,
1218 struct block
*block
)
1221 char *nam
= (char *)
1222 alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1226 strcat (nam
, TYPE_NAME (type
));
1227 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1229 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0);
1233 error (_("No template type named %s."), name
);
1235 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1237 error (_("This context has class, union or enum %s, not a struct."),
1240 return (SYMBOL_TYPE (sym
));
1243 /* Given a type TYPE, lookup the type of the component of type named
1246 TYPE can be either a struct or union, or a pointer or reference to
1247 a struct or union. If it is a pointer or reference, its target
1248 type is automatically used. Thus '.' and '->' are interchangable,
1249 as specified for the definitions of the expression element types
1250 STRUCTOP_STRUCT and STRUCTOP_PTR.
1252 If NOERR is nonzero, return zero if NAME is not suitably defined.
1253 If NAME is the name of a baseclass type, return that type. */
1256 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
1263 CHECK_TYPEDEF (type
);
1264 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1265 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1267 type
= TYPE_TARGET_TYPE (type
);
1270 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1271 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1273 typename
= type_to_string (type
);
1274 make_cleanup (xfree
, typename
);
1275 error (_("Type %s is not a structure or union type."), typename
);
1279 /* FIXME: This change put in by Michael seems incorrect for the case
1280 where the structure tag name is the same as the member name.
1281 I.E. when doing "ptype bell->bar" for "struct foo { int bar; int
1282 foo; } bell;" Disabled by fnf. */
1286 typename
= type_name_no_tag (type
);
1287 if (typename
!= NULL
&& strcmp (typename
, name
) == 0)
1292 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1294 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1296 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1298 return TYPE_FIELD_TYPE (type
, i
);
1300 else if (!t_field_name
|| *t_field_name
== '\0')
1302 struct type
*subtype
1303 = lookup_struct_elt_type (TYPE_FIELD_TYPE (type
, i
), name
, 1);
1305 if (subtype
!= NULL
)
1310 /* OK, it's not in this class. Recursively check the baseclasses. */
1311 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1315 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, 1);
1327 typename
= type_to_string (type
);
1328 make_cleanup (xfree
, typename
);
1329 error (_("Type %s has no component named %s."), typename
, name
);
1332 /* Lookup the vptr basetype/fieldno values for TYPE.
1333 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1334 vptr_fieldno. Also, if found and basetype is from the same objfile,
1336 If not found, return -1 and ignore BASETYPEP.
1337 Callers should be aware that in some cases (for example,
1338 the type or one of its baseclasses is a stub type and we are
1339 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1340 this function will not be able to find the
1341 virtual function table pointer, and vptr_fieldno will remain -1 and
1342 vptr_basetype will remain NULL or incomplete. */
1345 get_vptr_fieldno (struct type
*type
, struct type
**basetypep
)
1347 CHECK_TYPEDEF (type
);
1349 if (TYPE_VPTR_FIELDNO (type
) < 0)
1353 /* We must start at zero in case the first (and only) baseclass
1354 is virtual (and hence we cannot share the table pointer). */
1355 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1357 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1359 struct type
*basetype
;
1361 fieldno
= get_vptr_fieldno (baseclass
, &basetype
);
1364 /* If the type comes from a different objfile we can't cache
1365 it, it may have a different lifetime. PR 2384 */
1366 if (TYPE_OBJFILE (type
) == TYPE_OBJFILE (basetype
))
1368 TYPE_VPTR_FIELDNO (type
) = fieldno
;
1369 TYPE_VPTR_BASETYPE (type
) = basetype
;
1372 *basetypep
= basetype
;
1383 *basetypep
= TYPE_VPTR_BASETYPE (type
);
1384 return TYPE_VPTR_FIELDNO (type
);
1389 stub_noname_complaint (void)
1391 complaint (&symfile_complaints
, _("stub type has NULL name"));
1394 /* Find the real type of TYPE. This function returns the real type,
1395 after removing all layers of typedefs, and completing opaque or stub
1396 types. Completion changes the TYPE argument, but stripping of
1399 Instance flags (e.g. const/volatile) are preserved as typedefs are
1400 stripped. If necessary a new qualified form of the underlying type
1403 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
1404 not been computed and we're either in the middle of reading symbols, or
1405 there was no name for the typedef in the debug info.
1407 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
1410 If this is a stubbed struct (i.e. declared as struct foo *), see if
1411 we can find a full definition in some other file. If so, copy this
1412 definition, so we can use it in future. There used to be a comment
1413 (but not any code) that if we don't find a full definition, we'd
1414 set a flag so we don't spend time in the future checking the same
1415 type. That would be a mistake, though--we might load in more
1416 symbols which contain a full definition for the type. */
1419 check_typedef (struct type
*type
)
1421 struct type
*orig_type
= type
;
1422 /* While we're removing typedefs, we don't want to lose qualifiers.
1423 E.g., const/volatile. */
1424 int instance_flags
= TYPE_INSTANCE_FLAGS (type
);
1428 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1430 if (!TYPE_TARGET_TYPE (type
))
1435 /* It is dangerous to call lookup_symbol if we are currently
1436 reading a symtab. Infinite recursion is one danger. */
1437 if (currently_reading_symtab
)
1438 return make_qualified_type (type
, instance_flags
, NULL
);
1440 name
= type_name_no_tag (type
);
1441 /* FIXME: shouldn't we separately check the TYPE_NAME and
1442 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1443 VAR_DOMAIN as appropriate? (this code was written before
1444 TYPE_NAME and TYPE_TAG_NAME were separate). */
1447 stub_noname_complaint ();
1448 return make_qualified_type (type
, instance_flags
, NULL
);
1450 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1452 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1453 else /* TYPE_CODE_UNDEF */
1454 TYPE_TARGET_TYPE (type
) = alloc_type_arch (get_type_arch (type
));
1456 type
= TYPE_TARGET_TYPE (type
);
1458 /* Preserve the instance flags as we traverse down the typedef chain.
1460 Handling address spaces/classes is nasty, what do we do if there's a
1462 E.g., what if an outer typedef marks the type as class_1 and an inner
1463 typedef marks the type as class_2?
1464 This is the wrong place to do such error checking. We leave it to
1465 the code that created the typedef in the first place to flag the
1466 error. We just pick the outer address space (akin to letting the
1467 outer cast in a chain of casting win), instead of assuming
1468 "it can't happen". */
1470 const int ALL_SPACES
= (TYPE_INSTANCE_FLAG_CODE_SPACE
1471 | TYPE_INSTANCE_FLAG_DATA_SPACE
);
1472 const int ALL_CLASSES
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
;
1473 int new_instance_flags
= TYPE_INSTANCE_FLAGS (type
);
1475 /* Treat code vs data spaces and address classes separately. */
1476 if ((instance_flags
& ALL_SPACES
) != 0)
1477 new_instance_flags
&= ~ALL_SPACES
;
1478 if ((instance_flags
& ALL_CLASSES
) != 0)
1479 new_instance_flags
&= ~ALL_CLASSES
;
1481 instance_flags
|= new_instance_flags
;
1485 /* If this is a struct/class/union with no fields, then check
1486 whether a full definition exists somewhere else. This is for
1487 systems where a type definition with no fields is issued for such
1488 types, instead of identifying them as stub types in the first
1491 if (TYPE_IS_OPAQUE (type
)
1492 && opaque_type_resolution
1493 && !currently_reading_symtab
)
1495 char *name
= type_name_no_tag (type
);
1496 struct type
*newtype
;
1500 stub_noname_complaint ();
1501 return make_qualified_type (type
, instance_flags
, NULL
);
1503 newtype
= lookup_transparent_type (name
);
1507 /* If the resolved type and the stub are in the same
1508 objfile, then replace the stub type with the real deal.
1509 But if they're in separate objfiles, leave the stub
1510 alone; we'll just look up the transparent type every time
1511 we call check_typedef. We can't create pointers between
1512 types allocated to different objfiles, since they may
1513 have different lifetimes. Trying to copy NEWTYPE over to
1514 TYPE's objfile is pointless, too, since you'll have to
1515 move over any other types NEWTYPE refers to, which could
1516 be an unbounded amount of stuff. */
1517 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
1518 type
= make_qualified_type (newtype
,
1519 TYPE_INSTANCE_FLAGS (type
),
1525 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1527 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1529 char *name
= type_name_no_tag (type
);
1530 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1531 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1532 as appropriate? (this code was written before TYPE_NAME and
1533 TYPE_TAG_NAME were separate). */
1538 stub_noname_complaint ();
1539 return make_qualified_type (type
, instance_flags
, NULL
);
1541 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1544 /* Same as above for opaque types, we can replace the stub
1545 with the complete type only if they are in the same
1547 if (TYPE_OBJFILE (SYMBOL_TYPE(sym
)) == TYPE_OBJFILE (type
))
1548 type
= make_qualified_type (SYMBOL_TYPE (sym
),
1549 TYPE_INSTANCE_FLAGS (type
),
1552 type
= SYMBOL_TYPE (sym
);
1556 if (TYPE_TARGET_STUB (type
))
1558 struct type
*range_type
;
1559 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1561 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1565 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1566 && TYPE_NFIELDS (type
) == 1
1567 && (TYPE_CODE (range_type
= TYPE_INDEX_TYPE (type
))
1568 == TYPE_CODE_RANGE
))
1570 /* Now recompute the length of the array type, based on its
1571 number of elements and the target type's length.
1572 Watch out for Ada null Ada arrays where the high bound
1573 is smaller than the low bound. */
1574 const LONGEST low_bound
= TYPE_LOW_BOUND (range_type
);
1575 const LONGEST high_bound
= TYPE_HIGH_BOUND (range_type
);
1578 if (high_bound
< low_bound
)
1582 /* For now, we conservatively take the array length to be 0
1583 if its length exceeds UINT_MAX. The code below assumes
1584 that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
1585 which is technically not guaranteed by C, but is usually true
1586 (because it would be true if x were unsigned with its
1587 high-order bit on). It uses the fact that
1588 high_bound-low_bound is always representable in
1589 ULONGEST and that if high_bound-low_bound+1 overflows,
1590 it overflows to 0. We must change these tests if we
1591 decide to increase the representation of TYPE_LENGTH
1592 from unsigned int to ULONGEST. */
1593 ULONGEST ulow
= low_bound
, uhigh
= high_bound
;
1594 ULONGEST tlen
= TYPE_LENGTH (target_type
);
1596 len
= tlen
* (uhigh
- ulow
+ 1);
1597 if (tlen
== 0 || (len
/ tlen
- 1 + ulow
) != uhigh
1601 TYPE_LENGTH (type
) = len
;
1602 TYPE_TARGET_STUB (type
) = 0;
1604 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1606 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1607 TYPE_TARGET_STUB (type
) = 0;
1611 type
= make_qualified_type (type
, instance_flags
, NULL
);
1613 /* Cache TYPE_LENGTH for future use. */
1614 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1619 /* Parse a type expression in the string [P..P+LENGTH). If an error
1620 occurs, silently return a void type. */
1622 static struct type
*
1623 safe_parse_type (struct gdbarch
*gdbarch
, char *p
, int length
)
1625 struct ui_file
*saved_gdb_stderr
;
1628 /* Suppress error messages. */
1629 saved_gdb_stderr
= gdb_stderr
;
1630 gdb_stderr
= ui_file_new ();
1632 /* Call parse_and_eval_type() without fear of longjmp()s. */
1633 if (!gdb_parse_and_eval_type (p
, length
, &type
))
1634 type
= builtin_type (gdbarch
)->builtin_void
;
1636 /* Stop suppressing error messages. */
1637 ui_file_delete (gdb_stderr
);
1638 gdb_stderr
= saved_gdb_stderr
;
1643 /* Ugly hack to convert method stubs into method types.
1645 He ain't kiddin'. This demangles the name of the method into a
1646 string including argument types, parses out each argument type,
1647 generates a string casting a zero to that type, evaluates the
1648 string, and stuffs the resulting type into an argtype vector!!!
1649 Then it knows the type of the whole function (including argument
1650 types for overloading), which info used to be in the stab's but was
1651 removed to hack back the space required for them. */
1654 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1656 struct gdbarch
*gdbarch
= get_type_arch (type
);
1658 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1659 char *demangled_name
= cplus_demangle (mangled_name
,
1660 DMGL_PARAMS
| DMGL_ANSI
);
1661 char *argtypetext
, *p
;
1662 int depth
= 0, argcount
= 1;
1663 struct field
*argtypes
;
1666 /* Make sure we got back a function string that we can use. */
1668 p
= strchr (demangled_name
, '(');
1672 if (demangled_name
== NULL
|| p
== NULL
)
1673 error (_("Internal: Cannot demangle mangled name `%s'."),
1676 /* Now, read in the parameters that define this type. */
1681 if (*p
== '(' || *p
== '<')
1685 else if (*p
== ')' || *p
== '>')
1689 else if (*p
== ',' && depth
== 0)
1697 /* If we read one argument and it was ``void'', don't count it. */
1698 if (strncmp (argtypetext
, "(void)", 6) == 0)
1701 /* We need one extra slot, for the THIS pointer. */
1703 argtypes
= (struct field
*)
1704 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
1707 /* Add THIS pointer for non-static methods. */
1708 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1709 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
1713 argtypes
[0].type
= lookup_pointer_type (type
);
1717 if (*p
!= ')') /* () means no args, skip while */
1722 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1724 /* Avoid parsing of ellipsis, they will be handled below.
1725 Also avoid ``void'' as above. */
1726 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
1727 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
1729 argtypes
[argcount
].type
=
1730 safe_parse_type (gdbarch
, argtypetext
, p
- argtypetext
);
1733 argtypetext
= p
+ 1;
1736 if (*p
== '(' || *p
== '<')
1740 else if (*p
== ')' || *p
== '>')
1749 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1751 /* Now update the old "stub" type into a real type. */
1752 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1753 TYPE_DOMAIN_TYPE (mtype
) = type
;
1754 TYPE_FIELDS (mtype
) = argtypes
;
1755 TYPE_NFIELDS (mtype
) = argcount
;
1756 TYPE_STUB (mtype
) = 0;
1757 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1759 TYPE_VARARGS (mtype
) = 1;
1761 xfree (demangled_name
);
1764 /* This is the external interface to check_stub_method, above. This
1765 function unstubs all of the signatures for TYPE's METHOD_ID method
1766 name. After calling this function TYPE_FN_FIELD_STUB will be
1767 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1770 This function unfortunately can not die until stabs do. */
1773 check_stub_method_group (struct type
*type
, int method_id
)
1775 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
1776 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1777 int j
, found_stub
= 0;
1779 for (j
= 0; j
< len
; j
++)
1780 if (TYPE_FN_FIELD_STUB (f
, j
))
1783 check_stub_method (type
, method_id
, j
);
1786 /* GNU v3 methods with incorrect names were corrected when we read
1787 in type information, because it was cheaper to do it then. The
1788 only GNU v2 methods with incorrect method names are operators and
1789 destructors; destructors were also corrected when we read in type
1792 Therefore the only thing we need to handle here are v2 operator
1794 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
1797 char dem_opname
[256];
1799 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1801 dem_opname
, DMGL_ANSI
);
1803 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1807 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
1811 /* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */
1812 const struct cplus_struct_type cplus_struct_default
= { };
1815 allocate_cplus_struct_type (struct type
*type
)
1817 if (HAVE_CPLUS_STRUCT (type
))
1818 /* Structure was already allocated. Nothing more to do. */
1821 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_CPLUS_STUFF
;
1822 TYPE_RAW_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1823 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1824 *(TYPE_RAW_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1827 const struct gnat_aux_type gnat_aux_default
=
1830 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
1831 and allocate the associated gnat-specific data. The gnat-specific
1832 data is also initialized to gnat_aux_default. */
1834 allocate_gnat_aux_type (struct type
*type
)
1836 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_GNAT_STUFF
;
1837 TYPE_GNAT_SPECIFIC (type
) = (struct gnat_aux_type
*)
1838 TYPE_ALLOC (type
, sizeof (struct gnat_aux_type
));
1839 *(TYPE_GNAT_SPECIFIC (type
)) = gnat_aux_default
;
1843 /* Helper function to initialize the standard scalar types.
1845 If NAME is non-NULL, then we make a copy of the string pointed
1846 to by name in the objfile_obstack for that objfile, and initialize
1847 the type name to that copy. There are places (mipsread.c in particular),
1848 where init_type is called with a NULL value for NAME). */
1851 init_type (enum type_code code
, int length
, int flags
,
1852 char *name
, struct objfile
*objfile
)
1856 type
= alloc_type (objfile
);
1857 TYPE_CODE (type
) = code
;
1858 TYPE_LENGTH (type
) = length
;
1860 gdb_assert (!(flags
& (TYPE_FLAG_MIN
- 1)));
1861 if (flags
& TYPE_FLAG_UNSIGNED
)
1862 TYPE_UNSIGNED (type
) = 1;
1863 if (flags
& TYPE_FLAG_NOSIGN
)
1864 TYPE_NOSIGN (type
) = 1;
1865 if (flags
& TYPE_FLAG_STUB
)
1866 TYPE_STUB (type
) = 1;
1867 if (flags
& TYPE_FLAG_TARGET_STUB
)
1868 TYPE_TARGET_STUB (type
) = 1;
1869 if (flags
& TYPE_FLAG_STATIC
)
1870 TYPE_STATIC (type
) = 1;
1871 if (flags
& TYPE_FLAG_PROTOTYPED
)
1872 TYPE_PROTOTYPED (type
) = 1;
1873 if (flags
& TYPE_FLAG_INCOMPLETE
)
1874 TYPE_INCOMPLETE (type
) = 1;
1875 if (flags
& TYPE_FLAG_VARARGS
)
1876 TYPE_VARARGS (type
) = 1;
1877 if (flags
& TYPE_FLAG_VECTOR
)
1878 TYPE_VECTOR (type
) = 1;
1879 if (flags
& TYPE_FLAG_STUB_SUPPORTED
)
1880 TYPE_STUB_SUPPORTED (type
) = 1;
1881 if (flags
& TYPE_FLAG_FIXED_INSTANCE
)
1882 TYPE_FIXED_INSTANCE (type
) = 1;
1885 TYPE_NAME (type
) = obsavestring (name
, strlen (name
),
1886 &objfile
->objfile_obstack
);
1890 if (name
&& strcmp (name
, "char") == 0)
1891 TYPE_NOSIGN (type
) = 1;
1895 case TYPE_CODE_STRUCT
:
1896 case TYPE_CODE_UNION
:
1897 case TYPE_CODE_NAMESPACE
:
1898 INIT_CPLUS_SPECIFIC (type
);
1901 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_FLOATFORMAT
;
1903 case TYPE_CODE_FUNC
:
1904 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_CALLING_CONVENTION
;
1911 can_dereference (struct type
*t
)
1913 /* FIXME: Should we return true for references as well as
1918 && TYPE_CODE (t
) == TYPE_CODE_PTR
1919 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1923 is_integral_type (struct type
*t
)
1928 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
1929 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
1930 || (TYPE_CODE (t
) == TYPE_CODE_FLAGS
)
1931 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
1932 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
1933 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
1936 /* A helper function which returns true if types A and B represent the
1937 "same" class type. This is true if the types have the same main
1938 type, or the same name. */
1941 class_types_same_p (const struct type
*a
, const struct type
*b
)
1943 return (TYPE_MAIN_TYPE (a
) == TYPE_MAIN_TYPE (b
)
1944 || (TYPE_NAME (a
) && TYPE_NAME (b
)
1945 && !strcmp (TYPE_NAME (a
), TYPE_NAME (b
))));
1948 /* Check whether BASE is an ancestor or base class of DCLASS
1949 Return 1 if so, and 0 if not. If PUBLIC is 1 then only public
1950 ancestors are considered, and the function returns 1 only if
1951 BASE is a public ancestor of DCLASS. */
1954 do_is_ancestor (struct type
*base
, struct type
*dclass
, int public)
1958 CHECK_TYPEDEF (base
);
1959 CHECK_TYPEDEF (dclass
);
1961 if (class_types_same_p (base
, dclass
))
1964 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1966 if (public && ! BASETYPE_VIA_PUBLIC (dclass
, i
))
1969 if (do_is_ancestor (base
, TYPE_BASECLASS (dclass
, i
), public))
1976 /* Check whether BASE is an ancestor or base class or DCLASS
1977 Return 1 if so, and 0 if not.
1978 Note: If BASE and DCLASS are of the same type, this function
1979 will return 1. So for some class A, is_ancestor (A, A) will
1983 is_ancestor (struct type
*base
, struct type
*dclass
)
1985 return do_is_ancestor (base
, dclass
, 0);
1988 /* Like is_ancestor, but only returns true when BASE is a public
1989 ancestor of DCLASS. */
1992 is_public_ancestor (struct type
*base
, struct type
*dclass
)
1994 return do_is_ancestor (base
, dclass
, 1);
1997 /* A helper function for is_unique_ancestor. */
2000 is_unique_ancestor_worker (struct type
*base
, struct type
*dclass
,
2002 const bfd_byte
*contents
, CORE_ADDR address
)
2006 CHECK_TYPEDEF (base
);
2007 CHECK_TYPEDEF (dclass
);
2009 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
) && count
< 2; ++i
)
2011 struct type
*iter
= check_typedef (TYPE_BASECLASS (dclass
, i
));
2012 int this_offset
= baseclass_offset (dclass
, i
, contents
, address
);
2014 if (this_offset
== -1)
2015 error (_("virtual baseclass botch"));
2017 if (class_types_same_p (base
, iter
))
2019 /* If this is the first subclass, set *OFFSET and set count
2020 to 1. Otherwise, if this is at the same offset as
2021 previous instances, do nothing. Otherwise, increment
2025 *offset
= this_offset
;
2028 else if (this_offset
== *offset
)
2036 count
+= is_unique_ancestor_worker (base
, iter
, offset
,
2037 contents
+ this_offset
,
2038 address
+ this_offset
);
2044 /* Like is_ancestor, but only returns true if BASE is a unique base
2045 class of the type of VAL. */
2048 is_unique_ancestor (struct type
*base
, struct value
*val
)
2052 return is_unique_ancestor_worker (base
, value_type (val
), &offset
,
2053 value_contents (val
),
2054 value_address (val
)) == 1;
2060 /* Functions for overload resolution begin here */
2062 /* Compare two badness vectors A and B and return the result.
2063 0 => A and B are identical
2064 1 => A and B are incomparable
2065 2 => A is better than B
2066 3 => A is worse than B */
2069 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
2073 short found_pos
= 0; /* any positives in c? */
2074 short found_neg
= 0; /* any negatives in c? */
2076 /* differing lengths => incomparable */
2077 if (a
->length
!= b
->length
)
2080 /* Subtract b from a */
2081 for (i
= 0; i
< a
->length
; i
++)
2083 tmp
= a
->rank
[i
] - b
->rank
[i
];
2093 return 1; /* incomparable */
2095 return 3; /* A > B */
2101 return 2; /* A < B */
2103 return 0; /* A == B */
2107 /* Rank a function by comparing its parameter types (PARMS, length
2108 NPARMS), to the types of an argument list (ARGS, length NARGS).
2109 Return a pointer to a badness vector. This has NARGS + 1
2112 struct badness_vector
*
2113 rank_function (struct type
**parms
, int nparms
,
2114 struct type
**args
, int nargs
)
2117 struct badness_vector
*bv
;
2118 int min_len
= nparms
< nargs
? nparms
: nargs
;
2120 bv
= xmalloc (sizeof (struct badness_vector
));
2121 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank */
2122 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
2124 /* First compare the lengths of the supplied lists.
2125 If there is a mismatch, set it to a high value. */
2127 /* pai/1997-06-03 FIXME: when we have debug info about default
2128 arguments and ellipsis parameter lists, we should consider those
2129 and rank the length-match more finely. */
2131 LENGTH_MATCH (bv
) = (nargs
!= nparms
) ? LENGTH_MISMATCH_BADNESS
: 0;
2133 /* Now rank all the parameters of the candidate function */
2134 for (i
= 1; i
<= min_len
; i
++)
2135 bv
->rank
[i
] = rank_one_type (parms
[i
-1], args
[i
-1]);
2137 /* If more arguments than parameters, add dummy entries */
2138 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2139 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2144 /* Compare the names of two integer types, assuming that any sign
2145 qualifiers have been checked already. We do it this way because
2146 there may be an "int" in the name of one of the types. */
2149 integer_types_same_name_p (const char *first
, const char *second
)
2151 int first_p
, second_p
;
2153 /* If both are shorts, return 1; if neither is a short, keep
2155 first_p
= (strstr (first
, "short") != NULL
);
2156 second_p
= (strstr (second
, "short") != NULL
);
2157 if (first_p
&& second_p
)
2159 if (first_p
|| second_p
)
2162 /* Likewise for long. */
2163 first_p
= (strstr (first
, "long") != NULL
);
2164 second_p
= (strstr (second
, "long") != NULL
);
2165 if (first_p
&& second_p
)
2167 if (first_p
|| second_p
)
2170 /* Likewise for char. */
2171 first_p
= (strstr (first
, "char") != NULL
);
2172 second_p
= (strstr (second
, "char") != NULL
);
2173 if (first_p
&& second_p
)
2175 if (first_p
|| second_p
)
2178 /* They must both be ints. */
2182 /* Compares type A to type B returns 1 if the represent the same type
2186 types_equal (struct type
*a
, struct type
*b
)
2188 /* Identical type pointers. */
2189 /* However, this still doesn't catch all cases of same type for b
2190 and a. The reason is that builtin types are different from
2191 the same ones constructed from the object. */
2195 /* Resolve typedefs */
2196 if (TYPE_CODE (a
) == TYPE_CODE_TYPEDEF
)
2197 a
= check_typedef (a
);
2198 if (TYPE_CODE (b
) == TYPE_CODE_TYPEDEF
)
2199 b
= check_typedef (b
);
2201 /* If after resolving typedefs a and b are not of the same type
2202 code then they are not equal. */
2203 if (TYPE_CODE (a
) != TYPE_CODE (b
))
2206 /* If a and b are both pointers types or both reference types then
2207 they are equal of the same type iff the objects they refer to are
2208 of the same type. */
2209 if (TYPE_CODE (a
) == TYPE_CODE_PTR
2210 || TYPE_CODE (a
) == TYPE_CODE_REF
)
2211 return types_equal (TYPE_TARGET_TYPE (a
),
2212 TYPE_TARGET_TYPE (b
));
2215 Well, damnit, if the names are exactly the same, I'll say they
2216 are exactly the same. This happens when we generate method
2217 stubs. The types won't point to the same address, but they
2218 really are the same.
2221 if (TYPE_NAME (a
) && TYPE_NAME (b
)
2222 && strcmp (TYPE_NAME (a
), TYPE_NAME (b
)) == 0)
2225 /* Check if identical after resolving typedefs. */
2232 /* Compare one type (PARM) for compatibility with another (ARG).
2233 * PARM is intended to be the parameter type of a function; and
2234 * ARG is the supplied argument's type. This function tests if
2235 * the latter can be converted to the former.
2237 * Return 0 if they are identical types;
2238 * Otherwise, return an integer which corresponds to how compatible
2239 * PARM is to ARG. The higher the return value, the worse the match.
2240 * Generally the "bad" conversions are all uniformly assigned a 100. */
2243 rank_one_type (struct type
*parm
, struct type
*arg
)
2246 if (types_equal (parm
, arg
))
2249 /* Resolve typedefs */
2250 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2251 parm
= check_typedef (parm
);
2252 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2253 arg
= check_typedef (arg
);
2255 /* See through references, since we can almost make non-references
2257 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2258 return (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
))
2259 + REFERENCE_CONVERSION_BADNESS
);
2260 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2261 return (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
)
2262 + REFERENCE_CONVERSION_BADNESS
);
2264 /* Debugging only. */
2265 fprintf_filtered (gdb_stderr
,
2266 "------ Arg is %s [%d], parm is %s [%d]\n",
2267 TYPE_NAME (arg
), TYPE_CODE (arg
),
2268 TYPE_NAME (parm
), TYPE_CODE (parm
));
2270 /* x -> y means arg of type x being supplied for parameter of type y */
2272 switch (TYPE_CODE (parm
))
2275 switch (TYPE_CODE (arg
))
2279 /* Allowed pointer conversions are:
2280 (a) pointer to void-pointer conversion. */
2281 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2282 return VOID_PTR_CONVERSION_BADNESS
;
2284 /* (b) pointer to ancestor-pointer conversion. */
2285 if (is_ancestor (TYPE_TARGET_TYPE (parm
),
2286 TYPE_TARGET_TYPE (arg
)))
2287 return BASE_PTR_CONVERSION_BADNESS
;
2289 return INCOMPATIBLE_TYPE_BADNESS
;
2290 case TYPE_CODE_ARRAY
:
2291 if (types_equal (TYPE_TARGET_TYPE (parm
),
2292 TYPE_TARGET_TYPE (arg
)))
2294 return INCOMPATIBLE_TYPE_BADNESS
;
2295 case TYPE_CODE_FUNC
:
2296 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
);
2298 case TYPE_CODE_ENUM
:
2299 case TYPE_CODE_FLAGS
:
2300 case TYPE_CODE_CHAR
:
2301 case TYPE_CODE_RANGE
:
2302 case TYPE_CODE_BOOL
:
2304 return INCOMPATIBLE_TYPE_BADNESS
;
2306 case TYPE_CODE_ARRAY
:
2307 switch (TYPE_CODE (arg
))
2310 case TYPE_CODE_ARRAY
:
2311 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2312 TYPE_TARGET_TYPE (arg
));
2314 return INCOMPATIBLE_TYPE_BADNESS
;
2316 case TYPE_CODE_FUNC
:
2317 switch (TYPE_CODE (arg
))
2319 case TYPE_CODE_PTR
: /* funcptr -> func */
2320 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
));
2322 return INCOMPATIBLE_TYPE_BADNESS
;
2325 switch (TYPE_CODE (arg
))
2328 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2330 /* Deal with signed, unsigned, and plain chars and
2331 signed and unsigned ints. */
2332 if (TYPE_NOSIGN (parm
))
2334 /* This case only for character types */
2335 if (TYPE_NOSIGN (arg
))
2336 return 0; /* plain char -> plain char */
2337 else /* signed/unsigned char -> plain char */
2338 return INTEGER_CONVERSION_BADNESS
;
2340 else if (TYPE_UNSIGNED (parm
))
2342 if (TYPE_UNSIGNED (arg
))
2344 /* unsigned int -> unsigned int, or
2345 unsigned long -> unsigned long */
2346 if (integer_types_same_name_p (TYPE_NAME (parm
),
2349 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2351 && integer_types_same_name_p (TYPE_NAME (parm
),
2353 return INTEGER_PROMOTION_BADNESS
; /* unsigned int -> unsigned long */
2355 return INTEGER_CONVERSION_BADNESS
; /* unsigned long -> unsigned int */
2359 if (integer_types_same_name_p (TYPE_NAME (arg
),
2361 && integer_types_same_name_p (TYPE_NAME (parm
),
2363 return INTEGER_CONVERSION_BADNESS
; /* signed long -> unsigned int */
2365 return INTEGER_CONVERSION_BADNESS
; /* signed int/long -> unsigned int/long */
2368 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2370 if (integer_types_same_name_p (TYPE_NAME (parm
),
2373 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2375 && integer_types_same_name_p (TYPE_NAME (parm
),
2377 return INTEGER_PROMOTION_BADNESS
;
2379 return INTEGER_CONVERSION_BADNESS
;
2382 return INTEGER_CONVERSION_BADNESS
;
2384 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2385 return INTEGER_PROMOTION_BADNESS
;
2387 return INTEGER_CONVERSION_BADNESS
;
2388 case TYPE_CODE_ENUM
:
2389 case TYPE_CODE_FLAGS
:
2390 case TYPE_CODE_CHAR
:
2391 case TYPE_CODE_RANGE
:
2392 case TYPE_CODE_BOOL
:
2393 return INTEGER_PROMOTION_BADNESS
;
2395 return INT_FLOAT_CONVERSION_BADNESS
;
2397 return NS_POINTER_CONVERSION_BADNESS
;
2399 return INCOMPATIBLE_TYPE_BADNESS
;
2402 case TYPE_CODE_ENUM
:
2403 switch (TYPE_CODE (arg
))
2406 case TYPE_CODE_CHAR
:
2407 case TYPE_CODE_RANGE
:
2408 case TYPE_CODE_BOOL
:
2409 case TYPE_CODE_ENUM
:
2410 return INTEGER_CONVERSION_BADNESS
;
2412 return INT_FLOAT_CONVERSION_BADNESS
;
2414 return INCOMPATIBLE_TYPE_BADNESS
;
2417 case TYPE_CODE_CHAR
:
2418 switch (TYPE_CODE (arg
))
2420 case TYPE_CODE_RANGE
:
2421 case TYPE_CODE_BOOL
:
2422 case TYPE_CODE_ENUM
:
2423 return INTEGER_CONVERSION_BADNESS
;
2425 return INT_FLOAT_CONVERSION_BADNESS
;
2427 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2428 return INTEGER_CONVERSION_BADNESS
;
2429 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2430 return INTEGER_PROMOTION_BADNESS
;
2431 /* >>> !! else fall through !! <<< */
2432 case TYPE_CODE_CHAR
:
2433 /* Deal with signed, unsigned, and plain chars for C++ and
2434 with int cases falling through from previous case. */
2435 if (TYPE_NOSIGN (parm
))
2437 if (TYPE_NOSIGN (arg
))
2440 return INTEGER_CONVERSION_BADNESS
;
2442 else if (TYPE_UNSIGNED (parm
))
2444 if (TYPE_UNSIGNED (arg
))
2447 return INTEGER_PROMOTION_BADNESS
;
2449 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2452 return INTEGER_CONVERSION_BADNESS
;
2454 return INCOMPATIBLE_TYPE_BADNESS
;
2457 case TYPE_CODE_RANGE
:
2458 switch (TYPE_CODE (arg
))
2461 case TYPE_CODE_CHAR
:
2462 case TYPE_CODE_RANGE
:
2463 case TYPE_CODE_BOOL
:
2464 case TYPE_CODE_ENUM
:
2465 return INTEGER_CONVERSION_BADNESS
;
2467 return INT_FLOAT_CONVERSION_BADNESS
;
2469 return INCOMPATIBLE_TYPE_BADNESS
;
2472 case TYPE_CODE_BOOL
:
2473 switch (TYPE_CODE (arg
))
2476 case TYPE_CODE_CHAR
:
2477 case TYPE_CODE_RANGE
:
2478 case TYPE_CODE_ENUM
:
2480 return INCOMPATIBLE_TYPE_BADNESS
;
2482 return BOOL_PTR_CONVERSION_BADNESS
;
2483 case TYPE_CODE_BOOL
:
2486 return INCOMPATIBLE_TYPE_BADNESS
;
2490 switch (TYPE_CODE (arg
))
2493 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2494 return FLOAT_PROMOTION_BADNESS
;
2495 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2498 return FLOAT_CONVERSION_BADNESS
;
2500 case TYPE_CODE_BOOL
:
2501 case TYPE_CODE_ENUM
:
2502 case TYPE_CODE_RANGE
:
2503 case TYPE_CODE_CHAR
:
2504 return INT_FLOAT_CONVERSION_BADNESS
;
2506 return INCOMPATIBLE_TYPE_BADNESS
;
2509 case TYPE_CODE_COMPLEX
:
2510 switch (TYPE_CODE (arg
))
2511 { /* Strictly not needed for C++, but... */
2513 return FLOAT_PROMOTION_BADNESS
;
2514 case TYPE_CODE_COMPLEX
:
2517 return INCOMPATIBLE_TYPE_BADNESS
;
2520 case TYPE_CODE_STRUCT
:
2521 /* currently same as TYPE_CODE_CLASS */
2522 switch (TYPE_CODE (arg
))
2524 case TYPE_CODE_STRUCT
:
2525 /* Check for derivation */
2526 if (is_ancestor (parm
, arg
))
2527 return BASE_CONVERSION_BADNESS
;
2528 /* else fall through */
2530 return INCOMPATIBLE_TYPE_BADNESS
;
2533 case TYPE_CODE_UNION
:
2534 switch (TYPE_CODE (arg
))
2536 case TYPE_CODE_UNION
:
2538 return INCOMPATIBLE_TYPE_BADNESS
;
2541 case TYPE_CODE_MEMBERPTR
:
2542 switch (TYPE_CODE (arg
))
2545 return INCOMPATIBLE_TYPE_BADNESS
;
2548 case TYPE_CODE_METHOD
:
2549 switch (TYPE_CODE (arg
))
2553 return INCOMPATIBLE_TYPE_BADNESS
;
2557 switch (TYPE_CODE (arg
))
2561 return INCOMPATIBLE_TYPE_BADNESS
;
2566 switch (TYPE_CODE (arg
))
2570 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0),
2571 TYPE_FIELD_TYPE (arg
, 0));
2573 return INCOMPATIBLE_TYPE_BADNESS
;
2576 case TYPE_CODE_VOID
:
2578 return INCOMPATIBLE_TYPE_BADNESS
;
2579 } /* switch (TYPE_CODE (arg)) */
2583 /* End of functions for overload resolution */
2586 print_bit_vector (B_TYPE
*bits
, int nbits
)
2590 for (bitno
= 0; bitno
< nbits
; bitno
++)
2592 if ((bitno
% 8) == 0)
2594 puts_filtered (" ");
2596 if (B_TST (bits
, bitno
))
2597 printf_filtered (("1"));
2599 printf_filtered (("0"));
2603 /* Note the first arg should be the "this" pointer, we may not want to
2604 include it since we may get into a infinitely recursive
2608 print_arg_types (struct field
*args
, int nargs
, int spaces
)
2614 for (i
= 0; i
< nargs
; i
++)
2615 recursive_dump_type (args
[i
].type
, spaces
+ 2);
2620 field_is_static (struct field
*f
)
2622 /* "static" fields are the fields whose location is not relative
2623 to the address of the enclosing struct. It would be nice to
2624 have a dedicated flag that would be set for static fields when
2625 the type is being created. But in practice, checking the field
2626 loc_kind should give us an accurate answer. */
2627 return (FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSNAME
2628 || FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSADDR
);
2632 dump_fn_fieldlists (struct type
*type
, int spaces
)
2638 printfi_filtered (spaces
, "fn_fieldlists ");
2639 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2640 printf_filtered ("\n");
2641 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2643 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2644 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2646 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2647 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2649 printf_filtered (_(") length %d\n"),
2650 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2651 for (overload_idx
= 0;
2652 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2655 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2657 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2658 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2660 printf_filtered (")\n");
2661 printfi_filtered (spaces
+ 8, "type ");
2662 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2664 printf_filtered ("\n");
2666 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2669 printfi_filtered (spaces
+ 8, "args ");
2670 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2672 printf_filtered ("\n");
2674 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2675 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
,
2678 printfi_filtered (spaces
+ 8, "fcontext ");
2679 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2681 printf_filtered ("\n");
2683 printfi_filtered (spaces
+ 8, "is_const %d\n",
2684 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2685 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2686 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2687 printfi_filtered (spaces
+ 8, "is_private %d\n",
2688 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2689 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2690 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2691 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2692 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2693 printfi_filtered (spaces
+ 8, "voffset %u\n",
2694 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2700 print_cplus_stuff (struct type
*type
, int spaces
)
2702 printfi_filtered (spaces
, "n_baseclasses %d\n",
2703 TYPE_N_BASECLASSES (type
));
2704 printfi_filtered (spaces
, "nfn_fields %d\n",
2705 TYPE_NFN_FIELDS (type
));
2706 printfi_filtered (spaces
, "nfn_fields_total %d\n",
2707 TYPE_NFN_FIELDS_TOTAL (type
));
2708 if (TYPE_N_BASECLASSES (type
) > 0)
2710 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2711 TYPE_N_BASECLASSES (type
));
2712 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
2714 printf_filtered (")");
2716 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2717 TYPE_N_BASECLASSES (type
));
2718 puts_filtered ("\n");
2720 if (TYPE_NFIELDS (type
) > 0)
2722 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2724 printfi_filtered (spaces
,
2725 "private_field_bits (%d bits at *",
2726 TYPE_NFIELDS (type
));
2727 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
2729 printf_filtered (")");
2730 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2731 TYPE_NFIELDS (type
));
2732 puts_filtered ("\n");
2734 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2736 printfi_filtered (spaces
,
2737 "protected_field_bits (%d bits at *",
2738 TYPE_NFIELDS (type
));
2739 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
2741 printf_filtered (")");
2742 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2743 TYPE_NFIELDS (type
));
2744 puts_filtered ("\n");
2747 if (TYPE_NFN_FIELDS (type
) > 0)
2749 dump_fn_fieldlists (type
, spaces
);
2753 /* Print the contents of the TYPE's type_specific union, assuming that
2754 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
2757 print_gnat_stuff (struct type
*type
, int spaces
)
2759 struct type
*descriptive_type
= TYPE_DESCRIPTIVE_TYPE (type
);
2761 recursive_dump_type (descriptive_type
, spaces
+ 2);
2764 static struct obstack dont_print_type_obstack
;
2767 recursive_dump_type (struct type
*type
, int spaces
)
2772 obstack_begin (&dont_print_type_obstack
, 0);
2774 if (TYPE_NFIELDS (type
) > 0
2775 || (HAVE_CPLUS_STRUCT (type
) && TYPE_NFN_FIELDS (type
) > 0))
2777 struct type
**first_dont_print
2778 = (struct type
**) obstack_base (&dont_print_type_obstack
);
2780 int i
= (struct type
**)
2781 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
2785 if (type
== first_dont_print
[i
])
2787 printfi_filtered (spaces
, "type node ");
2788 gdb_print_host_address (type
, gdb_stdout
);
2789 printf_filtered (_(" <same as already seen type>\n"));
2794 obstack_ptr_grow (&dont_print_type_obstack
, type
);
2797 printfi_filtered (spaces
, "type node ");
2798 gdb_print_host_address (type
, gdb_stdout
);
2799 printf_filtered ("\n");
2800 printfi_filtered (spaces
, "name '%s' (",
2801 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
2802 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
2803 printf_filtered (")\n");
2804 printfi_filtered (spaces
, "tagname '%s' (",
2805 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
2806 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
2807 printf_filtered (")\n");
2808 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
2809 switch (TYPE_CODE (type
))
2811 case TYPE_CODE_UNDEF
:
2812 printf_filtered ("(TYPE_CODE_UNDEF)");
2815 printf_filtered ("(TYPE_CODE_PTR)");
2817 case TYPE_CODE_ARRAY
:
2818 printf_filtered ("(TYPE_CODE_ARRAY)");
2820 case TYPE_CODE_STRUCT
:
2821 printf_filtered ("(TYPE_CODE_STRUCT)");
2823 case TYPE_CODE_UNION
:
2824 printf_filtered ("(TYPE_CODE_UNION)");
2826 case TYPE_CODE_ENUM
:
2827 printf_filtered ("(TYPE_CODE_ENUM)");
2829 case TYPE_CODE_FLAGS
:
2830 printf_filtered ("(TYPE_CODE_FLAGS)");
2832 case TYPE_CODE_FUNC
:
2833 printf_filtered ("(TYPE_CODE_FUNC)");
2836 printf_filtered ("(TYPE_CODE_INT)");
2839 printf_filtered ("(TYPE_CODE_FLT)");
2841 case TYPE_CODE_VOID
:
2842 printf_filtered ("(TYPE_CODE_VOID)");
2845 printf_filtered ("(TYPE_CODE_SET)");
2847 case TYPE_CODE_RANGE
:
2848 printf_filtered ("(TYPE_CODE_RANGE)");
2850 case TYPE_CODE_STRING
:
2851 printf_filtered ("(TYPE_CODE_STRING)");
2853 case TYPE_CODE_BITSTRING
:
2854 printf_filtered ("(TYPE_CODE_BITSTRING)");
2856 case TYPE_CODE_ERROR
:
2857 printf_filtered ("(TYPE_CODE_ERROR)");
2859 case TYPE_CODE_MEMBERPTR
:
2860 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
2862 case TYPE_CODE_METHODPTR
:
2863 printf_filtered ("(TYPE_CODE_METHODPTR)");
2865 case TYPE_CODE_METHOD
:
2866 printf_filtered ("(TYPE_CODE_METHOD)");
2869 printf_filtered ("(TYPE_CODE_REF)");
2871 case TYPE_CODE_CHAR
:
2872 printf_filtered ("(TYPE_CODE_CHAR)");
2874 case TYPE_CODE_BOOL
:
2875 printf_filtered ("(TYPE_CODE_BOOL)");
2877 case TYPE_CODE_COMPLEX
:
2878 printf_filtered ("(TYPE_CODE_COMPLEX)");
2880 case TYPE_CODE_TYPEDEF
:
2881 printf_filtered ("(TYPE_CODE_TYPEDEF)");
2883 case TYPE_CODE_NAMESPACE
:
2884 printf_filtered ("(TYPE_CODE_NAMESPACE)");
2887 printf_filtered ("(UNKNOWN TYPE CODE)");
2890 puts_filtered ("\n");
2891 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
2892 if (TYPE_OBJFILE_OWNED (type
))
2894 printfi_filtered (spaces
, "objfile ");
2895 gdb_print_host_address (TYPE_OWNER (type
).objfile
, gdb_stdout
);
2899 printfi_filtered (spaces
, "gdbarch ");
2900 gdb_print_host_address (TYPE_OWNER (type
).gdbarch
, gdb_stdout
);
2902 printf_filtered ("\n");
2903 printfi_filtered (spaces
, "target_type ");
2904 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
2905 printf_filtered ("\n");
2906 if (TYPE_TARGET_TYPE (type
) != NULL
)
2908 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
2910 printfi_filtered (spaces
, "pointer_type ");
2911 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
2912 printf_filtered ("\n");
2913 printfi_filtered (spaces
, "reference_type ");
2914 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
2915 printf_filtered ("\n");
2916 printfi_filtered (spaces
, "type_chain ");
2917 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
2918 printf_filtered ("\n");
2919 printfi_filtered (spaces
, "instance_flags 0x%x",
2920 TYPE_INSTANCE_FLAGS (type
));
2921 if (TYPE_CONST (type
))
2923 puts_filtered (" TYPE_FLAG_CONST");
2925 if (TYPE_VOLATILE (type
))
2927 puts_filtered (" TYPE_FLAG_VOLATILE");
2929 if (TYPE_CODE_SPACE (type
))
2931 puts_filtered (" TYPE_FLAG_CODE_SPACE");
2933 if (TYPE_DATA_SPACE (type
))
2935 puts_filtered (" TYPE_FLAG_DATA_SPACE");
2937 if (TYPE_ADDRESS_CLASS_1 (type
))
2939 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
2941 if (TYPE_ADDRESS_CLASS_2 (type
))
2943 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
2945 puts_filtered ("\n");
2947 printfi_filtered (spaces
, "flags");
2948 if (TYPE_UNSIGNED (type
))
2950 puts_filtered (" TYPE_FLAG_UNSIGNED");
2952 if (TYPE_NOSIGN (type
))
2954 puts_filtered (" TYPE_FLAG_NOSIGN");
2956 if (TYPE_STUB (type
))
2958 puts_filtered (" TYPE_FLAG_STUB");
2960 if (TYPE_TARGET_STUB (type
))
2962 puts_filtered (" TYPE_FLAG_TARGET_STUB");
2964 if (TYPE_STATIC (type
))
2966 puts_filtered (" TYPE_FLAG_STATIC");
2968 if (TYPE_PROTOTYPED (type
))
2970 puts_filtered (" TYPE_FLAG_PROTOTYPED");
2972 if (TYPE_INCOMPLETE (type
))
2974 puts_filtered (" TYPE_FLAG_INCOMPLETE");
2976 if (TYPE_VARARGS (type
))
2978 puts_filtered (" TYPE_FLAG_VARARGS");
2980 /* This is used for things like AltiVec registers on ppc. Gcc emits
2981 an attribute for the array type, which tells whether or not we
2982 have a vector, instead of a regular array. */
2983 if (TYPE_VECTOR (type
))
2985 puts_filtered (" TYPE_FLAG_VECTOR");
2987 if (TYPE_FIXED_INSTANCE (type
))
2989 puts_filtered (" TYPE_FIXED_INSTANCE");
2991 if (TYPE_STUB_SUPPORTED (type
))
2993 puts_filtered (" TYPE_STUB_SUPPORTED");
2995 if (TYPE_NOTTEXT (type
))
2997 puts_filtered (" TYPE_NOTTEXT");
2999 puts_filtered ("\n");
3000 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
3001 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
3002 puts_filtered ("\n");
3003 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
3005 printfi_filtered (spaces
+ 2,
3006 "[%d] bitpos %d bitsize %d type ",
3007 idx
, TYPE_FIELD_BITPOS (type
, idx
),
3008 TYPE_FIELD_BITSIZE (type
, idx
));
3009 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
3010 printf_filtered (" name '%s' (",
3011 TYPE_FIELD_NAME (type
, idx
) != NULL
3012 ? TYPE_FIELD_NAME (type
, idx
)
3014 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
3015 printf_filtered (")\n");
3016 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
3018 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
3021 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
3023 printfi_filtered (spaces
, "low %s%s high %s%s\n",
3024 plongest (TYPE_LOW_BOUND (type
)),
3025 TYPE_LOW_BOUND_UNDEFINED (type
) ? " (undefined)" : "",
3026 plongest (TYPE_HIGH_BOUND (type
)),
3027 TYPE_HIGH_BOUND_UNDEFINED (type
) ? " (undefined)" : "");
3029 printfi_filtered (spaces
, "vptr_basetype ");
3030 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
3031 puts_filtered ("\n");
3032 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
3034 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
3036 printfi_filtered (spaces
, "vptr_fieldno %d\n",
3037 TYPE_VPTR_FIELDNO (type
));
3039 switch (TYPE_SPECIFIC_FIELD (type
))
3041 case TYPE_SPECIFIC_CPLUS_STUFF
:
3042 printfi_filtered (spaces
, "cplus_stuff ");
3043 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
),
3045 puts_filtered ("\n");
3046 print_cplus_stuff (type
, spaces
);
3049 case TYPE_SPECIFIC_GNAT_STUFF
:
3050 printfi_filtered (spaces
, "gnat_stuff ");
3051 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type
), gdb_stdout
);
3052 puts_filtered ("\n");
3053 print_gnat_stuff (type
, spaces
);
3056 case TYPE_SPECIFIC_FLOATFORMAT
:
3057 printfi_filtered (spaces
, "floatformat ");
3058 if (TYPE_FLOATFORMAT (type
) == NULL
)
3059 puts_filtered ("(null)");
3062 puts_filtered ("{ ");
3063 if (TYPE_FLOATFORMAT (type
)[0] == NULL
3064 || TYPE_FLOATFORMAT (type
)[0]->name
== NULL
)
3065 puts_filtered ("(null)");
3067 puts_filtered (TYPE_FLOATFORMAT (type
)[0]->name
);
3069 puts_filtered (", ");
3070 if (TYPE_FLOATFORMAT (type
)[1] == NULL
3071 || TYPE_FLOATFORMAT (type
)[1]->name
== NULL
)
3072 puts_filtered ("(null)");
3074 puts_filtered (TYPE_FLOATFORMAT (type
)[1]->name
);
3076 puts_filtered (" }");
3078 puts_filtered ("\n");
3081 case TYPE_SPECIFIC_CALLING_CONVENTION
:
3082 printfi_filtered (spaces
, "calling_convention %d\n",
3083 TYPE_CALLING_CONVENTION (type
));
3088 obstack_free (&dont_print_type_obstack
, NULL
);
3091 /* Trivial helpers for the libiberty hash table, for mapping one
3096 struct type
*old
, *new;
3100 type_pair_hash (const void *item
)
3102 const struct type_pair
*pair
= item
;
3104 return htab_hash_pointer (pair
->old
);
3108 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
3110 const struct type_pair
*lhs
= item_lhs
, *rhs
= item_rhs
;
3112 return lhs
->old
== rhs
->old
;
3115 /* Allocate the hash table used by copy_type_recursive to walk
3116 types without duplicates. We use OBJFILE's obstack, because
3117 OBJFILE is about to be deleted. */
3120 create_copied_types_hash (struct objfile
*objfile
)
3122 return htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
3123 NULL
, &objfile
->objfile_obstack
,
3124 hashtab_obstack_allocate
,
3125 dummy_obstack_deallocate
);
3128 /* Recursively copy (deep copy) TYPE, if it is associated with
3129 OBJFILE. Return a new type allocated using malloc, a saved type if
3130 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
3131 not associated with OBJFILE. */
3134 copy_type_recursive (struct objfile
*objfile
,
3136 htab_t copied_types
)
3138 struct type_pair
*stored
, pair
;
3140 struct type
*new_type
;
3142 if (! TYPE_OBJFILE_OWNED (type
))
3145 /* This type shouldn't be pointing to any types in other objfiles;
3146 if it did, the type might disappear unexpectedly. */
3147 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
3150 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
3152 return ((struct type_pair
*) *slot
)->new;
3154 new_type
= alloc_type_arch (get_type_arch (type
));
3156 /* We must add the new type to the hash table immediately, in case
3157 we encounter this type again during a recursive call below. */
3158 stored
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct type_pair
));
3160 stored
->new = new_type
;
3163 /* Copy the common fields of types. For the main type, we simply
3164 copy the entire thing and then update specific fields as needed. */
3165 *TYPE_MAIN_TYPE (new_type
) = *TYPE_MAIN_TYPE (type
);
3166 TYPE_OBJFILE_OWNED (new_type
) = 0;
3167 TYPE_OWNER (new_type
).gdbarch
= get_type_arch (type
);
3169 if (TYPE_NAME (type
))
3170 TYPE_NAME (new_type
) = xstrdup (TYPE_NAME (type
));
3171 if (TYPE_TAG_NAME (type
))
3172 TYPE_TAG_NAME (new_type
) = xstrdup (TYPE_TAG_NAME (type
));
3174 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
3175 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
3177 /* Copy the fields. */
3178 if (TYPE_NFIELDS (type
))
3182 nfields
= TYPE_NFIELDS (type
);
3183 TYPE_FIELDS (new_type
) = XCALLOC (nfields
, struct field
);
3184 for (i
= 0; i
< nfields
; i
++)
3186 TYPE_FIELD_ARTIFICIAL (new_type
, i
) =
3187 TYPE_FIELD_ARTIFICIAL (type
, i
);
3188 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
3189 if (TYPE_FIELD_TYPE (type
, i
))
3190 TYPE_FIELD_TYPE (new_type
, i
)
3191 = copy_type_recursive (objfile
, TYPE_FIELD_TYPE (type
, i
),
3193 if (TYPE_FIELD_NAME (type
, i
))
3194 TYPE_FIELD_NAME (new_type
, i
) =
3195 xstrdup (TYPE_FIELD_NAME (type
, i
));
3196 switch (TYPE_FIELD_LOC_KIND (type
, i
))
3198 case FIELD_LOC_KIND_BITPOS
:
3199 SET_FIELD_BITPOS (TYPE_FIELD (new_type
, i
),
3200 TYPE_FIELD_BITPOS (type
, i
));
3202 case FIELD_LOC_KIND_PHYSADDR
:
3203 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type
, i
),
3204 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
3206 case FIELD_LOC_KIND_PHYSNAME
:
3207 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type
, i
),
3208 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
,
3212 internal_error (__FILE__
, __LINE__
,
3213 _("Unexpected type field location kind: %d"),
3214 TYPE_FIELD_LOC_KIND (type
, i
));
3219 /* For range types, copy the bounds information. */
3220 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
3222 TYPE_RANGE_DATA (new_type
) = xmalloc (sizeof (struct range_bounds
));
3223 *TYPE_RANGE_DATA (new_type
) = *TYPE_RANGE_DATA (type
);
3226 /* Copy pointers to other types. */
3227 if (TYPE_TARGET_TYPE (type
))
3228 TYPE_TARGET_TYPE (new_type
) =
3229 copy_type_recursive (objfile
,
3230 TYPE_TARGET_TYPE (type
),
3232 if (TYPE_VPTR_BASETYPE (type
))
3233 TYPE_VPTR_BASETYPE (new_type
) =
3234 copy_type_recursive (objfile
,
3235 TYPE_VPTR_BASETYPE (type
),
3237 /* Maybe copy the type_specific bits.
3239 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3240 base classes and methods. There's no fundamental reason why we
3241 can't, but at the moment it is not needed. */
3243 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
3244 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
3245 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3246 || TYPE_CODE (type
) == TYPE_CODE_UNION
3247 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
3248 INIT_CPLUS_SPECIFIC (new_type
);
3253 /* Make a copy of the given TYPE, except that the pointer & reference
3254 types are not preserved.
3256 This function assumes that the given type has an associated objfile.
3257 This objfile is used to allocate the new type. */
3260 copy_type (const struct type
*type
)
3262 struct type
*new_type
;
3264 gdb_assert (TYPE_OBJFILE_OWNED (type
));
3266 new_type
= alloc_type_copy (type
);
3267 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
3268 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
3269 memcpy (TYPE_MAIN_TYPE (new_type
), TYPE_MAIN_TYPE (type
),
3270 sizeof (struct main_type
));
3276 /* Helper functions to initialize architecture-specific types. */
3278 /* Allocate a type structure associated with GDBARCH and set its
3279 CODE, LENGTH, and NAME fields. */
3281 arch_type (struct gdbarch
*gdbarch
,
3282 enum type_code code
, int length
, char *name
)
3286 type
= alloc_type_arch (gdbarch
);
3287 TYPE_CODE (type
) = code
;
3288 TYPE_LENGTH (type
) = length
;
3291 TYPE_NAME (type
) = xstrdup (name
);
3296 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
3297 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3298 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3300 arch_integer_type (struct gdbarch
*gdbarch
,
3301 int bit
, int unsigned_p
, char *name
)
3305 t
= arch_type (gdbarch
, TYPE_CODE_INT
, bit
/ TARGET_CHAR_BIT
, name
);
3307 TYPE_UNSIGNED (t
) = 1;
3308 if (name
&& strcmp (name
, "char") == 0)
3309 TYPE_NOSIGN (t
) = 1;
3314 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
3315 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3316 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3318 arch_character_type (struct gdbarch
*gdbarch
,
3319 int bit
, int unsigned_p
, char *name
)
3323 t
= arch_type (gdbarch
, TYPE_CODE_CHAR
, bit
/ TARGET_CHAR_BIT
, name
);
3325 TYPE_UNSIGNED (t
) = 1;
3330 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
3331 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3332 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3334 arch_boolean_type (struct gdbarch
*gdbarch
,
3335 int bit
, int unsigned_p
, char *name
)
3339 t
= arch_type (gdbarch
, TYPE_CODE_BOOL
, bit
/ TARGET_CHAR_BIT
, name
);
3341 TYPE_UNSIGNED (t
) = 1;
3346 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
3347 BIT is the type size in bits; if BIT equals -1, the size is
3348 determined by the floatformat. NAME is the type name. Set the
3349 TYPE_FLOATFORMAT from FLOATFORMATS. */
3351 arch_float_type (struct gdbarch
*gdbarch
,
3352 int bit
, char *name
, const struct floatformat
**floatformats
)
3358 gdb_assert (floatformats
!= NULL
);
3359 gdb_assert (floatformats
[0] != NULL
&& floatformats
[1] != NULL
);
3360 bit
= floatformats
[0]->totalsize
;
3362 gdb_assert (bit
>= 0);
3364 t
= arch_type (gdbarch
, TYPE_CODE_FLT
, bit
/ TARGET_CHAR_BIT
, name
);
3365 TYPE_FLOATFORMAT (t
) = floatformats
;
3369 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
3370 NAME is the type name. TARGET_TYPE is the component float type. */
3372 arch_complex_type (struct gdbarch
*gdbarch
,
3373 char *name
, struct type
*target_type
)
3377 t
= arch_type (gdbarch
, TYPE_CODE_COMPLEX
,
3378 2 * TYPE_LENGTH (target_type
), name
);
3379 TYPE_TARGET_TYPE (t
) = target_type
;
3383 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
3384 NAME is the type name. LENGTH is the size of the flag word in bytes. */
3386 arch_flags_type (struct gdbarch
*gdbarch
, char *name
, int length
)
3388 int nfields
= length
* TARGET_CHAR_BIT
;
3391 type
= arch_type (gdbarch
, TYPE_CODE_FLAGS
, length
, name
);
3392 TYPE_UNSIGNED (type
) = 1;
3393 TYPE_NFIELDS (type
) = nfields
;
3394 TYPE_FIELDS (type
) = TYPE_ZALLOC (type
, nfields
* sizeof (struct field
));
3399 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
3400 position BITPOS is called NAME. */
3402 append_flags_type_flag (struct type
*type
, int bitpos
, char *name
)
3404 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLAGS
);
3405 gdb_assert (bitpos
< TYPE_NFIELDS (type
));
3406 gdb_assert (bitpos
>= 0);
3410 TYPE_FIELD_NAME (type
, bitpos
) = xstrdup (name
);
3411 TYPE_FIELD_BITPOS (type
, bitpos
) = bitpos
;
3415 /* Don't show this field to the user. */
3416 TYPE_FIELD_BITPOS (type
, bitpos
) = -1;
3420 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
3421 specified by CODE) associated with GDBARCH. NAME is the type name. */
3423 arch_composite_type (struct gdbarch
*gdbarch
, char *name
, enum type_code code
)
3427 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
3428 t
= arch_type (gdbarch
, code
, 0, NULL
);
3429 TYPE_TAG_NAME (t
) = name
;
3430 INIT_CPLUS_SPECIFIC (t
);
3434 /* Add new field with name NAME and type FIELD to composite type T.
3435 Do not set the field's position or adjust the type's length;
3436 the caller should do so. Return the new field. */
3438 append_composite_type_field_raw (struct type
*t
, char *name
,
3443 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
3444 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
3445 sizeof (struct field
) * TYPE_NFIELDS (t
));
3446 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
3447 memset (f
, 0, sizeof f
[0]);
3448 FIELD_TYPE (f
[0]) = field
;
3449 FIELD_NAME (f
[0]) = name
;
3453 /* Add new field with name NAME and type FIELD to composite type T.
3454 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
3456 append_composite_type_field_aligned (struct type
*t
, char *name
,
3457 struct type
*field
, int alignment
)
3459 struct field
*f
= append_composite_type_field_raw (t
, name
, field
);
3461 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
3463 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
3464 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
3466 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
3468 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
3469 if (TYPE_NFIELDS (t
) > 1)
3471 FIELD_BITPOS (f
[0]) = (FIELD_BITPOS (f
[-1])
3472 + (TYPE_LENGTH (FIELD_TYPE (f
[-1]))
3473 * TARGET_CHAR_BIT
));
3477 int left
= FIELD_BITPOS (f
[0]) % (alignment
* TARGET_CHAR_BIT
);
3481 FIELD_BITPOS (f
[0]) += left
;
3482 TYPE_LENGTH (t
) += left
/ TARGET_CHAR_BIT
;
3489 /* Add new field with name NAME and type FIELD to composite type T. */
3491 append_composite_type_field (struct type
*t
, char *name
,
3494 append_composite_type_field_aligned (t
, name
, field
, 0);
3498 static struct gdbarch_data
*gdbtypes_data
;
3500 const struct builtin_type
*
3501 builtin_type (struct gdbarch
*gdbarch
)
3503 return gdbarch_data (gdbarch
, gdbtypes_data
);
3507 gdbtypes_post_init (struct gdbarch
*gdbarch
)
3509 struct builtin_type
*builtin_type
3510 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
3513 builtin_type
->builtin_void
3514 = arch_type (gdbarch
, TYPE_CODE_VOID
, 1, "void");
3515 builtin_type
->builtin_char
3516 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3517 !gdbarch_char_signed (gdbarch
), "char");
3518 builtin_type
->builtin_signed_char
3519 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3521 builtin_type
->builtin_unsigned_char
3522 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3523 1, "unsigned char");
3524 builtin_type
->builtin_short
3525 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
3527 builtin_type
->builtin_unsigned_short
3528 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
3529 1, "unsigned short");
3530 builtin_type
->builtin_int
3531 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
3533 builtin_type
->builtin_unsigned_int
3534 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
3536 builtin_type
->builtin_long
3537 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
3539 builtin_type
->builtin_unsigned_long
3540 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
3541 1, "unsigned long");
3542 builtin_type
->builtin_long_long
3543 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
3545 builtin_type
->builtin_unsigned_long_long
3546 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
3547 1, "unsigned long long");
3548 builtin_type
->builtin_float
3549 = arch_float_type (gdbarch
, gdbarch_float_bit (gdbarch
),
3550 "float", gdbarch_float_format (gdbarch
));
3551 builtin_type
->builtin_double
3552 = arch_float_type (gdbarch
, gdbarch_double_bit (gdbarch
),
3553 "double", gdbarch_double_format (gdbarch
));
3554 builtin_type
->builtin_long_double
3555 = arch_float_type (gdbarch
, gdbarch_long_double_bit (gdbarch
),
3556 "long double", gdbarch_long_double_format (gdbarch
));
3557 builtin_type
->builtin_complex
3558 = arch_complex_type (gdbarch
, "complex",
3559 builtin_type
->builtin_float
);
3560 builtin_type
->builtin_double_complex
3561 = arch_complex_type (gdbarch
, "double complex",
3562 builtin_type
->builtin_double
);
3563 builtin_type
->builtin_string
3564 = arch_type (gdbarch
, TYPE_CODE_STRING
, 1, "string");
3565 builtin_type
->builtin_bool
3566 = arch_type (gdbarch
, TYPE_CODE_BOOL
, 1, "bool");
3568 /* The following three are about decimal floating point types, which
3569 are 32-bits, 64-bits and 128-bits respectively. */
3570 builtin_type
->builtin_decfloat
3571 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 32 / 8, "_Decimal32");
3572 builtin_type
->builtin_decdouble
3573 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 64 / 8, "_Decimal64");
3574 builtin_type
->builtin_declong
3575 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 128 / 8, "_Decimal128");
3577 /* "True" character types. */
3578 builtin_type
->builtin_true_char
3579 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 0, "true character");
3580 builtin_type
->builtin_true_unsigned_char
3581 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 1, "true character");
3583 /* Fixed-size integer types. */
3584 builtin_type
->builtin_int0
3585 = arch_integer_type (gdbarch
, 0, 0, "int0_t");
3586 builtin_type
->builtin_int8
3587 = arch_integer_type (gdbarch
, 8, 0, "int8_t");
3588 builtin_type
->builtin_uint8
3589 = arch_integer_type (gdbarch
, 8, 1, "uint8_t");
3590 builtin_type
->builtin_int16
3591 = arch_integer_type (gdbarch
, 16, 0, "int16_t");
3592 builtin_type
->builtin_uint16
3593 = arch_integer_type (gdbarch
, 16, 1, "uint16_t");
3594 builtin_type
->builtin_int32
3595 = arch_integer_type (gdbarch
, 32, 0, "int32_t");
3596 builtin_type
->builtin_uint32
3597 = arch_integer_type (gdbarch
, 32, 1, "uint32_t");
3598 builtin_type
->builtin_int64
3599 = arch_integer_type (gdbarch
, 64, 0, "int64_t");
3600 builtin_type
->builtin_uint64
3601 = arch_integer_type (gdbarch
, 64, 1, "uint64_t");
3602 builtin_type
->builtin_int128
3603 = arch_integer_type (gdbarch
, 128, 0, "int128_t");
3604 builtin_type
->builtin_uint128
3605 = arch_integer_type (gdbarch
, 128, 1, "uint128_t");
3606 TYPE_INSTANCE_FLAGS (builtin_type
->builtin_int8
) |=
3607 TYPE_INSTANCE_FLAG_NOTTEXT
;
3608 TYPE_INSTANCE_FLAGS (builtin_type
->builtin_uint8
) |=
3609 TYPE_INSTANCE_FLAG_NOTTEXT
;
3611 /* Wide character types. */
3612 builtin_type
->builtin_char16
3613 = arch_integer_type (gdbarch
, 16, 0, "char16_t");
3614 builtin_type
->builtin_char32
3615 = arch_integer_type (gdbarch
, 32, 0, "char32_t");
3618 /* Default data/code pointer types. */
3619 builtin_type
->builtin_data_ptr
3620 = lookup_pointer_type (builtin_type
->builtin_void
);
3621 builtin_type
->builtin_func_ptr
3622 = lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
3624 /* This type represents a GDB internal function. */
3625 builtin_type
->internal_fn
3626 = arch_type (gdbarch
, TYPE_CODE_INTERNAL_FUNCTION
, 0,
3627 "<internal function>");
3629 return builtin_type
;
3633 /* This set of objfile-based types is intended to be used by symbol
3634 readers as basic types. */
3636 static const struct objfile_data
*objfile_type_data
;
3638 const struct objfile_type
*
3639 objfile_type (struct objfile
*objfile
)
3641 struct gdbarch
*gdbarch
;
3642 struct objfile_type
*objfile_type
3643 = objfile_data (objfile
, objfile_type_data
);
3646 return objfile_type
;
3648 objfile_type
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
3649 1, struct objfile_type
);
3651 /* Use the objfile architecture to determine basic type properties. */
3652 gdbarch
= get_objfile_arch (objfile
);
3655 objfile_type
->builtin_void
3656 = init_type (TYPE_CODE_VOID
, 1,
3660 objfile_type
->builtin_char
3661 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3663 | (gdbarch_char_signed (gdbarch
) ? 0 : TYPE_FLAG_UNSIGNED
)),
3665 objfile_type
->builtin_signed_char
3666 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3668 "signed char", objfile
);
3669 objfile_type
->builtin_unsigned_char
3670 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3672 "unsigned char", objfile
);
3673 objfile_type
->builtin_short
3674 = init_type (TYPE_CODE_INT
,
3675 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3676 0, "short", objfile
);
3677 objfile_type
->builtin_unsigned_short
3678 = init_type (TYPE_CODE_INT
,
3679 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3680 TYPE_FLAG_UNSIGNED
, "unsigned short", objfile
);
3681 objfile_type
->builtin_int
3682 = init_type (TYPE_CODE_INT
,
3683 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3685 objfile_type
->builtin_unsigned_int
3686 = init_type (TYPE_CODE_INT
,
3687 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3688 TYPE_FLAG_UNSIGNED
, "unsigned int", objfile
);
3689 objfile_type
->builtin_long
3690 = init_type (TYPE_CODE_INT
,
3691 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3692 0, "long", objfile
);
3693 objfile_type
->builtin_unsigned_long
3694 = init_type (TYPE_CODE_INT
,
3695 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3696 TYPE_FLAG_UNSIGNED
, "unsigned long", objfile
);
3697 objfile_type
->builtin_long_long
3698 = init_type (TYPE_CODE_INT
,
3699 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3700 0, "long long", objfile
);
3701 objfile_type
->builtin_unsigned_long_long
3702 = init_type (TYPE_CODE_INT
,
3703 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3704 TYPE_FLAG_UNSIGNED
, "unsigned long long", objfile
);
3706 objfile_type
->builtin_float
3707 = init_type (TYPE_CODE_FLT
,
3708 gdbarch_float_bit (gdbarch
) / TARGET_CHAR_BIT
,
3709 0, "float", objfile
);
3710 TYPE_FLOATFORMAT (objfile_type
->builtin_float
)
3711 = gdbarch_float_format (gdbarch
);
3712 objfile_type
->builtin_double
3713 = init_type (TYPE_CODE_FLT
,
3714 gdbarch_double_bit (gdbarch
) / TARGET_CHAR_BIT
,
3715 0, "double", objfile
);
3716 TYPE_FLOATFORMAT (objfile_type
->builtin_double
)
3717 = gdbarch_double_format (gdbarch
);
3718 objfile_type
->builtin_long_double
3719 = init_type (TYPE_CODE_FLT
,
3720 gdbarch_long_double_bit (gdbarch
) / TARGET_CHAR_BIT
,
3721 0, "long double", objfile
);
3722 TYPE_FLOATFORMAT (objfile_type
->builtin_long_double
)
3723 = gdbarch_long_double_format (gdbarch
);
3725 /* This type represents a type that was unrecognized in symbol read-in. */
3726 objfile_type
->builtin_error
3727 = init_type (TYPE_CODE_ERROR
, 0, 0, "<unknown type>", objfile
);
3729 /* The following set of types is used for symbols with no
3730 debug information. */
3731 objfile_type
->nodebug_text_symbol
3732 = init_type (TYPE_CODE_FUNC
, 1, 0,
3733 "<text variable, no debug info>", objfile
);
3734 TYPE_TARGET_TYPE (objfile_type
->nodebug_text_symbol
)
3735 = objfile_type
->builtin_int
;
3736 objfile_type
->nodebug_data_symbol
3737 = init_type (TYPE_CODE_INT
,
3738 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3739 "<data variable, no debug info>", objfile
);
3740 objfile_type
->nodebug_unknown_symbol
3741 = init_type (TYPE_CODE_INT
, 1, 0,
3742 "<variable (not text or data), no debug info>", objfile
);
3743 objfile_type
->nodebug_tls_symbol
3744 = init_type (TYPE_CODE_INT
,
3745 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3746 "<thread local variable, no debug info>", objfile
);
3748 /* NOTE: on some targets, addresses and pointers are not necessarily
3749 the same --- for example, on the D10V, pointers are 16 bits long,
3750 but addresses are 32 bits long. See doc/gdbint.texinfo,
3751 ``Pointers Are Not Always Addresses''.
3754 - gdb's `struct type' always describes the target's
3756 - gdb's `struct value' objects should always hold values in
3758 - gdb's CORE_ADDR values are addresses in the unified virtual
3759 address space that the assembler and linker work with. Thus,
3760 since target_read_memory takes a CORE_ADDR as an argument, it
3761 can access any memory on the target, even if the processor has
3762 separate code and data address spaces.
3765 - If v is a value holding a D10V code pointer, its contents are
3766 in target form: a big-endian address left-shifted two bits.
3767 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3768 sizeof (void *) == 2 on the target.
3770 In this context, objfile_type->builtin_core_addr is a bit odd:
3771 it's a target type for a value the target will never see. It's
3772 only used to hold the values of (typeless) linker symbols, which
3773 are indeed in the unified virtual address space. */
3775 objfile_type
->builtin_core_addr
3776 = init_type (TYPE_CODE_INT
,
3777 gdbarch_addr_bit (gdbarch
) / 8,
3778 TYPE_FLAG_UNSIGNED
, "__CORE_ADDR", objfile
);
3780 set_objfile_data (objfile
, objfile_type_data
, objfile_type
);
3781 return objfile_type
;
3785 extern void _initialize_gdbtypes (void);
3787 _initialize_gdbtypes (void)
3789 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
3790 objfile_type_data
= register_objfile_data ();
3792 add_setshow_zinteger_cmd ("overload", no_class
, &overload_debug
, _("\
3793 Set debugging of C++ overloading."), _("\
3794 Show debugging of C++ overloading."), _("\
3795 When enabled, ranking of the functions is displayed."),
3797 show_overload_debug
,
3798 &setdebuglist
, &showdebuglist
);
3800 /* Add user knob for controlling resolution of opaque types. */
3801 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
3802 &opaque_type_resolution
, _("\
3803 Set resolution of opaque struct/class/union types (if set before loading symbols)."), _("\
3804 Show resolution of opaque struct/class/union types (if set before loading symbols)."), NULL
,
3806 show_opaque_type_resolution
,
3807 &setlist
, &showlist
);