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, 2011
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 /* Initialize BADNESS constants. */
46 const struct rank LENGTH_MISMATCH_BADNESS
= {100,0};
48 const struct rank TOO_FEW_PARAMS_BADNESS
= {100,0};
49 const struct rank INCOMPATIBLE_TYPE_BADNESS
= {100,0};
51 const struct rank EXACT_MATCH_BADNESS
= {0,0};
53 const struct rank INTEGER_PROMOTION_BADNESS
= {1,0};
54 const struct rank FLOAT_PROMOTION_BADNESS
= {1,0};
55 const struct rank BASE_PTR_CONVERSION_BADNESS
= {1,0};
56 const struct rank INTEGER_CONVERSION_BADNESS
= {2,0};
57 const struct rank FLOAT_CONVERSION_BADNESS
= {2,0};
58 const struct rank INT_FLOAT_CONVERSION_BADNESS
= {2,0};
59 const struct rank VOID_PTR_CONVERSION_BADNESS
= {2,0};
60 const struct rank BOOL_PTR_CONVERSION_BADNESS
= {3,0};
61 const struct rank BASE_CONVERSION_BADNESS
= {2,0};
62 const struct rank REFERENCE_CONVERSION_BADNESS
= {2,0};
64 const struct rank NS_POINTER_CONVERSION_BADNESS
= {10,0};
66 /* Floatformat pairs. */
67 const struct floatformat
*floatformats_ieee_half
[BFD_ENDIAN_UNKNOWN
] = {
68 &floatformat_ieee_half_big
,
69 &floatformat_ieee_half_little
71 const struct floatformat
*floatformats_ieee_single
[BFD_ENDIAN_UNKNOWN
] = {
72 &floatformat_ieee_single_big
,
73 &floatformat_ieee_single_little
75 const struct floatformat
*floatformats_ieee_double
[BFD_ENDIAN_UNKNOWN
] = {
76 &floatformat_ieee_double_big
,
77 &floatformat_ieee_double_little
79 const struct floatformat
*floatformats_ieee_double_littlebyte_bigword
[BFD_ENDIAN_UNKNOWN
] = {
80 &floatformat_ieee_double_big
,
81 &floatformat_ieee_double_littlebyte_bigword
83 const struct floatformat
*floatformats_i387_ext
[BFD_ENDIAN_UNKNOWN
] = {
84 &floatformat_i387_ext
,
87 const struct floatformat
*floatformats_m68881_ext
[BFD_ENDIAN_UNKNOWN
] = {
88 &floatformat_m68881_ext
,
89 &floatformat_m68881_ext
91 const struct floatformat
*floatformats_arm_ext
[BFD_ENDIAN_UNKNOWN
] = {
92 &floatformat_arm_ext_big
,
93 &floatformat_arm_ext_littlebyte_bigword
95 const struct floatformat
*floatformats_ia64_spill
[BFD_ENDIAN_UNKNOWN
] = {
96 &floatformat_ia64_spill_big
,
97 &floatformat_ia64_spill_little
99 const struct floatformat
*floatformats_ia64_quad
[BFD_ENDIAN_UNKNOWN
] = {
100 &floatformat_ia64_quad_big
,
101 &floatformat_ia64_quad_little
103 const struct floatformat
*floatformats_vax_f
[BFD_ENDIAN_UNKNOWN
] = {
107 const struct floatformat
*floatformats_vax_d
[BFD_ENDIAN_UNKNOWN
] = {
111 const struct floatformat
*floatformats_ibm_long_double
[BFD_ENDIAN_UNKNOWN
] = {
112 &floatformat_ibm_long_double
,
113 &floatformat_ibm_long_double
117 int opaque_type_resolution
= 1;
119 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
120 struct cmd_list_element
*c
,
123 fprintf_filtered (file
, _("Resolution of opaque struct/class/union types "
124 "(if set before loading symbols) is %s.\n"),
128 int overload_debug
= 0;
130 show_overload_debug (struct ui_file
*file
, int from_tty
,
131 struct cmd_list_element
*c
, const char *value
)
133 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"),
141 }; /* Maximum extension is 128! FIXME */
143 static void print_bit_vector (B_TYPE
*, int);
144 static void print_arg_types (struct field
*, int, int);
145 static void dump_fn_fieldlists (struct type
*, int);
146 static void print_cplus_stuff (struct type
*, int);
149 /* Allocate a new OBJFILE-associated type structure and fill it
150 with some defaults. Space for the type structure is allocated
151 on the objfile's objfile_obstack. */
154 alloc_type (struct objfile
*objfile
)
158 gdb_assert (objfile
!= NULL
);
160 /* Alloc the structure and start off with all fields zeroed. */
161 type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct type
);
162 TYPE_MAIN_TYPE (type
) = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
164 OBJSTAT (objfile
, n_types
++);
166 TYPE_OBJFILE_OWNED (type
) = 1;
167 TYPE_OWNER (type
).objfile
= objfile
;
169 /* Initialize the fields that might not be zero. */
171 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
172 TYPE_VPTR_FIELDNO (type
) = -1;
173 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
178 /* Allocate a new GDBARCH-associated type structure and fill it
179 with some defaults. Space for the type structure is allocated
183 alloc_type_arch (struct gdbarch
*gdbarch
)
187 gdb_assert (gdbarch
!= NULL
);
189 /* Alloc the structure and start off with all fields zeroed. */
191 type
= XZALLOC (struct type
);
192 TYPE_MAIN_TYPE (type
) = XZALLOC (struct main_type
);
194 TYPE_OBJFILE_OWNED (type
) = 0;
195 TYPE_OWNER (type
).gdbarch
= gdbarch
;
197 /* Initialize the fields that might not be zero. */
199 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
200 TYPE_VPTR_FIELDNO (type
) = -1;
201 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
206 /* If TYPE is objfile-associated, allocate a new type structure
207 associated with the same objfile. If TYPE is gdbarch-associated,
208 allocate a new type structure associated with the same gdbarch. */
211 alloc_type_copy (const struct type
*type
)
213 if (TYPE_OBJFILE_OWNED (type
))
214 return alloc_type (TYPE_OWNER (type
).objfile
);
216 return alloc_type_arch (TYPE_OWNER (type
).gdbarch
);
219 /* If TYPE is gdbarch-associated, return that architecture.
220 If TYPE is objfile-associated, return that objfile's architecture. */
223 get_type_arch (const struct type
*type
)
225 if (TYPE_OBJFILE_OWNED (type
))
226 return get_objfile_arch (TYPE_OWNER (type
).objfile
);
228 return TYPE_OWNER (type
).gdbarch
;
232 /* Alloc a new type instance structure, fill it with some defaults,
233 and point it at OLDTYPE. Allocate the new type instance from the
234 same place as OLDTYPE. */
237 alloc_type_instance (struct type
*oldtype
)
241 /* Allocate the structure. */
243 if (! TYPE_OBJFILE_OWNED (oldtype
))
244 type
= XZALLOC (struct type
);
246 type
= OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype
)->objfile_obstack
,
249 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
251 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
256 /* Clear all remnants of the previous type at TYPE, in preparation for
257 replacing it with something else. Preserve owner information. */
259 smash_type (struct type
*type
)
261 int objfile_owned
= TYPE_OBJFILE_OWNED (type
);
262 union type_owner owner
= TYPE_OWNER (type
);
264 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
266 /* Restore owner information. */
267 TYPE_OBJFILE_OWNED (type
) = objfile_owned
;
268 TYPE_OWNER (type
) = owner
;
270 /* For now, delete the rings. */
271 TYPE_CHAIN (type
) = type
;
273 /* For now, leave the pointer/reference types alone. */
276 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
277 to a pointer to memory where the pointer type should be stored.
278 If *TYPEPTR is zero, update it to point to the pointer type we return.
279 We allocate new memory if needed. */
282 make_pointer_type (struct type
*type
, struct type
**typeptr
)
284 struct type
*ntype
; /* New type */
287 ntype
= TYPE_POINTER_TYPE (type
);
292 return ntype
; /* Don't care about alloc,
293 and have new type. */
294 else if (*typeptr
== 0)
296 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
301 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
303 ntype
= alloc_type_copy (type
);
307 else /* We have storage, but need to reset it. */
310 chain
= TYPE_CHAIN (ntype
);
312 TYPE_CHAIN (ntype
) = chain
;
315 TYPE_TARGET_TYPE (ntype
) = type
;
316 TYPE_POINTER_TYPE (type
) = ntype
;
318 /* FIXME! Assume the machine has only one representation for
322 = gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
323 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
325 /* Mark pointers as unsigned. The target converts between pointers
326 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
327 gdbarch_address_to_pointer. */
328 TYPE_UNSIGNED (ntype
) = 1;
330 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
331 TYPE_POINTER_TYPE (type
) = ntype
;
333 /* Update the length of all the other variants of this type. */
334 chain
= TYPE_CHAIN (ntype
);
335 while (chain
!= ntype
)
337 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
338 chain
= TYPE_CHAIN (chain
);
344 /* Given a type TYPE, return a type of pointers to that type.
345 May need to construct such a type if this is the first use. */
348 lookup_pointer_type (struct type
*type
)
350 return make_pointer_type (type
, (struct type
**) 0);
353 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
354 points to a pointer to memory where the reference type should be
355 stored. If *TYPEPTR is zero, update it to point to the reference
356 type we return. We allocate new memory if needed. */
359 make_reference_type (struct type
*type
, struct type
**typeptr
)
361 struct type
*ntype
; /* New type */
364 ntype
= TYPE_REFERENCE_TYPE (type
);
369 return ntype
; /* Don't care about alloc,
370 and have new type. */
371 else if (*typeptr
== 0)
373 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
378 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
380 ntype
= alloc_type_copy (type
);
384 else /* We have storage, but need to reset it. */
387 chain
= TYPE_CHAIN (ntype
);
389 TYPE_CHAIN (ntype
) = chain
;
392 TYPE_TARGET_TYPE (ntype
) = type
;
393 TYPE_REFERENCE_TYPE (type
) = ntype
;
395 /* FIXME! Assume the machine has only one representation for
396 references, and that it matches the (only) representation for
399 TYPE_LENGTH (ntype
) =
400 gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
401 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
403 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
404 TYPE_REFERENCE_TYPE (type
) = ntype
;
406 /* Update the length of all the other variants of this type. */
407 chain
= TYPE_CHAIN (ntype
);
408 while (chain
!= ntype
)
410 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
411 chain
= TYPE_CHAIN (chain
);
417 /* Same as above, but caller doesn't care about memory allocation
421 lookup_reference_type (struct type
*type
)
423 return make_reference_type (type
, (struct type
**) 0);
426 /* Lookup a function type that returns type TYPE. TYPEPTR, if
427 nonzero, points to a pointer to memory where the function type
428 should be stored. If *TYPEPTR is zero, update it to point to the
429 function type we return. We allocate new memory if needed. */
432 make_function_type (struct type
*type
, struct type
**typeptr
)
434 struct type
*ntype
; /* New type */
436 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
438 ntype
= alloc_type_copy (type
);
442 else /* We have storage, but need to reset it. */
448 TYPE_TARGET_TYPE (ntype
) = type
;
450 TYPE_LENGTH (ntype
) = 1;
451 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
457 /* Given a type TYPE, return a type of functions that return that type.
458 May need to construct such a type if this is the first use. */
461 lookup_function_type (struct type
*type
)
463 return make_function_type (type
, (struct type
**) 0);
466 /* Identify address space identifier by name --
467 return the integer flag defined in gdbtypes.h. */
469 address_space_name_to_int (struct gdbarch
*gdbarch
, char *space_identifier
)
473 /* Check for known address space delimiters. */
474 if (!strcmp (space_identifier
, "code"))
475 return TYPE_INSTANCE_FLAG_CODE_SPACE
;
476 else if (!strcmp (space_identifier
, "data"))
477 return TYPE_INSTANCE_FLAG_DATA_SPACE
;
478 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
479 && gdbarch_address_class_name_to_type_flags (gdbarch
,
484 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
487 /* Identify address space identifier by integer flag as defined in
488 gdbtypes.h -- return the string version of the adress space name. */
491 address_space_int_to_name (struct gdbarch
*gdbarch
, int space_flag
)
493 if (space_flag
& TYPE_INSTANCE_FLAG_CODE_SPACE
)
495 else if (space_flag
& TYPE_INSTANCE_FLAG_DATA_SPACE
)
497 else if ((space_flag
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
498 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
499 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
504 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
506 If STORAGE is non-NULL, create the new type instance there.
507 STORAGE must be in the same obstack as TYPE. */
510 make_qualified_type (struct type
*type
, int new_flags
,
511 struct type
*storage
)
518 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
520 ntype
= TYPE_CHAIN (ntype
);
522 while (ntype
!= type
);
524 /* Create a new type instance. */
526 ntype
= alloc_type_instance (type
);
529 /* If STORAGE was provided, it had better be in the same objfile
530 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
531 if one objfile is freed and the other kept, we'd have
532 dangling pointers. */
533 gdb_assert (TYPE_OBJFILE (type
) == TYPE_OBJFILE (storage
));
536 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
537 TYPE_CHAIN (ntype
) = ntype
;
540 /* Pointers or references to the original type are not relevant to
542 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
543 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
545 /* Chain the new qualified type to the old type. */
546 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
547 TYPE_CHAIN (type
) = ntype
;
549 /* Now set the instance flags and return the new type. */
550 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
552 /* Set length of new type to that of the original type. */
553 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
558 /* Make an address-space-delimited variant of a type -- a type that
559 is identical to the one supplied except that it has an address
560 space attribute attached to it (such as "code" or "data").
562 The space attributes "code" and "data" are for Harvard
563 architectures. The address space attributes are for architectures
564 which have alternately sized pointers or pointers with alternate
568 make_type_with_address_space (struct type
*type
, int space_flag
)
570 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
571 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
572 | TYPE_INSTANCE_FLAG_DATA_SPACE
573 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
))
576 return make_qualified_type (type
, new_flags
, NULL
);
579 /* Make a "c-v" variant of a type -- a type that is identical to the
580 one supplied except that it may have const or volatile attributes
581 CNST is a flag for setting the const attribute
582 VOLTL is a flag for setting the volatile attribute
583 TYPE is the base type whose variant we are creating.
585 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
586 storage to hold the new qualified type; *TYPEPTR and TYPE must be
587 in the same objfile. Otherwise, allocate fresh memory for the new
588 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
589 new type we construct. */
591 make_cv_type (int cnst
, int voltl
,
593 struct type
**typeptr
)
595 struct type
*ntype
; /* New type */
597 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
598 & ~(TYPE_INSTANCE_FLAG_CONST
599 | TYPE_INSTANCE_FLAG_VOLATILE
));
602 new_flags
|= TYPE_INSTANCE_FLAG_CONST
;
605 new_flags
|= TYPE_INSTANCE_FLAG_VOLATILE
;
607 if (typeptr
&& *typeptr
!= NULL
)
609 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
610 a C-V variant chain that threads across objfiles: if one
611 objfile gets freed, then the other has a broken C-V chain.
613 This code used to try to copy over the main type from TYPE to
614 *TYPEPTR if they were in different objfiles, but that's
615 wrong, too: TYPE may have a field list or member function
616 lists, which refer to types of their own, etc. etc. The
617 whole shebang would need to be copied over recursively; you
618 can't have inter-objfile pointers. The only thing to do is
619 to leave stub types as stub types, and look them up afresh by
620 name each time you encounter them. */
621 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
));
624 ntype
= make_qualified_type (type
, new_flags
,
625 typeptr
? *typeptr
: NULL
);
633 /* Replace the contents of ntype with the type *type. This changes the
634 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
635 the changes are propogated to all types in the TYPE_CHAIN.
637 In order to build recursive types, it's inevitable that we'll need
638 to update types in place --- but this sort of indiscriminate
639 smashing is ugly, and needs to be replaced with something more
640 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
641 clear if more steps are needed. */
643 replace_type (struct type
*ntype
, struct type
*type
)
647 /* These two types had better be in the same objfile. Otherwise,
648 the assignment of one type's main type structure to the other
649 will produce a type with references to objects (names; field
650 lists; etc.) allocated on an objfile other than its own. */
651 gdb_assert (TYPE_OBJFILE (ntype
) == TYPE_OBJFILE (ntype
));
653 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
655 /* The type length is not a part of the main type. Update it for
656 each type on the variant chain. */
660 /* Assert that this element of the chain has no address-class bits
661 set in its flags. Such type variants might have type lengths
662 which are supposed to be different from the non-address-class
663 variants. This assertion shouldn't ever be triggered because
664 symbol readers which do construct address-class variants don't
665 call replace_type(). */
666 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
668 TYPE_LENGTH (chain
) = TYPE_LENGTH (type
);
669 chain
= TYPE_CHAIN (chain
);
671 while (ntype
!= chain
);
673 /* Assert that the two types have equivalent instance qualifiers.
674 This should be true for at least all of our debug readers. */
675 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
678 /* Implement direct support for MEMBER_TYPE in GNU C++.
679 May need to construct such a type if this is the first use.
680 The TYPE is the type of the member. The DOMAIN is the type
681 of the aggregate that the member belongs to. */
684 lookup_memberptr_type (struct type
*type
, struct type
*domain
)
688 mtype
= alloc_type_copy (type
);
689 smash_to_memberptr_type (mtype
, domain
, type
);
693 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
696 lookup_methodptr_type (struct type
*to_type
)
700 mtype
= alloc_type_copy (to_type
);
701 smash_to_methodptr_type (mtype
, to_type
);
705 /* Allocate a stub method whose return type is TYPE. This apparently
706 happens for speed of symbol reading, since parsing out the
707 arguments to the method is cpu-intensive, the way we are doing it.
708 So, we will fill in arguments later. This always returns a fresh
712 allocate_stub_method (struct type
*type
)
716 mtype
= alloc_type_copy (type
);
717 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
718 TYPE_LENGTH (mtype
) = 1;
719 TYPE_STUB (mtype
) = 1;
720 TYPE_TARGET_TYPE (mtype
) = type
;
721 /* _DOMAIN_TYPE (mtype) = unknown yet */
725 /* Create a range type using either a blank type supplied in
726 RESULT_TYPE, or creating a new type, inheriting the objfile from
729 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
730 to HIGH_BOUND, inclusive.
732 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
733 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
736 create_range_type (struct type
*result_type
, struct type
*index_type
,
737 LONGEST low_bound
, LONGEST high_bound
)
739 if (result_type
== NULL
)
740 result_type
= alloc_type_copy (index_type
);
741 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
742 TYPE_TARGET_TYPE (result_type
) = index_type
;
743 if (TYPE_STUB (index_type
))
744 TYPE_TARGET_STUB (result_type
) = 1;
746 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
747 TYPE_RANGE_DATA (result_type
) = (struct range_bounds
*)
748 TYPE_ZALLOC (result_type
, sizeof (struct range_bounds
));
749 TYPE_LOW_BOUND (result_type
) = low_bound
;
750 TYPE_HIGH_BOUND (result_type
) = high_bound
;
753 TYPE_UNSIGNED (result_type
) = 1;
758 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
759 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
760 bounds will fit in LONGEST), or -1 otherwise. */
763 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
765 CHECK_TYPEDEF (type
);
766 switch (TYPE_CODE (type
))
768 case TYPE_CODE_RANGE
:
769 *lowp
= TYPE_LOW_BOUND (type
);
770 *highp
= TYPE_HIGH_BOUND (type
);
773 if (TYPE_NFIELDS (type
) > 0)
775 /* The enums may not be sorted by value, so search all
779 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
780 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
782 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
783 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
784 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
785 *highp
= TYPE_FIELD_BITPOS (type
, i
);
788 /* Set unsigned indicator if warranted. */
791 TYPE_UNSIGNED (type
) = 1;
805 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
807 if (!TYPE_UNSIGNED (type
))
809 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
813 /* ... fall through for unsigned ints ... */
816 /* This round-about calculation is to avoid shifting by
817 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
818 if TYPE_LENGTH (type) == sizeof (LONGEST). */
819 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
820 *highp
= (*highp
- 1) | *highp
;
827 /* Assuming TYPE is a simple, non-empty array type, compute its upper
828 and lower bound. Save the low bound into LOW_BOUND if not NULL.
829 Save the high bound into HIGH_BOUND if not NULL.
831 Return 1 if the operation was successful. Return zero otherwise,
832 in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
834 We now simply use get_discrete_bounds call to get the values
835 of the low and high bounds.
836 get_discrete_bounds can return three values:
837 1, meaning that index is a range,
838 0, meaning that index is a discrete type,
839 or -1 for failure. */
842 get_array_bounds (struct type
*type
, LONGEST
*low_bound
, LONGEST
*high_bound
)
844 struct type
*index
= TYPE_INDEX_TYPE (type
);
852 res
= get_discrete_bounds (index
, &low
, &high
);
856 /* Check if the array bounds are undefined. */
858 && ((low_bound
&& TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type
))
859 || (high_bound
&& TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))))
871 /* Create an array type using either a blank type supplied in
872 RESULT_TYPE, or creating a new type, inheriting the objfile from
875 Elements will be of type ELEMENT_TYPE, the indices will be of type
878 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
879 sure it is TYPE_CODE_UNDEF before we bash it into an array
883 create_array_type (struct type
*result_type
,
884 struct type
*element_type
,
885 struct type
*range_type
)
887 LONGEST low_bound
, high_bound
;
889 if (result_type
== NULL
)
890 result_type
= alloc_type_copy (range_type
);
892 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
893 TYPE_TARGET_TYPE (result_type
) = element_type
;
894 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
895 low_bound
= high_bound
= 0;
896 CHECK_TYPEDEF (element_type
);
897 /* Be careful when setting the array length. Ada arrays can be
898 empty arrays with the high_bound being smaller than the low_bound.
899 In such cases, the array length should be zero. */
900 if (high_bound
< low_bound
)
901 TYPE_LENGTH (result_type
) = 0;
903 TYPE_LENGTH (result_type
) =
904 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
905 TYPE_NFIELDS (result_type
) = 1;
906 TYPE_FIELDS (result_type
) =
907 (struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
));
908 TYPE_INDEX_TYPE (result_type
) = range_type
;
909 TYPE_VPTR_FIELDNO (result_type
) = -1;
911 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays. */
912 if (TYPE_LENGTH (result_type
) == 0)
913 TYPE_TARGET_STUB (result_type
) = 1;
919 lookup_array_range_type (struct type
*element_type
,
920 int low_bound
, int high_bound
)
922 struct gdbarch
*gdbarch
= get_type_arch (element_type
);
923 struct type
*index_type
= builtin_type (gdbarch
)->builtin_int
;
924 struct type
*range_type
925 = create_range_type (NULL
, index_type
, low_bound
, high_bound
);
927 return create_array_type (NULL
, element_type
, range_type
);
930 /* Create a string type using either a blank type supplied in
931 RESULT_TYPE, or creating a new type. String types are similar
932 enough to array of char types that we can use create_array_type to
933 build the basic type and then bash it into a string type.
935 For fixed length strings, the range type contains 0 as the lower
936 bound and the length of the string minus one as the upper bound.
938 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
939 sure it is TYPE_CODE_UNDEF before we bash it into a string
943 create_string_type (struct type
*result_type
,
944 struct type
*string_char_type
,
945 struct type
*range_type
)
947 result_type
= create_array_type (result_type
,
950 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
955 lookup_string_range_type (struct type
*string_char_type
,
956 int low_bound
, int high_bound
)
958 struct type
*result_type
;
960 result_type
= lookup_array_range_type (string_char_type
,
961 low_bound
, high_bound
);
962 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
967 create_set_type (struct type
*result_type
, struct type
*domain_type
)
969 if (result_type
== NULL
)
970 result_type
= alloc_type_copy (domain_type
);
972 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
973 TYPE_NFIELDS (result_type
) = 1;
974 TYPE_FIELDS (result_type
) = TYPE_ZALLOC (result_type
, sizeof (struct field
));
976 if (!TYPE_STUB (domain_type
))
978 LONGEST low_bound
, high_bound
, bit_length
;
980 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
981 low_bound
= high_bound
= 0;
982 bit_length
= high_bound
- low_bound
+ 1;
983 TYPE_LENGTH (result_type
)
984 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
986 TYPE_UNSIGNED (result_type
) = 1;
988 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
993 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
994 and any array types nested inside it. */
997 make_vector_type (struct type
*array_type
)
999 struct type
*inner_array
, *elt_type
;
1002 /* Find the innermost array type, in case the array is
1003 multi-dimensional. */
1004 inner_array
= array_type
;
1005 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
1006 inner_array
= TYPE_TARGET_TYPE (inner_array
);
1008 elt_type
= TYPE_TARGET_TYPE (inner_array
);
1009 if (TYPE_CODE (elt_type
) == TYPE_CODE_INT
)
1011 flags
= TYPE_INSTANCE_FLAGS (elt_type
) | TYPE_INSTANCE_FLAG_NOTTEXT
;
1012 elt_type
= make_qualified_type (elt_type
, flags
, NULL
);
1013 TYPE_TARGET_TYPE (inner_array
) = elt_type
;
1016 TYPE_VECTOR (array_type
) = 1;
1020 init_vector_type (struct type
*elt_type
, int n
)
1022 struct type
*array_type
;
1024 array_type
= lookup_array_range_type (elt_type
, 0, n
- 1);
1025 make_vector_type (array_type
);
1029 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
1030 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1031 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1032 TYPE doesn't include the offset (that's the value of the MEMBER
1033 itself), but does include the structure type into which it points
1036 When "smashing" the type, we preserve the objfile that the old type
1037 pointed to, since we aren't changing where the type is actually
1041 smash_to_memberptr_type (struct type
*type
, struct type
*domain
,
1042 struct type
*to_type
)
1045 TYPE_TARGET_TYPE (type
) = to_type
;
1046 TYPE_DOMAIN_TYPE (type
) = domain
;
1047 /* Assume that a data member pointer is the same size as a normal
1050 = gdbarch_ptr_bit (get_type_arch (to_type
)) / TARGET_CHAR_BIT
;
1051 TYPE_CODE (type
) = TYPE_CODE_MEMBERPTR
;
1054 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1056 When "smashing" the type, we preserve the objfile that the old type
1057 pointed to, since we aren't changing where the type is actually
1061 smash_to_methodptr_type (struct type
*type
, struct type
*to_type
)
1064 TYPE_TARGET_TYPE (type
) = to_type
;
1065 TYPE_DOMAIN_TYPE (type
) = TYPE_DOMAIN_TYPE (to_type
);
1066 TYPE_LENGTH (type
) = cplus_method_ptr_size (to_type
);
1067 TYPE_CODE (type
) = TYPE_CODE_METHODPTR
;
1070 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
1071 METHOD just means `function that gets an extra "this" argument'.
1073 When "smashing" the type, we preserve the objfile that the old type
1074 pointed to, since we aren't changing where the type is actually
1078 smash_to_method_type (struct type
*type
, struct type
*domain
,
1079 struct type
*to_type
, struct field
*args
,
1080 int nargs
, int varargs
)
1083 TYPE_TARGET_TYPE (type
) = to_type
;
1084 TYPE_DOMAIN_TYPE (type
) = domain
;
1085 TYPE_FIELDS (type
) = args
;
1086 TYPE_NFIELDS (type
) = nargs
;
1088 TYPE_VARARGS (type
) = 1;
1089 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1090 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
1093 /* Return a typename for a struct/union/enum type without "struct ",
1094 "union ", or "enum ". If the type has a NULL name, return NULL. */
1097 type_name_no_tag (const struct type
*type
)
1099 if (TYPE_TAG_NAME (type
) != NULL
)
1100 return TYPE_TAG_NAME (type
);
1102 /* Is there code which expects this to return the name if there is
1103 no tag name? My guess is that this is mainly used for C++ in
1104 cases where the two will always be the same. */
1105 return TYPE_NAME (type
);
1108 /* Lookup a typedef or primitive type named NAME, visible in lexical
1109 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1110 suitably defined. */
1113 lookup_typename (const struct language_defn
*language
,
1114 struct gdbarch
*gdbarch
, char *name
,
1115 const struct block
*block
, int noerr
)
1120 sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, 0);
1121 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1123 tmp
= language_lookup_primitive_type_by_name (language
, gdbarch
, name
);
1128 else if (!tmp
&& noerr
)
1134 error (_("No type named %s."), name
);
1137 return (SYMBOL_TYPE (sym
));
1141 lookup_unsigned_typename (const struct language_defn
*language
,
1142 struct gdbarch
*gdbarch
, char *name
)
1144 char *uns
= alloca (strlen (name
) + 10);
1146 strcpy (uns
, "unsigned ");
1147 strcpy (uns
+ 9, name
);
1148 return lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 0);
1152 lookup_signed_typename (const struct language_defn
*language
,
1153 struct gdbarch
*gdbarch
, char *name
)
1156 char *uns
= alloca (strlen (name
) + 8);
1158 strcpy (uns
, "signed ");
1159 strcpy (uns
+ 7, name
);
1160 t
= lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 1);
1161 /* If we don't find "signed FOO" just try again with plain "FOO". */
1164 return lookup_typename (language
, gdbarch
, name
, (struct block
*) NULL
, 0);
1167 /* Lookup a structure type named "struct NAME",
1168 visible in lexical block BLOCK. */
1171 lookup_struct (char *name
, struct block
*block
)
1175 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1179 error (_("No struct type named %s."), name
);
1181 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1183 error (_("This context has class, union or enum %s, not a struct."),
1186 return (SYMBOL_TYPE (sym
));
1189 /* Lookup a union type named "union NAME",
1190 visible in lexical block BLOCK. */
1193 lookup_union (char *name
, struct block
*block
)
1198 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1201 error (_("No union type named %s."), name
);
1203 t
= SYMBOL_TYPE (sym
);
1205 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1208 /* If we get here, it's not a union. */
1209 error (_("This context has class, struct or enum %s, not a union."),
1214 /* Lookup an enum type named "enum NAME",
1215 visible in lexical block BLOCK. */
1218 lookup_enum (char *name
, struct block
*block
)
1222 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1225 error (_("No enum type named %s."), name
);
1227 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1229 error (_("This context has class, struct or union %s, not an enum."),
1232 return (SYMBOL_TYPE (sym
));
1235 /* Lookup a template type named "template NAME<TYPE>",
1236 visible in lexical block BLOCK. */
1239 lookup_template_type (char *name
, struct type
*type
,
1240 struct block
*block
)
1243 char *nam
= (char *)
1244 alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1248 strcat (nam
, TYPE_NAME (type
));
1249 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1251 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0);
1255 error (_("No template type named %s."), name
);
1257 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1259 error (_("This context has class, union or enum %s, not a struct."),
1262 return (SYMBOL_TYPE (sym
));
1265 /* Given a type TYPE, lookup the type of the component of type named
1268 TYPE can be either a struct or union, or a pointer or reference to
1269 a struct or union. If it is a pointer or reference, its target
1270 type is automatically used. Thus '.' and '->' are interchangable,
1271 as specified for the definitions of the expression element types
1272 STRUCTOP_STRUCT and STRUCTOP_PTR.
1274 If NOERR is nonzero, return zero if NAME is not suitably defined.
1275 If NAME is the name of a baseclass type, return that type. */
1278 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
1285 CHECK_TYPEDEF (type
);
1286 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1287 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1289 type
= TYPE_TARGET_TYPE (type
);
1292 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1293 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1295 typename
= type_to_string (type
);
1296 make_cleanup (xfree
, typename
);
1297 error (_("Type %s is not a structure or union type."), typename
);
1301 /* FIXME: This change put in by Michael seems incorrect for the case
1302 where the structure tag name is the same as the member name.
1303 I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
1304 foo; } bell;" Disabled by fnf. */
1308 typename
= type_name_no_tag (type
);
1309 if (typename
!= NULL
&& strcmp (typename
, name
) == 0)
1314 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1316 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1318 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1320 return TYPE_FIELD_TYPE (type
, i
);
1322 else if (!t_field_name
|| *t_field_name
== '\0')
1324 struct type
*subtype
1325 = lookup_struct_elt_type (TYPE_FIELD_TYPE (type
, i
), name
, 1);
1327 if (subtype
!= NULL
)
1332 /* OK, it's not in this class. Recursively check the baseclasses. */
1333 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1337 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, 1);
1349 typename
= type_to_string (type
);
1350 make_cleanup (xfree
, typename
);
1351 error (_("Type %s has no component named %s."), typename
, name
);
1354 /* Lookup the vptr basetype/fieldno values for TYPE.
1355 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1356 vptr_fieldno. Also, if found and basetype is from the same objfile,
1358 If not found, return -1 and ignore BASETYPEP.
1359 Callers should be aware that in some cases (for example,
1360 the type or one of its baseclasses is a stub type and we are
1361 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1362 this function will not be able to find the
1363 virtual function table pointer, and vptr_fieldno will remain -1 and
1364 vptr_basetype will remain NULL or incomplete. */
1367 get_vptr_fieldno (struct type
*type
, struct type
**basetypep
)
1369 CHECK_TYPEDEF (type
);
1371 if (TYPE_VPTR_FIELDNO (type
) < 0)
1375 /* We must start at zero in case the first (and only) baseclass
1376 is virtual (and hence we cannot share the table pointer). */
1377 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1379 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1381 struct type
*basetype
;
1383 fieldno
= get_vptr_fieldno (baseclass
, &basetype
);
1386 /* If the type comes from a different objfile we can't cache
1387 it, it may have a different lifetime. PR 2384 */
1388 if (TYPE_OBJFILE (type
) == TYPE_OBJFILE (basetype
))
1390 TYPE_VPTR_FIELDNO (type
) = fieldno
;
1391 TYPE_VPTR_BASETYPE (type
) = basetype
;
1394 *basetypep
= basetype
;
1405 *basetypep
= TYPE_VPTR_BASETYPE (type
);
1406 return TYPE_VPTR_FIELDNO (type
);
1411 stub_noname_complaint (void)
1413 complaint (&symfile_complaints
, _("stub type has NULL name"));
1416 /* Find the real type of TYPE. This function returns the real type,
1417 after removing all layers of typedefs, and completing opaque or stub
1418 types. Completion changes the TYPE argument, but stripping of
1421 Instance flags (e.g. const/volatile) are preserved as typedefs are
1422 stripped. If necessary a new qualified form of the underlying type
1425 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
1426 not been computed and we're either in the middle of reading symbols, or
1427 there was no name for the typedef in the debug info.
1429 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
1432 If this is a stubbed struct (i.e. declared as struct foo *), see if
1433 we can find a full definition in some other file. If so, copy this
1434 definition, so we can use it in future. There used to be a comment
1435 (but not any code) that if we don't find a full definition, we'd
1436 set a flag so we don't spend time in the future checking the same
1437 type. That would be a mistake, though--we might load in more
1438 symbols which contain a full definition for the type. */
1441 check_typedef (struct type
*type
)
1443 struct type
*orig_type
= type
;
1444 /* While we're removing typedefs, we don't want to lose qualifiers.
1445 E.g., const/volatile. */
1446 int instance_flags
= TYPE_INSTANCE_FLAGS (type
);
1450 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1452 if (!TYPE_TARGET_TYPE (type
))
1457 /* It is dangerous to call lookup_symbol if we are currently
1458 reading a symtab. Infinite recursion is one danger. */
1459 if (currently_reading_symtab
)
1460 return make_qualified_type (type
, instance_flags
, NULL
);
1462 name
= type_name_no_tag (type
);
1463 /* FIXME: shouldn't we separately check the TYPE_NAME and
1464 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1465 VAR_DOMAIN as appropriate? (this code was written before
1466 TYPE_NAME and TYPE_TAG_NAME were separate). */
1469 stub_noname_complaint ();
1470 return make_qualified_type (type
, instance_flags
, NULL
);
1472 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1474 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1475 else /* TYPE_CODE_UNDEF */
1476 TYPE_TARGET_TYPE (type
) = alloc_type_arch (get_type_arch (type
));
1478 type
= TYPE_TARGET_TYPE (type
);
1480 /* Preserve the instance flags as we traverse down the typedef chain.
1482 Handling address spaces/classes is nasty, what do we do if there's a
1484 E.g., what if an outer typedef marks the type as class_1 and an inner
1485 typedef marks the type as class_2?
1486 This is the wrong place to do such error checking. We leave it to
1487 the code that created the typedef in the first place to flag the
1488 error. We just pick the outer address space (akin to letting the
1489 outer cast in a chain of casting win), instead of assuming
1490 "it can't happen". */
1492 const int ALL_SPACES
= (TYPE_INSTANCE_FLAG_CODE_SPACE
1493 | TYPE_INSTANCE_FLAG_DATA_SPACE
);
1494 const int ALL_CLASSES
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
;
1495 int new_instance_flags
= TYPE_INSTANCE_FLAGS (type
);
1497 /* Treat code vs data spaces and address classes separately. */
1498 if ((instance_flags
& ALL_SPACES
) != 0)
1499 new_instance_flags
&= ~ALL_SPACES
;
1500 if ((instance_flags
& ALL_CLASSES
) != 0)
1501 new_instance_flags
&= ~ALL_CLASSES
;
1503 instance_flags
|= new_instance_flags
;
1507 /* If this is a struct/class/union with no fields, then check
1508 whether a full definition exists somewhere else. This is for
1509 systems where a type definition with no fields is issued for such
1510 types, instead of identifying them as stub types in the first
1513 if (TYPE_IS_OPAQUE (type
)
1514 && opaque_type_resolution
1515 && !currently_reading_symtab
)
1517 char *name
= type_name_no_tag (type
);
1518 struct type
*newtype
;
1522 stub_noname_complaint ();
1523 return make_qualified_type (type
, instance_flags
, NULL
);
1525 newtype
= lookup_transparent_type (name
);
1529 /* If the resolved type and the stub are in the same
1530 objfile, then replace the stub type with the real deal.
1531 But if they're in separate objfiles, leave the stub
1532 alone; we'll just look up the transparent type every time
1533 we call check_typedef. We can't create pointers between
1534 types allocated to different objfiles, since they may
1535 have different lifetimes. Trying to copy NEWTYPE over to
1536 TYPE's objfile is pointless, too, since you'll have to
1537 move over any other types NEWTYPE refers to, which could
1538 be an unbounded amount of stuff. */
1539 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
1540 type
= make_qualified_type (newtype
,
1541 TYPE_INSTANCE_FLAGS (type
),
1547 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1549 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1551 char *name
= type_name_no_tag (type
);
1552 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1553 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1554 as appropriate? (this code was written before TYPE_NAME and
1555 TYPE_TAG_NAME were separate). */
1560 stub_noname_complaint ();
1561 return make_qualified_type (type
, instance_flags
, NULL
);
1563 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1566 /* Same as above for opaque types, we can replace the stub
1567 with the complete type only if they are in the same
1569 if (TYPE_OBJFILE (SYMBOL_TYPE(sym
)) == TYPE_OBJFILE (type
))
1570 type
= make_qualified_type (SYMBOL_TYPE (sym
),
1571 TYPE_INSTANCE_FLAGS (type
),
1574 type
= SYMBOL_TYPE (sym
);
1578 if (TYPE_TARGET_STUB (type
))
1580 struct type
*range_type
;
1581 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1583 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1585 /* Nothing we can do. */
1587 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1588 && TYPE_NFIELDS (type
) == 1
1589 && (TYPE_CODE (range_type
= TYPE_INDEX_TYPE (type
))
1590 == TYPE_CODE_RANGE
))
1592 /* Now recompute the length of the array type, based on its
1593 number of elements and the target type's length.
1594 Watch out for Ada null Ada arrays where the high bound
1595 is smaller than the low bound. */
1596 const LONGEST low_bound
= TYPE_LOW_BOUND (range_type
);
1597 const LONGEST high_bound
= TYPE_HIGH_BOUND (range_type
);
1600 if (high_bound
< low_bound
)
1604 /* For now, we conservatively take the array length to be 0
1605 if its length exceeds UINT_MAX. The code below assumes
1606 that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
1607 which is technically not guaranteed by C, but is usually true
1608 (because it would be true if x were unsigned with its
1609 high-order bit on). It uses the fact that
1610 high_bound-low_bound is always representable in
1611 ULONGEST and that if high_bound-low_bound+1 overflows,
1612 it overflows to 0. We must change these tests if we
1613 decide to increase the representation of TYPE_LENGTH
1614 from unsigned int to ULONGEST. */
1615 ULONGEST ulow
= low_bound
, uhigh
= high_bound
;
1616 ULONGEST tlen
= TYPE_LENGTH (target_type
);
1618 len
= tlen
* (uhigh
- ulow
+ 1);
1619 if (tlen
== 0 || (len
/ tlen
- 1 + ulow
) != uhigh
1623 TYPE_LENGTH (type
) = len
;
1624 TYPE_TARGET_STUB (type
) = 0;
1626 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1628 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1629 TYPE_TARGET_STUB (type
) = 0;
1633 type
= make_qualified_type (type
, instance_flags
, NULL
);
1635 /* Cache TYPE_LENGTH for future use. */
1636 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1641 /* Parse a type expression in the string [P..P+LENGTH). If an error
1642 occurs, silently return a void type. */
1644 static struct type
*
1645 safe_parse_type (struct gdbarch
*gdbarch
, char *p
, int length
)
1647 struct ui_file
*saved_gdb_stderr
;
1650 /* Suppress error messages. */
1651 saved_gdb_stderr
= gdb_stderr
;
1652 gdb_stderr
= ui_file_new ();
1654 /* Call parse_and_eval_type() without fear of longjmp()s. */
1655 if (!gdb_parse_and_eval_type (p
, length
, &type
))
1656 type
= builtin_type (gdbarch
)->builtin_void
;
1658 /* Stop suppressing error messages. */
1659 ui_file_delete (gdb_stderr
);
1660 gdb_stderr
= saved_gdb_stderr
;
1665 /* Ugly hack to convert method stubs into method types.
1667 He ain't kiddin'. This demangles the name of the method into a
1668 string including argument types, parses out each argument type,
1669 generates a string casting a zero to that type, evaluates the
1670 string, and stuffs the resulting type into an argtype vector!!!
1671 Then it knows the type of the whole function (including argument
1672 types for overloading), which info used to be in the stab's but was
1673 removed to hack back the space required for them. */
1676 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1678 struct gdbarch
*gdbarch
= get_type_arch (type
);
1680 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1681 char *demangled_name
= cplus_demangle (mangled_name
,
1682 DMGL_PARAMS
| DMGL_ANSI
);
1683 char *argtypetext
, *p
;
1684 int depth
= 0, argcount
= 1;
1685 struct field
*argtypes
;
1688 /* Make sure we got back a function string that we can use. */
1690 p
= strchr (demangled_name
, '(');
1694 if (demangled_name
== NULL
|| p
== NULL
)
1695 error (_("Internal: Cannot demangle mangled name `%s'."),
1698 /* Now, read in the parameters that define this type. */
1703 if (*p
== '(' || *p
== '<')
1707 else if (*p
== ')' || *p
== '>')
1711 else if (*p
== ',' && depth
== 0)
1719 /* If we read one argument and it was ``void'', don't count it. */
1720 if (strncmp (argtypetext
, "(void)", 6) == 0)
1723 /* We need one extra slot, for the THIS pointer. */
1725 argtypes
= (struct field
*)
1726 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
1729 /* Add THIS pointer for non-static methods. */
1730 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1731 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
1735 argtypes
[0].type
= lookup_pointer_type (type
);
1739 if (*p
!= ')') /* () means no args, skip while. */
1744 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1746 /* Avoid parsing of ellipsis, they will be handled below.
1747 Also avoid ``void'' as above. */
1748 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
1749 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
1751 argtypes
[argcount
].type
=
1752 safe_parse_type (gdbarch
, argtypetext
, p
- argtypetext
);
1755 argtypetext
= p
+ 1;
1758 if (*p
== '(' || *p
== '<')
1762 else if (*p
== ')' || *p
== '>')
1771 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1773 /* Now update the old "stub" type into a real type. */
1774 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1775 TYPE_DOMAIN_TYPE (mtype
) = type
;
1776 TYPE_FIELDS (mtype
) = argtypes
;
1777 TYPE_NFIELDS (mtype
) = argcount
;
1778 TYPE_STUB (mtype
) = 0;
1779 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1781 TYPE_VARARGS (mtype
) = 1;
1783 xfree (demangled_name
);
1786 /* This is the external interface to check_stub_method, above. This
1787 function unstubs all of the signatures for TYPE's METHOD_ID method
1788 name. After calling this function TYPE_FN_FIELD_STUB will be
1789 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1792 This function unfortunately can not die until stabs do. */
1795 check_stub_method_group (struct type
*type
, int method_id
)
1797 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
1798 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1799 int j
, found_stub
= 0;
1801 for (j
= 0; j
< len
; j
++)
1802 if (TYPE_FN_FIELD_STUB (f
, j
))
1805 check_stub_method (type
, method_id
, j
);
1808 /* GNU v3 methods with incorrect names were corrected when we read
1809 in type information, because it was cheaper to do it then. The
1810 only GNU v2 methods with incorrect method names are operators and
1811 destructors; destructors were also corrected when we read in type
1814 Therefore the only thing we need to handle here are v2 operator
1816 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
1819 char dem_opname
[256];
1821 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1823 dem_opname
, DMGL_ANSI
);
1825 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1829 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
1833 /* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */
1834 const struct cplus_struct_type cplus_struct_default
= { };
1837 allocate_cplus_struct_type (struct type
*type
)
1839 if (HAVE_CPLUS_STRUCT (type
))
1840 /* Structure was already allocated. Nothing more to do. */
1843 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_CPLUS_STUFF
;
1844 TYPE_RAW_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1845 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1846 *(TYPE_RAW_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1849 const struct gnat_aux_type gnat_aux_default
=
1852 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
1853 and allocate the associated gnat-specific data. The gnat-specific
1854 data is also initialized to gnat_aux_default. */
1856 allocate_gnat_aux_type (struct type
*type
)
1858 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_GNAT_STUFF
;
1859 TYPE_GNAT_SPECIFIC (type
) = (struct gnat_aux_type
*)
1860 TYPE_ALLOC (type
, sizeof (struct gnat_aux_type
));
1861 *(TYPE_GNAT_SPECIFIC (type
)) = gnat_aux_default
;
1865 /* Helper function to initialize the standard scalar types.
1867 If NAME is non-NULL, then we make a copy of the string pointed
1868 to by name in the objfile_obstack for that objfile, and initialize
1869 the type name to that copy. There are places (mipsread.c in particular),
1870 where init_type is called with a NULL value for NAME). */
1873 init_type (enum type_code code
, int length
, int flags
,
1874 char *name
, struct objfile
*objfile
)
1878 type
= alloc_type (objfile
);
1879 TYPE_CODE (type
) = code
;
1880 TYPE_LENGTH (type
) = length
;
1882 gdb_assert (!(flags
& (TYPE_FLAG_MIN
- 1)));
1883 if (flags
& TYPE_FLAG_UNSIGNED
)
1884 TYPE_UNSIGNED (type
) = 1;
1885 if (flags
& TYPE_FLAG_NOSIGN
)
1886 TYPE_NOSIGN (type
) = 1;
1887 if (flags
& TYPE_FLAG_STUB
)
1888 TYPE_STUB (type
) = 1;
1889 if (flags
& TYPE_FLAG_TARGET_STUB
)
1890 TYPE_TARGET_STUB (type
) = 1;
1891 if (flags
& TYPE_FLAG_STATIC
)
1892 TYPE_STATIC (type
) = 1;
1893 if (flags
& TYPE_FLAG_PROTOTYPED
)
1894 TYPE_PROTOTYPED (type
) = 1;
1895 if (flags
& TYPE_FLAG_INCOMPLETE
)
1896 TYPE_INCOMPLETE (type
) = 1;
1897 if (flags
& TYPE_FLAG_VARARGS
)
1898 TYPE_VARARGS (type
) = 1;
1899 if (flags
& TYPE_FLAG_VECTOR
)
1900 TYPE_VECTOR (type
) = 1;
1901 if (flags
& TYPE_FLAG_STUB_SUPPORTED
)
1902 TYPE_STUB_SUPPORTED (type
) = 1;
1903 if (flags
& TYPE_FLAG_FIXED_INSTANCE
)
1904 TYPE_FIXED_INSTANCE (type
) = 1;
1907 TYPE_NAME (type
) = obsavestring (name
, strlen (name
),
1908 &objfile
->objfile_obstack
);
1912 if (name
&& strcmp (name
, "char") == 0)
1913 TYPE_NOSIGN (type
) = 1;
1917 case TYPE_CODE_STRUCT
:
1918 case TYPE_CODE_UNION
:
1919 case TYPE_CODE_NAMESPACE
:
1920 INIT_CPLUS_SPECIFIC (type
);
1923 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_FLOATFORMAT
;
1925 case TYPE_CODE_FUNC
:
1926 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_CALLING_CONVENTION
;
1933 can_dereference (struct type
*t
)
1935 /* FIXME: Should we return true for references as well as
1940 && TYPE_CODE (t
) == TYPE_CODE_PTR
1941 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1945 is_integral_type (struct type
*t
)
1950 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
1951 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
1952 || (TYPE_CODE (t
) == TYPE_CODE_FLAGS
)
1953 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
1954 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
1955 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
1958 /* A helper function which returns true if types A and B represent the
1959 "same" class type. This is true if the types have the same main
1960 type, or the same name. */
1963 class_types_same_p (const struct type
*a
, const struct type
*b
)
1965 return (TYPE_MAIN_TYPE (a
) == TYPE_MAIN_TYPE (b
)
1966 || (TYPE_NAME (a
) && TYPE_NAME (b
)
1967 && !strcmp (TYPE_NAME (a
), TYPE_NAME (b
))));
1970 /* If BASE is an ancestor of DCLASS return the distance between them.
1971 otherwise return -1;
1975 class B: public A {};
1976 class C: public B {};
1979 distance_to_ancestor (A, A, 0) = 0
1980 distance_to_ancestor (A, B, 0) = 1
1981 distance_to_ancestor (A, C, 0) = 2
1982 distance_to_ancestor (A, D, 0) = 3
1984 If PUBLIC is 1 then only public ancestors are considered,
1985 and the function returns the distance only if BASE is a public ancestor
1989 distance_to_ancestor (A, D, 1) = -1. */
1992 distance_to_ancestor (struct type
*base
, struct type
*dclass
, int public)
1997 CHECK_TYPEDEF (base
);
1998 CHECK_TYPEDEF (dclass
);
2000 if (class_types_same_p (base
, dclass
))
2003 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2005 if (public && ! BASETYPE_VIA_PUBLIC (dclass
, i
))
2008 d
= distance_to_ancestor (base
, TYPE_BASECLASS (dclass
, i
), public);
2016 /* Check whether BASE is an ancestor or base class or DCLASS
2017 Return 1 if so, and 0 if not.
2018 Note: If BASE and DCLASS are of the same type, this function
2019 will return 1. So for some class A, is_ancestor (A, A) will
2023 is_ancestor (struct type
*base
, struct type
*dclass
)
2025 return distance_to_ancestor (base
, dclass
, 0) >= 0;
2028 /* Like is_ancestor, but only returns true when BASE is a public
2029 ancestor of DCLASS. */
2032 is_public_ancestor (struct type
*base
, struct type
*dclass
)
2034 return distance_to_ancestor (base
, dclass
, 1) >= 0;
2037 /* A helper function for is_unique_ancestor. */
2040 is_unique_ancestor_worker (struct type
*base
, struct type
*dclass
,
2042 const bfd_byte
*contents
, CORE_ADDR address
)
2046 CHECK_TYPEDEF (base
);
2047 CHECK_TYPEDEF (dclass
);
2049 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
) && count
< 2; ++i
)
2051 struct type
*iter
= check_typedef (TYPE_BASECLASS (dclass
, i
));
2052 int this_offset
= baseclass_offset (dclass
, i
, contents
, address
);
2054 if (this_offset
== -1)
2055 error (_("virtual baseclass botch"));
2057 if (class_types_same_p (base
, iter
))
2059 /* If this is the first subclass, set *OFFSET and set count
2060 to 1. Otherwise, if this is at the same offset as
2061 previous instances, do nothing. Otherwise, increment
2065 *offset
= this_offset
;
2068 else if (this_offset
== *offset
)
2076 count
+= is_unique_ancestor_worker (base
, iter
, offset
,
2077 contents
+ this_offset
,
2078 address
+ this_offset
);
2084 /* Like is_ancestor, but only returns true if BASE is a unique base
2085 class of the type of VAL. */
2088 is_unique_ancestor (struct type
*base
, struct value
*val
)
2092 return is_unique_ancestor_worker (base
, value_type (val
), &offset
,
2093 value_contents (val
),
2094 value_address (val
)) == 1;
2099 /* Return the sum of the rank of A with the rank of B. */
2102 sum_ranks (struct rank a
, struct rank b
)
2105 c
.rank
= a
.rank
+ b
.rank
;
2106 c
.subrank
= a
.subrank
+ b
.subrank
;
2110 /* Compare rank A and B and return:
2112 1 if a is better than b
2113 -1 if b is better than a. */
2116 compare_ranks (struct rank a
, struct rank b
)
2118 if (a
.rank
== b
.rank
)
2120 if (a
.subrank
== b
.subrank
)
2122 if (a
.subrank
< b
.subrank
)
2124 if (a
.subrank
> b
.subrank
)
2128 if (a
.rank
< b
.rank
)
2131 /* a.rank > b.rank */
2135 /* Functions for overload resolution begin here. */
2137 /* Compare two badness vectors A and B and return the result.
2138 0 => A and B are identical
2139 1 => A and B are incomparable
2140 2 => A is better than B
2141 3 => A is worse than B */
2144 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
2148 short found_pos
= 0; /* any positives in c? */
2149 short found_neg
= 0; /* any negatives in c? */
2151 /* differing lengths => incomparable */
2152 if (a
->length
!= b
->length
)
2155 /* Subtract b from a */
2156 for (i
= 0; i
< a
->length
; i
++)
2158 tmp
= compare_ranks (b
->rank
[i
], a
->rank
[i
]);
2168 return 1; /* incomparable */
2170 return 3; /* A > B */
2176 return 2; /* A < B */
2178 return 0; /* A == B */
2182 /* Rank a function by comparing its parameter types (PARMS, length
2183 NPARMS), to the types of an argument list (ARGS, length NARGS).
2184 Return a pointer to a badness vector. This has NARGS + 1
2187 struct badness_vector
*
2188 rank_function (struct type
**parms
, int nparms
,
2189 struct type
**args
, int nargs
)
2192 struct badness_vector
*bv
;
2193 int min_len
= nparms
< nargs
? nparms
: nargs
;
2195 bv
= xmalloc (sizeof (struct badness_vector
));
2196 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank. */
2197 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
2199 /* First compare the lengths of the supplied lists.
2200 If there is a mismatch, set it to a high value. */
2202 /* pai/1997-06-03 FIXME: when we have debug info about default
2203 arguments and ellipsis parameter lists, we should consider those
2204 and rank the length-match more finely. */
2206 LENGTH_MATCH (bv
) = (nargs
!= nparms
)
2207 ? LENGTH_MISMATCH_BADNESS
2208 : EXACT_MATCH_BADNESS
;
2210 /* Now rank all the parameters of the candidate function. */
2211 for (i
= 1; i
<= min_len
; i
++)
2212 bv
->rank
[i
] = rank_one_type (parms
[i
-1], args
[i
-1]);
2214 /* If more arguments than parameters, add dummy entries. */
2215 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2216 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2221 /* Compare the names of two integer types, assuming that any sign
2222 qualifiers have been checked already. We do it this way because
2223 there may be an "int" in the name of one of the types. */
2226 integer_types_same_name_p (const char *first
, const char *second
)
2228 int first_p
, second_p
;
2230 /* If both are shorts, return 1; if neither is a short, keep
2232 first_p
= (strstr (first
, "short") != NULL
);
2233 second_p
= (strstr (second
, "short") != NULL
);
2234 if (first_p
&& second_p
)
2236 if (first_p
|| second_p
)
2239 /* Likewise for long. */
2240 first_p
= (strstr (first
, "long") != NULL
);
2241 second_p
= (strstr (second
, "long") != NULL
);
2242 if (first_p
&& second_p
)
2244 if (first_p
|| second_p
)
2247 /* Likewise for char. */
2248 first_p
= (strstr (first
, "char") != NULL
);
2249 second_p
= (strstr (second
, "char") != NULL
);
2250 if (first_p
&& second_p
)
2252 if (first_p
|| second_p
)
2255 /* They must both be ints. */
2259 /* Compares type A to type B returns 1 if the represent the same type
2263 types_equal (struct type
*a
, struct type
*b
)
2265 /* Identical type pointers. */
2266 /* However, this still doesn't catch all cases of same type for b
2267 and a. The reason is that builtin types are different from
2268 the same ones constructed from the object. */
2272 /* Resolve typedefs */
2273 if (TYPE_CODE (a
) == TYPE_CODE_TYPEDEF
)
2274 a
= check_typedef (a
);
2275 if (TYPE_CODE (b
) == TYPE_CODE_TYPEDEF
)
2276 b
= check_typedef (b
);
2278 /* If after resolving typedefs a and b are not of the same type
2279 code then they are not equal. */
2280 if (TYPE_CODE (a
) != TYPE_CODE (b
))
2283 /* If a and b are both pointers types or both reference types then
2284 they are equal of the same type iff the objects they refer to are
2285 of the same type. */
2286 if (TYPE_CODE (a
) == TYPE_CODE_PTR
2287 || TYPE_CODE (a
) == TYPE_CODE_REF
)
2288 return types_equal (TYPE_TARGET_TYPE (a
),
2289 TYPE_TARGET_TYPE (b
));
2291 /* Well, damnit, if the names are exactly the same, I'll say they
2292 are exactly the same. This happens when we generate method
2293 stubs. The types won't point to the same address, but they
2294 really are the same. */
2296 if (TYPE_NAME (a
) && TYPE_NAME (b
)
2297 && strcmp (TYPE_NAME (a
), TYPE_NAME (b
)) == 0)
2300 /* Check if identical after resolving typedefs. */
2307 /* Compare one type (PARM) for compatibility with another (ARG).
2308 * PARM is intended to be the parameter type of a function; and
2309 * ARG is the supplied argument's type. This function tests if
2310 * the latter can be converted to the former.
2312 * Return 0 if they are identical types;
2313 * Otherwise, return an integer which corresponds to how compatible
2314 * PARM is to ARG. The higher the return value, the worse the match.
2315 * Generally the "bad" conversions are all uniformly assigned a 100. */
2318 rank_one_type (struct type
*parm
, struct type
*arg
)
2320 struct rank rank
= {0,0};
2322 if (types_equal (parm
, arg
))
2323 return EXACT_MATCH_BADNESS
;
2325 /* Resolve typedefs */
2326 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2327 parm
= check_typedef (parm
);
2328 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2329 arg
= check_typedef (arg
);
2331 /* See through references, since we can almost make non-references
2333 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2334 return (sum_ranks (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
)),
2335 REFERENCE_CONVERSION_BADNESS
));
2336 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2337 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
),
2338 REFERENCE_CONVERSION_BADNESS
));
2340 /* Debugging only. */
2341 fprintf_filtered (gdb_stderr
,
2342 "------ Arg is %s [%d], parm is %s [%d]\n",
2343 TYPE_NAME (arg
), TYPE_CODE (arg
),
2344 TYPE_NAME (parm
), TYPE_CODE (parm
));
2346 /* x -> y means arg of type x being supplied for parameter of type y. */
2348 switch (TYPE_CODE (parm
))
2351 switch (TYPE_CODE (arg
))
2355 /* Allowed pointer conversions are:
2356 (a) pointer to void-pointer conversion. */
2357 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2358 return VOID_PTR_CONVERSION_BADNESS
;
2360 /* (b) pointer to ancestor-pointer conversion. */
2361 rank
.subrank
= distance_to_ancestor (TYPE_TARGET_TYPE (parm
),
2362 TYPE_TARGET_TYPE (arg
),
2364 if (rank
.subrank
>= 0)
2365 return sum_ranks (BASE_PTR_CONVERSION_BADNESS
, rank
);
2367 return INCOMPATIBLE_TYPE_BADNESS
;
2368 case TYPE_CODE_ARRAY
:
2369 if (types_equal (TYPE_TARGET_TYPE (parm
),
2370 TYPE_TARGET_TYPE (arg
)))
2371 return EXACT_MATCH_BADNESS
;
2372 return INCOMPATIBLE_TYPE_BADNESS
;
2373 case TYPE_CODE_FUNC
:
2374 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
);
2376 case TYPE_CODE_ENUM
:
2377 case TYPE_CODE_FLAGS
:
2378 case TYPE_CODE_CHAR
:
2379 case TYPE_CODE_RANGE
:
2380 case TYPE_CODE_BOOL
:
2382 return INCOMPATIBLE_TYPE_BADNESS
;
2384 case TYPE_CODE_ARRAY
:
2385 switch (TYPE_CODE (arg
))
2388 case TYPE_CODE_ARRAY
:
2389 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2390 TYPE_TARGET_TYPE (arg
));
2392 return INCOMPATIBLE_TYPE_BADNESS
;
2394 case TYPE_CODE_FUNC
:
2395 switch (TYPE_CODE (arg
))
2397 case TYPE_CODE_PTR
: /* funcptr -> func */
2398 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
));
2400 return INCOMPATIBLE_TYPE_BADNESS
;
2403 switch (TYPE_CODE (arg
))
2406 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2408 /* Deal with signed, unsigned, and plain chars and
2409 signed and unsigned ints. */
2410 if (TYPE_NOSIGN (parm
))
2412 /* This case only for character types. */
2413 if (TYPE_NOSIGN (arg
))
2414 return EXACT_MATCH_BADNESS
; /* plain char -> plain char */
2415 else /* signed/unsigned char -> plain char */
2416 return INTEGER_CONVERSION_BADNESS
;
2418 else if (TYPE_UNSIGNED (parm
))
2420 if (TYPE_UNSIGNED (arg
))
2422 /* unsigned int -> unsigned int, or
2423 unsigned long -> unsigned long */
2424 if (integer_types_same_name_p (TYPE_NAME (parm
),
2426 return EXACT_MATCH_BADNESS
;
2427 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2429 && integer_types_same_name_p (TYPE_NAME (parm
),
2431 /* unsigned int -> unsigned long */
2432 return INTEGER_PROMOTION_BADNESS
;
2434 /* unsigned long -> unsigned int */
2435 return INTEGER_CONVERSION_BADNESS
;
2439 if (integer_types_same_name_p (TYPE_NAME (arg
),
2441 && integer_types_same_name_p (TYPE_NAME (parm
),
2443 /* signed long -> unsigned int */
2444 return INTEGER_CONVERSION_BADNESS
;
2446 /* signed int/long -> unsigned int/long */
2447 return INTEGER_CONVERSION_BADNESS
;
2450 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2452 if (integer_types_same_name_p (TYPE_NAME (parm
),
2454 return EXACT_MATCH_BADNESS
;
2455 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2457 && integer_types_same_name_p (TYPE_NAME (parm
),
2459 return INTEGER_PROMOTION_BADNESS
;
2461 return INTEGER_CONVERSION_BADNESS
;
2464 return INTEGER_CONVERSION_BADNESS
;
2466 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2467 return INTEGER_PROMOTION_BADNESS
;
2469 return INTEGER_CONVERSION_BADNESS
;
2470 case TYPE_CODE_ENUM
:
2471 case TYPE_CODE_FLAGS
:
2472 case TYPE_CODE_CHAR
:
2473 case TYPE_CODE_RANGE
:
2474 case TYPE_CODE_BOOL
:
2475 return INTEGER_PROMOTION_BADNESS
;
2477 return INT_FLOAT_CONVERSION_BADNESS
;
2479 return NS_POINTER_CONVERSION_BADNESS
;
2481 return INCOMPATIBLE_TYPE_BADNESS
;
2484 case TYPE_CODE_ENUM
:
2485 switch (TYPE_CODE (arg
))
2488 case TYPE_CODE_CHAR
:
2489 case TYPE_CODE_RANGE
:
2490 case TYPE_CODE_BOOL
:
2491 case TYPE_CODE_ENUM
:
2492 return INTEGER_CONVERSION_BADNESS
;
2494 return INT_FLOAT_CONVERSION_BADNESS
;
2496 return INCOMPATIBLE_TYPE_BADNESS
;
2499 case TYPE_CODE_CHAR
:
2500 switch (TYPE_CODE (arg
))
2502 case TYPE_CODE_RANGE
:
2503 case TYPE_CODE_BOOL
:
2504 case TYPE_CODE_ENUM
:
2505 return INTEGER_CONVERSION_BADNESS
;
2507 return INT_FLOAT_CONVERSION_BADNESS
;
2509 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2510 return INTEGER_CONVERSION_BADNESS
;
2511 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2512 return INTEGER_PROMOTION_BADNESS
;
2513 /* >>> !! else fall through !! <<< */
2514 case TYPE_CODE_CHAR
:
2515 /* Deal with signed, unsigned, and plain chars for C++ and
2516 with int cases falling through from previous case. */
2517 if (TYPE_NOSIGN (parm
))
2519 if (TYPE_NOSIGN (arg
))
2520 return EXACT_MATCH_BADNESS
;
2522 return INTEGER_CONVERSION_BADNESS
;
2524 else if (TYPE_UNSIGNED (parm
))
2526 if (TYPE_UNSIGNED (arg
))
2527 return EXACT_MATCH_BADNESS
;
2529 return INTEGER_PROMOTION_BADNESS
;
2531 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2532 return EXACT_MATCH_BADNESS
;
2534 return INTEGER_CONVERSION_BADNESS
;
2536 return INCOMPATIBLE_TYPE_BADNESS
;
2539 case TYPE_CODE_RANGE
:
2540 switch (TYPE_CODE (arg
))
2543 case TYPE_CODE_CHAR
:
2544 case TYPE_CODE_RANGE
:
2545 case TYPE_CODE_BOOL
:
2546 case TYPE_CODE_ENUM
:
2547 return INTEGER_CONVERSION_BADNESS
;
2549 return INT_FLOAT_CONVERSION_BADNESS
;
2551 return INCOMPATIBLE_TYPE_BADNESS
;
2554 case TYPE_CODE_BOOL
:
2555 switch (TYPE_CODE (arg
))
2558 case TYPE_CODE_CHAR
:
2559 case TYPE_CODE_RANGE
:
2560 case TYPE_CODE_ENUM
:
2562 return INCOMPATIBLE_TYPE_BADNESS
;
2564 return BOOL_PTR_CONVERSION_BADNESS
;
2565 case TYPE_CODE_BOOL
:
2566 return EXACT_MATCH_BADNESS
;
2568 return INCOMPATIBLE_TYPE_BADNESS
;
2572 switch (TYPE_CODE (arg
))
2575 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2576 return FLOAT_PROMOTION_BADNESS
;
2577 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2578 return EXACT_MATCH_BADNESS
;
2580 return FLOAT_CONVERSION_BADNESS
;
2582 case TYPE_CODE_BOOL
:
2583 case TYPE_CODE_ENUM
:
2584 case TYPE_CODE_RANGE
:
2585 case TYPE_CODE_CHAR
:
2586 return INT_FLOAT_CONVERSION_BADNESS
;
2588 return INCOMPATIBLE_TYPE_BADNESS
;
2591 case TYPE_CODE_COMPLEX
:
2592 switch (TYPE_CODE (arg
))
2593 { /* Strictly not needed for C++, but... */
2595 return FLOAT_PROMOTION_BADNESS
;
2596 case TYPE_CODE_COMPLEX
:
2597 return EXACT_MATCH_BADNESS
;
2599 return INCOMPATIBLE_TYPE_BADNESS
;
2602 case TYPE_CODE_STRUCT
:
2603 /* currently same as TYPE_CODE_CLASS. */
2604 switch (TYPE_CODE (arg
))
2606 case TYPE_CODE_STRUCT
:
2607 /* Check for derivation */
2608 rank
.subrank
= distance_to_ancestor (parm
, arg
, 0);
2609 if (rank
.subrank
>= 0)
2610 return sum_ranks (BASE_CONVERSION_BADNESS
, rank
);
2611 /* else fall through */
2613 return INCOMPATIBLE_TYPE_BADNESS
;
2616 case TYPE_CODE_UNION
:
2617 switch (TYPE_CODE (arg
))
2619 case TYPE_CODE_UNION
:
2621 return INCOMPATIBLE_TYPE_BADNESS
;
2624 case TYPE_CODE_MEMBERPTR
:
2625 switch (TYPE_CODE (arg
))
2628 return INCOMPATIBLE_TYPE_BADNESS
;
2631 case TYPE_CODE_METHOD
:
2632 switch (TYPE_CODE (arg
))
2636 return INCOMPATIBLE_TYPE_BADNESS
;
2640 switch (TYPE_CODE (arg
))
2644 return INCOMPATIBLE_TYPE_BADNESS
;
2649 switch (TYPE_CODE (arg
))
2653 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0),
2654 TYPE_FIELD_TYPE (arg
, 0));
2656 return INCOMPATIBLE_TYPE_BADNESS
;
2659 case TYPE_CODE_VOID
:
2661 return INCOMPATIBLE_TYPE_BADNESS
;
2662 } /* switch (TYPE_CODE (arg)) */
2666 /* End of functions for overload resolution. */
2669 print_bit_vector (B_TYPE
*bits
, int nbits
)
2673 for (bitno
= 0; bitno
< nbits
; bitno
++)
2675 if ((bitno
% 8) == 0)
2677 puts_filtered (" ");
2679 if (B_TST (bits
, bitno
))
2680 printf_filtered (("1"));
2682 printf_filtered (("0"));
2686 /* Note the first arg should be the "this" pointer, we may not want to
2687 include it since we may get into a infinitely recursive
2691 print_arg_types (struct field
*args
, int nargs
, int spaces
)
2697 for (i
= 0; i
< nargs
; i
++)
2698 recursive_dump_type (args
[i
].type
, spaces
+ 2);
2703 field_is_static (struct field
*f
)
2705 /* "static" fields are the fields whose location is not relative
2706 to the address of the enclosing struct. It would be nice to
2707 have a dedicated flag that would be set for static fields when
2708 the type is being created. But in practice, checking the field
2709 loc_kind should give us an accurate answer. */
2710 return (FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSNAME
2711 || FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSADDR
);
2715 dump_fn_fieldlists (struct type
*type
, int spaces
)
2721 printfi_filtered (spaces
, "fn_fieldlists ");
2722 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2723 printf_filtered ("\n");
2724 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2726 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2727 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2729 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2730 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2732 printf_filtered (_(") length %d\n"),
2733 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2734 for (overload_idx
= 0;
2735 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2738 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2740 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2741 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2743 printf_filtered (")\n");
2744 printfi_filtered (spaces
+ 8, "type ");
2745 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2747 printf_filtered ("\n");
2749 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2752 printfi_filtered (spaces
+ 8, "args ");
2753 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2755 printf_filtered ("\n");
2757 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2758 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
,
2761 printfi_filtered (spaces
+ 8, "fcontext ");
2762 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2764 printf_filtered ("\n");
2766 printfi_filtered (spaces
+ 8, "is_const %d\n",
2767 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2768 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2769 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2770 printfi_filtered (spaces
+ 8, "is_private %d\n",
2771 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2772 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2773 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2774 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2775 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2776 printfi_filtered (spaces
+ 8, "voffset %u\n",
2777 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2783 print_cplus_stuff (struct type
*type
, int spaces
)
2785 printfi_filtered (spaces
, "n_baseclasses %d\n",
2786 TYPE_N_BASECLASSES (type
));
2787 printfi_filtered (spaces
, "nfn_fields %d\n",
2788 TYPE_NFN_FIELDS (type
));
2789 printfi_filtered (spaces
, "nfn_fields_total %d\n",
2790 TYPE_NFN_FIELDS_TOTAL (type
));
2791 if (TYPE_N_BASECLASSES (type
) > 0)
2793 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2794 TYPE_N_BASECLASSES (type
));
2795 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
2797 printf_filtered (")");
2799 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2800 TYPE_N_BASECLASSES (type
));
2801 puts_filtered ("\n");
2803 if (TYPE_NFIELDS (type
) > 0)
2805 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2807 printfi_filtered (spaces
,
2808 "private_field_bits (%d bits at *",
2809 TYPE_NFIELDS (type
));
2810 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
2812 printf_filtered (")");
2813 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2814 TYPE_NFIELDS (type
));
2815 puts_filtered ("\n");
2817 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2819 printfi_filtered (spaces
,
2820 "protected_field_bits (%d bits at *",
2821 TYPE_NFIELDS (type
));
2822 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
2824 printf_filtered (")");
2825 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2826 TYPE_NFIELDS (type
));
2827 puts_filtered ("\n");
2830 if (TYPE_NFN_FIELDS (type
) > 0)
2832 dump_fn_fieldlists (type
, spaces
);
2836 /* Print the contents of the TYPE's type_specific union, assuming that
2837 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
2840 print_gnat_stuff (struct type
*type
, int spaces
)
2842 struct type
*descriptive_type
= TYPE_DESCRIPTIVE_TYPE (type
);
2844 recursive_dump_type (descriptive_type
, spaces
+ 2);
2847 static struct obstack dont_print_type_obstack
;
2850 recursive_dump_type (struct type
*type
, int spaces
)
2855 obstack_begin (&dont_print_type_obstack
, 0);
2857 if (TYPE_NFIELDS (type
) > 0
2858 || (HAVE_CPLUS_STRUCT (type
) && TYPE_NFN_FIELDS (type
) > 0))
2860 struct type
**first_dont_print
2861 = (struct type
**) obstack_base (&dont_print_type_obstack
);
2863 int i
= (struct type
**)
2864 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
2868 if (type
== first_dont_print
[i
])
2870 printfi_filtered (spaces
, "type node ");
2871 gdb_print_host_address (type
, gdb_stdout
);
2872 printf_filtered (_(" <same as already seen type>\n"));
2877 obstack_ptr_grow (&dont_print_type_obstack
, type
);
2880 printfi_filtered (spaces
, "type node ");
2881 gdb_print_host_address (type
, gdb_stdout
);
2882 printf_filtered ("\n");
2883 printfi_filtered (spaces
, "name '%s' (",
2884 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
2885 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
2886 printf_filtered (")\n");
2887 printfi_filtered (spaces
, "tagname '%s' (",
2888 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
2889 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
2890 printf_filtered (")\n");
2891 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
2892 switch (TYPE_CODE (type
))
2894 case TYPE_CODE_UNDEF
:
2895 printf_filtered ("(TYPE_CODE_UNDEF)");
2898 printf_filtered ("(TYPE_CODE_PTR)");
2900 case TYPE_CODE_ARRAY
:
2901 printf_filtered ("(TYPE_CODE_ARRAY)");
2903 case TYPE_CODE_STRUCT
:
2904 printf_filtered ("(TYPE_CODE_STRUCT)");
2906 case TYPE_CODE_UNION
:
2907 printf_filtered ("(TYPE_CODE_UNION)");
2909 case TYPE_CODE_ENUM
:
2910 printf_filtered ("(TYPE_CODE_ENUM)");
2912 case TYPE_CODE_FLAGS
:
2913 printf_filtered ("(TYPE_CODE_FLAGS)");
2915 case TYPE_CODE_FUNC
:
2916 printf_filtered ("(TYPE_CODE_FUNC)");
2919 printf_filtered ("(TYPE_CODE_INT)");
2922 printf_filtered ("(TYPE_CODE_FLT)");
2924 case TYPE_CODE_VOID
:
2925 printf_filtered ("(TYPE_CODE_VOID)");
2928 printf_filtered ("(TYPE_CODE_SET)");
2930 case TYPE_CODE_RANGE
:
2931 printf_filtered ("(TYPE_CODE_RANGE)");
2933 case TYPE_CODE_STRING
:
2934 printf_filtered ("(TYPE_CODE_STRING)");
2936 case TYPE_CODE_BITSTRING
:
2937 printf_filtered ("(TYPE_CODE_BITSTRING)");
2939 case TYPE_CODE_ERROR
:
2940 printf_filtered ("(TYPE_CODE_ERROR)");
2942 case TYPE_CODE_MEMBERPTR
:
2943 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
2945 case TYPE_CODE_METHODPTR
:
2946 printf_filtered ("(TYPE_CODE_METHODPTR)");
2948 case TYPE_CODE_METHOD
:
2949 printf_filtered ("(TYPE_CODE_METHOD)");
2952 printf_filtered ("(TYPE_CODE_REF)");
2954 case TYPE_CODE_CHAR
:
2955 printf_filtered ("(TYPE_CODE_CHAR)");
2957 case TYPE_CODE_BOOL
:
2958 printf_filtered ("(TYPE_CODE_BOOL)");
2960 case TYPE_CODE_COMPLEX
:
2961 printf_filtered ("(TYPE_CODE_COMPLEX)");
2963 case TYPE_CODE_TYPEDEF
:
2964 printf_filtered ("(TYPE_CODE_TYPEDEF)");
2966 case TYPE_CODE_NAMESPACE
:
2967 printf_filtered ("(TYPE_CODE_NAMESPACE)");
2970 printf_filtered ("(UNKNOWN TYPE CODE)");
2973 puts_filtered ("\n");
2974 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
2975 if (TYPE_OBJFILE_OWNED (type
))
2977 printfi_filtered (spaces
, "objfile ");
2978 gdb_print_host_address (TYPE_OWNER (type
).objfile
, gdb_stdout
);
2982 printfi_filtered (spaces
, "gdbarch ");
2983 gdb_print_host_address (TYPE_OWNER (type
).gdbarch
, gdb_stdout
);
2985 printf_filtered ("\n");
2986 printfi_filtered (spaces
, "target_type ");
2987 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
2988 printf_filtered ("\n");
2989 if (TYPE_TARGET_TYPE (type
) != NULL
)
2991 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
2993 printfi_filtered (spaces
, "pointer_type ");
2994 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
2995 printf_filtered ("\n");
2996 printfi_filtered (spaces
, "reference_type ");
2997 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
2998 printf_filtered ("\n");
2999 printfi_filtered (spaces
, "type_chain ");
3000 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
3001 printf_filtered ("\n");
3002 printfi_filtered (spaces
, "instance_flags 0x%x",
3003 TYPE_INSTANCE_FLAGS (type
));
3004 if (TYPE_CONST (type
))
3006 puts_filtered (" TYPE_FLAG_CONST");
3008 if (TYPE_VOLATILE (type
))
3010 puts_filtered (" TYPE_FLAG_VOLATILE");
3012 if (TYPE_CODE_SPACE (type
))
3014 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3016 if (TYPE_DATA_SPACE (type
))
3018 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3020 if (TYPE_ADDRESS_CLASS_1 (type
))
3022 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3024 if (TYPE_ADDRESS_CLASS_2 (type
))
3026 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3028 puts_filtered ("\n");
3030 printfi_filtered (spaces
, "flags");
3031 if (TYPE_UNSIGNED (type
))
3033 puts_filtered (" TYPE_FLAG_UNSIGNED");
3035 if (TYPE_NOSIGN (type
))
3037 puts_filtered (" TYPE_FLAG_NOSIGN");
3039 if (TYPE_STUB (type
))
3041 puts_filtered (" TYPE_FLAG_STUB");
3043 if (TYPE_TARGET_STUB (type
))
3045 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3047 if (TYPE_STATIC (type
))
3049 puts_filtered (" TYPE_FLAG_STATIC");
3051 if (TYPE_PROTOTYPED (type
))
3053 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3055 if (TYPE_INCOMPLETE (type
))
3057 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3059 if (TYPE_VARARGS (type
))
3061 puts_filtered (" TYPE_FLAG_VARARGS");
3063 /* This is used for things like AltiVec registers on ppc. Gcc emits
3064 an attribute for the array type, which tells whether or not we
3065 have a vector, instead of a regular array. */
3066 if (TYPE_VECTOR (type
))
3068 puts_filtered (" TYPE_FLAG_VECTOR");
3070 if (TYPE_FIXED_INSTANCE (type
))
3072 puts_filtered (" TYPE_FIXED_INSTANCE");
3074 if (TYPE_STUB_SUPPORTED (type
))
3076 puts_filtered (" TYPE_STUB_SUPPORTED");
3078 if (TYPE_NOTTEXT (type
))
3080 puts_filtered (" TYPE_NOTTEXT");
3082 puts_filtered ("\n");
3083 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
3084 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
3085 puts_filtered ("\n");
3086 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
3088 printfi_filtered (spaces
+ 2,
3089 "[%d] bitpos %d bitsize %d type ",
3090 idx
, TYPE_FIELD_BITPOS (type
, idx
),
3091 TYPE_FIELD_BITSIZE (type
, idx
));
3092 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
3093 printf_filtered (" name '%s' (",
3094 TYPE_FIELD_NAME (type
, idx
) != NULL
3095 ? TYPE_FIELD_NAME (type
, idx
)
3097 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
3098 printf_filtered (")\n");
3099 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
3101 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
3104 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
3106 printfi_filtered (spaces
, "low %s%s high %s%s\n",
3107 plongest (TYPE_LOW_BOUND (type
)),
3108 TYPE_LOW_BOUND_UNDEFINED (type
) ? " (undefined)" : "",
3109 plongest (TYPE_HIGH_BOUND (type
)),
3110 TYPE_HIGH_BOUND_UNDEFINED (type
)
3111 ? " (undefined)" : "");
3113 printfi_filtered (spaces
, "vptr_basetype ");
3114 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
3115 puts_filtered ("\n");
3116 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
3118 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
3120 printfi_filtered (spaces
, "vptr_fieldno %d\n",
3121 TYPE_VPTR_FIELDNO (type
));
3123 switch (TYPE_SPECIFIC_FIELD (type
))
3125 case TYPE_SPECIFIC_CPLUS_STUFF
:
3126 printfi_filtered (spaces
, "cplus_stuff ");
3127 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
),
3129 puts_filtered ("\n");
3130 print_cplus_stuff (type
, spaces
);
3133 case TYPE_SPECIFIC_GNAT_STUFF
:
3134 printfi_filtered (spaces
, "gnat_stuff ");
3135 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type
), gdb_stdout
);
3136 puts_filtered ("\n");
3137 print_gnat_stuff (type
, spaces
);
3140 case TYPE_SPECIFIC_FLOATFORMAT
:
3141 printfi_filtered (spaces
, "floatformat ");
3142 if (TYPE_FLOATFORMAT (type
) == NULL
)
3143 puts_filtered ("(null)");
3146 puts_filtered ("{ ");
3147 if (TYPE_FLOATFORMAT (type
)[0] == NULL
3148 || TYPE_FLOATFORMAT (type
)[0]->name
== NULL
)
3149 puts_filtered ("(null)");
3151 puts_filtered (TYPE_FLOATFORMAT (type
)[0]->name
);
3153 puts_filtered (", ");
3154 if (TYPE_FLOATFORMAT (type
)[1] == NULL
3155 || TYPE_FLOATFORMAT (type
)[1]->name
== NULL
)
3156 puts_filtered ("(null)");
3158 puts_filtered (TYPE_FLOATFORMAT (type
)[1]->name
);
3160 puts_filtered (" }");
3162 puts_filtered ("\n");
3165 case TYPE_SPECIFIC_CALLING_CONVENTION
:
3166 printfi_filtered (spaces
, "calling_convention %d\n",
3167 TYPE_CALLING_CONVENTION (type
));
3172 obstack_free (&dont_print_type_obstack
, NULL
);
3175 /* Trivial helpers for the libiberty hash table, for mapping one
3180 struct type
*old
, *new;
3184 type_pair_hash (const void *item
)
3186 const struct type_pair
*pair
= item
;
3188 return htab_hash_pointer (pair
->old
);
3192 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
3194 const struct type_pair
*lhs
= item_lhs
, *rhs
= item_rhs
;
3196 return lhs
->old
== rhs
->old
;
3199 /* Allocate the hash table used by copy_type_recursive to walk
3200 types without duplicates. We use OBJFILE's obstack, because
3201 OBJFILE is about to be deleted. */
3204 create_copied_types_hash (struct objfile
*objfile
)
3206 return htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
3207 NULL
, &objfile
->objfile_obstack
,
3208 hashtab_obstack_allocate
,
3209 dummy_obstack_deallocate
);
3212 /* Recursively copy (deep copy) TYPE, if it is associated with
3213 OBJFILE. Return a new type allocated using malloc, a saved type if
3214 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
3215 not associated with OBJFILE. */
3218 copy_type_recursive (struct objfile
*objfile
,
3220 htab_t copied_types
)
3222 struct type_pair
*stored
, pair
;
3224 struct type
*new_type
;
3226 if (! TYPE_OBJFILE_OWNED (type
))
3229 /* This type shouldn't be pointing to any types in other objfiles;
3230 if it did, the type might disappear unexpectedly. */
3231 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
3234 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
3236 return ((struct type_pair
*) *slot
)->new;
3238 new_type
= alloc_type_arch (get_type_arch (type
));
3240 /* We must add the new type to the hash table immediately, in case
3241 we encounter this type again during a recursive call below. */
3243 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct type_pair
));
3245 stored
->new = new_type
;
3248 /* Copy the common fields of types. For the main type, we simply
3249 copy the entire thing and then update specific fields as needed. */
3250 *TYPE_MAIN_TYPE (new_type
) = *TYPE_MAIN_TYPE (type
);
3251 TYPE_OBJFILE_OWNED (new_type
) = 0;
3252 TYPE_OWNER (new_type
).gdbarch
= get_type_arch (type
);
3254 if (TYPE_NAME (type
))
3255 TYPE_NAME (new_type
) = xstrdup (TYPE_NAME (type
));
3256 if (TYPE_TAG_NAME (type
))
3257 TYPE_TAG_NAME (new_type
) = xstrdup (TYPE_TAG_NAME (type
));
3259 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
3260 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
3262 /* Copy the fields. */
3263 if (TYPE_NFIELDS (type
))
3267 nfields
= TYPE_NFIELDS (type
);
3268 TYPE_FIELDS (new_type
) = XCALLOC (nfields
, struct field
);
3269 for (i
= 0; i
< nfields
; i
++)
3271 TYPE_FIELD_ARTIFICIAL (new_type
, i
) =
3272 TYPE_FIELD_ARTIFICIAL (type
, i
);
3273 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
3274 if (TYPE_FIELD_TYPE (type
, i
))
3275 TYPE_FIELD_TYPE (new_type
, i
)
3276 = copy_type_recursive (objfile
, TYPE_FIELD_TYPE (type
, i
),
3278 if (TYPE_FIELD_NAME (type
, i
))
3279 TYPE_FIELD_NAME (new_type
, i
) =
3280 xstrdup (TYPE_FIELD_NAME (type
, i
));
3281 switch (TYPE_FIELD_LOC_KIND (type
, i
))
3283 case FIELD_LOC_KIND_BITPOS
:
3284 SET_FIELD_BITPOS (TYPE_FIELD (new_type
, i
),
3285 TYPE_FIELD_BITPOS (type
, i
));
3287 case FIELD_LOC_KIND_PHYSADDR
:
3288 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type
, i
),
3289 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
3291 case FIELD_LOC_KIND_PHYSNAME
:
3292 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type
, i
),
3293 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
,
3297 internal_error (__FILE__
, __LINE__
,
3298 _("Unexpected type field location kind: %d"),
3299 TYPE_FIELD_LOC_KIND (type
, i
));
3304 /* For range types, copy the bounds information. */
3305 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
3307 TYPE_RANGE_DATA (new_type
) = xmalloc (sizeof (struct range_bounds
));
3308 *TYPE_RANGE_DATA (new_type
) = *TYPE_RANGE_DATA (type
);
3311 /* Copy pointers to other types. */
3312 if (TYPE_TARGET_TYPE (type
))
3313 TYPE_TARGET_TYPE (new_type
) =
3314 copy_type_recursive (objfile
,
3315 TYPE_TARGET_TYPE (type
),
3317 if (TYPE_VPTR_BASETYPE (type
))
3318 TYPE_VPTR_BASETYPE (new_type
) =
3319 copy_type_recursive (objfile
,
3320 TYPE_VPTR_BASETYPE (type
),
3322 /* Maybe copy the type_specific bits.
3324 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3325 base classes and methods. There's no fundamental reason why we
3326 can't, but at the moment it is not needed. */
3328 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
3329 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
3330 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3331 || TYPE_CODE (type
) == TYPE_CODE_UNION
3332 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
3333 INIT_CPLUS_SPECIFIC (new_type
);
3338 /* Make a copy of the given TYPE, except that the pointer & reference
3339 types are not preserved.
3341 This function assumes that the given type has an associated objfile.
3342 This objfile is used to allocate the new type. */
3345 copy_type (const struct type
*type
)
3347 struct type
*new_type
;
3349 gdb_assert (TYPE_OBJFILE_OWNED (type
));
3351 new_type
= alloc_type_copy (type
);
3352 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
3353 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
3354 memcpy (TYPE_MAIN_TYPE (new_type
), TYPE_MAIN_TYPE (type
),
3355 sizeof (struct main_type
));
3361 /* Helper functions to initialize architecture-specific types. */
3363 /* Allocate a type structure associated with GDBARCH and set its
3364 CODE, LENGTH, and NAME fields. */
3366 arch_type (struct gdbarch
*gdbarch
,
3367 enum type_code code
, int length
, char *name
)
3371 type
= alloc_type_arch (gdbarch
);
3372 TYPE_CODE (type
) = code
;
3373 TYPE_LENGTH (type
) = length
;
3376 TYPE_NAME (type
) = xstrdup (name
);
3381 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
3382 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3383 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3385 arch_integer_type (struct gdbarch
*gdbarch
,
3386 int bit
, int unsigned_p
, char *name
)
3390 t
= arch_type (gdbarch
, TYPE_CODE_INT
, bit
/ TARGET_CHAR_BIT
, name
);
3392 TYPE_UNSIGNED (t
) = 1;
3393 if (name
&& strcmp (name
, "char") == 0)
3394 TYPE_NOSIGN (t
) = 1;
3399 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
3400 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3401 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3403 arch_character_type (struct gdbarch
*gdbarch
,
3404 int bit
, int unsigned_p
, char *name
)
3408 t
= arch_type (gdbarch
, TYPE_CODE_CHAR
, bit
/ TARGET_CHAR_BIT
, name
);
3410 TYPE_UNSIGNED (t
) = 1;
3415 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
3416 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3417 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3419 arch_boolean_type (struct gdbarch
*gdbarch
,
3420 int bit
, int unsigned_p
, char *name
)
3424 t
= arch_type (gdbarch
, TYPE_CODE_BOOL
, bit
/ TARGET_CHAR_BIT
, name
);
3426 TYPE_UNSIGNED (t
) = 1;
3431 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
3432 BIT is the type size in bits; if BIT equals -1, the size is
3433 determined by the floatformat. NAME is the type name. Set the
3434 TYPE_FLOATFORMAT from FLOATFORMATS. */
3436 arch_float_type (struct gdbarch
*gdbarch
,
3437 int bit
, char *name
, const struct floatformat
**floatformats
)
3443 gdb_assert (floatformats
!= NULL
);
3444 gdb_assert (floatformats
[0] != NULL
&& floatformats
[1] != NULL
);
3445 bit
= floatformats
[0]->totalsize
;
3447 gdb_assert (bit
>= 0);
3449 t
= arch_type (gdbarch
, TYPE_CODE_FLT
, bit
/ TARGET_CHAR_BIT
, name
);
3450 TYPE_FLOATFORMAT (t
) = floatformats
;
3454 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
3455 NAME is the type name. TARGET_TYPE is the component float type. */
3457 arch_complex_type (struct gdbarch
*gdbarch
,
3458 char *name
, struct type
*target_type
)
3462 t
= arch_type (gdbarch
, TYPE_CODE_COMPLEX
,
3463 2 * TYPE_LENGTH (target_type
), name
);
3464 TYPE_TARGET_TYPE (t
) = target_type
;
3468 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
3469 NAME is the type name. LENGTH is the size of the flag word in bytes. */
3471 arch_flags_type (struct gdbarch
*gdbarch
, char *name
, int length
)
3473 int nfields
= length
* TARGET_CHAR_BIT
;
3476 type
= arch_type (gdbarch
, TYPE_CODE_FLAGS
, length
, name
);
3477 TYPE_UNSIGNED (type
) = 1;
3478 TYPE_NFIELDS (type
) = nfields
;
3479 TYPE_FIELDS (type
) = TYPE_ZALLOC (type
, nfields
* sizeof (struct field
));
3484 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
3485 position BITPOS is called NAME. */
3487 append_flags_type_flag (struct type
*type
, int bitpos
, char *name
)
3489 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLAGS
);
3490 gdb_assert (bitpos
< TYPE_NFIELDS (type
));
3491 gdb_assert (bitpos
>= 0);
3495 TYPE_FIELD_NAME (type
, bitpos
) = xstrdup (name
);
3496 TYPE_FIELD_BITPOS (type
, bitpos
) = bitpos
;
3500 /* Don't show this field to the user. */
3501 TYPE_FIELD_BITPOS (type
, bitpos
) = -1;
3505 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
3506 specified by CODE) associated with GDBARCH. NAME is the type name. */
3508 arch_composite_type (struct gdbarch
*gdbarch
, char *name
, enum type_code code
)
3512 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
3513 t
= arch_type (gdbarch
, code
, 0, NULL
);
3514 TYPE_TAG_NAME (t
) = name
;
3515 INIT_CPLUS_SPECIFIC (t
);
3519 /* Add new field with name NAME and type FIELD to composite type T.
3520 Do not set the field's position or adjust the type's length;
3521 the caller should do so. Return the new field. */
3523 append_composite_type_field_raw (struct type
*t
, char *name
,
3528 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
3529 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
3530 sizeof (struct field
) * TYPE_NFIELDS (t
));
3531 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
3532 memset (f
, 0, sizeof f
[0]);
3533 FIELD_TYPE (f
[0]) = field
;
3534 FIELD_NAME (f
[0]) = name
;
3538 /* Add new field with name NAME and type FIELD to composite type T.
3539 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
3541 append_composite_type_field_aligned (struct type
*t
, char *name
,
3542 struct type
*field
, int alignment
)
3544 struct field
*f
= append_composite_type_field_raw (t
, name
, field
);
3546 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
3548 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
3549 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
3551 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
3553 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
3554 if (TYPE_NFIELDS (t
) > 1)
3556 FIELD_BITPOS (f
[0]) = (FIELD_BITPOS (f
[-1])
3557 + (TYPE_LENGTH (FIELD_TYPE (f
[-1]))
3558 * TARGET_CHAR_BIT
));
3562 int left
= FIELD_BITPOS (f
[0]) % (alignment
* TARGET_CHAR_BIT
);
3566 FIELD_BITPOS (f
[0]) += left
;
3567 TYPE_LENGTH (t
) += left
/ TARGET_CHAR_BIT
;
3574 /* Add new field with name NAME and type FIELD to composite type T. */
3576 append_composite_type_field (struct type
*t
, char *name
,
3579 append_composite_type_field_aligned (t
, name
, field
, 0);
3583 static struct gdbarch_data
*gdbtypes_data
;
3585 const struct builtin_type
*
3586 builtin_type (struct gdbarch
*gdbarch
)
3588 return gdbarch_data (gdbarch
, gdbtypes_data
);
3592 gdbtypes_post_init (struct gdbarch
*gdbarch
)
3594 struct builtin_type
*builtin_type
3595 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
3598 builtin_type
->builtin_void
3599 = arch_type (gdbarch
, TYPE_CODE_VOID
, 1, "void");
3600 builtin_type
->builtin_char
3601 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3602 !gdbarch_char_signed (gdbarch
), "char");
3603 builtin_type
->builtin_signed_char
3604 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3606 builtin_type
->builtin_unsigned_char
3607 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3608 1, "unsigned char");
3609 builtin_type
->builtin_short
3610 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
3612 builtin_type
->builtin_unsigned_short
3613 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
3614 1, "unsigned short");
3615 builtin_type
->builtin_int
3616 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
3618 builtin_type
->builtin_unsigned_int
3619 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
3621 builtin_type
->builtin_long
3622 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
3624 builtin_type
->builtin_unsigned_long
3625 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
3626 1, "unsigned long");
3627 builtin_type
->builtin_long_long
3628 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
3630 builtin_type
->builtin_unsigned_long_long
3631 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
3632 1, "unsigned long long");
3633 builtin_type
->builtin_float
3634 = arch_float_type (gdbarch
, gdbarch_float_bit (gdbarch
),
3635 "float", gdbarch_float_format (gdbarch
));
3636 builtin_type
->builtin_double
3637 = arch_float_type (gdbarch
, gdbarch_double_bit (gdbarch
),
3638 "double", gdbarch_double_format (gdbarch
));
3639 builtin_type
->builtin_long_double
3640 = arch_float_type (gdbarch
, gdbarch_long_double_bit (gdbarch
),
3641 "long double", gdbarch_long_double_format (gdbarch
));
3642 builtin_type
->builtin_complex
3643 = arch_complex_type (gdbarch
, "complex",
3644 builtin_type
->builtin_float
);
3645 builtin_type
->builtin_double_complex
3646 = arch_complex_type (gdbarch
, "double complex",
3647 builtin_type
->builtin_double
);
3648 builtin_type
->builtin_string
3649 = arch_type (gdbarch
, TYPE_CODE_STRING
, 1, "string");
3650 builtin_type
->builtin_bool
3651 = arch_type (gdbarch
, TYPE_CODE_BOOL
, 1, "bool");
3653 /* The following three are about decimal floating point types, which
3654 are 32-bits, 64-bits and 128-bits respectively. */
3655 builtin_type
->builtin_decfloat
3656 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 32 / 8, "_Decimal32");
3657 builtin_type
->builtin_decdouble
3658 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 64 / 8, "_Decimal64");
3659 builtin_type
->builtin_declong
3660 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 128 / 8, "_Decimal128");
3662 /* "True" character types. */
3663 builtin_type
->builtin_true_char
3664 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 0, "true character");
3665 builtin_type
->builtin_true_unsigned_char
3666 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 1, "true character");
3668 /* Fixed-size integer types. */
3669 builtin_type
->builtin_int0
3670 = arch_integer_type (gdbarch
, 0, 0, "int0_t");
3671 builtin_type
->builtin_int8
3672 = arch_integer_type (gdbarch
, 8, 0, "int8_t");
3673 builtin_type
->builtin_uint8
3674 = arch_integer_type (gdbarch
, 8, 1, "uint8_t");
3675 builtin_type
->builtin_int16
3676 = arch_integer_type (gdbarch
, 16, 0, "int16_t");
3677 builtin_type
->builtin_uint16
3678 = arch_integer_type (gdbarch
, 16, 1, "uint16_t");
3679 builtin_type
->builtin_int32
3680 = arch_integer_type (gdbarch
, 32, 0, "int32_t");
3681 builtin_type
->builtin_uint32
3682 = arch_integer_type (gdbarch
, 32, 1, "uint32_t");
3683 builtin_type
->builtin_int64
3684 = arch_integer_type (gdbarch
, 64, 0, "int64_t");
3685 builtin_type
->builtin_uint64
3686 = arch_integer_type (gdbarch
, 64, 1, "uint64_t");
3687 builtin_type
->builtin_int128
3688 = arch_integer_type (gdbarch
, 128, 0, "int128_t");
3689 builtin_type
->builtin_uint128
3690 = arch_integer_type (gdbarch
, 128, 1, "uint128_t");
3691 TYPE_INSTANCE_FLAGS (builtin_type
->builtin_int8
) |=
3692 TYPE_INSTANCE_FLAG_NOTTEXT
;
3693 TYPE_INSTANCE_FLAGS (builtin_type
->builtin_uint8
) |=
3694 TYPE_INSTANCE_FLAG_NOTTEXT
;
3696 /* Wide character types. */
3697 builtin_type
->builtin_char16
3698 = arch_integer_type (gdbarch
, 16, 0, "char16_t");
3699 builtin_type
->builtin_char32
3700 = arch_integer_type (gdbarch
, 32, 0, "char32_t");
3703 /* Default data/code pointer types. */
3704 builtin_type
->builtin_data_ptr
3705 = lookup_pointer_type (builtin_type
->builtin_void
);
3706 builtin_type
->builtin_func_ptr
3707 = lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
3709 /* This type represents a GDB internal function. */
3710 builtin_type
->internal_fn
3711 = arch_type (gdbarch
, TYPE_CODE_INTERNAL_FUNCTION
, 0,
3712 "<internal function>");
3714 return builtin_type
;
3718 /* This set of objfile-based types is intended to be used by symbol
3719 readers as basic types. */
3721 static const struct objfile_data
*objfile_type_data
;
3723 const struct objfile_type
*
3724 objfile_type (struct objfile
*objfile
)
3726 struct gdbarch
*gdbarch
;
3727 struct objfile_type
*objfile_type
3728 = objfile_data (objfile
, objfile_type_data
);
3731 return objfile_type
;
3733 objfile_type
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
3734 1, struct objfile_type
);
3736 /* Use the objfile architecture to determine basic type properties. */
3737 gdbarch
= get_objfile_arch (objfile
);
3740 objfile_type
->builtin_void
3741 = init_type (TYPE_CODE_VOID
, 1,
3745 objfile_type
->builtin_char
3746 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3748 | (gdbarch_char_signed (gdbarch
) ? 0 : TYPE_FLAG_UNSIGNED
)),
3750 objfile_type
->builtin_signed_char
3751 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3753 "signed char", objfile
);
3754 objfile_type
->builtin_unsigned_char
3755 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3757 "unsigned char", objfile
);
3758 objfile_type
->builtin_short
3759 = init_type (TYPE_CODE_INT
,
3760 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3761 0, "short", objfile
);
3762 objfile_type
->builtin_unsigned_short
3763 = init_type (TYPE_CODE_INT
,
3764 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3765 TYPE_FLAG_UNSIGNED
, "unsigned short", objfile
);
3766 objfile_type
->builtin_int
3767 = init_type (TYPE_CODE_INT
,
3768 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3770 objfile_type
->builtin_unsigned_int
3771 = init_type (TYPE_CODE_INT
,
3772 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3773 TYPE_FLAG_UNSIGNED
, "unsigned int", objfile
);
3774 objfile_type
->builtin_long
3775 = init_type (TYPE_CODE_INT
,
3776 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3777 0, "long", objfile
);
3778 objfile_type
->builtin_unsigned_long
3779 = init_type (TYPE_CODE_INT
,
3780 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3781 TYPE_FLAG_UNSIGNED
, "unsigned long", objfile
);
3782 objfile_type
->builtin_long_long
3783 = init_type (TYPE_CODE_INT
,
3784 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3785 0, "long long", objfile
);
3786 objfile_type
->builtin_unsigned_long_long
3787 = init_type (TYPE_CODE_INT
,
3788 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3789 TYPE_FLAG_UNSIGNED
, "unsigned long long", objfile
);
3791 objfile_type
->builtin_float
3792 = init_type (TYPE_CODE_FLT
,
3793 gdbarch_float_bit (gdbarch
) / TARGET_CHAR_BIT
,
3794 0, "float", objfile
);
3795 TYPE_FLOATFORMAT (objfile_type
->builtin_float
)
3796 = gdbarch_float_format (gdbarch
);
3797 objfile_type
->builtin_double
3798 = init_type (TYPE_CODE_FLT
,
3799 gdbarch_double_bit (gdbarch
) / TARGET_CHAR_BIT
,
3800 0, "double", objfile
);
3801 TYPE_FLOATFORMAT (objfile_type
->builtin_double
)
3802 = gdbarch_double_format (gdbarch
);
3803 objfile_type
->builtin_long_double
3804 = init_type (TYPE_CODE_FLT
,
3805 gdbarch_long_double_bit (gdbarch
) / TARGET_CHAR_BIT
,
3806 0, "long double", objfile
);
3807 TYPE_FLOATFORMAT (objfile_type
->builtin_long_double
)
3808 = gdbarch_long_double_format (gdbarch
);
3810 /* This type represents a type that was unrecognized in symbol read-in. */
3811 objfile_type
->builtin_error
3812 = init_type (TYPE_CODE_ERROR
, 0, 0, "<unknown type>", objfile
);
3814 /* The following set of types is used for symbols with no
3815 debug information. */
3816 objfile_type
->nodebug_text_symbol
3817 = init_type (TYPE_CODE_FUNC
, 1, 0,
3818 "<text variable, no debug info>", objfile
);
3819 TYPE_TARGET_TYPE (objfile_type
->nodebug_text_symbol
)
3820 = objfile_type
->builtin_int
;
3821 objfile_type
->nodebug_data_symbol
3822 = init_type (TYPE_CODE_INT
,
3823 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3824 "<data variable, no debug info>", objfile
);
3825 objfile_type
->nodebug_unknown_symbol
3826 = init_type (TYPE_CODE_INT
, 1, 0,
3827 "<variable (not text or data), no debug info>", objfile
);
3828 objfile_type
->nodebug_tls_symbol
3829 = init_type (TYPE_CODE_INT
,
3830 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3831 "<thread local variable, no debug info>", objfile
);
3833 /* NOTE: on some targets, addresses and pointers are not necessarily
3834 the same --- for example, on the D10V, pointers are 16 bits long,
3835 but addresses are 32 bits long. See doc/gdbint.texinfo,
3836 ``Pointers Are Not Always Addresses''.
3839 - gdb's `struct type' always describes the target's
3841 - gdb's `struct value' objects should always hold values in
3843 - gdb's CORE_ADDR values are addresses in the unified virtual
3844 address space that the assembler and linker work with. Thus,
3845 since target_read_memory takes a CORE_ADDR as an argument, it
3846 can access any memory on the target, even if the processor has
3847 separate code and data address spaces.
3850 - If v is a value holding a D10V code pointer, its contents are
3851 in target form: a big-endian address left-shifted two bits.
3852 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3853 sizeof (void *) == 2 on the target.
3855 In this context, objfile_type->builtin_core_addr is a bit odd:
3856 it's a target type for a value the target will never see. It's
3857 only used to hold the values of (typeless) linker symbols, which
3858 are indeed in the unified virtual address space. */
3860 objfile_type
->builtin_core_addr
3861 = init_type (TYPE_CODE_INT
,
3862 gdbarch_addr_bit (gdbarch
) / 8,
3863 TYPE_FLAG_UNSIGNED
, "__CORE_ADDR", objfile
);
3865 set_objfile_data (objfile
, objfile_type_data
, objfile_type
);
3866 return objfile_type
;
3870 extern void _initialize_gdbtypes (void);
3872 _initialize_gdbtypes (void)
3874 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
3875 objfile_type_data
= register_objfile_data ();
3877 add_setshow_zinteger_cmd ("overload", no_class
, &overload_debug
,
3878 _("Set debugging of C++ overloading."),
3879 _("Show debugging of C++ overloading."),
3880 _("When enabled, ranking of the "
3881 "functions is displayed."),
3883 show_overload_debug
,
3884 &setdebuglist
, &showdebuglist
);
3886 /* Add user knob for controlling resolution of opaque types. */
3887 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
3888 &opaque_type_resolution
,
3889 _("Set resolution of opaque struct/class/union"
3890 " types (if set before loading symbols)."),
3891 _("Show resolution of opaque struct/class/union"
3892 " types (if set before loading symbols)."),
3894 show_opaque_type_resolution
,
3895 &setlist
, &showlist
);