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 Free Software Foundation, Inc.
6 Contributed by Cygnus Support, using pieces from other GDB modules.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor,
23 Boston, MA 02110-1301, USA. */
26 #include "gdb_string.h"
32 #include "expression.h"
37 #include "complaints.h"
41 #include "gdb_assert.h"
44 /* These variables point to the objects
45 representing the predefined C data types. */
47 struct type
*builtin_type_void
;
48 struct type
*builtin_type_char
;
49 struct type
*builtin_type_true_char
;
50 struct type
*builtin_type_short
;
51 struct type
*builtin_type_int
;
52 struct type
*builtin_type_long
;
53 struct type
*builtin_type_long_long
;
54 struct type
*builtin_type_signed_char
;
55 struct type
*builtin_type_unsigned_char
;
56 struct type
*builtin_type_unsigned_short
;
57 struct type
*builtin_type_unsigned_int
;
58 struct type
*builtin_type_unsigned_long
;
59 struct type
*builtin_type_unsigned_long_long
;
60 struct type
*builtin_type_float
;
61 struct type
*builtin_type_double
;
62 struct type
*builtin_type_long_double
;
63 struct type
*builtin_type_complex
;
64 struct type
*builtin_type_double_complex
;
65 struct type
*builtin_type_string
;
66 struct type
*builtin_type_int0
;
67 struct type
*builtin_type_int8
;
68 struct type
*builtin_type_uint8
;
69 struct type
*builtin_type_int16
;
70 struct type
*builtin_type_uint16
;
71 struct type
*builtin_type_int32
;
72 struct type
*builtin_type_uint32
;
73 struct type
*builtin_type_int64
;
74 struct type
*builtin_type_uint64
;
75 struct type
*builtin_type_int128
;
76 struct type
*builtin_type_uint128
;
77 struct type
*builtin_type_bool
;
79 /* 128 bit long vector types */
80 struct type
*builtin_type_v2_double
;
81 struct type
*builtin_type_v4_float
;
82 struct type
*builtin_type_v2_int64
;
83 struct type
*builtin_type_v4_int32
;
84 struct type
*builtin_type_v8_int16
;
85 struct type
*builtin_type_v16_int8
;
86 /* 64 bit long vector types */
87 struct type
*builtin_type_v2_float
;
88 struct type
*builtin_type_v2_int32
;
89 struct type
*builtin_type_v4_int16
;
90 struct type
*builtin_type_v8_int8
;
92 struct type
*builtin_type_v4sf
;
93 struct type
*builtin_type_v4si
;
94 struct type
*builtin_type_v16qi
;
95 struct type
*builtin_type_v8qi
;
96 struct type
*builtin_type_v8hi
;
97 struct type
*builtin_type_v4hi
;
98 struct type
*builtin_type_v2si
;
99 struct type
*builtin_type_vec64
;
100 struct type
*builtin_type_vec128
;
102 /* Floatformat pairs. */
103 const struct floatformat
*floatformats_ieee_single
[BFD_ENDIAN_UNKNOWN
] = {
104 &floatformat_ieee_single_big
,
105 &floatformat_ieee_single_little
107 const struct floatformat
*floatformats_ieee_double
[BFD_ENDIAN_UNKNOWN
] = {
108 &floatformat_ieee_double_big
,
109 &floatformat_ieee_double_little
111 const struct floatformat
*floatformats_ieee_double_littlebyte_bigword
[BFD_ENDIAN_UNKNOWN
] = {
112 &floatformat_ieee_double_big
,
113 &floatformat_ieee_double_littlebyte_bigword
115 const struct floatformat
*floatformats_i387_ext
[BFD_ENDIAN_UNKNOWN
] = {
116 &floatformat_i387_ext
,
117 &floatformat_i387_ext
119 const struct floatformat
*floatformats_m68881_ext
[BFD_ENDIAN_UNKNOWN
] = {
120 &floatformat_m68881_ext
,
121 &floatformat_m68881_ext
123 const struct floatformat
*floatformats_arm_ext
[BFD_ENDIAN_UNKNOWN
] = {
124 &floatformat_arm_ext_big
,
125 &floatformat_arm_ext_littlebyte_bigword
127 const struct floatformat
*floatformats_ia64_spill
[BFD_ENDIAN_UNKNOWN
] = {
128 &floatformat_ia64_spill_big
,
129 &floatformat_ia64_spill_little
131 const struct floatformat
*floatformats_ia64_quad
[BFD_ENDIAN_UNKNOWN
] = {
132 &floatformat_ia64_quad_big
,
133 &floatformat_ia64_quad_little
135 const struct floatformat
*floatformats_vax_f
[BFD_ENDIAN_UNKNOWN
] = {
139 const struct floatformat
*floatformats_vax_d
[BFD_ENDIAN_UNKNOWN
] = {
144 struct type
*builtin_type_ieee_single
;
145 struct type
*builtin_type_ieee_double
;
146 struct type
*builtin_type_i387_ext
;
147 struct type
*builtin_type_m68881_ext
;
148 struct type
*builtin_type_arm_ext
;
149 struct type
*builtin_type_ia64_spill
;
150 struct type
*builtin_type_ia64_quad
;
152 struct type
*builtin_type_void_data_ptr
;
153 struct type
*builtin_type_void_func_ptr
;
154 struct type
*builtin_type_CORE_ADDR
;
155 struct type
*builtin_type_bfd_vma
;
157 int opaque_type_resolution
= 1;
159 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
160 struct cmd_list_element
*c
, const char *value
)
162 fprintf_filtered (file
, _("\
163 Resolution of opaque struct/class/union types (if set before loading symbols) is %s.\n"),
167 int overload_debug
= 0;
169 show_overload_debug (struct ui_file
*file
, int from_tty
,
170 struct cmd_list_element
*c
, const char *value
)
172 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"), value
);
179 }; /* maximum extension is 128! FIXME */
181 static void print_bit_vector (B_TYPE
*, int);
182 static void print_arg_types (struct field
*, int, int);
183 static void dump_fn_fieldlists (struct type
*, int);
184 static void print_cplus_stuff (struct type
*, int);
185 static void virtual_base_list_aux (struct type
*dclass
);
188 /* Alloc a new type structure and fill it with some defaults. If
189 OBJFILE is non-NULL, then allocate the space for the type structure
190 in that objfile's objfile_obstack. Otherwise allocate the new type structure
191 by xmalloc () (for permanent types). */
194 alloc_type (struct objfile
*objfile
)
198 /* Alloc the structure and start off with all fields zeroed. */
202 type
= xmalloc (sizeof (struct type
));
203 memset (type
, 0, sizeof (struct type
));
204 TYPE_MAIN_TYPE (type
) = xmalloc (sizeof (struct main_type
));
208 type
= obstack_alloc (&objfile
->objfile_obstack
,
209 sizeof (struct type
));
210 memset (type
, 0, sizeof (struct type
));
211 TYPE_MAIN_TYPE (type
) = obstack_alloc (&objfile
->objfile_obstack
,
212 sizeof (struct main_type
));
213 OBJSTAT (objfile
, n_types
++);
215 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
217 /* Initialize the fields that might not be zero. */
219 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
220 TYPE_OBJFILE (type
) = objfile
;
221 TYPE_VPTR_FIELDNO (type
) = -1;
222 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
227 /* Alloc a new type instance structure, fill it with some defaults,
228 and point it at OLDTYPE. Allocate the new type instance from the
229 same place as OLDTYPE. */
232 alloc_type_instance (struct type
*oldtype
)
236 /* Allocate the structure. */
238 if (TYPE_OBJFILE (oldtype
) == NULL
)
240 type
= xmalloc (sizeof (struct type
));
241 memset (type
, 0, sizeof (struct type
));
245 type
= obstack_alloc (&TYPE_OBJFILE (oldtype
)->objfile_obstack
,
246 sizeof (struct type
));
247 memset (type
, 0, sizeof (struct type
));
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. */
259 smash_type (struct type
*type
)
261 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
263 /* For now, delete the rings. */
264 TYPE_CHAIN (type
) = type
;
266 /* For now, leave the pointer/reference types alone. */
269 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
270 to a pointer to memory where the pointer type should be stored.
271 If *TYPEPTR is zero, update it to point to the pointer type we return.
272 We allocate new memory if needed. */
275 make_pointer_type (struct type
*type
, struct type
**typeptr
)
277 struct type
*ntype
; /* New type */
278 struct objfile
*objfile
;
281 ntype
= TYPE_POINTER_TYPE (type
);
286 return ntype
; /* Don't care about alloc, and have new type. */
287 else if (*typeptr
== 0)
289 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
294 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
296 ntype
= alloc_type (TYPE_OBJFILE (type
));
301 /* We have storage, but need to reset it. */
304 objfile
= TYPE_OBJFILE (ntype
);
305 chain
= TYPE_CHAIN (ntype
);
307 TYPE_CHAIN (ntype
) = chain
;
308 TYPE_OBJFILE (ntype
) = objfile
;
311 TYPE_TARGET_TYPE (ntype
) = type
;
312 TYPE_POINTER_TYPE (type
) = ntype
;
314 /* FIXME! Assume the machine has only one representation for pointers! */
316 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
317 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
319 /* Mark pointers as unsigned. The target converts between pointers
320 and addresses (CORE_ADDRs) using POINTER_TO_ADDRESS() and
321 ADDRESS_TO_POINTER(). */
322 TYPE_FLAGS (ntype
) |= TYPE_FLAG_UNSIGNED
;
324 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
325 TYPE_POINTER_TYPE (type
) = ntype
;
327 /* Update the length of all the other variants of this type. */
328 chain
= TYPE_CHAIN (ntype
);
329 while (chain
!= ntype
)
331 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
332 chain
= TYPE_CHAIN (chain
);
338 /* Given a type TYPE, return a type of pointers to that type.
339 May need to construct such a type if this is the first use. */
342 lookup_pointer_type (struct type
*type
)
344 return make_pointer_type (type
, (struct type
**) 0);
347 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero, points
348 to a pointer to memory where the reference type should be stored.
349 If *TYPEPTR is zero, update it to point to the reference type we return.
350 We allocate new memory if needed. */
353 make_reference_type (struct type
*type
, struct type
**typeptr
)
355 struct type
*ntype
; /* New type */
356 struct objfile
*objfile
;
359 ntype
= TYPE_REFERENCE_TYPE (type
);
364 return ntype
; /* Don't care about alloc, and have new type. */
365 else if (*typeptr
== 0)
367 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
372 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
374 ntype
= alloc_type (TYPE_OBJFILE (type
));
379 /* We have storage, but need to reset it. */
382 objfile
= TYPE_OBJFILE (ntype
);
383 chain
= TYPE_CHAIN (ntype
);
385 TYPE_CHAIN (ntype
) = chain
;
386 TYPE_OBJFILE (ntype
) = objfile
;
389 TYPE_TARGET_TYPE (ntype
) = type
;
390 TYPE_REFERENCE_TYPE (type
) = ntype
;
392 /* FIXME! Assume the machine has only one representation for references,
393 and that it matches the (only) representation for pointers! */
395 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
396 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
398 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
399 TYPE_REFERENCE_TYPE (type
) = ntype
;
401 /* Update the length of all the other variants of this type. */
402 chain
= TYPE_CHAIN (ntype
);
403 while (chain
!= ntype
)
405 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
406 chain
= TYPE_CHAIN (chain
);
412 /* Same as above, but caller doesn't care about memory allocation details. */
415 lookup_reference_type (struct type
*type
)
417 return make_reference_type (type
, (struct type
**) 0);
420 /* Lookup a function type that returns type TYPE. TYPEPTR, if nonzero, points
421 to a pointer to memory where the function type should be stored.
422 If *TYPEPTR is zero, update it to point to the function type we return.
423 We allocate new memory if needed. */
426 make_function_type (struct type
*type
, struct type
**typeptr
)
428 struct type
*ntype
; /* New type */
429 struct objfile
*objfile
;
431 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
433 ntype
= alloc_type (TYPE_OBJFILE (type
));
438 /* We have storage, but need to reset it. */
441 objfile
= TYPE_OBJFILE (ntype
);
443 TYPE_OBJFILE (ntype
) = objfile
;
446 TYPE_TARGET_TYPE (ntype
) = type
;
448 TYPE_LENGTH (ntype
) = 1;
449 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
455 /* Given a type TYPE, return a type of functions that return that type.
456 May need to construct such a type if this is the first use. */
459 lookup_function_type (struct type
*type
)
461 return make_function_type (type
, (struct type
**) 0);
464 /* Identify address space identifier by name --
465 return the integer flag defined in gdbtypes.h. */
467 address_space_name_to_int (char *space_identifier
)
469 struct gdbarch
*gdbarch
= current_gdbarch
;
471 /* Check for known address space delimiters. */
472 if (!strcmp (space_identifier
, "code"))
473 return TYPE_FLAG_CODE_SPACE
;
474 else if (!strcmp (space_identifier
, "data"))
475 return TYPE_FLAG_DATA_SPACE
;
476 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
477 && gdbarch_address_class_name_to_type_flags (gdbarch
,
482 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
485 /* Identify address space identifier by integer flag as defined in
486 gdbtypes.h -- return the string version of the adress space name. */
489 address_space_int_to_name (int space_flag
)
491 struct gdbarch
*gdbarch
= current_gdbarch
;
492 if (space_flag
& TYPE_FLAG_CODE_SPACE
)
494 else if (space_flag
& TYPE_FLAG_DATA_SPACE
)
496 else if ((space_flag
& TYPE_FLAG_ADDRESS_CLASS_ALL
)
497 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
498 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
503 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
505 If STORAGE is non-NULL, create the new type instance there.
506 STORAGE must be in the same obstack as TYPE. */
509 make_qualified_type (struct type
*type
, int new_flags
,
510 struct type
*storage
)
516 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
518 ntype
= TYPE_CHAIN (ntype
);
519 } while (ntype
!= type
);
521 /* Create a new type instance. */
523 ntype
= alloc_type_instance (type
);
526 /* If STORAGE was provided, it had better be in the same objfile as
527 TYPE. Otherwise, we can't link it into TYPE's cv chain: if one
528 objfile is freed and the other kept, we'd have dangling
530 gdb_assert (TYPE_OBJFILE (type
) == TYPE_OBJFILE (storage
));
533 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
534 TYPE_CHAIN (ntype
) = ntype
;
537 /* Pointers or references to the original type are not relevant to
539 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
540 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
542 /* Chain the new qualified type to the old type. */
543 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
544 TYPE_CHAIN (type
) = ntype
;
546 /* Now set the instance flags and return the new type. */
547 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
549 /* Set length of new type to that of the original type. */
550 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
555 /* Make an address-space-delimited variant of a type -- a type that
556 is identical to the one supplied except that it has an address
557 space attribute attached to it (such as "code" or "data").
559 The space attributes "code" and "data" are for Harvard architectures.
560 The address space attributes are for architectures which have
561 alternately sized pointers or pointers with alternate representations. */
564 make_type_with_address_space (struct type
*type
, int space_flag
)
567 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
568 & ~(TYPE_FLAG_CODE_SPACE
| TYPE_FLAG_DATA_SPACE
569 | TYPE_FLAG_ADDRESS_CLASS_ALL
))
572 return make_qualified_type (type
, new_flags
, NULL
);
575 /* Make a "c-v" variant of a type -- a type that is identical to the
576 one supplied except that it may have const or volatile attributes
577 CNST is a flag for setting the const attribute
578 VOLTL is a flag for setting the volatile attribute
579 TYPE is the base type whose variant we are creating.
581 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
582 storage to hold the new qualified type; *TYPEPTR and TYPE must be
583 in the same objfile. Otherwise, allocate fresh memory for the new
584 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
585 new type we construct. */
587 make_cv_type (int cnst
, int voltl
, struct type
*type
, struct type
**typeptr
)
589 struct type
*ntype
; /* New type */
590 struct type
*tmp_type
= type
; /* tmp type */
591 struct objfile
*objfile
;
593 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
594 & ~(TYPE_FLAG_CONST
| TYPE_FLAG_VOLATILE
));
597 new_flags
|= TYPE_FLAG_CONST
;
600 new_flags
|= TYPE_FLAG_VOLATILE
;
602 if (typeptr
&& *typeptr
!= NULL
)
604 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
605 a C-V variant chain that threads across objfiles: if one
606 objfile gets freed, then the other has a broken C-V chain.
608 This code used to try to copy over the main type from TYPE to
609 *TYPEPTR if they were in different objfiles, but that's
610 wrong, too: TYPE may have a field list or member function
611 lists, which refer to types of their own, etc. etc. The
612 whole shebang would need to be copied over recursively; you
613 can't have inter-objfile pointers. The only thing to do is
614 to leave stub types as stub types, and look them up afresh by
615 name each time you encounter them. */
616 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
));
619 ntype
= make_qualified_type (type
, new_flags
, typeptr
? *typeptr
: NULL
);
627 /* Replace the contents of ntype with the type *type. This changes the
628 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
629 the changes are propogated to all types in the TYPE_CHAIN.
631 In order to build recursive types, it's inevitable that we'll need
632 to update types in place --- but this sort of indiscriminate
633 smashing is ugly, and needs to be replaced with something more
634 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
635 clear if more steps are needed. */
637 replace_type (struct type
*ntype
, struct type
*type
)
641 /* These two types had better be in the same objfile. Otherwise,
642 the assignment of one type's main type structure to the other
643 will produce a type with references to objects (names; field
644 lists; etc.) allocated on an objfile other than its own. */
645 gdb_assert (TYPE_OBJFILE (ntype
) == TYPE_OBJFILE (ntype
));
647 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
649 /* The type length is not a part of the main type. Update it for each
650 type on the variant chain. */
653 /* Assert that this element of the chain has no address-class bits
654 set in its flags. Such type variants might have type lengths
655 which are supposed to be different from the non-address-class
656 variants. This assertion shouldn't ever be triggered because
657 symbol readers which do construct address-class variants don't
658 call replace_type(). */
659 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
661 TYPE_LENGTH (chain
) = TYPE_LENGTH (type
);
662 chain
= TYPE_CHAIN (chain
);
663 } while (ntype
!= chain
);
665 /* Assert that the two types have equivalent instance qualifiers.
666 This should be true for at least all of our debug readers. */
667 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
670 /* Implement direct support for MEMBER_TYPE in GNU C++.
671 May need to construct such a type if this is the first use.
672 The TYPE is the type of the member. The DOMAIN is the type
673 of the aggregate that the member belongs to. */
676 lookup_memberptr_type (struct type
*type
, struct type
*domain
)
680 mtype
= alloc_type (TYPE_OBJFILE (type
));
681 smash_to_memberptr_type (mtype
, domain
, type
);
685 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
688 lookup_methodptr_type (struct type
*to_type
)
692 mtype
= alloc_type (TYPE_OBJFILE (to_type
));
693 TYPE_TARGET_TYPE (mtype
) = to_type
;
694 TYPE_DOMAIN_TYPE (mtype
) = TYPE_DOMAIN_TYPE (to_type
);
695 TYPE_LENGTH (mtype
) = cplus_method_ptr_size ();
696 TYPE_CODE (mtype
) = TYPE_CODE_METHODPTR
;
700 /* Allocate a stub method whose return type is TYPE.
701 This apparently happens for speed of symbol reading, since parsing
702 out the arguments to the method is cpu-intensive, the way we are doing
703 it. So, we will fill in arguments later.
704 This always returns a fresh type. */
707 allocate_stub_method (struct type
*type
)
711 mtype
= init_type (TYPE_CODE_METHOD
, 1, TYPE_FLAG_STUB
, NULL
,
712 TYPE_OBJFILE (type
));
713 TYPE_TARGET_TYPE (mtype
) = type
;
714 /* _DOMAIN_TYPE (mtype) = unknown yet */
718 /* Create a range type using either a blank type supplied in RESULT_TYPE,
719 or creating a new type, inheriting the objfile from INDEX_TYPE.
721 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
722 HIGH_BOUND, inclusive.
724 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
725 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
728 create_range_type (struct type
*result_type
, struct type
*index_type
,
729 int low_bound
, int high_bound
)
731 if (result_type
== NULL
)
733 result_type
= alloc_type (TYPE_OBJFILE (index_type
));
735 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
736 TYPE_TARGET_TYPE (result_type
) = index_type
;
737 if (TYPE_STUB (index_type
))
738 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
740 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
741 TYPE_NFIELDS (result_type
) = 2;
742 TYPE_FIELDS (result_type
) = (struct field
*)
743 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
744 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
745 TYPE_FIELD_BITPOS (result_type
, 0) = low_bound
;
746 TYPE_FIELD_BITPOS (result_type
, 1) = high_bound
;
747 TYPE_FIELD_TYPE (result_type
, 0) = builtin_type_int
; /* FIXME */
748 TYPE_FIELD_TYPE (result_type
, 1) = builtin_type_int
; /* FIXME */
751 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
753 return (result_type
);
756 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE.
757 Return 1 if type is a range type, 0 if it is discrete (and bounds
758 will fit in LONGEST), or -1 otherwise. */
761 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
763 CHECK_TYPEDEF (type
);
764 switch (TYPE_CODE (type
))
766 case TYPE_CODE_RANGE
:
767 *lowp
= TYPE_LOW_BOUND (type
);
768 *highp
= TYPE_HIGH_BOUND (type
);
771 if (TYPE_NFIELDS (type
) > 0)
773 /* The enums may not be sorted by value, so search all
777 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
778 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
780 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
781 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
782 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
783 *highp
= TYPE_FIELD_BITPOS (type
, i
);
786 /* Set unsigned indicator if warranted. */
789 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
803 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
805 if (!TYPE_UNSIGNED (type
))
807 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
811 /* ... fall through for unsigned ints ... */
814 /* This round-about calculation is to avoid shifting by
815 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
816 if TYPE_LENGTH (type) == sizeof (LONGEST). */
817 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
818 *highp
= (*highp
- 1) | *highp
;
825 /* Create an array type using either a blank type supplied in RESULT_TYPE,
826 or creating a new type, inheriting the objfile from RANGE_TYPE.
828 Elements will be of type ELEMENT_TYPE, the indices will be of type
831 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
832 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
835 create_array_type (struct type
*result_type
, struct type
*element_type
,
836 struct type
*range_type
)
838 LONGEST low_bound
, high_bound
;
840 if (result_type
== NULL
)
842 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
844 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
845 TYPE_TARGET_TYPE (result_type
) = element_type
;
846 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
847 low_bound
= high_bound
= 0;
848 CHECK_TYPEDEF (element_type
);
849 TYPE_LENGTH (result_type
) =
850 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
851 TYPE_NFIELDS (result_type
) = 1;
852 TYPE_FIELDS (result_type
) =
853 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
854 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
855 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
856 TYPE_VPTR_FIELDNO (result_type
) = -1;
858 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
859 if (TYPE_LENGTH (result_type
) == 0)
860 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
862 return (result_type
);
865 /* Create a string type using either a blank type supplied in RESULT_TYPE,
866 or creating a new type. String types are similar enough to array of
867 char types that we can use create_array_type to build the basic type
868 and then bash it into a string type.
870 For fixed length strings, the range type contains 0 as the lower
871 bound and the length of the string minus one as the upper bound.
873 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
874 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
877 create_string_type (struct type
*result_type
, struct type
*range_type
)
879 struct type
*string_char_type
;
881 string_char_type
= language_string_char_type (current_language
,
883 result_type
= create_array_type (result_type
,
886 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
887 return (result_type
);
891 create_set_type (struct type
*result_type
, struct type
*domain_type
)
893 LONGEST low_bound
, high_bound
, bit_length
;
894 if (result_type
== NULL
)
896 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
898 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
899 TYPE_NFIELDS (result_type
) = 1;
900 TYPE_FIELDS (result_type
) = (struct field
*)
901 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
902 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
904 if (!TYPE_STUB (domain_type
))
906 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
907 low_bound
= high_bound
= 0;
908 bit_length
= high_bound
- low_bound
+ 1;
909 TYPE_LENGTH (result_type
)
910 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
912 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
915 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
917 return (result_type
);
921 append_flags_type_flag (struct type
*type
, int bitpos
, char *name
)
923 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLAGS
);
924 gdb_assert (bitpos
< TYPE_NFIELDS (type
));
925 gdb_assert (bitpos
>= 0);
929 TYPE_FIELD_NAME (type
, bitpos
) = xstrdup (name
);
930 TYPE_FIELD_BITPOS (type
, bitpos
) = bitpos
;
934 /* Don't show this field to the user. */
935 TYPE_FIELD_BITPOS (type
, bitpos
) = -1;
940 init_flags_type (char *name
, int length
)
942 int nfields
= length
* TARGET_CHAR_BIT
;
945 type
= init_type (TYPE_CODE_FLAGS
, length
, TYPE_FLAG_UNSIGNED
, name
, NULL
);
946 TYPE_NFIELDS (type
) = nfields
;
947 TYPE_FIELDS (type
) = TYPE_ALLOC (type
, nfields
* sizeof (struct field
));
948 memset (TYPE_FIELDS (type
), 0, nfields
* sizeof (struct field
));
953 /* Construct and return a type of the form:
954 struct NAME { ELT_TYPE ELT_NAME[N]; }
955 We use these types for SIMD registers. For example, the type of
956 the SSE registers on the late x86-family processors is:
957 struct __builtin_v4sf { float f[4]; }
958 built by the function call:
959 init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4)
960 The type returned is a permanent type, allocated using malloc; it
961 doesn't live in any objfile's obstack. */
963 init_simd_type (char *name
,
964 struct type
*elt_type
,
968 struct type
*simd_type
;
969 struct type
*array_type
;
971 simd_type
= init_composite_type (name
, TYPE_CODE_STRUCT
);
972 array_type
= create_array_type (0, elt_type
,
973 create_range_type (0, builtin_type_int
,
975 append_composite_type_field (simd_type
, elt_name
, array_type
);
980 init_vector_type (struct type
*elt_type
, int n
)
982 struct type
*array_type
;
984 array_type
= create_array_type (0, elt_type
,
985 create_range_type (0, builtin_type_int
,
987 TYPE_FLAGS (array_type
) |= TYPE_FLAG_VECTOR
;
992 build_builtin_type_vec64 (void)
994 /* Construct a type for the 64 bit registers. The type we're
997 union __gdb_builtin_type_vec64
1001 int32_t v2_int32
[2];
1002 int16_t v4_int16
[4];
1009 t
= init_composite_type ("__gdb_builtin_type_vec64", TYPE_CODE_UNION
);
1010 append_composite_type_field (t
, "uint64", builtin_type_int64
);
1011 append_composite_type_field (t
, "v2_float", builtin_type_v2_float
);
1012 append_composite_type_field (t
, "v2_int32", builtin_type_v2_int32
);
1013 append_composite_type_field (t
, "v4_int16", builtin_type_v4_int16
);
1014 append_composite_type_field (t
, "v8_int8", builtin_type_v8_int8
);
1016 TYPE_FLAGS (t
) |= TYPE_FLAG_VECTOR
;
1017 TYPE_NAME (t
) = "builtin_type_vec64";
1021 static struct type
*
1022 build_builtin_type_vec128 (void)
1024 /* Construct a type for the 128 bit registers. The type we're
1025 building is this: */
1027 union __gdb_builtin_type_vec128
1031 int32_t v4_int32
[4];
1032 int16_t v8_int16
[8];
1033 int8_t v16_int8
[16];
1039 t
= init_composite_type ("__gdb_builtin_type_vec128", TYPE_CODE_UNION
);
1040 append_composite_type_field (t
, "uint128", builtin_type_int128
);
1041 append_composite_type_field (t
, "v4_float", builtin_type_v4_float
);
1042 append_composite_type_field (t
, "v4_int32", builtin_type_v4_int32
);
1043 append_composite_type_field (t
, "v8_int16", builtin_type_v8_int16
);
1044 append_composite_type_field (t
, "v16_int8", builtin_type_v16_int8
);
1046 TYPE_FLAGS (t
) |= TYPE_FLAG_VECTOR
;
1047 TYPE_NAME (t
) = "builtin_type_vec128";
1051 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
1052 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1053 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1054 TYPE doesn't include the offset (that's the value of the MEMBER
1055 itself), but does include the structure type into which it points
1058 When "smashing" the type, we preserve the objfile that the
1059 old type pointed to, since we aren't changing where the type is actually
1063 smash_to_memberptr_type (struct type
*type
, struct type
*domain
,
1064 struct type
*to_type
)
1066 struct objfile
*objfile
;
1068 objfile
= TYPE_OBJFILE (type
);
1071 TYPE_OBJFILE (type
) = objfile
;
1072 TYPE_TARGET_TYPE (type
) = to_type
;
1073 TYPE_DOMAIN_TYPE (type
) = domain
;
1074 /* Assume that a data member pointer is the same size as a normal
1076 TYPE_LENGTH (type
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
1077 TYPE_CODE (type
) = TYPE_CODE_MEMBERPTR
;
1080 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
1081 METHOD just means `function that gets an extra "this" argument'.
1083 When "smashing" the type, we preserve the objfile that the
1084 old type pointed to, since we aren't changing where the type is actually
1088 smash_to_method_type (struct type
*type
, struct type
*domain
,
1089 struct type
*to_type
, struct field
*args
,
1090 int nargs
, int varargs
)
1092 struct objfile
*objfile
;
1094 objfile
= TYPE_OBJFILE (type
);
1097 TYPE_OBJFILE (type
) = objfile
;
1098 TYPE_TARGET_TYPE (type
) = to_type
;
1099 TYPE_DOMAIN_TYPE (type
) = domain
;
1100 TYPE_FIELDS (type
) = args
;
1101 TYPE_NFIELDS (type
) = nargs
;
1103 TYPE_FLAGS (type
) |= TYPE_FLAG_VARARGS
;
1104 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1105 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
1108 /* Return a typename for a struct/union/enum type without "struct ",
1109 "union ", or "enum ". If the type has a NULL name, return NULL. */
1112 type_name_no_tag (const struct type
*type
)
1114 if (TYPE_TAG_NAME (type
) != NULL
)
1115 return TYPE_TAG_NAME (type
);
1117 /* Is there code which expects this to return the name if there is no
1118 tag name? My guess is that this is mainly used for C++ in cases where
1119 the two will always be the same. */
1120 return TYPE_NAME (type
);
1123 /* Lookup a typedef or primitive type named NAME,
1124 visible in lexical block BLOCK.
1125 If NOERR is nonzero, return zero if NAME is not suitably defined. */
1128 lookup_typename (char *name
, struct block
*block
, int noerr
)
1133 sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, 0, (struct symtab
**) NULL
);
1134 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1136 tmp
= language_lookup_primitive_type_by_name (current_language
,
1143 else if (!tmp
&& noerr
)
1149 error (_("No type named %s."), name
);
1152 return (SYMBOL_TYPE (sym
));
1156 lookup_unsigned_typename (char *name
)
1158 char *uns
= alloca (strlen (name
) + 10);
1160 strcpy (uns
, "unsigned ");
1161 strcpy (uns
+ 9, name
);
1162 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
1166 lookup_signed_typename (char *name
)
1169 char *uns
= alloca (strlen (name
) + 8);
1171 strcpy (uns
, "signed ");
1172 strcpy (uns
+ 7, name
);
1173 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
1174 /* If we don't find "signed FOO" just try again with plain "FOO". */
1177 return lookup_typename (name
, (struct block
*) NULL
, 0);
1180 /* Lookup a structure type named "struct NAME",
1181 visible in lexical block BLOCK. */
1184 lookup_struct (char *name
, struct block
*block
)
1188 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
1189 (struct symtab
**) NULL
);
1193 error (_("No struct type named %s."), name
);
1195 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1197 error (_("This context has class, union or enum %s, not a struct."), name
);
1199 return (SYMBOL_TYPE (sym
));
1202 /* Lookup a union type named "union NAME",
1203 visible in lexical block BLOCK. */
1206 lookup_union (char *name
, struct block
*block
)
1211 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
1212 (struct symtab
**) NULL
);
1215 error (_("No union type named %s."), name
);
1217 t
= SYMBOL_TYPE (sym
);
1219 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1222 /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
1223 * a further "declared_type" field to discover it is really a union.
1225 if (HAVE_CPLUS_STRUCT (t
))
1226 if (TYPE_DECLARED_TYPE (t
) == DECLARED_TYPE_UNION
)
1229 /* If we get here, it's not a union */
1230 error (_("This context has class, struct or enum %s, not a union."), name
);
1234 /* Lookup an enum type named "enum NAME",
1235 visible in lexical block BLOCK. */
1238 lookup_enum (char *name
, struct block
*block
)
1242 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
1243 (struct symtab
**) NULL
);
1246 error (_("No enum type named %s."), name
);
1248 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1250 error (_("This context has class, struct or union %s, not an enum."), name
);
1252 return (SYMBOL_TYPE (sym
));
1255 /* Lookup a template type named "template NAME<TYPE>",
1256 visible in lexical block BLOCK. */
1259 lookup_template_type (char *name
, struct type
*type
, struct block
*block
)
1262 char *nam
= (char *) alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1265 strcat (nam
, TYPE_NAME (type
));
1266 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1268 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0, (struct symtab
**) NULL
);
1272 error (_("No template type named %s."), name
);
1274 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1276 error (_("This context has class, union or enum %s, not a struct."), name
);
1278 return (SYMBOL_TYPE (sym
));
1281 /* Given a type TYPE, lookup the type of the component of type named NAME.
1283 TYPE can be either a struct or union, or a pointer or reference to a struct or
1284 union. If it is a pointer or reference, its target type is automatically used.
1285 Thus '.' and '->' are interchangable, as specified for the definitions of the
1286 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
1288 If NOERR is nonzero, return zero if NAME is not suitably defined.
1289 If NAME is the name of a baseclass type, return that type. */
1292 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
1298 CHECK_TYPEDEF (type
);
1299 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1300 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1302 type
= TYPE_TARGET_TYPE (type
);
1305 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
1306 TYPE_CODE (type
) != TYPE_CODE_UNION
)
1308 target_terminal_ours ();
1309 gdb_flush (gdb_stdout
);
1310 fprintf_unfiltered (gdb_stderr
, "Type ");
1311 type_print (type
, "", gdb_stderr
, -1);
1312 error (_(" is not a structure or union type."));
1316 /* FIXME: This change put in by Michael seems incorrect for the case where
1317 the structure tag name is the same as the member name. I.E. when doing
1318 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
1323 typename
= type_name_no_tag (type
);
1324 if (typename
!= NULL
&& strcmp (typename
, name
) == 0)
1329 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1331 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1333 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1335 return TYPE_FIELD_TYPE (type
, i
);
1339 /* OK, it's not in this class. Recursively check the baseclasses. */
1340 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1344 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, 1);
1356 target_terminal_ours ();
1357 gdb_flush (gdb_stdout
);
1358 fprintf_unfiltered (gdb_stderr
, "Type ");
1359 type_print (type
, "", gdb_stderr
, -1);
1360 fprintf_unfiltered (gdb_stderr
, " has no component named ");
1361 fputs_filtered (name
, gdb_stderr
);
1363 return (struct type
*) -1; /* For lint */
1366 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
1367 valid. Callers should be aware that in some cases (for example,
1368 the type or one of its baseclasses is a stub type and we are
1369 debugging a .o file), this function will not be able to find the virtual
1370 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
1371 will remain NULL. */
1374 fill_in_vptr_fieldno (struct type
*type
)
1376 CHECK_TYPEDEF (type
);
1378 if (TYPE_VPTR_FIELDNO (type
) < 0)
1382 /* We must start at zero in case the first (and only) baseclass is
1383 virtual (and hence we cannot share the table pointer). */
1384 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1386 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1387 fill_in_vptr_fieldno (baseclass
);
1388 if (TYPE_VPTR_FIELDNO (baseclass
) >= 0)
1390 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (baseclass
);
1391 TYPE_VPTR_BASETYPE (type
) = TYPE_VPTR_BASETYPE (baseclass
);
1398 /* Find the method and field indices for the destructor in class type T.
1399 Return 1 if the destructor was found, otherwise, return 0. */
1402 get_destructor_fn_field (struct type
*t
, int *method_indexp
, int *field_indexp
)
1406 for (i
= 0; i
< TYPE_NFN_FIELDS (t
); i
++)
1409 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1411 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (t
, i
); j
++)
1413 if (is_destructor_name (TYPE_FN_FIELD_PHYSNAME (f
, j
)) != 0)
1425 stub_noname_complaint (void)
1427 complaint (&symfile_complaints
, _("stub type has NULL name"));
1430 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
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 (but
1435 not any code) that if we don't find a full definition, we'd set a flag
1436 so we don't spend time in the future checking the same type. That would
1437 be a mistake, though--we might load in more symbols which contain a
1438 full definition for the type.
1440 This used to be coded as a macro, but I don't think it is called
1441 often enough to merit such treatment. */
1443 /* Find the real type of TYPE. This function returns the real type, after
1444 removing all layers of typedefs and completing opaque or stub types.
1445 Completion changes the TYPE argument, but stripping of typedefs does
1449 check_typedef (struct type
*type
)
1451 struct type
*orig_type
= type
;
1452 int is_const
, is_volatile
;
1454 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1456 if (!TYPE_TARGET_TYPE (type
))
1461 /* It is dangerous to call lookup_symbol if we are currently
1462 reading a symtab. Infinite recursion is one danger. */
1463 if (currently_reading_symtab
)
1466 name
= type_name_no_tag (type
);
1467 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1468 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1469 as appropriate? (this code was written before TYPE_NAME and
1470 TYPE_TAG_NAME were separate). */
1473 stub_noname_complaint ();
1476 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0,
1477 (struct symtab
**) NULL
);
1479 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1481 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
); /* TYPE_CODE_UNDEF */
1483 type
= TYPE_TARGET_TYPE (type
);
1486 is_const
= TYPE_CONST (type
);
1487 is_volatile
= TYPE_VOLATILE (type
);
1489 /* If this is a struct/class/union with no fields, then check whether a
1490 full definition exists somewhere else. This is for systems where a
1491 type definition with no fields is issued for such types, instead of
1492 identifying them as stub types in the first place */
1494 if (TYPE_IS_OPAQUE (type
) && opaque_type_resolution
&& !currently_reading_symtab
)
1496 char *name
= type_name_no_tag (type
);
1497 struct type
*newtype
;
1500 stub_noname_complaint ();
1503 newtype
= lookup_transparent_type (name
);
1507 /* If the resolved type and the stub are in the same objfile,
1508 then replace the stub type with the real deal. But if
1509 they're in separate objfiles, leave the stub alone; we'll
1510 just look up the transparent type every time we call
1511 check_typedef. We can't create pointers between types
1512 allocated to different objfiles, since they may have
1513 different lifetimes. Trying to copy NEWTYPE over to TYPE's
1514 objfile is pointless, too, since you'll have to move over any
1515 other types NEWTYPE refers to, which could be an unbounded
1517 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
1518 make_cv_type (is_const
, is_volatile
, newtype
, &type
);
1523 /* Otherwise, rely on the stub flag being set for opaque/stubbed types */
1524 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1526 char *name
= type_name_no_tag (type
);
1527 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1528 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1529 as appropriate? (this code was written before TYPE_NAME and
1530 TYPE_TAG_NAME were separate). */
1534 stub_noname_complaint ();
1537 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0, (struct symtab
**) NULL
);
1540 /* Same as above for opaque types, we can replace the stub
1541 with the complete type only if they are int the same
1543 if (TYPE_OBJFILE (SYMBOL_TYPE(sym
)) == TYPE_OBJFILE (type
))
1544 make_cv_type (is_const
, is_volatile
, SYMBOL_TYPE (sym
), &type
);
1546 type
= SYMBOL_TYPE (sym
);
1550 if (TYPE_TARGET_STUB (type
))
1552 struct type
*range_type
;
1553 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1555 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1558 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1559 && TYPE_NFIELDS (type
) == 1
1560 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
1561 == TYPE_CODE_RANGE
))
1563 /* Now recompute the length of the array type, based on its
1564 number of elements and the target type's length. */
1565 TYPE_LENGTH (type
) =
1566 ((TYPE_FIELD_BITPOS (range_type
, 1)
1567 - TYPE_FIELD_BITPOS (range_type
, 0)
1569 * TYPE_LENGTH (target_type
));
1570 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1572 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1574 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1575 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1578 /* Cache TYPE_LENGTH for future use. */
1579 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1583 /* Parse a type expression in the string [P..P+LENGTH). If an error occurs,
1584 silently return builtin_type_void. */
1586 static struct type
*
1587 safe_parse_type (char *p
, int length
)
1589 struct ui_file
*saved_gdb_stderr
;
1592 /* Suppress error messages. */
1593 saved_gdb_stderr
= gdb_stderr
;
1594 gdb_stderr
= ui_file_new ();
1596 /* Call parse_and_eval_type() without fear of longjmp()s. */
1597 if (!gdb_parse_and_eval_type (p
, length
, &type
))
1598 type
= builtin_type_void
;
1600 /* Stop suppressing error messages. */
1601 ui_file_delete (gdb_stderr
);
1602 gdb_stderr
= saved_gdb_stderr
;
1607 /* Ugly hack to convert method stubs into method types.
1609 He ain't kiddin'. This demangles the name of the method into a string
1610 including argument types, parses out each argument type, generates
1611 a string casting a zero to that type, evaluates the string, and stuffs
1612 the resulting type into an argtype vector!!! Then it knows the type
1613 of the whole function (including argument types for overloading),
1614 which info used to be in the stab's but was removed to hack back
1615 the space required for them. */
1618 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1621 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1622 char *demangled_name
= cplus_demangle (mangled_name
,
1623 DMGL_PARAMS
| DMGL_ANSI
);
1624 char *argtypetext
, *p
;
1625 int depth
= 0, argcount
= 1;
1626 struct field
*argtypes
;
1629 /* Make sure we got back a function string that we can use. */
1631 p
= strchr (demangled_name
, '(');
1635 if (demangled_name
== NULL
|| p
== NULL
)
1636 error (_("Internal: Cannot demangle mangled name `%s'."), mangled_name
);
1638 /* Now, read in the parameters that define this type. */
1643 if (*p
== '(' || *p
== '<')
1647 else if (*p
== ')' || *p
== '>')
1651 else if (*p
== ',' && depth
== 0)
1659 /* If we read one argument and it was ``void'', don't count it. */
1660 if (strncmp (argtypetext
, "(void)", 6) == 0)
1663 /* We need one extra slot, for the THIS pointer. */
1665 argtypes
= (struct field
*)
1666 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
1669 /* Add THIS pointer for non-static methods. */
1670 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1671 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
1675 argtypes
[0].type
= lookup_pointer_type (type
);
1679 if (*p
!= ')') /* () means no args, skip while */
1684 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1686 /* Avoid parsing of ellipsis, they will be handled below.
1687 Also avoid ``void'' as above. */
1688 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
1689 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
1691 argtypes
[argcount
].type
=
1692 safe_parse_type (argtypetext
, p
- argtypetext
);
1695 argtypetext
= p
+ 1;
1698 if (*p
== '(' || *p
== '<')
1702 else if (*p
== ')' || *p
== '>')
1711 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1713 /* Now update the old "stub" type into a real type. */
1714 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1715 TYPE_DOMAIN_TYPE (mtype
) = type
;
1716 TYPE_FIELDS (mtype
) = argtypes
;
1717 TYPE_NFIELDS (mtype
) = argcount
;
1718 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1719 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1721 TYPE_FLAGS (mtype
) |= TYPE_FLAG_VARARGS
;
1723 xfree (demangled_name
);
1726 /* This is the external interface to check_stub_method, above. This function
1727 unstubs all of the signatures for TYPE's METHOD_ID method name. After
1728 calling this function TYPE_FN_FIELD_STUB will be cleared for each signature
1729 and TYPE_FN_FIELDLIST_NAME will be correct.
1731 This function unfortunately can not die until stabs do. */
1734 check_stub_method_group (struct type
*type
, int method_id
)
1736 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
1737 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1738 int j
, found_stub
= 0;
1740 for (j
= 0; j
< len
; j
++)
1741 if (TYPE_FN_FIELD_STUB (f
, j
))
1744 check_stub_method (type
, method_id
, j
);
1747 /* GNU v3 methods with incorrect names were corrected when we read in
1748 type information, because it was cheaper to do it then. The only GNU v2
1749 methods with incorrect method names are operators and destructors;
1750 destructors were also corrected when we read in type information.
1752 Therefore the only thing we need to handle here are v2 operator
1754 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
1757 char dem_opname
[256];
1759 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
, method_id
),
1760 dem_opname
, DMGL_ANSI
);
1762 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
, method_id
),
1765 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
1769 const struct cplus_struct_type cplus_struct_default
;
1772 allocate_cplus_struct_type (struct type
*type
)
1774 if (!HAVE_CPLUS_STRUCT (type
))
1776 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1777 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1778 *(TYPE_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1782 /* Helper function to initialize the standard scalar types.
1784 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1785 of the string pointed to by name in the objfile_obstack for that objfile,
1786 and initialize the type name to that copy. There are places (mipsread.c
1787 in particular, where init_type is called with a NULL value for NAME). */
1790 init_type (enum type_code code
, int length
, int flags
, char *name
,
1791 struct objfile
*objfile
)
1795 type
= alloc_type (objfile
);
1796 TYPE_CODE (type
) = code
;
1797 TYPE_LENGTH (type
) = length
;
1798 TYPE_FLAGS (type
) |= flags
;
1799 if ((name
!= NULL
) && (objfile
!= NULL
))
1802 obsavestring (name
, strlen (name
), &objfile
->objfile_obstack
);
1806 TYPE_NAME (type
) = name
;
1811 if (name
&& strcmp (name
, "char") == 0)
1812 TYPE_FLAGS (type
) |= TYPE_FLAG_NOSIGN
;
1814 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
1815 || code
== TYPE_CODE_NAMESPACE
)
1817 INIT_CPLUS_SPECIFIC (type
);
1822 /* Helper function. Create an empty composite type. */
1825 init_composite_type (char *name
, enum type_code code
)
1828 gdb_assert (code
== TYPE_CODE_STRUCT
1829 || code
== TYPE_CODE_UNION
);
1830 t
= init_type (code
, 0, 0, NULL
, NULL
);
1831 TYPE_TAG_NAME (t
) = name
;
1835 /* Helper function. Append a field to a composite type. */
1838 append_composite_type_field (struct type
*t
, char *name
, struct type
*field
)
1841 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
1842 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
1843 sizeof (struct field
) * TYPE_NFIELDS (t
));
1844 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
1845 memset (f
, 0, sizeof f
[0]);
1846 FIELD_TYPE (f
[0]) = field
;
1847 FIELD_NAME (f
[0]) = name
;
1848 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1850 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
1851 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
1853 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
1855 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
1856 if (TYPE_NFIELDS (t
) > 1)
1858 FIELD_BITPOS (f
[0]) = (FIELD_BITPOS (f
[-1])
1859 + TYPE_LENGTH (field
) * TARGET_CHAR_BIT
);
1864 /* Look up a fundamental type for the specified objfile.
1865 May need to construct such a type if this is the first use.
1867 Some object file formats (ELF, COFF, etc) do not define fundamental
1868 types such as "int" or "double". Others (stabs for example), do
1869 define fundamental types.
1871 For the formats which don't provide fundamental types, gdb can create
1872 such types, using defaults reasonable for the current language and
1873 the current target machine.
1875 NOTE: This routine is obsolescent. Each debugging format reader
1876 should manage it's own fundamental types, either creating them from
1877 suitable defaults or reading them from the debugging information,
1878 whichever is appropriate. The DWARF reader has already been
1879 fixed to do this. Once the other readers are fixed, this routine
1880 will go away. Also note that fundamental types should be managed
1881 on a compilation unit basis in a multi-language environment, not
1882 on a linkage unit basis as is done here. */
1886 lookup_fundamental_type (struct objfile
*objfile
, int typeid)
1888 struct type
**typep
;
1891 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1893 error (_("internal error - invalid fundamental type id %d"), typeid);
1896 /* If this is the first time we need a fundamental type for this objfile
1897 then we need to initialize the vector of type pointers. */
1899 if (objfile
->fundamental_types
== NULL
)
1901 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1902 objfile
->fundamental_types
= (struct type
**)
1903 obstack_alloc (&objfile
->objfile_obstack
, nbytes
);
1904 memset ((char *) objfile
->fundamental_types
, 0, nbytes
);
1905 OBJSTAT (objfile
, n_types
+= FT_NUM_MEMBERS
);
1908 /* Look for this particular type in the fundamental type vector. If one is
1909 not found, create and install one appropriate for the current language. */
1911 typep
= objfile
->fundamental_types
+ typeid;
1914 *typep
= create_fundamental_type (objfile
, typeid);
1921 can_dereference (struct type
*t
)
1923 /* FIXME: Should we return true for references as well as pointers? */
1927 && TYPE_CODE (t
) == TYPE_CODE_PTR
1928 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1932 is_integral_type (struct type
*t
)
1937 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
1938 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
1939 || (TYPE_CODE (t
) == TYPE_CODE_FLAGS
)
1940 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
1941 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
1942 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
1945 /* Check whether BASE is an ancestor or base class or DCLASS
1946 Return 1 if so, and 0 if not.
1947 Note: callers may want to check for identity of the types before
1948 calling this function -- identical types are considered to satisfy
1949 the ancestor relationship even if they're identical */
1952 is_ancestor (struct type
*base
, struct type
*dclass
)
1956 CHECK_TYPEDEF (base
);
1957 CHECK_TYPEDEF (dclass
);
1961 if (TYPE_NAME (base
) && TYPE_NAME (dclass
) &&
1962 !strcmp (TYPE_NAME (base
), TYPE_NAME (dclass
)))
1965 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1966 if (is_ancestor (base
, TYPE_BASECLASS (dclass
, i
)))
1974 /* See whether DCLASS has a virtual table. This routine is aimed at
1975 the HP/Taligent ANSI C++ runtime model, and may not work with other
1976 runtime models. Return 1 => Yes, 0 => No. */
1979 has_vtable (struct type
*dclass
)
1981 /* In the HP ANSI C++ runtime model, a class has a vtable only if it
1982 has virtual functions or virtual bases. */
1986 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1989 /* First check for the presence of virtual bases */
1990 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
1991 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1992 if (B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
))
1995 /* Next check for virtual functions */
1996 if (TYPE_FN_FIELDLISTS (dclass
))
1997 for (i
= 0; i
< TYPE_NFN_FIELDS (dclass
); i
++)
1998 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, i
), 0))
2001 /* Recurse on non-virtual bases to see if any of them needs a vtable */
2002 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
2003 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2004 if ((!B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
)) &&
2005 (has_vtable (TYPE_FIELD_TYPE (dclass
, i
))))
2008 /* Well, maybe we don't need a virtual table */
2012 /* Return a pointer to the "primary base class" of DCLASS.
2014 A NULL return indicates that DCLASS has no primary base, or that it
2015 couldn't be found (insufficient information).
2017 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
2018 and may not work with other runtime models. */
2021 primary_base_class (struct type
*dclass
)
2023 /* In HP ANSI C++'s runtime model, a "primary base class" of a class
2024 is the first directly inherited, non-virtual base class that
2025 requires a virtual table */
2029 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
2032 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2033 if (!TYPE_FIELD_VIRTUAL (dclass
, i
) &&
2034 has_vtable (TYPE_FIELD_TYPE (dclass
, i
)))
2035 return TYPE_FIELD_TYPE (dclass
, i
);
2040 /* Global manipulated by virtual_base_list[_aux]() */
2042 static struct vbase
*current_vbase_list
= NULL
;
2044 /* Return a pointer to a null-terminated list of struct vbase
2045 items. The vbasetype pointer of each item in the list points to the
2046 type information for a virtual base of the argument DCLASS.
2048 Helper function for virtual_base_list().
2049 Note: the list goes backward, right-to-left. virtual_base_list()
2050 copies the items out in reverse order. */
2053 virtual_base_list_aux (struct type
*dclass
)
2055 struct vbase
*tmp_vbase
;
2058 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
2061 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2063 /* Recurse on this ancestor, first */
2064 virtual_base_list_aux (TYPE_FIELD_TYPE (dclass
, i
));
2066 /* If this current base is itself virtual, add it to the list */
2067 if (BASETYPE_VIA_VIRTUAL (dclass
, i
))
2069 struct type
*basetype
= TYPE_FIELD_TYPE (dclass
, i
);
2071 /* Check if base already recorded */
2072 tmp_vbase
= current_vbase_list
;
2075 if (tmp_vbase
->vbasetype
== basetype
)
2076 break; /* found it */
2077 tmp_vbase
= tmp_vbase
->next
;
2080 if (!tmp_vbase
) /* normal exit from loop */
2082 /* Allocate new item for this virtual base */
2083 tmp_vbase
= (struct vbase
*) xmalloc (sizeof (struct vbase
));
2085 /* Stick it on at the end of the list */
2086 tmp_vbase
->vbasetype
= basetype
;
2087 tmp_vbase
->next
= current_vbase_list
;
2088 current_vbase_list
= tmp_vbase
;
2091 } /* for loop over bases */
2095 /* Compute the list of virtual bases in the right order. Virtual
2096 bases are laid out in the object's memory area in order of their
2097 occurrence in a depth-first, left-to-right search through the
2100 Argument DCLASS is the type whose virtual bases are required.
2101 Return value is the address of a null-terminated array of pointers
2102 to struct type items.
2104 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
2105 and may not work with other runtime models.
2107 This routine merely hands off the argument to virtual_base_list_aux()
2108 and then copies the result into an array to save space. */
2111 virtual_base_list (struct type
*dclass
)
2113 struct vbase
*tmp_vbase
;
2114 struct vbase
*tmp_vbase_2
;
2117 struct type
**vbase_array
;
2119 current_vbase_list
= NULL
;
2120 virtual_base_list_aux (dclass
);
2122 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
2127 vbase_array
= (struct type
**) xmalloc ((count
+ 1) * sizeof (struct type
*));
2129 for (i
= count
- 1, tmp_vbase
= current_vbase_list
; i
>= 0; i
--, tmp_vbase
= tmp_vbase
->next
)
2130 vbase_array
[i
] = tmp_vbase
->vbasetype
;
2132 /* Get rid of constructed chain */
2133 tmp_vbase_2
= tmp_vbase
= current_vbase_list
;
2136 tmp_vbase
= tmp_vbase
->next
;
2137 xfree (tmp_vbase_2
);
2138 tmp_vbase_2
= tmp_vbase
;
2141 vbase_array
[count
] = NULL
;
2145 /* Return the length of the virtual base list of the type DCLASS. */
2148 virtual_base_list_length (struct type
*dclass
)
2151 struct vbase
*tmp_vbase
;
2153 current_vbase_list
= NULL
;
2154 virtual_base_list_aux (dclass
);
2156 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
2161 /* Return the number of elements of the virtual base list of the type
2162 DCLASS, ignoring those appearing in the primary base (and its
2163 primary base, recursively). */
2166 virtual_base_list_length_skip_primaries (struct type
*dclass
)
2169 struct vbase
*tmp_vbase
;
2170 struct type
*primary
;
2172 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
2175 return virtual_base_list_length (dclass
);
2177 current_vbase_list
= NULL
;
2178 virtual_base_list_aux (dclass
);
2180 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; tmp_vbase
= tmp_vbase
->next
)
2182 if (virtual_base_index (tmp_vbase
->vbasetype
, primary
) >= 0)
2190 /* Return the index (position) of type BASE, which is a virtual base
2191 class of DCLASS, in the latter's virtual base list. A return of -1
2192 indicates "not found" or a problem. */
2195 virtual_base_index (struct type
*base
, struct type
*dclass
)
2200 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
2201 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
2205 vbase
= virtual_base_list (dclass
)[0];
2210 vbase
= virtual_base_list (dclass
)[++i
];
2213 return vbase
? i
: -1;
2218 /* Return the index (position) of type BASE, which is a virtual base
2219 class of DCLASS, in the latter's virtual base list. Skip over all
2220 bases that may appear in the virtual base list of the primary base
2221 class of DCLASS (recursively). A return of -1 indicates "not
2222 found" or a problem. */
2225 virtual_base_index_skip_primaries (struct type
*base
, struct type
*dclass
)
2229 struct type
*primary
;
2231 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
2232 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
2235 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
2239 vbase
= virtual_base_list (dclass
)[0];
2242 if (!primary
|| (virtual_base_index_skip_primaries (vbase
, primary
) < 0))
2246 vbase
= virtual_base_list (dclass
)[++i
];
2249 return vbase
? j
: -1;
2252 /* Return position of a derived class DCLASS in the list of
2253 * primary bases starting with the remotest ancestor.
2254 * Position returned is 0-based. */
2257 class_index_in_primary_list (struct type
*dclass
)
2259 struct type
*pbc
; /* primary base class */
2261 /* Simply recurse on primary base */
2262 pbc
= TYPE_PRIMARY_BASE (dclass
);
2264 return 1 + class_index_in_primary_list (pbc
);
2269 /* Return a count of the number of virtual functions a type has.
2270 * This includes all the virtual functions it inherits from its
2274 /* pai: FIXME This doesn't do the right thing: count redefined virtual
2275 * functions only once (latest redefinition)
2279 count_virtual_fns (struct type
*dclass
)
2281 int fn
, oi
; /* function and overloaded instance indices */
2282 int vfuncs
; /* count to return */
2284 /* recurse on bases that can share virtual table */
2285 struct type
*pbc
= primary_base_class (dclass
);
2287 vfuncs
= count_virtual_fns (pbc
);
2291 for (fn
= 0; fn
< TYPE_NFN_FIELDS (dclass
); fn
++)
2292 for (oi
= 0; oi
< TYPE_FN_FIELDLIST_LENGTH (dclass
, fn
); oi
++)
2293 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, fn
), oi
))
2301 /* Functions for overload resolution begin here */
2303 /* Compare two badness vectors A and B and return the result.
2304 * 0 => A and B are identical
2305 * 1 => A and B are incomparable
2306 * 2 => A is better than B
2307 * 3 => A is worse than B */
2310 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
2314 short found_pos
= 0; /* any positives in c? */
2315 short found_neg
= 0; /* any negatives in c? */
2317 /* differing lengths => incomparable */
2318 if (a
->length
!= b
->length
)
2321 /* Subtract b from a */
2322 for (i
= 0; i
< a
->length
; i
++)
2324 tmp
= a
->rank
[i
] - b
->rank
[i
];
2334 return 1; /* incomparable */
2336 return 3; /* A > B */
2342 return 2; /* A < B */
2344 return 0; /* A == B */
2348 /* Rank a function by comparing its parameter types (PARMS, length NPARMS),
2349 * to the types of an argument list (ARGS, length NARGS).
2350 * Return a pointer to a badness vector. This has NARGS + 1 entries. */
2352 struct badness_vector
*
2353 rank_function (struct type
**parms
, int nparms
, struct type
**args
, int nargs
)
2356 struct badness_vector
*bv
;
2357 int min_len
= nparms
< nargs
? nparms
: nargs
;
2359 bv
= xmalloc (sizeof (struct badness_vector
));
2360 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank */
2361 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
2363 /* First compare the lengths of the supplied lists.
2364 * If there is a mismatch, set it to a high value. */
2366 /* pai/1997-06-03 FIXME: when we have debug info about default
2367 * arguments and ellipsis parameter lists, we should consider those
2368 * and rank the length-match more finely. */
2370 LENGTH_MATCH (bv
) = (nargs
!= nparms
) ? LENGTH_MISMATCH_BADNESS
: 0;
2372 /* Now rank all the parameters of the candidate function */
2373 for (i
= 1; i
<= min_len
; i
++)
2374 bv
->rank
[i
] = rank_one_type (parms
[i
-1], args
[i
-1]);
2376 /* If more arguments than parameters, add dummy entries */
2377 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2378 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2383 /* Compare the names of two integer types, assuming that any sign
2384 qualifiers have been checked already. We do it this way because
2385 there may be an "int" in the name of one of the types. */
2388 integer_types_same_name_p (const char *first
, const char *second
)
2390 int first_p
, second_p
;
2392 /* If both are shorts, return 1; if neither is a short, keep checking. */
2393 first_p
= (strstr (first
, "short") != NULL
);
2394 second_p
= (strstr (second
, "short") != NULL
);
2395 if (first_p
&& second_p
)
2397 if (first_p
|| second_p
)
2400 /* Likewise for long. */
2401 first_p
= (strstr (first
, "long") != NULL
);
2402 second_p
= (strstr (second
, "long") != NULL
);
2403 if (first_p
&& second_p
)
2405 if (first_p
|| second_p
)
2408 /* Likewise for char. */
2409 first_p
= (strstr (first
, "char") != NULL
);
2410 second_p
= (strstr (second
, "char") != NULL
);
2411 if (first_p
&& second_p
)
2413 if (first_p
|| second_p
)
2416 /* They must both be ints. */
2420 /* Compare one type (PARM) for compatibility with another (ARG).
2421 * PARM is intended to be the parameter type of a function; and
2422 * ARG is the supplied argument's type. This function tests if
2423 * the latter can be converted to the former.
2425 * Return 0 if they are identical types;
2426 * Otherwise, return an integer which corresponds to how compatible
2427 * PARM is to ARG. The higher the return value, the worse the match.
2428 * Generally the "bad" conversions are all uniformly assigned a 100 */
2431 rank_one_type (struct type
*parm
, struct type
*arg
)
2433 /* Identical type pointers */
2434 /* However, this still doesn't catch all cases of same type for arg
2435 * and param. The reason is that builtin types are different from
2436 * the same ones constructed from the object. */
2440 /* Resolve typedefs */
2441 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2442 parm
= check_typedef (parm
);
2443 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2444 arg
= check_typedef (arg
);
2447 Well, damnit, if the names are exactly the same,
2448 i'll say they are exactly the same. This happens when we generate
2449 method stubs. The types won't point to the same address, but they
2450 really are the same.
2453 if (TYPE_NAME (parm
) && TYPE_NAME (arg
) &&
2454 !strcmp (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2457 /* Check if identical after resolving typedefs */
2461 /* See through references, since we can almost make non-references
2463 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2464 return (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
))
2465 + REFERENCE_CONVERSION_BADNESS
);
2466 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2467 return (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
)
2468 + REFERENCE_CONVERSION_BADNESS
);
2470 /* Debugging only. */
2471 fprintf_filtered (gdb_stderr
,"------ Arg is %s [%d], parm is %s [%d]\n",
2472 TYPE_NAME (arg
), TYPE_CODE (arg
), TYPE_NAME (parm
), TYPE_CODE (parm
));
2474 /* x -> y means arg of type x being supplied for parameter of type y */
2476 switch (TYPE_CODE (parm
))
2479 switch (TYPE_CODE (arg
))
2482 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2483 return VOID_PTR_CONVERSION_BADNESS
;
2485 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2486 case TYPE_CODE_ARRAY
:
2487 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2488 case TYPE_CODE_FUNC
:
2489 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
);
2491 case TYPE_CODE_ENUM
:
2492 case TYPE_CODE_FLAGS
:
2493 case TYPE_CODE_CHAR
:
2494 case TYPE_CODE_RANGE
:
2495 case TYPE_CODE_BOOL
:
2496 return POINTER_CONVERSION_BADNESS
;
2498 return INCOMPATIBLE_TYPE_BADNESS
;
2500 case TYPE_CODE_ARRAY
:
2501 switch (TYPE_CODE (arg
))
2504 case TYPE_CODE_ARRAY
:
2505 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2507 return INCOMPATIBLE_TYPE_BADNESS
;
2509 case TYPE_CODE_FUNC
:
2510 switch (TYPE_CODE (arg
))
2512 case TYPE_CODE_PTR
: /* funcptr -> func */
2513 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
));
2515 return INCOMPATIBLE_TYPE_BADNESS
;
2518 switch (TYPE_CODE (arg
))
2521 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2523 /* Deal with signed, unsigned, and plain chars and
2524 signed and unsigned ints */
2525 if (TYPE_NOSIGN (parm
))
2527 /* This case only for character types */
2528 if (TYPE_NOSIGN (arg
)) /* plain char -> plain char */
2531 return INTEGER_CONVERSION_BADNESS
; /* signed/unsigned char -> plain char */
2533 else if (TYPE_UNSIGNED (parm
))
2535 if (TYPE_UNSIGNED (arg
))
2537 /* unsigned int -> unsigned int, or unsigned long -> unsigned long */
2538 if (integer_types_same_name_p (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2540 else if (integer_types_same_name_p (TYPE_NAME (arg
), "int")
2541 && integer_types_same_name_p (TYPE_NAME (parm
), "long"))
2542 return INTEGER_PROMOTION_BADNESS
; /* unsigned int -> unsigned long */
2544 return INTEGER_CONVERSION_BADNESS
; /* unsigned long -> unsigned int */
2548 if (integer_types_same_name_p (TYPE_NAME (arg
), "long")
2549 && integer_types_same_name_p (TYPE_NAME (parm
), "int"))
2550 return INTEGER_CONVERSION_BADNESS
; /* signed long -> unsigned int */
2552 return INTEGER_CONVERSION_BADNESS
; /* signed int/long -> unsigned int/long */
2555 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2557 if (integer_types_same_name_p (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2559 else if (integer_types_same_name_p (TYPE_NAME (arg
), "int")
2560 && integer_types_same_name_p (TYPE_NAME (parm
), "long"))
2561 return INTEGER_PROMOTION_BADNESS
;
2563 return INTEGER_CONVERSION_BADNESS
;
2566 return INTEGER_CONVERSION_BADNESS
;
2568 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2569 return INTEGER_PROMOTION_BADNESS
;
2571 return INTEGER_CONVERSION_BADNESS
;
2572 case TYPE_CODE_ENUM
:
2573 case TYPE_CODE_FLAGS
:
2574 case TYPE_CODE_CHAR
:
2575 case TYPE_CODE_RANGE
:
2576 case TYPE_CODE_BOOL
:
2577 return INTEGER_PROMOTION_BADNESS
;
2579 return INT_FLOAT_CONVERSION_BADNESS
;
2581 return NS_POINTER_CONVERSION_BADNESS
;
2583 return INCOMPATIBLE_TYPE_BADNESS
;
2586 case TYPE_CODE_ENUM
:
2587 switch (TYPE_CODE (arg
))
2590 case TYPE_CODE_CHAR
:
2591 case TYPE_CODE_RANGE
:
2592 case TYPE_CODE_BOOL
:
2593 case TYPE_CODE_ENUM
:
2594 return INTEGER_CONVERSION_BADNESS
;
2596 return INT_FLOAT_CONVERSION_BADNESS
;
2598 return INCOMPATIBLE_TYPE_BADNESS
;
2601 case TYPE_CODE_CHAR
:
2602 switch (TYPE_CODE (arg
))
2604 case TYPE_CODE_RANGE
:
2605 case TYPE_CODE_BOOL
:
2606 case TYPE_CODE_ENUM
:
2607 return INTEGER_CONVERSION_BADNESS
;
2609 return INT_FLOAT_CONVERSION_BADNESS
;
2611 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2612 return INTEGER_CONVERSION_BADNESS
;
2613 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2614 return INTEGER_PROMOTION_BADNESS
;
2615 /* >>> !! else fall through !! <<< */
2616 case TYPE_CODE_CHAR
:
2617 /* Deal with signed, unsigned, and plain chars for C++
2618 and with int cases falling through from previous case */
2619 if (TYPE_NOSIGN (parm
))
2621 if (TYPE_NOSIGN (arg
))
2624 return INTEGER_CONVERSION_BADNESS
;
2626 else if (TYPE_UNSIGNED (parm
))
2628 if (TYPE_UNSIGNED (arg
))
2631 return INTEGER_PROMOTION_BADNESS
;
2633 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2636 return INTEGER_CONVERSION_BADNESS
;
2638 return INCOMPATIBLE_TYPE_BADNESS
;
2641 case TYPE_CODE_RANGE
:
2642 switch (TYPE_CODE (arg
))
2645 case TYPE_CODE_CHAR
:
2646 case TYPE_CODE_RANGE
:
2647 case TYPE_CODE_BOOL
:
2648 case TYPE_CODE_ENUM
:
2649 return INTEGER_CONVERSION_BADNESS
;
2651 return INT_FLOAT_CONVERSION_BADNESS
;
2653 return INCOMPATIBLE_TYPE_BADNESS
;
2656 case TYPE_CODE_BOOL
:
2657 switch (TYPE_CODE (arg
))
2660 case TYPE_CODE_CHAR
:
2661 case TYPE_CODE_RANGE
:
2662 case TYPE_CODE_ENUM
:
2665 return BOOLEAN_CONVERSION_BADNESS
;
2666 case TYPE_CODE_BOOL
:
2669 return INCOMPATIBLE_TYPE_BADNESS
;
2673 switch (TYPE_CODE (arg
))
2676 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2677 return FLOAT_PROMOTION_BADNESS
;
2678 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2681 return FLOAT_CONVERSION_BADNESS
;
2683 case TYPE_CODE_BOOL
:
2684 case TYPE_CODE_ENUM
:
2685 case TYPE_CODE_RANGE
:
2686 case TYPE_CODE_CHAR
:
2687 return INT_FLOAT_CONVERSION_BADNESS
;
2689 return INCOMPATIBLE_TYPE_BADNESS
;
2692 case TYPE_CODE_COMPLEX
:
2693 switch (TYPE_CODE (arg
))
2694 { /* Strictly not needed for C++, but... */
2696 return FLOAT_PROMOTION_BADNESS
;
2697 case TYPE_CODE_COMPLEX
:
2700 return INCOMPATIBLE_TYPE_BADNESS
;
2703 case TYPE_CODE_STRUCT
:
2704 /* currently same as TYPE_CODE_CLASS */
2705 switch (TYPE_CODE (arg
))
2707 case TYPE_CODE_STRUCT
:
2708 /* Check for derivation */
2709 if (is_ancestor (parm
, arg
))
2710 return BASE_CONVERSION_BADNESS
;
2711 /* else fall through */
2713 return INCOMPATIBLE_TYPE_BADNESS
;
2716 case TYPE_CODE_UNION
:
2717 switch (TYPE_CODE (arg
))
2719 case TYPE_CODE_UNION
:
2721 return INCOMPATIBLE_TYPE_BADNESS
;
2724 case TYPE_CODE_MEMBERPTR
:
2725 switch (TYPE_CODE (arg
))
2728 return INCOMPATIBLE_TYPE_BADNESS
;
2731 case TYPE_CODE_METHOD
:
2732 switch (TYPE_CODE (arg
))
2736 return INCOMPATIBLE_TYPE_BADNESS
;
2740 switch (TYPE_CODE (arg
))
2744 return INCOMPATIBLE_TYPE_BADNESS
;
2749 switch (TYPE_CODE (arg
))
2753 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0), TYPE_FIELD_TYPE (arg
, 0));
2755 return INCOMPATIBLE_TYPE_BADNESS
;
2758 case TYPE_CODE_VOID
:
2760 return INCOMPATIBLE_TYPE_BADNESS
;
2761 } /* switch (TYPE_CODE (arg)) */
2765 /* End of functions for overload resolution */
2768 print_bit_vector (B_TYPE
*bits
, int nbits
)
2772 for (bitno
= 0; bitno
< nbits
; bitno
++)
2774 if ((bitno
% 8) == 0)
2776 puts_filtered (" ");
2778 if (B_TST (bits
, bitno
))
2779 printf_filtered (("1"));
2781 printf_filtered (("0"));
2785 /* Note the first arg should be the "this" pointer, we may not want to
2786 include it since we may get into a infinitely recursive situation. */
2789 print_arg_types (struct field
*args
, int nargs
, int spaces
)
2795 for (i
= 0; i
< nargs
; i
++)
2796 recursive_dump_type (args
[i
].type
, spaces
+ 2);
2801 dump_fn_fieldlists (struct type
*type
, int spaces
)
2807 printfi_filtered (spaces
, "fn_fieldlists ");
2808 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2809 printf_filtered ("\n");
2810 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2812 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2813 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2815 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2816 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2818 printf_filtered (_(") length %d\n"),
2819 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2820 for (overload_idx
= 0;
2821 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2824 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2826 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2827 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2829 printf_filtered (")\n");
2830 printfi_filtered (spaces
+ 8, "type ");
2831 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
2832 printf_filtered ("\n");
2834 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2837 printfi_filtered (spaces
+ 8, "args ");
2838 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
2839 printf_filtered ("\n");
2841 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2842 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
, overload_idx
)),
2844 printfi_filtered (spaces
+ 8, "fcontext ");
2845 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2847 printf_filtered ("\n");
2849 printfi_filtered (spaces
+ 8, "is_const %d\n",
2850 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2851 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2852 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2853 printfi_filtered (spaces
+ 8, "is_private %d\n",
2854 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2855 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2856 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2857 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2858 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2859 printfi_filtered (spaces
+ 8, "voffset %u\n",
2860 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2866 print_cplus_stuff (struct type
*type
, int spaces
)
2868 printfi_filtered (spaces
, "n_baseclasses %d\n",
2869 TYPE_N_BASECLASSES (type
));
2870 printfi_filtered (spaces
, "nfn_fields %d\n",
2871 TYPE_NFN_FIELDS (type
));
2872 printfi_filtered (spaces
, "nfn_fields_total %d\n",
2873 TYPE_NFN_FIELDS_TOTAL (type
));
2874 if (TYPE_N_BASECLASSES (type
) > 0)
2876 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2877 TYPE_N_BASECLASSES (type
));
2878 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
2879 printf_filtered (")");
2881 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2882 TYPE_N_BASECLASSES (type
));
2883 puts_filtered ("\n");
2885 if (TYPE_NFIELDS (type
) > 0)
2887 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2889 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
2890 TYPE_NFIELDS (type
));
2891 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
2892 printf_filtered (")");
2893 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2894 TYPE_NFIELDS (type
));
2895 puts_filtered ("\n");
2897 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2899 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
2900 TYPE_NFIELDS (type
));
2901 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
2902 printf_filtered (")");
2903 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2904 TYPE_NFIELDS (type
));
2905 puts_filtered ("\n");
2908 if (TYPE_NFN_FIELDS (type
) > 0)
2910 dump_fn_fieldlists (type
, spaces
);
2915 print_bound_type (int bt
)
2919 case BOUND_CANNOT_BE_DETERMINED
:
2920 printf_filtered ("(BOUND_CANNOT_BE_DETERMINED)");
2922 case BOUND_BY_REF_ON_STACK
:
2923 printf_filtered ("(BOUND_BY_REF_ON_STACK)");
2925 case BOUND_BY_VALUE_ON_STACK
:
2926 printf_filtered ("(BOUND_BY_VALUE_ON_STACK)");
2928 case BOUND_BY_REF_IN_REG
:
2929 printf_filtered ("(BOUND_BY_REF_IN_REG)");
2931 case BOUND_BY_VALUE_IN_REG
:
2932 printf_filtered ("(BOUND_BY_VALUE_IN_REG)");
2935 printf_filtered ("(BOUND_SIMPLE)");
2938 printf_filtered (_("(unknown bound type)"));
2943 static struct obstack dont_print_type_obstack
;
2946 recursive_dump_type (struct type
*type
, int spaces
)
2951 obstack_begin (&dont_print_type_obstack
, 0);
2953 if (TYPE_NFIELDS (type
) > 0
2954 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
2956 struct type
**first_dont_print
2957 = (struct type
**) obstack_base (&dont_print_type_obstack
);
2959 int i
= (struct type
**) obstack_next_free (&dont_print_type_obstack
)
2964 if (type
== first_dont_print
[i
])
2966 printfi_filtered (spaces
, "type node ");
2967 gdb_print_host_address (type
, gdb_stdout
);
2968 printf_filtered (_(" <same as already seen type>\n"));
2973 obstack_ptr_grow (&dont_print_type_obstack
, type
);
2976 printfi_filtered (spaces
, "type node ");
2977 gdb_print_host_address (type
, gdb_stdout
);
2978 printf_filtered ("\n");
2979 printfi_filtered (spaces
, "name '%s' (",
2980 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
2981 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
2982 printf_filtered (")\n");
2983 printfi_filtered (spaces
, "tagname '%s' (",
2984 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
2985 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
2986 printf_filtered (")\n");
2987 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
2988 switch (TYPE_CODE (type
))
2990 case TYPE_CODE_UNDEF
:
2991 printf_filtered ("(TYPE_CODE_UNDEF)");
2994 printf_filtered ("(TYPE_CODE_PTR)");
2996 case TYPE_CODE_ARRAY
:
2997 printf_filtered ("(TYPE_CODE_ARRAY)");
2999 case TYPE_CODE_STRUCT
:
3000 printf_filtered ("(TYPE_CODE_STRUCT)");
3002 case TYPE_CODE_UNION
:
3003 printf_filtered ("(TYPE_CODE_UNION)");
3005 case TYPE_CODE_ENUM
:
3006 printf_filtered ("(TYPE_CODE_ENUM)");
3008 case TYPE_CODE_FLAGS
:
3009 printf_filtered ("(TYPE_CODE_FLAGS)");
3011 case TYPE_CODE_FUNC
:
3012 printf_filtered ("(TYPE_CODE_FUNC)");
3015 printf_filtered ("(TYPE_CODE_INT)");
3018 printf_filtered ("(TYPE_CODE_FLT)");
3020 case TYPE_CODE_VOID
:
3021 printf_filtered ("(TYPE_CODE_VOID)");
3024 printf_filtered ("(TYPE_CODE_SET)");
3026 case TYPE_CODE_RANGE
:
3027 printf_filtered ("(TYPE_CODE_RANGE)");
3029 case TYPE_CODE_STRING
:
3030 printf_filtered ("(TYPE_CODE_STRING)");
3032 case TYPE_CODE_BITSTRING
:
3033 printf_filtered ("(TYPE_CODE_BITSTRING)");
3035 case TYPE_CODE_ERROR
:
3036 printf_filtered ("(TYPE_CODE_ERROR)");
3038 case TYPE_CODE_MEMBERPTR
:
3039 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
3041 case TYPE_CODE_METHODPTR
:
3042 printf_filtered ("(TYPE_CODE_METHODPTR)");
3044 case TYPE_CODE_METHOD
:
3045 printf_filtered ("(TYPE_CODE_METHOD)");
3048 printf_filtered ("(TYPE_CODE_REF)");
3050 case TYPE_CODE_CHAR
:
3051 printf_filtered ("(TYPE_CODE_CHAR)");
3053 case TYPE_CODE_BOOL
:
3054 printf_filtered ("(TYPE_CODE_BOOL)");
3056 case TYPE_CODE_COMPLEX
:
3057 printf_filtered ("(TYPE_CODE_COMPLEX)");
3059 case TYPE_CODE_TYPEDEF
:
3060 printf_filtered ("(TYPE_CODE_TYPEDEF)");
3062 case TYPE_CODE_TEMPLATE
:
3063 printf_filtered ("(TYPE_CODE_TEMPLATE)");
3065 case TYPE_CODE_TEMPLATE_ARG
:
3066 printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)");
3068 case TYPE_CODE_NAMESPACE
:
3069 printf_filtered ("(TYPE_CODE_NAMESPACE)");
3072 printf_filtered ("(UNKNOWN TYPE CODE)");
3075 puts_filtered ("\n");
3076 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
3077 printfi_filtered (spaces
, "upper_bound_type 0x%x ",
3078 TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
3079 print_bound_type (TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
3080 puts_filtered ("\n");
3081 printfi_filtered (spaces
, "lower_bound_type 0x%x ",
3082 TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
3083 print_bound_type (TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
3084 puts_filtered ("\n");
3085 printfi_filtered (spaces
, "objfile ");
3086 gdb_print_host_address (TYPE_OBJFILE (type
), gdb_stdout
);
3087 printf_filtered ("\n");
3088 printfi_filtered (spaces
, "target_type ");
3089 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
3090 printf_filtered ("\n");
3091 if (TYPE_TARGET_TYPE (type
) != NULL
)
3093 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
3095 printfi_filtered (spaces
, "pointer_type ");
3096 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
3097 printf_filtered ("\n");
3098 printfi_filtered (spaces
, "reference_type ");
3099 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
3100 printf_filtered ("\n");
3101 printfi_filtered (spaces
, "type_chain ");
3102 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
3103 printf_filtered ("\n");
3104 printfi_filtered (spaces
, "instance_flags 0x%x", TYPE_INSTANCE_FLAGS (type
));
3105 if (TYPE_CONST (type
))
3107 puts_filtered (" TYPE_FLAG_CONST");
3109 if (TYPE_VOLATILE (type
))
3111 puts_filtered (" TYPE_FLAG_VOLATILE");
3113 if (TYPE_CODE_SPACE (type
))
3115 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3117 if (TYPE_DATA_SPACE (type
))
3119 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3121 if (TYPE_ADDRESS_CLASS_1 (type
))
3123 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3125 if (TYPE_ADDRESS_CLASS_2 (type
))
3127 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3129 puts_filtered ("\n");
3130 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
3131 if (TYPE_UNSIGNED (type
))
3133 puts_filtered (" TYPE_FLAG_UNSIGNED");
3135 if (TYPE_NOSIGN (type
))
3137 puts_filtered (" TYPE_FLAG_NOSIGN");
3139 if (TYPE_STUB (type
))
3141 puts_filtered (" TYPE_FLAG_STUB");
3143 if (TYPE_TARGET_STUB (type
))
3145 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3147 if (TYPE_STATIC (type
))
3149 puts_filtered (" TYPE_FLAG_STATIC");
3151 if (TYPE_PROTOTYPED (type
))
3153 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3155 if (TYPE_INCOMPLETE (type
))
3157 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3159 if (TYPE_VARARGS (type
))
3161 puts_filtered (" TYPE_FLAG_VARARGS");
3163 /* This is used for things like AltiVec registers on ppc. Gcc emits
3164 an attribute for the array type, which tells whether or not we
3165 have a vector, instead of a regular array. */
3166 if (TYPE_VECTOR (type
))
3168 puts_filtered (" TYPE_FLAG_VECTOR");
3170 puts_filtered ("\n");
3171 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
3172 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
3173 puts_filtered ("\n");
3174 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
3176 printfi_filtered (spaces
+ 2,
3177 "[%d] bitpos %d bitsize %d type ",
3178 idx
, TYPE_FIELD_BITPOS (type
, idx
),
3179 TYPE_FIELD_BITSIZE (type
, idx
));
3180 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
3181 printf_filtered (" name '%s' (",
3182 TYPE_FIELD_NAME (type
, idx
) != NULL
3183 ? TYPE_FIELD_NAME (type
, idx
)
3185 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
3186 printf_filtered (")\n");
3187 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
3189 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
3192 printfi_filtered (spaces
, "vptr_basetype ");
3193 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
3194 puts_filtered ("\n");
3195 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
3197 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
3199 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
3200 switch (TYPE_CODE (type
))
3202 case TYPE_CODE_STRUCT
:
3203 printfi_filtered (spaces
, "cplus_stuff ");
3204 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
3205 puts_filtered ("\n");
3206 print_cplus_stuff (type
, spaces
);
3210 printfi_filtered (spaces
, "floatformat ");
3211 if (TYPE_FLOATFORMAT (type
) == NULL
)
3212 puts_filtered ("(null)");
3215 puts_filtered ("{ ");
3216 if (TYPE_FLOATFORMAT (type
)[0] == NULL
3217 || TYPE_FLOATFORMAT (type
)[0]->name
== NULL
)
3218 puts_filtered ("(null)");
3220 puts_filtered (TYPE_FLOATFORMAT (type
)[0]->name
);
3222 puts_filtered (", ");
3223 if (TYPE_FLOATFORMAT (type
)[1] == NULL
3224 || TYPE_FLOATFORMAT (type
)[1]->name
== NULL
)
3225 puts_filtered ("(null)");
3227 puts_filtered (TYPE_FLOATFORMAT (type
)[1]->name
);
3229 puts_filtered (" }");
3231 puts_filtered ("\n");
3235 /* We have to pick one of the union types to be able print and test
3236 the value. Pick cplus_struct_type, even though we know it isn't
3237 any particular one. */
3238 printfi_filtered (spaces
, "type_specific ");
3239 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
3240 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
3242 printf_filtered (_(" (unknown data form)"));
3244 printf_filtered ("\n");
3249 obstack_free (&dont_print_type_obstack
, NULL
);
3252 /* Trivial helpers for the libiberty hash table, for mapping one
3257 struct type
*old
, *new;
3261 type_pair_hash (const void *item
)
3263 const struct type_pair
*pair
= item
;
3264 return htab_hash_pointer (pair
->old
);
3268 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
3270 const struct type_pair
*lhs
= item_lhs
, *rhs
= item_rhs
;
3271 return lhs
->old
== rhs
->old
;
3274 /* Allocate the hash table used by copy_type_recursive to walk
3275 types without duplicates. We use OBJFILE's obstack, because
3276 OBJFILE is about to be deleted. */
3279 create_copied_types_hash (struct objfile
*objfile
)
3281 return htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
3282 NULL
, &objfile
->objfile_obstack
,
3283 hashtab_obstack_allocate
,
3284 dummy_obstack_deallocate
);
3287 /* Recursively copy (deep copy) TYPE, if it is associated with OBJFILE.
3288 Return a new type allocated using malloc, a saved type if we have already
3289 visited TYPE (using COPIED_TYPES), or TYPE if it is not associated with
3293 copy_type_recursive (struct objfile
*objfile
, struct type
*type
,
3294 htab_t copied_types
)
3296 struct type_pair
*stored
, pair
;
3298 struct type
*new_type
;
3300 if (TYPE_OBJFILE (type
) == NULL
)
3303 /* This type shouldn't be pointing to any types in other objfiles; if
3304 it did, the type might disappear unexpectedly. */
3305 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
3308 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
3310 return ((struct type_pair
*) *slot
)->new;
3312 new_type
= alloc_type (NULL
);
3314 /* We must add the new type to the hash table immediately, in case
3315 we encounter this type again during a recursive call below. */
3316 stored
= xmalloc (sizeof (struct type_pair
));
3318 stored
->new = new_type
;
3321 /* Copy the common fields of types. */
3322 TYPE_CODE (new_type
) = TYPE_CODE (type
);
3323 TYPE_ARRAY_UPPER_BOUND_TYPE (new_type
) = TYPE_ARRAY_UPPER_BOUND_TYPE (type
);
3324 TYPE_ARRAY_LOWER_BOUND_TYPE (new_type
) = TYPE_ARRAY_LOWER_BOUND_TYPE (type
);
3325 if (TYPE_NAME (type
))
3326 TYPE_NAME (new_type
) = xstrdup (TYPE_NAME (type
));
3327 if (TYPE_TAG_NAME (type
))
3328 TYPE_TAG_NAME (new_type
) = xstrdup (TYPE_TAG_NAME (type
));
3329 TYPE_FLAGS (new_type
) = TYPE_FLAGS (type
);
3330 TYPE_VPTR_FIELDNO (new_type
) = TYPE_VPTR_FIELDNO (type
);
3332 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
3333 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
3335 /* Copy the fields. */
3336 TYPE_NFIELDS (new_type
) = TYPE_NFIELDS (type
);
3337 if (TYPE_NFIELDS (type
))
3341 nfields
= TYPE_NFIELDS (type
);
3342 TYPE_FIELDS (new_type
) = xmalloc (sizeof (struct field
) * nfields
);
3343 for (i
= 0; i
< nfields
; i
++)
3345 TYPE_FIELD_ARTIFICIAL (new_type
, i
) = TYPE_FIELD_ARTIFICIAL (type
, i
);
3346 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
3347 if (TYPE_FIELD_TYPE (type
, i
))
3348 TYPE_FIELD_TYPE (new_type
, i
)
3349 = copy_type_recursive (objfile
, TYPE_FIELD_TYPE (type
, i
),
3351 if (TYPE_FIELD_NAME (type
, i
))
3352 TYPE_FIELD_NAME (new_type
, i
) = xstrdup (TYPE_FIELD_NAME (type
, i
));
3353 if (TYPE_FIELD_STATIC_HAS_ADDR (type
, i
))
3354 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type
, i
),
3355 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
3356 else if (TYPE_FIELD_STATIC (type
, i
))
3357 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type
, i
),
3358 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
, i
)));
3361 TYPE_FIELD_BITPOS (new_type
, i
) = TYPE_FIELD_BITPOS (type
, i
);
3362 TYPE_FIELD_STATIC_KIND (new_type
, i
) = 0;
3367 /* Copy pointers to other types. */
3368 if (TYPE_TARGET_TYPE (type
))
3369 TYPE_TARGET_TYPE (new_type
) = copy_type_recursive (objfile
,
3370 TYPE_TARGET_TYPE (type
),
3372 if (TYPE_VPTR_BASETYPE (type
))
3373 TYPE_VPTR_BASETYPE (new_type
) = copy_type_recursive (objfile
,
3374 TYPE_VPTR_BASETYPE (type
),
3376 /* Maybe copy the type_specific bits.
3378 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3379 base classes and methods. There's no fundamental reason why we
3380 can't, but at the moment it is not needed. */
3382 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
3383 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
3384 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3385 || TYPE_CODE (type
) == TYPE_CODE_UNION
3386 || TYPE_CODE (type
) == TYPE_CODE_TEMPLATE
3387 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
3388 INIT_CPLUS_SPECIFIC (new_type
);
3393 static struct type
*
3394 build_flt (int bit
, char *name
, const struct floatformat
**floatformats
)
3400 gdb_assert (floatformats
!= NULL
);
3401 gdb_assert (floatformats
[0] != NULL
&& floatformats
[1] != NULL
);
3402 bit
= floatformats
[0]->totalsize
;
3404 gdb_assert (bit
>= 0);
3406 t
= init_type (TYPE_CODE_FLT
, bit
/ TARGET_CHAR_BIT
, 0, name
, NULL
);
3407 TYPE_FLOATFORMAT (t
) = floatformats
;
3412 build_gdbtypes (void)
3415 init_type (TYPE_CODE_VOID
, 1,
3417 "void", (struct objfile
*) NULL
);
3419 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3421 | (TARGET_CHAR_SIGNED
? 0 : TYPE_FLAG_UNSIGNED
)),
3422 "char", (struct objfile
*) NULL
);
3423 builtin_type_true_char
=
3424 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3426 "true character", (struct objfile
*) NULL
);
3427 builtin_type_signed_char
=
3428 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3430 "signed char", (struct objfile
*) NULL
);
3431 builtin_type_unsigned_char
=
3432 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3434 "unsigned char", (struct objfile
*) NULL
);
3435 builtin_type_short
=
3436 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
3438 "short", (struct objfile
*) NULL
);
3439 builtin_type_unsigned_short
=
3440 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
3442 "unsigned short", (struct objfile
*) NULL
);
3444 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3446 "int", (struct objfile
*) NULL
);
3447 builtin_type_unsigned_int
=
3448 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3450 "unsigned int", (struct objfile
*) NULL
);
3452 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
3454 "long", (struct objfile
*) NULL
);
3455 builtin_type_unsigned_long
=
3456 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
3458 "unsigned long", (struct objfile
*) NULL
);
3459 builtin_type_long_long
=
3460 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
3462 "long long", (struct objfile
*) NULL
);
3463 builtin_type_unsigned_long_long
=
3464 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
3466 "unsigned long long", (struct objfile
*) NULL
);
3468 builtin_type_float
= build_flt (TARGET_FLOAT_BIT
, "float",
3469 TARGET_FLOAT_FORMAT
);
3470 builtin_type_double
= build_flt (TARGET_DOUBLE_BIT
, "double",
3471 TARGET_DOUBLE_FORMAT
);
3472 builtin_type_long_double
= build_flt (TARGET_LONG_DOUBLE_BIT
, "long double",
3473 TARGET_LONG_DOUBLE_FORMAT
);
3475 builtin_type_complex
=
3476 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
3478 "complex", (struct objfile
*) NULL
);
3479 TYPE_TARGET_TYPE (builtin_type_complex
) = builtin_type_float
;
3480 builtin_type_double_complex
=
3481 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3483 "double complex", (struct objfile
*) NULL
);
3484 TYPE_TARGET_TYPE (builtin_type_double_complex
) = builtin_type_double
;
3485 builtin_type_string
=
3486 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3488 "string", (struct objfile
*) NULL
);
3490 init_type (TYPE_CODE_BOOL
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3492 "bool", (struct objfile
*) NULL
);
3494 /* Add user knob for controlling resolution of opaque types */
3495 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
3496 &opaque_type_resolution
, _("\
3497 Set resolution of opaque struct/class/union types (if set before loading symbols)."), _("\
3498 Show resolution of opaque struct/class/union types (if set before loading symbols)."), NULL
,
3500 show_opaque_type_resolution
,
3501 &setlist
, &showlist
);
3502 opaque_type_resolution
= 1;
3504 /* Build SIMD types. */
3506 = init_simd_type ("__builtin_v4sf", builtin_type_float
, "f", 4);
3508 = init_simd_type ("__builtin_v4si", builtin_type_int32
, "f", 4);
3510 = init_simd_type ("__builtin_v16qi", builtin_type_int8
, "f", 16);
3512 = init_simd_type ("__builtin_v8qi", builtin_type_int8
, "f", 8);
3514 = init_simd_type ("__builtin_v8hi", builtin_type_int16
, "f", 8);
3516 = init_simd_type ("__builtin_v4hi", builtin_type_int16
, "f", 4);
3518 = init_simd_type ("__builtin_v2si", builtin_type_int32
, "f", 2);
3520 /* 128 bit vectors. */
3521 builtin_type_v2_double
= init_vector_type (builtin_type_double
, 2);
3522 builtin_type_v4_float
= init_vector_type (builtin_type_float
, 4);
3523 builtin_type_v2_int64
= init_vector_type (builtin_type_int64
, 2);
3524 builtin_type_v4_int32
= init_vector_type (builtin_type_int32
, 4);
3525 builtin_type_v8_int16
= init_vector_type (builtin_type_int16
, 8);
3526 builtin_type_v16_int8
= init_vector_type (builtin_type_int8
, 16);
3527 /* 64 bit vectors. */
3528 builtin_type_v2_float
= init_vector_type (builtin_type_float
, 2);
3529 builtin_type_v2_int32
= init_vector_type (builtin_type_int32
, 2);
3530 builtin_type_v4_int16
= init_vector_type (builtin_type_int16
, 4);
3531 builtin_type_v8_int8
= init_vector_type (builtin_type_int8
, 8);
3534 builtin_type_vec64
= build_builtin_type_vec64 ();
3535 builtin_type_vec128
= build_builtin_type_vec128 ();
3537 /* Pointer/Address types. */
3539 /* NOTE: on some targets, addresses and pointers are not necessarily
3540 the same --- for example, on the D10V, pointers are 16 bits long,
3541 but addresses are 32 bits long. See doc/gdbint.texinfo,
3542 ``Pointers Are Not Always Addresses''.
3545 - gdb's `struct type' always describes the target's
3547 - gdb's `struct value' objects should always hold values in
3549 - gdb's CORE_ADDR values are addresses in the unified virtual
3550 address space that the assembler and linker work with. Thus,
3551 since target_read_memory takes a CORE_ADDR as an argument, it
3552 can access any memory on the target, even if the processor has
3553 separate code and data address spaces.
3556 - If v is a value holding a D10V code pointer, its contents are
3557 in target form: a big-endian address left-shifted two bits.
3558 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3559 sizeof (void *) == 2 on the target.
3561 In this context, builtin_type_CORE_ADDR is a bit odd: it's a
3562 target type for a value the target will never see. It's only
3563 used to hold the values of (typeless) linker symbols, which are
3564 indeed in the unified virtual address space. */
3565 builtin_type_void_data_ptr
= make_pointer_type (builtin_type_void
, NULL
);
3566 builtin_type_void_func_ptr
3567 = lookup_pointer_type (lookup_function_type (builtin_type_void
));
3568 builtin_type_CORE_ADDR
=
3569 init_type (TYPE_CODE_INT
, TARGET_ADDR_BIT
/ 8,
3571 "__CORE_ADDR", (struct objfile
*) NULL
);
3572 builtin_type_bfd_vma
=
3573 init_type (TYPE_CODE_INT
, TARGET_BFD_VMA_BIT
/ 8,
3575 "__bfd_vma", (struct objfile
*) NULL
);
3578 static struct gdbarch_data
*gdbtypes_data
;
3580 const struct builtin_type
*
3581 builtin_type (struct gdbarch
*gdbarch
)
3583 return gdbarch_data (gdbarch
, gdbtypes_data
);
3587 static struct type
*
3588 build_complex (int bit
, char *name
, struct type
*target_type
)
3591 if (bit
<= 0 || target_type
== builtin_type_error
)
3593 gdb_assert (builtin_type_error
!= NULL
);
3594 return builtin_type_error
;
3596 t
= init_type (TYPE_CODE_COMPLEX
, 2 * bit
/ TARGET_CHAR_BIT
,
3597 0, name
, (struct objfile
*) NULL
);
3598 TYPE_TARGET_TYPE (t
) = target_type
;
3603 gdbtypes_post_init (struct gdbarch
*gdbarch
)
3605 struct builtin_type
*builtin_type
3606 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
3608 builtin_type
->builtin_void
=
3609 init_type (TYPE_CODE_VOID
, 1,
3611 "void", (struct objfile
*) NULL
);
3612 builtin_type
->builtin_char
=
3613 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3615 | (TARGET_CHAR_SIGNED
? 0 : TYPE_FLAG_UNSIGNED
)),
3616 "char", (struct objfile
*) NULL
);
3617 builtin_type
->builtin_true_char
=
3618 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3620 "true character", (struct objfile
*) NULL
);
3621 builtin_type
->builtin_signed_char
=
3622 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3624 "signed char", (struct objfile
*) NULL
);
3625 builtin_type
->builtin_unsigned_char
=
3626 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3628 "unsigned char", (struct objfile
*) NULL
);
3629 builtin_type
->builtin_short
=
3630 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
3632 "short", (struct objfile
*) NULL
);
3633 builtin_type
->builtin_unsigned_short
=
3634 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
3636 "unsigned short", (struct objfile
*) NULL
);
3637 builtin_type
->builtin_int
=
3638 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3640 "int", (struct objfile
*) NULL
);
3641 builtin_type
->builtin_unsigned_int
=
3642 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3644 "unsigned int", (struct objfile
*) NULL
);
3645 builtin_type
->builtin_long
=
3646 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
3648 "long", (struct objfile
*) NULL
);
3649 builtin_type
->builtin_unsigned_long
=
3650 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
3652 "unsigned long", (struct objfile
*) NULL
);
3653 builtin_type
->builtin_long_long
=
3654 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
3656 "long long", (struct objfile
*) NULL
);
3657 builtin_type
->builtin_unsigned_long_long
=
3658 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
3660 "unsigned long long", (struct objfile
*) NULL
);
3661 builtin_type
->builtin_float
3662 = build_flt (gdbarch_float_bit (gdbarch
), "float",
3663 gdbarch_float_format (gdbarch
));
3664 builtin_type
->builtin_double
3665 = build_flt (gdbarch_double_bit (gdbarch
), "double",
3666 gdbarch_double_format (gdbarch
));
3667 builtin_type
->builtin_long_double
3668 = build_flt (gdbarch_long_double_bit (gdbarch
), "long double",
3669 gdbarch_long_double_format (gdbarch
));
3670 builtin_type
->builtin_complex
3671 = build_complex (gdbarch_float_bit (gdbarch
), "complex",
3672 builtin_type
->builtin_float
);
3673 builtin_type
->builtin_double_complex
3674 = build_complex (gdbarch_double_bit (gdbarch
), "double complex",
3675 builtin_type
->builtin_double
);
3676 builtin_type
->builtin_string
=
3677 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3679 "string", (struct objfile
*) NULL
);
3680 builtin_type
->builtin_bool
=
3681 init_type (TYPE_CODE_BOOL
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3683 "bool", (struct objfile
*) NULL
);
3685 /* Pointer/Address types. */
3687 /* NOTE: on some targets, addresses and pointers are not necessarily
3688 the same --- for example, on the D10V, pointers are 16 bits long,
3689 but addresses are 32 bits long. See doc/gdbint.texinfo,
3690 ``Pointers Are Not Always Addresses''.
3693 - gdb's `struct type' always describes the target's
3695 - gdb's `struct value' objects should always hold values in
3697 - gdb's CORE_ADDR values are addresses in the unified virtual
3698 address space that the assembler and linker work with. Thus,
3699 since target_read_memory takes a CORE_ADDR as an argument, it
3700 can access any memory on the target, even if the processor has
3701 separate code and data address spaces.
3704 - If v is a value holding a D10V code pointer, its contents are
3705 in target form: a big-endian address left-shifted two bits.
3706 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3707 sizeof (void *) == 2 on the target.
3709 In this context, builtin_type->CORE_ADDR is a bit odd: it's a
3710 target type for a value the target will never see. It's only
3711 used to hold the values of (typeless) linker symbols, which are
3712 indeed in the unified virtual address space. */
3713 builtin_type
->builtin_data_ptr
3714 = make_pointer_type (builtin_type
->builtin_void
, NULL
);
3715 builtin_type
->builtin_func_ptr
3716 = lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
3717 builtin_type
->builtin_core_addr
=
3718 init_type (TYPE_CODE_INT
, TARGET_ADDR_BIT
/ 8,
3720 "__CORE_ADDR", (struct objfile
*) NULL
);
3722 return builtin_type
;
3725 extern void _initialize_gdbtypes (void);
3727 _initialize_gdbtypes (void)
3729 struct cmd_list_element
*c
;
3731 /* FIXME: Why don't the following types need to be arch-swapped?
3732 See the comment at the top of the calls to
3733 DEPRECATED_REGISTER_GDBARCH_SWAP below. */
3735 init_type (TYPE_CODE_INT
, 0 / 8,
3737 "int0_t", (struct objfile
*) NULL
);
3739 init_type (TYPE_CODE_INT
, 8 / 8,
3741 "int8_t", (struct objfile
*) NULL
);
3742 builtin_type_uint8
=
3743 init_type (TYPE_CODE_INT
, 8 / 8,
3745 "uint8_t", (struct objfile
*) NULL
);
3746 builtin_type_int16
=
3747 init_type (TYPE_CODE_INT
, 16 / 8,
3749 "int16_t", (struct objfile
*) NULL
);
3750 builtin_type_uint16
=
3751 init_type (TYPE_CODE_INT
, 16 / 8,
3753 "uint16_t", (struct objfile
*) NULL
);
3754 builtin_type_int32
=
3755 init_type (TYPE_CODE_INT
, 32 / 8,
3757 "int32_t", (struct objfile
*) NULL
);
3758 builtin_type_uint32
=
3759 init_type (TYPE_CODE_INT
, 32 / 8,
3761 "uint32_t", (struct objfile
*) NULL
);
3762 builtin_type_int64
=
3763 init_type (TYPE_CODE_INT
, 64 / 8,
3765 "int64_t", (struct objfile
*) NULL
);
3766 builtin_type_uint64
=
3767 init_type (TYPE_CODE_INT
, 64 / 8,
3769 "uint64_t", (struct objfile
*) NULL
);
3770 builtin_type_int128
=
3771 init_type (TYPE_CODE_INT
, 128 / 8,
3773 "int128_t", (struct objfile
*) NULL
);
3774 builtin_type_uint128
=
3775 init_type (TYPE_CODE_INT
, 128 / 8,
3777 "uint128_t", (struct objfile
*) NULL
);
3781 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
3783 /* FIXME - For the moment, handle types by swapping them in and out.
3784 Should be using the per-architecture data-pointer and a large
3787 Note that any type T that we might create a 'T *' type for must
3788 be arch-swapped: we cache a type's 'T *' type in the pointer_type
3789 field, so if we change architectures but don't swap T, then
3790 lookup_pointer_type will start handing out pointer types made for
3791 a different architecture. */
3792 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void
);
3793 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_char
);
3794 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_short
);
3795 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int
);
3796 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long
);
3797 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long_long
);
3798 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_signed_char
);
3799 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_char
);
3800 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_short
);
3801 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_int
);
3802 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_long
);
3803 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_long_long
);
3804 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_float
);
3805 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_double
);
3806 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long_double
);
3807 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_complex
);
3808 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_double_complex
);
3809 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_string
);
3810 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4sf
);
3811 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4si
);
3812 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v16qi
);
3813 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8qi
);
3814 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8hi
);
3815 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4hi
);
3816 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2si
);
3817 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_double
);
3818 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_float
);
3819 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_int64
);
3820 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_int32
);
3821 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8_int16
);
3822 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v16_int8
);
3823 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_float
);
3824 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_int32
);
3825 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8_int8
);
3826 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_int16
);
3827 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_vec128
);
3828 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void_data_ptr
);
3829 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void_func_ptr
);
3830 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR
);
3831 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma
);
3832 deprecated_register_gdbarch_swap (NULL
, 0, build_gdbtypes
);
3834 /* Note: These types do not need to be swapped - they are target
3835 neutral. FIXME: Are you sure? See the comment above the calls
3836 to DEPRECATED_REGISTER_GDBARCH_SWAP above. */
3837 builtin_type_ieee_single
3838 = build_flt (-1, "builtin_type_ieee_single", floatformats_ieee_single
);
3839 builtin_type_ieee_double
3840 = build_flt (-1, "builtin_type_ieee_double", floatformats_ieee_double
);
3841 builtin_type_i387_ext
3842 = build_flt (-1, "builtin_type_i387_ext", floatformats_i387_ext
);
3843 builtin_type_m68881_ext
3844 = build_flt (-1, "builtin_type_m68881_ext", floatformats_m68881_ext
);
3845 builtin_type_arm_ext
3846 = build_flt (-1, "builtin_type_arm_ext", floatformats_arm_ext
);
3847 builtin_type_ia64_spill
3848 = build_flt (-1, "builtin_type_ia64_spill", floatformats_ia64_spill
);
3849 builtin_type_ia64_quad
3850 = build_flt (-1, "builtin_type_ia64_quad", floatformats_ia64_quad
);
3852 add_setshow_zinteger_cmd ("overload", no_class
, &overload_debug
, _("\
3853 Set debugging of C++ overloading."), _("\
3854 Show debugging of C++ overloading."), _("\
3855 When enabled, ranking of the functions is displayed."),
3857 show_overload_debug
,
3858 &setdebuglist
, &showdebuglist
);