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_int0
;
48 struct type
*builtin_type_int8
;
49 struct type
*builtin_type_uint8
;
50 struct type
*builtin_type_int16
;
51 struct type
*builtin_type_uint16
;
52 struct type
*builtin_type_int32
;
53 struct type
*builtin_type_uint32
;
54 struct type
*builtin_type_int64
;
55 struct type
*builtin_type_uint64
;
56 struct type
*builtin_type_int128
;
57 struct type
*builtin_type_uint128
;
59 /* Floatformat pairs. */
60 const struct floatformat
*floatformats_ieee_single
[BFD_ENDIAN_UNKNOWN
] = {
61 &floatformat_ieee_single_big
,
62 &floatformat_ieee_single_little
64 const struct floatformat
*floatformats_ieee_double
[BFD_ENDIAN_UNKNOWN
] = {
65 &floatformat_ieee_double_big
,
66 &floatformat_ieee_double_little
68 const struct floatformat
*floatformats_ieee_double_littlebyte_bigword
[BFD_ENDIAN_UNKNOWN
] = {
69 &floatformat_ieee_double_big
,
70 &floatformat_ieee_double_littlebyte_bigword
72 const struct floatformat
*floatformats_i387_ext
[BFD_ENDIAN_UNKNOWN
] = {
73 &floatformat_i387_ext
,
76 const struct floatformat
*floatformats_m68881_ext
[BFD_ENDIAN_UNKNOWN
] = {
77 &floatformat_m68881_ext
,
78 &floatformat_m68881_ext
80 const struct floatformat
*floatformats_arm_ext
[BFD_ENDIAN_UNKNOWN
] = {
81 &floatformat_arm_ext_big
,
82 &floatformat_arm_ext_littlebyte_bigword
84 const struct floatformat
*floatformats_ia64_spill
[BFD_ENDIAN_UNKNOWN
] = {
85 &floatformat_ia64_spill_big
,
86 &floatformat_ia64_spill_little
88 const struct floatformat
*floatformats_ia64_quad
[BFD_ENDIAN_UNKNOWN
] = {
89 &floatformat_ia64_quad_big
,
90 &floatformat_ia64_quad_little
92 const struct floatformat
*floatformats_vax_f
[BFD_ENDIAN_UNKNOWN
] = {
96 const struct floatformat
*floatformats_vax_d
[BFD_ENDIAN_UNKNOWN
] = {
101 struct type
*builtin_type_ieee_single
;
102 struct type
*builtin_type_ieee_double
;
103 struct type
*builtin_type_i387_ext
;
104 struct type
*builtin_type_m68881_ext
;
105 struct type
*builtin_type_arm_ext
;
106 struct type
*builtin_type_ia64_spill
;
107 struct type
*builtin_type_ia64_quad
;
110 int opaque_type_resolution
= 1;
112 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
113 struct cmd_list_element
*c
, const char *value
)
115 fprintf_filtered (file
, _("\
116 Resolution of opaque struct/class/union types (if set before loading symbols) is %s.\n"),
120 int overload_debug
= 0;
122 show_overload_debug (struct ui_file
*file
, int from_tty
,
123 struct cmd_list_element
*c
, const char *value
)
125 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"), value
);
132 }; /* maximum extension is 128! FIXME */
134 static void print_bit_vector (B_TYPE
*, int);
135 static void print_arg_types (struct field
*, int, int);
136 static void dump_fn_fieldlists (struct type
*, int);
137 static void print_cplus_stuff (struct type
*, int);
138 static void virtual_base_list_aux (struct type
*dclass
);
141 /* Alloc a new type structure and fill it with some defaults. If
142 OBJFILE is non-NULL, then allocate the space for the type structure
143 in that objfile's objfile_obstack. Otherwise allocate the new type structure
144 by xmalloc () (for permanent types). */
147 alloc_type (struct objfile
*objfile
)
151 /* Alloc the structure and start off with all fields zeroed. */
155 type
= xmalloc (sizeof (struct type
));
156 memset (type
, 0, sizeof (struct type
));
157 TYPE_MAIN_TYPE (type
) = xmalloc (sizeof (struct main_type
));
161 type
= obstack_alloc (&objfile
->objfile_obstack
,
162 sizeof (struct type
));
163 memset (type
, 0, sizeof (struct type
));
164 TYPE_MAIN_TYPE (type
) = obstack_alloc (&objfile
->objfile_obstack
,
165 sizeof (struct main_type
));
166 OBJSTAT (objfile
, n_types
++);
168 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
170 /* Initialize the fields that might not be zero. */
172 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
173 TYPE_OBJFILE (type
) = objfile
;
174 TYPE_VPTR_FIELDNO (type
) = -1;
175 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
180 /* Alloc a new type instance structure, fill it with some defaults,
181 and point it at OLDTYPE. Allocate the new type instance from the
182 same place as OLDTYPE. */
185 alloc_type_instance (struct type
*oldtype
)
189 /* Allocate the structure. */
191 if (TYPE_OBJFILE (oldtype
) == NULL
)
193 type
= xmalloc (sizeof (struct type
));
194 memset (type
, 0, sizeof (struct type
));
198 type
= obstack_alloc (&TYPE_OBJFILE (oldtype
)->objfile_obstack
,
199 sizeof (struct type
));
200 memset (type
, 0, sizeof (struct type
));
202 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
204 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
209 /* Clear all remnants of the previous type at TYPE, in preparation for
210 replacing it with something else. */
212 smash_type (struct type
*type
)
214 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
216 /* For now, delete the rings. */
217 TYPE_CHAIN (type
) = type
;
219 /* For now, leave the pointer/reference types alone. */
222 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
223 to a pointer to memory where the pointer type should be stored.
224 If *TYPEPTR is zero, update it to point to the pointer type we return.
225 We allocate new memory if needed. */
228 make_pointer_type (struct type
*type
, struct type
**typeptr
)
230 struct type
*ntype
; /* New type */
231 struct objfile
*objfile
;
234 ntype
= TYPE_POINTER_TYPE (type
);
239 return ntype
; /* Don't care about alloc, and have new type. */
240 else if (*typeptr
== 0)
242 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
247 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
249 ntype
= alloc_type (TYPE_OBJFILE (type
));
254 /* We have storage, but need to reset it. */
257 objfile
= TYPE_OBJFILE (ntype
);
258 chain
= TYPE_CHAIN (ntype
);
260 TYPE_CHAIN (ntype
) = chain
;
261 TYPE_OBJFILE (ntype
) = objfile
;
264 TYPE_TARGET_TYPE (ntype
) = type
;
265 TYPE_POINTER_TYPE (type
) = ntype
;
267 /* FIXME! Assume the machine has only one representation for pointers! */
269 TYPE_LENGTH (ntype
) = gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
;
270 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
272 /* Mark pointers as unsigned. The target converts between pointers
273 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
274 gdbarch_address_to_pointer. */
275 TYPE_FLAGS (ntype
) |= TYPE_FLAG_UNSIGNED
;
277 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
278 TYPE_POINTER_TYPE (type
) = ntype
;
280 /* Update the length of all the other variants of this type. */
281 chain
= TYPE_CHAIN (ntype
);
282 while (chain
!= ntype
)
284 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
285 chain
= TYPE_CHAIN (chain
);
291 /* Given a type TYPE, return a type of pointers to that type.
292 May need to construct such a type if this is the first use. */
295 lookup_pointer_type (struct type
*type
)
297 return make_pointer_type (type
, (struct type
**) 0);
300 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero, points
301 to a pointer to memory where the reference type should be stored.
302 If *TYPEPTR is zero, update it to point to the reference type we return.
303 We allocate new memory if needed. */
306 make_reference_type (struct type
*type
, struct type
**typeptr
)
308 struct type
*ntype
; /* New type */
309 struct objfile
*objfile
;
312 ntype
= TYPE_REFERENCE_TYPE (type
);
317 return ntype
; /* Don't care about alloc, and have new type. */
318 else if (*typeptr
== 0)
320 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
325 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
327 ntype
= alloc_type (TYPE_OBJFILE (type
));
332 /* We have storage, but need to reset it. */
335 objfile
= TYPE_OBJFILE (ntype
);
336 chain
= TYPE_CHAIN (ntype
);
338 TYPE_CHAIN (ntype
) = chain
;
339 TYPE_OBJFILE (ntype
) = objfile
;
342 TYPE_TARGET_TYPE (ntype
) = type
;
343 TYPE_REFERENCE_TYPE (type
) = ntype
;
345 /* FIXME! Assume the machine has only one representation for references,
346 and that it matches the (only) representation for pointers! */
348 TYPE_LENGTH (ntype
) = gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
;
349 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
351 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
352 TYPE_REFERENCE_TYPE (type
) = ntype
;
354 /* Update the length of all the other variants of this type. */
355 chain
= TYPE_CHAIN (ntype
);
356 while (chain
!= ntype
)
358 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
359 chain
= TYPE_CHAIN (chain
);
365 /* Same as above, but caller doesn't care about memory allocation details. */
368 lookup_reference_type (struct type
*type
)
370 return make_reference_type (type
, (struct type
**) 0);
373 /* Lookup a function type that returns type TYPE. TYPEPTR, if nonzero, points
374 to a pointer to memory where the function type should be stored.
375 If *TYPEPTR is zero, update it to point to the function type we return.
376 We allocate new memory if needed. */
379 make_function_type (struct type
*type
, struct type
**typeptr
)
381 struct type
*ntype
; /* New type */
382 struct objfile
*objfile
;
384 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
386 ntype
= alloc_type (TYPE_OBJFILE (type
));
391 /* We have storage, but need to reset it. */
394 objfile
= TYPE_OBJFILE (ntype
);
396 TYPE_OBJFILE (ntype
) = objfile
;
399 TYPE_TARGET_TYPE (ntype
) = type
;
401 TYPE_LENGTH (ntype
) = 1;
402 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
408 /* Given a type TYPE, return a type of functions that return that type.
409 May need to construct such a type if this is the first use. */
412 lookup_function_type (struct type
*type
)
414 return make_function_type (type
, (struct type
**) 0);
417 /* Identify address space identifier by name --
418 return the integer flag defined in gdbtypes.h. */
420 address_space_name_to_int (char *space_identifier
)
422 struct gdbarch
*gdbarch
= current_gdbarch
;
424 /* Check for known address space delimiters. */
425 if (!strcmp (space_identifier
, "code"))
426 return TYPE_FLAG_CODE_SPACE
;
427 else if (!strcmp (space_identifier
, "data"))
428 return TYPE_FLAG_DATA_SPACE
;
429 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
430 && gdbarch_address_class_name_to_type_flags (gdbarch
,
435 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
438 /* Identify address space identifier by integer flag as defined in
439 gdbtypes.h -- return the string version of the adress space name. */
442 address_space_int_to_name (int space_flag
)
444 struct gdbarch
*gdbarch
= current_gdbarch
;
445 if (space_flag
& TYPE_FLAG_CODE_SPACE
)
447 else if (space_flag
& TYPE_FLAG_DATA_SPACE
)
449 else if ((space_flag
& TYPE_FLAG_ADDRESS_CLASS_ALL
)
450 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
451 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
456 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
458 If STORAGE is non-NULL, create the new type instance there.
459 STORAGE must be in the same obstack as TYPE. */
462 make_qualified_type (struct type
*type
, int new_flags
,
463 struct type
*storage
)
469 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
471 ntype
= TYPE_CHAIN (ntype
);
472 } while (ntype
!= type
);
474 /* Create a new type instance. */
476 ntype
= alloc_type_instance (type
);
479 /* If STORAGE was provided, it had better be in the same objfile as
480 TYPE. Otherwise, we can't link it into TYPE's cv chain: if one
481 objfile is freed and the other kept, we'd have dangling
483 gdb_assert (TYPE_OBJFILE (type
) == TYPE_OBJFILE (storage
));
486 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
487 TYPE_CHAIN (ntype
) = ntype
;
490 /* Pointers or references to the original type are not relevant to
492 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
493 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
495 /* Chain the new qualified type to the old type. */
496 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
497 TYPE_CHAIN (type
) = ntype
;
499 /* Now set the instance flags and return the new type. */
500 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
502 /* Set length of new type to that of the original type. */
503 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
508 /* Make an address-space-delimited variant of a type -- a type that
509 is identical to the one supplied except that it has an address
510 space attribute attached to it (such as "code" or "data").
512 The space attributes "code" and "data" are for Harvard architectures.
513 The address space attributes are for architectures which have
514 alternately sized pointers or pointers with alternate representations. */
517 make_type_with_address_space (struct type
*type
, int space_flag
)
520 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
521 & ~(TYPE_FLAG_CODE_SPACE
| TYPE_FLAG_DATA_SPACE
522 | TYPE_FLAG_ADDRESS_CLASS_ALL
))
525 return make_qualified_type (type
, new_flags
, NULL
);
528 /* Make a "c-v" variant of a type -- a type that is identical to the
529 one supplied except that it may have const or volatile attributes
530 CNST is a flag for setting the const attribute
531 VOLTL is a flag for setting the volatile attribute
532 TYPE is the base type whose variant we are creating.
534 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
535 storage to hold the new qualified type; *TYPEPTR and TYPE must be
536 in the same objfile. Otherwise, allocate fresh memory for the new
537 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
538 new type we construct. */
540 make_cv_type (int cnst
, int voltl
, struct type
*type
, struct type
**typeptr
)
542 struct type
*ntype
; /* New type */
543 struct type
*tmp_type
= type
; /* tmp type */
544 struct objfile
*objfile
;
546 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
547 & ~(TYPE_FLAG_CONST
| TYPE_FLAG_VOLATILE
));
550 new_flags
|= TYPE_FLAG_CONST
;
553 new_flags
|= TYPE_FLAG_VOLATILE
;
555 if (typeptr
&& *typeptr
!= NULL
)
557 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
558 a C-V variant chain that threads across objfiles: if one
559 objfile gets freed, then the other has a broken C-V chain.
561 This code used to try to copy over the main type from TYPE to
562 *TYPEPTR if they were in different objfiles, but that's
563 wrong, too: TYPE may have a field list or member function
564 lists, which refer to types of their own, etc. etc. The
565 whole shebang would need to be copied over recursively; you
566 can't have inter-objfile pointers. The only thing to do is
567 to leave stub types as stub types, and look them up afresh by
568 name each time you encounter them. */
569 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
));
572 ntype
= make_qualified_type (type
, new_flags
, typeptr
? *typeptr
: NULL
);
580 /* Replace the contents of ntype with the type *type. This changes the
581 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
582 the changes are propogated to all types in the TYPE_CHAIN.
584 In order to build recursive types, it's inevitable that we'll need
585 to update types in place --- but this sort of indiscriminate
586 smashing is ugly, and needs to be replaced with something more
587 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
588 clear if more steps are needed. */
590 replace_type (struct type
*ntype
, struct type
*type
)
594 /* These two types had better be in the same objfile. Otherwise,
595 the assignment of one type's main type structure to the other
596 will produce a type with references to objects (names; field
597 lists; etc.) allocated on an objfile other than its own. */
598 gdb_assert (TYPE_OBJFILE (ntype
) == TYPE_OBJFILE (ntype
));
600 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
602 /* The type length is not a part of the main type. Update it for each
603 type on the variant chain. */
606 /* Assert that this element of the chain has no address-class bits
607 set in its flags. Such type variants might have type lengths
608 which are supposed to be different from the non-address-class
609 variants. This assertion shouldn't ever be triggered because
610 symbol readers which do construct address-class variants don't
611 call replace_type(). */
612 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
614 TYPE_LENGTH (chain
) = TYPE_LENGTH (type
);
615 chain
= TYPE_CHAIN (chain
);
616 } while (ntype
!= chain
);
618 /* Assert that the two types have equivalent instance qualifiers.
619 This should be true for at least all of our debug readers. */
620 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
623 /* Implement direct support for MEMBER_TYPE in GNU C++.
624 May need to construct such a type if this is the first use.
625 The TYPE is the type of the member. The DOMAIN is the type
626 of the aggregate that the member belongs to. */
629 lookup_memberptr_type (struct type
*type
, struct type
*domain
)
633 mtype
= alloc_type (TYPE_OBJFILE (type
));
634 smash_to_memberptr_type (mtype
, domain
, type
);
638 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
641 lookup_methodptr_type (struct type
*to_type
)
645 mtype
= alloc_type (TYPE_OBJFILE (to_type
));
646 TYPE_TARGET_TYPE (mtype
) = to_type
;
647 TYPE_DOMAIN_TYPE (mtype
) = TYPE_DOMAIN_TYPE (to_type
);
648 TYPE_LENGTH (mtype
) = cplus_method_ptr_size ();
649 TYPE_CODE (mtype
) = TYPE_CODE_METHODPTR
;
653 /* Allocate a stub method whose return type is TYPE.
654 This apparently happens for speed of symbol reading, since parsing
655 out the arguments to the method is cpu-intensive, the way we are doing
656 it. So, we will fill in arguments later.
657 This always returns a fresh type. */
660 allocate_stub_method (struct type
*type
)
664 mtype
= init_type (TYPE_CODE_METHOD
, 1, TYPE_FLAG_STUB
, NULL
,
665 TYPE_OBJFILE (type
));
666 TYPE_TARGET_TYPE (mtype
) = type
;
667 /* _DOMAIN_TYPE (mtype) = unknown yet */
671 /* Create a range type using either a blank type supplied in RESULT_TYPE,
672 or creating a new type, inheriting the objfile from INDEX_TYPE.
674 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
675 HIGH_BOUND, inclusive.
677 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
678 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
681 create_range_type (struct type
*result_type
, struct type
*index_type
,
682 int low_bound
, int high_bound
)
684 if (result_type
== NULL
)
686 result_type
= alloc_type (TYPE_OBJFILE (index_type
));
688 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
689 TYPE_TARGET_TYPE (result_type
) = index_type
;
690 if (TYPE_STUB (index_type
))
691 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
693 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
694 TYPE_NFIELDS (result_type
) = 2;
695 TYPE_FIELDS (result_type
) = (struct field
*)
696 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
697 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
698 TYPE_FIELD_BITPOS (result_type
, 0) = low_bound
;
699 TYPE_FIELD_BITPOS (result_type
, 1) = high_bound
;
700 TYPE_FIELD_TYPE (result_type
, 0) = builtin_type_int
; /* FIXME */
701 TYPE_FIELD_TYPE (result_type
, 1) = builtin_type_int
; /* FIXME */
704 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
706 return (result_type
);
709 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE.
710 Return 1 if type is a range type, 0 if it is discrete (and bounds
711 will fit in LONGEST), or -1 otherwise. */
714 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
716 CHECK_TYPEDEF (type
);
717 switch (TYPE_CODE (type
))
719 case TYPE_CODE_RANGE
:
720 *lowp
= TYPE_LOW_BOUND (type
);
721 *highp
= TYPE_HIGH_BOUND (type
);
724 if (TYPE_NFIELDS (type
) > 0)
726 /* The enums may not be sorted by value, so search all
730 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
731 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
733 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
734 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
735 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
736 *highp
= TYPE_FIELD_BITPOS (type
, i
);
739 /* Set unsigned indicator if warranted. */
742 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
756 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
758 if (!TYPE_UNSIGNED (type
))
760 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
764 /* ... fall through for unsigned ints ... */
767 /* This round-about calculation is to avoid shifting by
768 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
769 if TYPE_LENGTH (type) == sizeof (LONGEST). */
770 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
771 *highp
= (*highp
- 1) | *highp
;
778 /* Create an array type using either a blank type supplied in RESULT_TYPE,
779 or creating a new type, inheriting the objfile from RANGE_TYPE.
781 Elements will be of type ELEMENT_TYPE, the indices will be of type
784 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
785 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
788 create_array_type (struct type
*result_type
, struct type
*element_type
,
789 struct type
*range_type
)
791 LONGEST low_bound
, high_bound
;
793 if (result_type
== NULL
)
795 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
797 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
798 TYPE_TARGET_TYPE (result_type
) = element_type
;
799 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
800 low_bound
= high_bound
= 0;
801 CHECK_TYPEDEF (element_type
);
802 TYPE_LENGTH (result_type
) =
803 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
804 TYPE_NFIELDS (result_type
) = 1;
805 TYPE_FIELDS (result_type
) =
806 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
807 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
808 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
809 TYPE_VPTR_FIELDNO (result_type
) = -1;
811 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
812 if (TYPE_LENGTH (result_type
) == 0)
813 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
815 return (result_type
);
818 /* Create a string type using either a blank type supplied in RESULT_TYPE,
819 or creating a new type. String types are similar enough to array of
820 char types that we can use create_array_type to build the basic type
821 and then bash it into a string type.
823 For fixed length strings, the range type contains 0 as the lower
824 bound and the length of the string minus one as the upper bound.
826 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
827 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
830 create_string_type (struct type
*result_type
, struct type
*range_type
)
832 struct type
*string_char_type
;
834 string_char_type
= language_string_char_type (current_language
,
836 result_type
= create_array_type (result_type
,
839 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
840 return (result_type
);
844 create_set_type (struct type
*result_type
, struct type
*domain_type
)
846 LONGEST low_bound
, high_bound
, bit_length
;
847 if (result_type
== NULL
)
849 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
851 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
852 TYPE_NFIELDS (result_type
) = 1;
853 TYPE_FIELDS (result_type
) = (struct field
*)
854 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
855 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
857 if (!TYPE_STUB (domain_type
))
859 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
860 low_bound
= high_bound
= 0;
861 bit_length
= high_bound
- low_bound
+ 1;
862 TYPE_LENGTH (result_type
)
863 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
865 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
868 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
870 return (result_type
);
874 append_flags_type_flag (struct type
*type
, int bitpos
, char *name
)
876 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLAGS
);
877 gdb_assert (bitpos
< TYPE_NFIELDS (type
));
878 gdb_assert (bitpos
>= 0);
882 TYPE_FIELD_NAME (type
, bitpos
) = xstrdup (name
);
883 TYPE_FIELD_BITPOS (type
, bitpos
) = bitpos
;
887 /* Don't show this field to the user. */
888 TYPE_FIELD_BITPOS (type
, bitpos
) = -1;
893 init_flags_type (char *name
, int length
)
895 int nfields
= length
* TARGET_CHAR_BIT
;
898 type
= init_type (TYPE_CODE_FLAGS
, length
, TYPE_FLAG_UNSIGNED
, name
, NULL
);
899 TYPE_NFIELDS (type
) = nfields
;
900 TYPE_FIELDS (type
) = TYPE_ALLOC (type
, nfields
* sizeof (struct field
));
901 memset (TYPE_FIELDS (type
), 0, nfields
* sizeof (struct field
));
907 init_vector_type (struct type
*elt_type
, int n
)
909 struct type
*array_type
;
911 array_type
= create_array_type (0, elt_type
,
912 create_range_type (0, builtin_type_int
,
914 TYPE_FLAGS (array_type
) |= TYPE_FLAG_VECTOR
;
918 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
919 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
920 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
921 TYPE doesn't include the offset (that's the value of the MEMBER
922 itself), but does include the structure type into which it points
925 When "smashing" the type, we preserve the objfile that the
926 old type pointed to, since we aren't changing where the type is actually
930 smash_to_memberptr_type (struct type
*type
, struct type
*domain
,
931 struct type
*to_type
)
933 struct objfile
*objfile
;
935 objfile
= TYPE_OBJFILE (type
);
938 TYPE_OBJFILE (type
) = objfile
;
939 TYPE_TARGET_TYPE (type
) = to_type
;
940 TYPE_DOMAIN_TYPE (type
) = domain
;
941 /* Assume that a data member pointer is the same size as a normal
943 TYPE_LENGTH (type
) = gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
;
944 TYPE_CODE (type
) = TYPE_CODE_MEMBERPTR
;
947 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
948 METHOD just means `function that gets an extra "this" argument'.
950 When "smashing" the type, we preserve the objfile that the
951 old type pointed to, since we aren't changing where the type is actually
955 smash_to_method_type (struct type
*type
, struct type
*domain
,
956 struct type
*to_type
, struct field
*args
,
957 int nargs
, int varargs
)
959 struct objfile
*objfile
;
961 objfile
= TYPE_OBJFILE (type
);
964 TYPE_OBJFILE (type
) = objfile
;
965 TYPE_TARGET_TYPE (type
) = to_type
;
966 TYPE_DOMAIN_TYPE (type
) = domain
;
967 TYPE_FIELDS (type
) = args
;
968 TYPE_NFIELDS (type
) = nargs
;
970 TYPE_FLAGS (type
) |= TYPE_FLAG_VARARGS
;
971 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
972 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
975 /* Return a typename for a struct/union/enum type without "struct ",
976 "union ", or "enum ". If the type has a NULL name, return NULL. */
979 type_name_no_tag (const struct type
*type
)
981 if (TYPE_TAG_NAME (type
) != NULL
)
982 return TYPE_TAG_NAME (type
);
984 /* Is there code which expects this to return the name if there is no
985 tag name? My guess is that this is mainly used for C++ in cases where
986 the two will always be the same. */
987 return TYPE_NAME (type
);
990 /* Lookup a typedef or primitive type named NAME,
991 visible in lexical block BLOCK.
992 If NOERR is nonzero, return zero if NAME is not suitably defined. */
995 lookup_typename (char *name
, struct block
*block
, int noerr
)
1000 sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, 0, (struct symtab
**) NULL
);
1001 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1003 tmp
= language_lookup_primitive_type_by_name (current_language
,
1010 else if (!tmp
&& noerr
)
1016 error (_("No type named %s."), name
);
1019 return (SYMBOL_TYPE (sym
));
1023 lookup_unsigned_typename (char *name
)
1025 char *uns
= alloca (strlen (name
) + 10);
1027 strcpy (uns
, "unsigned ");
1028 strcpy (uns
+ 9, name
);
1029 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
1033 lookup_signed_typename (char *name
)
1036 char *uns
= alloca (strlen (name
) + 8);
1038 strcpy (uns
, "signed ");
1039 strcpy (uns
+ 7, name
);
1040 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
1041 /* If we don't find "signed FOO" just try again with plain "FOO". */
1044 return lookup_typename (name
, (struct block
*) NULL
, 0);
1047 /* Lookup a structure type named "struct NAME",
1048 visible in lexical block BLOCK. */
1051 lookup_struct (char *name
, struct block
*block
)
1055 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
1056 (struct symtab
**) NULL
);
1060 error (_("No struct type named %s."), name
);
1062 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1064 error (_("This context has class, union or enum %s, not a struct."), name
);
1066 return (SYMBOL_TYPE (sym
));
1069 /* Lookup a union type named "union NAME",
1070 visible in lexical block BLOCK. */
1073 lookup_union (char *name
, struct block
*block
)
1078 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
1079 (struct symtab
**) NULL
);
1082 error (_("No union type named %s."), name
);
1084 t
= SYMBOL_TYPE (sym
);
1086 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1089 /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
1090 * a further "declared_type" field to discover it is really a union.
1092 if (HAVE_CPLUS_STRUCT (t
))
1093 if (TYPE_DECLARED_TYPE (t
) == DECLARED_TYPE_UNION
)
1096 /* If we get here, it's not a union */
1097 error (_("This context has class, struct or enum %s, not a union."), name
);
1101 /* Lookup an enum type named "enum NAME",
1102 visible in lexical block BLOCK. */
1105 lookup_enum (char *name
, struct block
*block
)
1109 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
1110 (struct symtab
**) NULL
);
1113 error (_("No enum type named %s."), name
);
1115 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1117 error (_("This context has class, struct or union %s, not an enum."), name
);
1119 return (SYMBOL_TYPE (sym
));
1122 /* Lookup a template type named "template NAME<TYPE>",
1123 visible in lexical block BLOCK. */
1126 lookup_template_type (char *name
, struct type
*type
, struct block
*block
)
1129 char *nam
= (char *) alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1132 strcat (nam
, TYPE_NAME (type
));
1133 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1135 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0, (struct symtab
**) NULL
);
1139 error (_("No template type named %s."), name
);
1141 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1143 error (_("This context has class, union or enum %s, not a struct."), name
);
1145 return (SYMBOL_TYPE (sym
));
1148 /* Given a type TYPE, lookup the type of the component of type named NAME.
1150 TYPE can be either a struct or union, or a pointer or reference to a struct or
1151 union. If it is a pointer or reference, its target type is automatically used.
1152 Thus '.' and '->' are interchangable, as specified for the definitions of the
1153 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
1155 If NOERR is nonzero, return zero if NAME is not suitably defined.
1156 If NAME is the name of a baseclass type, return that type. */
1159 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
1165 CHECK_TYPEDEF (type
);
1166 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1167 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1169 type
= TYPE_TARGET_TYPE (type
);
1172 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
1173 TYPE_CODE (type
) != TYPE_CODE_UNION
)
1175 target_terminal_ours ();
1176 gdb_flush (gdb_stdout
);
1177 fprintf_unfiltered (gdb_stderr
, "Type ");
1178 type_print (type
, "", gdb_stderr
, -1);
1179 error (_(" is not a structure or union type."));
1183 /* FIXME: This change put in by Michael seems incorrect for the case where
1184 the structure tag name is the same as the member name. I.E. when doing
1185 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
1190 typename
= type_name_no_tag (type
);
1191 if (typename
!= NULL
&& strcmp (typename
, name
) == 0)
1196 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1198 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1200 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1202 return TYPE_FIELD_TYPE (type
, i
);
1206 /* OK, it's not in this class. Recursively check the baseclasses. */
1207 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1211 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, 1);
1223 target_terminal_ours ();
1224 gdb_flush (gdb_stdout
);
1225 fprintf_unfiltered (gdb_stderr
, "Type ");
1226 type_print (type
, "", gdb_stderr
, -1);
1227 fprintf_unfiltered (gdb_stderr
, " has no component named ");
1228 fputs_filtered (name
, gdb_stderr
);
1230 return (struct type
*) -1; /* For lint */
1233 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
1234 valid. Callers should be aware that in some cases (for example,
1235 the type or one of its baseclasses is a stub type and we are
1236 debugging a .o file), this function will not be able to find the virtual
1237 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
1238 will remain NULL. */
1241 fill_in_vptr_fieldno (struct type
*type
)
1243 CHECK_TYPEDEF (type
);
1245 if (TYPE_VPTR_FIELDNO (type
) < 0)
1249 /* We must start at zero in case the first (and only) baseclass is
1250 virtual (and hence we cannot share the table pointer). */
1251 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1253 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1254 fill_in_vptr_fieldno (baseclass
);
1255 if (TYPE_VPTR_FIELDNO (baseclass
) >= 0)
1257 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (baseclass
);
1258 TYPE_VPTR_BASETYPE (type
) = TYPE_VPTR_BASETYPE (baseclass
);
1265 /* Find the method and field indices for the destructor in class type T.
1266 Return 1 if the destructor was found, otherwise, return 0. */
1269 get_destructor_fn_field (struct type
*t
, int *method_indexp
, int *field_indexp
)
1273 for (i
= 0; i
< TYPE_NFN_FIELDS (t
); i
++)
1276 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1278 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (t
, i
); j
++)
1280 if (is_destructor_name (TYPE_FN_FIELD_PHYSNAME (f
, j
)) != 0)
1292 stub_noname_complaint (void)
1294 complaint (&symfile_complaints
, _("stub type has NULL name"));
1297 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1299 If this is a stubbed struct (i.e. declared as struct foo *), see if
1300 we can find a full definition in some other file. If so, copy this
1301 definition, so we can use it in future. There used to be a comment (but
1302 not any code) that if we don't find a full definition, we'd set a flag
1303 so we don't spend time in the future checking the same type. That would
1304 be a mistake, though--we might load in more symbols which contain a
1305 full definition for the type.
1307 This used to be coded as a macro, but I don't think it is called
1308 often enough to merit such treatment. */
1310 /* Find the real type of TYPE. This function returns the real type, after
1311 removing all layers of typedefs and completing opaque or stub types.
1312 Completion changes the TYPE argument, but stripping of typedefs does
1316 check_typedef (struct type
*type
)
1318 struct type
*orig_type
= type
;
1319 int is_const
, is_volatile
;
1321 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1323 if (!TYPE_TARGET_TYPE (type
))
1328 /* It is dangerous to call lookup_symbol if we are currently
1329 reading a symtab. Infinite recursion is one danger. */
1330 if (currently_reading_symtab
)
1333 name
= type_name_no_tag (type
);
1334 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1335 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1336 as appropriate? (this code was written before TYPE_NAME and
1337 TYPE_TAG_NAME were separate). */
1340 stub_noname_complaint ();
1343 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0,
1344 (struct symtab
**) NULL
);
1346 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1348 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
); /* TYPE_CODE_UNDEF */
1350 type
= TYPE_TARGET_TYPE (type
);
1353 is_const
= TYPE_CONST (type
);
1354 is_volatile
= TYPE_VOLATILE (type
);
1356 /* If this is a struct/class/union with no fields, then check whether a
1357 full definition exists somewhere else. This is for systems where a
1358 type definition with no fields is issued for such types, instead of
1359 identifying them as stub types in the first place */
1361 if (TYPE_IS_OPAQUE (type
) && opaque_type_resolution
&& !currently_reading_symtab
)
1363 char *name
= type_name_no_tag (type
);
1364 struct type
*newtype
;
1367 stub_noname_complaint ();
1370 newtype
= lookup_transparent_type (name
);
1374 /* If the resolved type and the stub are in the same objfile,
1375 then replace the stub type with the real deal. But if
1376 they're in separate objfiles, leave the stub alone; we'll
1377 just look up the transparent type every time we call
1378 check_typedef. We can't create pointers between types
1379 allocated to different objfiles, since they may have
1380 different lifetimes. Trying to copy NEWTYPE over to TYPE's
1381 objfile is pointless, too, since you'll have to move over any
1382 other types NEWTYPE refers to, which could be an unbounded
1384 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
1385 make_cv_type (is_const
, is_volatile
, newtype
, &type
);
1390 /* Otherwise, rely on the stub flag being set for opaque/stubbed types */
1391 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1393 char *name
= type_name_no_tag (type
);
1394 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1395 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1396 as appropriate? (this code was written before TYPE_NAME and
1397 TYPE_TAG_NAME were separate). */
1401 stub_noname_complaint ();
1404 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0, (struct symtab
**) NULL
);
1407 /* Same as above for opaque types, we can replace the stub
1408 with the complete type only if they are int the same
1410 if (TYPE_OBJFILE (SYMBOL_TYPE(sym
)) == TYPE_OBJFILE (type
))
1411 make_cv_type (is_const
, is_volatile
, SYMBOL_TYPE (sym
), &type
);
1413 type
= SYMBOL_TYPE (sym
);
1417 if (TYPE_TARGET_STUB (type
))
1419 struct type
*range_type
;
1420 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1422 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1425 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1426 && TYPE_NFIELDS (type
) == 1
1427 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
1428 == TYPE_CODE_RANGE
))
1430 /* Now recompute the length of the array type, based on its
1431 number of elements and the target type's length. */
1432 TYPE_LENGTH (type
) =
1433 ((TYPE_FIELD_BITPOS (range_type
, 1)
1434 - TYPE_FIELD_BITPOS (range_type
, 0)
1436 * TYPE_LENGTH (target_type
));
1437 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1439 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1441 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1442 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1445 /* Cache TYPE_LENGTH for future use. */
1446 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1450 /* Parse a type expression in the string [P..P+LENGTH). If an error occurs,
1451 silently return builtin_type_void. */
1453 static struct type
*
1454 safe_parse_type (char *p
, int length
)
1456 struct ui_file
*saved_gdb_stderr
;
1459 /* Suppress error messages. */
1460 saved_gdb_stderr
= gdb_stderr
;
1461 gdb_stderr
= ui_file_new ();
1463 /* Call parse_and_eval_type() without fear of longjmp()s. */
1464 if (!gdb_parse_and_eval_type (p
, length
, &type
))
1465 type
= builtin_type_void
;
1467 /* Stop suppressing error messages. */
1468 ui_file_delete (gdb_stderr
);
1469 gdb_stderr
= saved_gdb_stderr
;
1474 /* Ugly hack to convert method stubs into method types.
1476 He ain't kiddin'. This demangles the name of the method into a string
1477 including argument types, parses out each argument type, generates
1478 a string casting a zero to that type, evaluates the string, and stuffs
1479 the resulting type into an argtype vector!!! Then it knows the type
1480 of the whole function (including argument types for overloading),
1481 which info used to be in the stab's but was removed to hack back
1482 the space required for them. */
1485 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1488 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1489 char *demangled_name
= cplus_demangle (mangled_name
,
1490 DMGL_PARAMS
| DMGL_ANSI
);
1491 char *argtypetext
, *p
;
1492 int depth
= 0, argcount
= 1;
1493 struct field
*argtypes
;
1496 /* Make sure we got back a function string that we can use. */
1498 p
= strchr (demangled_name
, '(');
1502 if (demangled_name
== NULL
|| p
== NULL
)
1503 error (_("Internal: Cannot demangle mangled name `%s'."), mangled_name
);
1505 /* Now, read in the parameters that define this type. */
1510 if (*p
== '(' || *p
== '<')
1514 else if (*p
== ')' || *p
== '>')
1518 else if (*p
== ',' && depth
== 0)
1526 /* If we read one argument and it was ``void'', don't count it. */
1527 if (strncmp (argtypetext
, "(void)", 6) == 0)
1530 /* We need one extra slot, for the THIS pointer. */
1532 argtypes
= (struct field
*)
1533 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
1536 /* Add THIS pointer for non-static methods. */
1537 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1538 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
1542 argtypes
[0].type
= lookup_pointer_type (type
);
1546 if (*p
!= ')') /* () means no args, skip while */
1551 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1553 /* Avoid parsing of ellipsis, they will be handled below.
1554 Also avoid ``void'' as above. */
1555 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
1556 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
1558 argtypes
[argcount
].type
=
1559 safe_parse_type (argtypetext
, p
- argtypetext
);
1562 argtypetext
= p
+ 1;
1565 if (*p
== '(' || *p
== '<')
1569 else if (*p
== ')' || *p
== '>')
1578 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1580 /* Now update the old "stub" type into a real type. */
1581 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1582 TYPE_DOMAIN_TYPE (mtype
) = type
;
1583 TYPE_FIELDS (mtype
) = argtypes
;
1584 TYPE_NFIELDS (mtype
) = argcount
;
1585 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1586 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1588 TYPE_FLAGS (mtype
) |= TYPE_FLAG_VARARGS
;
1590 xfree (demangled_name
);
1593 /* This is the external interface to check_stub_method, above. This function
1594 unstubs all of the signatures for TYPE's METHOD_ID method name. After
1595 calling this function TYPE_FN_FIELD_STUB will be cleared for each signature
1596 and TYPE_FN_FIELDLIST_NAME will be correct.
1598 This function unfortunately can not die until stabs do. */
1601 check_stub_method_group (struct type
*type
, int method_id
)
1603 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
1604 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1605 int j
, found_stub
= 0;
1607 for (j
= 0; j
< len
; j
++)
1608 if (TYPE_FN_FIELD_STUB (f
, j
))
1611 check_stub_method (type
, method_id
, j
);
1614 /* GNU v3 methods with incorrect names were corrected when we read in
1615 type information, because it was cheaper to do it then. The only GNU v2
1616 methods with incorrect method names are operators and destructors;
1617 destructors were also corrected when we read in type information.
1619 Therefore the only thing we need to handle here are v2 operator
1621 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
1624 char dem_opname
[256];
1626 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
, method_id
),
1627 dem_opname
, DMGL_ANSI
);
1629 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
, method_id
),
1632 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
1636 const struct cplus_struct_type cplus_struct_default
;
1639 allocate_cplus_struct_type (struct type
*type
)
1641 if (!HAVE_CPLUS_STRUCT (type
))
1643 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1644 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1645 *(TYPE_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1649 /* Helper function to initialize the standard scalar types.
1651 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1652 of the string pointed to by name in the objfile_obstack for that objfile,
1653 and initialize the type name to that copy. There are places (mipsread.c
1654 in particular, where init_type is called with a NULL value for NAME). */
1657 init_type (enum type_code code
, int length
, int flags
, char *name
,
1658 struct objfile
*objfile
)
1662 type
= alloc_type (objfile
);
1663 TYPE_CODE (type
) = code
;
1664 TYPE_LENGTH (type
) = length
;
1665 TYPE_FLAGS (type
) |= flags
;
1666 if ((name
!= NULL
) && (objfile
!= NULL
))
1669 obsavestring (name
, strlen (name
), &objfile
->objfile_obstack
);
1673 TYPE_NAME (type
) = name
;
1678 if (name
&& strcmp (name
, "char") == 0)
1679 TYPE_FLAGS (type
) |= TYPE_FLAG_NOSIGN
;
1681 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
1682 || code
== TYPE_CODE_NAMESPACE
)
1684 INIT_CPLUS_SPECIFIC (type
);
1689 /* Helper function. Create an empty composite type. */
1692 init_composite_type (char *name
, enum type_code code
)
1695 gdb_assert (code
== TYPE_CODE_STRUCT
1696 || code
== TYPE_CODE_UNION
);
1697 t
= init_type (code
, 0, 0, NULL
, NULL
);
1698 TYPE_TAG_NAME (t
) = name
;
1702 /* Helper function. Append a field to a composite type. */
1705 append_composite_type_field (struct type
*t
, char *name
, struct type
*field
)
1708 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
1709 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
1710 sizeof (struct field
) * TYPE_NFIELDS (t
));
1711 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
1712 memset (f
, 0, sizeof f
[0]);
1713 FIELD_TYPE (f
[0]) = field
;
1714 FIELD_NAME (f
[0]) = name
;
1715 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1717 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
1718 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
1720 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
1722 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
1723 if (TYPE_NFIELDS (t
) > 1)
1725 FIELD_BITPOS (f
[0]) = (FIELD_BITPOS (f
[-1])
1726 + TYPE_LENGTH (field
) * TARGET_CHAR_BIT
);
1731 /* Look up a fundamental type for the specified objfile.
1732 May need to construct such a type if this is the first use.
1734 Some object file formats (ELF, COFF, etc) do not define fundamental
1735 types such as "int" or "double". Others (stabs for example), do
1736 define fundamental types.
1738 For the formats which don't provide fundamental types, gdb can create
1739 such types, using defaults reasonable for the current language and
1740 the current target machine.
1742 NOTE: This routine is obsolescent. Each debugging format reader
1743 should manage it's own fundamental types, either creating them from
1744 suitable defaults or reading them from the debugging information,
1745 whichever is appropriate. The DWARF reader has already been
1746 fixed to do this. Once the other readers are fixed, this routine
1747 will go away. Also note that fundamental types should be managed
1748 on a compilation unit basis in a multi-language environment, not
1749 on a linkage unit basis as is done here. */
1753 lookup_fundamental_type (struct objfile
*objfile
, int typeid)
1755 struct type
**typep
;
1758 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1760 error (_("internal error - invalid fundamental type id %d"), typeid);
1763 /* If this is the first time we need a fundamental type for this objfile
1764 then we need to initialize the vector of type pointers. */
1766 if (objfile
->fundamental_types
== NULL
)
1768 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1769 objfile
->fundamental_types
= (struct type
**)
1770 obstack_alloc (&objfile
->objfile_obstack
, nbytes
);
1771 memset ((char *) objfile
->fundamental_types
, 0, nbytes
);
1772 OBJSTAT (objfile
, n_types
+= FT_NUM_MEMBERS
);
1775 /* Look for this particular type in the fundamental type vector. If one is
1776 not found, create and install one appropriate for the current language. */
1778 typep
= objfile
->fundamental_types
+ typeid;
1781 *typep
= create_fundamental_type (objfile
, typeid);
1788 can_dereference (struct type
*t
)
1790 /* FIXME: Should we return true for references as well as pointers? */
1794 && TYPE_CODE (t
) == TYPE_CODE_PTR
1795 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1799 is_integral_type (struct type
*t
)
1804 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
1805 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
1806 || (TYPE_CODE (t
) == TYPE_CODE_FLAGS
)
1807 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
1808 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
1809 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
1812 /* Check whether BASE is an ancestor or base class or DCLASS
1813 Return 1 if so, and 0 if not.
1814 Note: callers may want to check for identity of the types before
1815 calling this function -- identical types are considered to satisfy
1816 the ancestor relationship even if they're identical */
1819 is_ancestor (struct type
*base
, struct type
*dclass
)
1823 CHECK_TYPEDEF (base
);
1824 CHECK_TYPEDEF (dclass
);
1828 if (TYPE_NAME (base
) && TYPE_NAME (dclass
) &&
1829 !strcmp (TYPE_NAME (base
), TYPE_NAME (dclass
)))
1832 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1833 if (is_ancestor (base
, TYPE_BASECLASS (dclass
, i
)))
1841 /* See whether DCLASS has a virtual table. This routine is aimed at
1842 the HP/Taligent ANSI C++ runtime model, and may not work with other
1843 runtime models. Return 1 => Yes, 0 => No. */
1846 has_vtable (struct type
*dclass
)
1848 /* In the HP ANSI C++ runtime model, a class has a vtable only if it
1849 has virtual functions or virtual bases. */
1853 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1856 /* First check for the presence of virtual bases */
1857 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
1858 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1859 if (B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
))
1862 /* Next check for virtual functions */
1863 if (TYPE_FN_FIELDLISTS (dclass
))
1864 for (i
= 0; i
< TYPE_NFN_FIELDS (dclass
); i
++)
1865 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, i
), 0))
1868 /* Recurse on non-virtual bases to see if any of them needs a vtable */
1869 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
1870 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1871 if ((!B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
)) &&
1872 (has_vtable (TYPE_FIELD_TYPE (dclass
, i
))))
1875 /* Well, maybe we don't need a virtual table */
1879 /* Return a pointer to the "primary base class" of DCLASS.
1881 A NULL return indicates that DCLASS has no primary base, or that it
1882 couldn't be found (insufficient information).
1884 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
1885 and may not work with other runtime models. */
1888 primary_base_class (struct type
*dclass
)
1890 /* In HP ANSI C++'s runtime model, a "primary base class" of a class
1891 is the first directly inherited, non-virtual base class that
1892 requires a virtual table */
1896 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1899 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1900 if (!TYPE_FIELD_VIRTUAL (dclass
, i
) &&
1901 has_vtable (TYPE_FIELD_TYPE (dclass
, i
)))
1902 return TYPE_FIELD_TYPE (dclass
, i
);
1907 /* Global manipulated by virtual_base_list[_aux]() */
1909 static struct vbase
*current_vbase_list
= NULL
;
1911 /* Return a pointer to a null-terminated list of struct vbase
1912 items. The vbasetype pointer of each item in the list points to the
1913 type information for a virtual base of the argument DCLASS.
1915 Helper function for virtual_base_list().
1916 Note: the list goes backward, right-to-left. virtual_base_list()
1917 copies the items out in reverse order. */
1920 virtual_base_list_aux (struct type
*dclass
)
1922 struct vbase
*tmp_vbase
;
1925 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1928 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1930 /* Recurse on this ancestor, first */
1931 virtual_base_list_aux (TYPE_FIELD_TYPE (dclass
, i
));
1933 /* If this current base is itself virtual, add it to the list */
1934 if (BASETYPE_VIA_VIRTUAL (dclass
, i
))
1936 struct type
*basetype
= TYPE_FIELD_TYPE (dclass
, i
);
1938 /* Check if base already recorded */
1939 tmp_vbase
= current_vbase_list
;
1942 if (tmp_vbase
->vbasetype
== basetype
)
1943 break; /* found it */
1944 tmp_vbase
= tmp_vbase
->next
;
1947 if (!tmp_vbase
) /* normal exit from loop */
1949 /* Allocate new item for this virtual base */
1950 tmp_vbase
= (struct vbase
*) xmalloc (sizeof (struct vbase
));
1952 /* Stick it on at the end of the list */
1953 tmp_vbase
->vbasetype
= basetype
;
1954 tmp_vbase
->next
= current_vbase_list
;
1955 current_vbase_list
= tmp_vbase
;
1958 } /* for loop over bases */
1962 /* Compute the list of virtual bases in the right order. Virtual
1963 bases are laid out in the object's memory area in order of their
1964 occurrence in a depth-first, left-to-right search through the
1967 Argument DCLASS is the type whose virtual bases are required.
1968 Return value is the address of a null-terminated array of pointers
1969 to struct type items.
1971 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
1972 and may not work with other runtime models.
1974 This routine merely hands off the argument to virtual_base_list_aux()
1975 and then copies the result into an array to save space. */
1978 virtual_base_list (struct type
*dclass
)
1980 struct vbase
*tmp_vbase
;
1981 struct vbase
*tmp_vbase_2
;
1984 struct type
**vbase_array
;
1986 current_vbase_list
= NULL
;
1987 virtual_base_list_aux (dclass
);
1989 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
1994 vbase_array
= (struct type
**) xmalloc ((count
+ 1) * sizeof (struct type
*));
1996 for (i
= count
- 1, tmp_vbase
= current_vbase_list
; i
>= 0; i
--, tmp_vbase
= tmp_vbase
->next
)
1997 vbase_array
[i
] = tmp_vbase
->vbasetype
;
1999 /* Get rid of constructed chain */
2000 tmp_vbase_2
= tmp_vbase
= current_vbase_list
;
2003 tmp_vbase
= tmp_vbase
->next
;
2004 xfree (tmp_vbase_2
);
2005 tmp_vbase_2
= tmp_vbase
;
2008 vbase_array
[count
] = NULL
;
2012 /* Return the length of the virtual base list of the type DCLASS. */
2015 virtual_base_list_length (struct type
*dclass
)
2018 struct vbase
*tmp_vbase
;
2020 current_vbase_list
= NULL
;
2021 virtual_base_list_aux (dclass
);
2023 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
2028 /* Return the number of elements of the virtual base list of the type
2029 DCLASS, ignoring those appearing in the primary base (and its
2030 primary base, recursively). */
2033 virtual_base_list_length_skip_primaries (struct type
*dclass
)
2036 struct vbase
*tmp_vbase
;
2037 struct type
*primary
;
2039 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
2042 return virtual_base_list_length (dclass
);
2044 current_vbase_list
= NULL
;
2045 virtual_base_list_aux (dclass
);
2047 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; tmp_vbase
= tmp_vbase
->next
)
2049 if (virtual_base_index (tmp_vbase
->vbasetype
, primary
) >= 0)
2057 /* Return the index (position) of type BASE, which is a virtual base
2058 class of DCLASS, in the latter's virtual base list. A return of -1
2059 indicates "not found" or a problem. */
2062 virtual_base_index (struct type
*base
, struct type
*dclass
)
2067 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
2068 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
2072 vbase
= virtual_base_list (dclass
)[0];
2077 vbase
= virtual_base_list (dclass
)[++i
];
2080 return vbase
? i
: -1;
2085 /* Return the index (position) of type BASE, which is a virtual base
2086 class of DCLASS, in the latter's virtual base list. Skip over all
2087 bases that may appear in the virtual base list of the primary base
2088 class of DCLASS (recursively). A return of -1 indicates "not
2089 found" or a problem. */
2092 virtual_base_index_skip_primaries (struct type
*base
, struct type
*dclass
)
2096 struct type
*primary
;
2098 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
2099 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
2102 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
2106 vbase
= virtual_base_list (dclass
)[0];
2109 if (!primary
|| (virtual_base_index_skip_primaries (vbase
, primary
) < 0))
2113 vbase
= virtual_base_list (dclass
)[++i
];
2116 return vbase
? j
: -1;
2119 /* Return position of a derived class DCLASS in the list of
2120 * primary bases starting with the remotest ancestor.
2121 * Position returned is 0-based. */
2124 class_index_in_primary_list (struct type
*dclass
)
2126 struct type
*pbc
; /* primary base class */
2128 /* Simply recurse on primary base */
2129 pbc
= TYPE_PRIMARY_BASE (dclass
);
2131 return 1 + class_index_in_primary_list (pbc
);
2136 /* Return a count of the number of virtual functions a type has.
2137 * This includes all the virtual functions it inherits from its
2141 /* pai: FIXME This doesn't do the right thing: count redefined virtual
2142 * functions only once (latest redefinition)
2146 count_virtual_fns (struct type
*dclass
)
2148 int fn
, oi
; /* function and overloaded instance indices */
2149 int vfuncs
; /* count to return */
2151 /* recurse on bases that can share virtual table */
2152 struct type
*pbc
= primary_base_class (dclass
);
2154 vfuncs
= count_virtual_fns (pbc
);
2158 for (fn
= 0; fn
< TYPE_NFN_FIELDS (dclass
); fn
++)
2159 for (oi
= 0; oi
< TYPE_FN_FIELDLIST_LENGTH (dclass
, fn
); oi
++)
2160 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, fn
), oi
))
2168 /* Functions for overload resolution begin here */
2170 /* Compare two badness vectors A and B and return the result.
2171 * 0 => A and B are identical
2172 * 1 => A and B are incomparable
2173 * 2 => A is better than B
2174 * 3 => A is worse than B */
2177 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
2181 short found_pos
= 0; /* any positives in c? */
2182 short found_neg
= 0; /* any negatives in c? */
2184 /* differing lengths => incomparable */
2185 if (a
->length
!= b
->length
)
2188 /* Subtract b from a */
2189 for (i
= 0; i
< a
->length
; i
++)
2191 tmp
= a
->rank
[i
] - b
->rank
[i
];
2201 return 1; /* incomparable */
2203 return 3; /* A > B */
2209 return 2; /* A < B */
2211 return 0; /* A == B */
2215 /* Rank a function by comparing its parameter types (PARMS, length NPARMS),
2216 * to the types of an argument list (ARGS, length NARGS).
2217 * Return a pointer to a badness vector. This has NARGS + 1 entries. */
2219 struct badness_vector
*
2220 rank_function (struct type
**parms
, int nparms
, struct type
**args
, int nargs
)
2223 struct badness_vector
*bv
;
2224 int min_len
= nparms
< nargs
? nparms
: nargs
;
2226 bv
= xmalloc (sizeof (struct badness_vector
));
2227 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank */
2228 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
2230 /* First compare the lengths of the supplied lists.
2231 * If there is a mismatch, set it to a high value. */
2233 /* pai/1997-06-03 FIXME: when we have debug info about default
2234 * arguments and ellipsis parameter lists, we should consider those
2235 * and rank the length-match more finely. */
2237 LENGTH_MATCH (bv
) = (nargs
!= nparms
) ? LENGTH_MISMATCH_BADNESS
: 0;
2239 /* Now rank all the parameters of the candidate function */
2240 for (i
= 1; i
<= min_len
; i
++)
2241 bv
->rank
[i
] = rank_one_type (parms
[i
-1], args
[i
-1]);
2243 /* If more arguments than parameters, add dummy entries */
2244 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2245 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2250 /* Compare the names of two integer types, assuming that any sign
2251 qualifiers have been checked already. We do it this way because
2252 there may be an "int" in the name of one of the types. */
2255 integer_types_same_name_p (const char *first
, const char *second
)
2257 int first_p
, second_p
;
2259 /* If both are shorts, return 1; if neither is a short, keep checking. */
2260 first_p
= (strstr (first
, "short") != NULL
);
2261 second_p
= (strstr (second
, "short") != NULL
);
2262 if (first_p
&& second_p
)
2264 if (first_p
|| second_p
)
2267 /* Likewise for long. */
2268 first_p
= (strstr (first
, "long") != NULL
);
2269 second_p
= (strstr (second
, "long") != NULL
);
2270 if (first_p
&& second_p
)
2272 if (first_p
|| second_p
)
2275 /* Likewise for char. */
2276 first_p
= (strstr (first
, "char") != NULL
);
2277 second_p
= (strstr (second
, "char") != NULL
);
2278 if (first_p
&& second_p
)
2280 if (first_p
|| second_p
)
2283 /* They must both be ints. */
2287 /* Compare one type (PARM) for compatibility with another (ARG).
2288 * PARM is intended to be the parameter type of a function; and
2289 * ARG is the supplied argument's type. This function tests if
2290 * the latter can be converted to the former.
2292 * Return 0 if they are identical types;
2293 * Otherwise, return an integer which corresponds to how compatible
2294 * PARM is to ARG. The higher the return value, the worse the match.
2295 * Generally the "bad" conversions are all uniformly assigned a 100 */
2298 rank_one_type (struct type
*parm
, struct type
*arg
)
2300 /* Identical type pointers */
2301 /* However, this still doesn't catch all cases of same type for arg
2302 * and param. The reason is that builtin types are different from
2303 * the same ones constructed from the object. */
2307 /* Resolve typedefs */
2308 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2309 parm
= check_typedef (parm
);
2310 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2311 arg
= check_typedef (arg
);
2314 Well, damnit, if the names are exactly the same,
2315 i'll say they are exactly the same. This happens when we generate
2316 method stubs. The types won't point to the same address, but they
2317 really are the same.
2320 if (TYPE_NAME (parm
) && TYPE_NAME (arg
) &&
2321 !strcmp (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2324 /* Check if identical after resolving typedefs */
2328 /* See through references, since we can almost make non-references
2330 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2331 return (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
))
2332 + REFERENCE_CONVERSION_BADNESS
);
2333 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2334 return (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
)
2335 + REFERENCE_CONVERSION_BADNESS
);
2337 /* Debugging only. */
2338 fprintf_filtered (gdb_stderr
,"------ Arg is %s [%d], parm is %s [%d]\n",
2339 TYPE_NAME (arg
), TYPE_CODE (arg
), TYPE_NAME (parm
), TYPE_CODE (parm
));
2341 /* x -> y means arg of type x being supplied for parameter of type y */
2343 switch (TYPE_CODE (parm
))
2346 switch (TYPE_CODE (arg
))
2349 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2350 return VOID_PTR_CONVERSION_BADNESS
;
2352 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2353 case TYPE_CODE_ARRAY
:
2354 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2355 case TYPE_CODE_FUNC
:
2356 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
);
2358 case TYPE_CODE_ENUM
:
2359 case TYPE_CODE_FLAGS
:
2360 case TYPE_CODE_CHAR
:
2361 case TYPE_CODE_RANGE
:
2362 case TYPE_CODE_BOOL
:
2363 return POINTER_CONVERSION_BADNESS
;
2365 return INCOMPATIBLE_TYPE_BADNESS
;
2367 case TYPE_CODE_ARRAY
:
2368 switch (TYPE_CODE (arg
))
2371 case TYPE_CODE_ARRAY
:
2372 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2374 return INCOMPATIBLE_TYPE_BADNESS
;
2376 case TYPE_CODE_FUNC
:
2377 switch (TYPE_CODE (arg
))
2379 case TYPE_CODE_PTR
: /* funcptr -> func */
2380 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
));
2382 return INCOMPATIBLE_TYPE_BADNESS
;
2385 switch (TYPE_CODE (arg
))
2388 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2390 /* Deal with signed, unsigned, and plain chars and
2391 signed and unsigned ints */
2392 if (TYPE_NOSIGN (parm
))
2394 /* This case only for character types */
2395 if (TYPE_NOSIGN (arg
)) /* plain char -> plain char */
2398 return INTEGER_CONVERSION_BADNESS
; /* signed/unsigned char -> plain char */
2400 else if (TYPE_UNSIGNED (parm
))
2402 if (TYPE_UNSIGNED (arg
))
2404 /* unsigned int -> unsigned int, or unsigned long -> unsigned long */
2405 if (integer_types_same_name_p (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2407 else if (integer_types_same_name_p (TYPE_NAME (arg
), "int")
2408 && integer_types_same_name_p (TYPE_NAME (parm
), "long"))
2409 return INTEGER_PROMOTION_BADNESS
; /* unsigned int -> unsigned long */
2411 return INTEGER_CONVERSION_BADNESS
; /* unsigned long -> unsigned int */
2415 if (integer_types_same_name_p (TYPE_NAME (arg
), "long")
2416 && integer_types_same_name_p (TYPE_NAME (parm
), "int"))
2417 return INTEGER_CONVERSION_BADNESS
; /* signed long -> unsigned int */
2419 return INTEGER_CONVERSION_BADNESS
; /* signed int/long -> unsigned int/long */
2422 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2424 if (integer_types_same_name_p (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2426 else if (integer_types_same_name_p (TYPE_NAME (arg
), "int")
2427 && integer_types_same_name_p (TYPE_NAME (parm
), "long"))
2428 return INTEGER_PROMOTION_BADNESS
;
2430 return INTEGER_CONVERSION_BADNESS
;
2433 return INTEGER_CONVERSION_BADNESS
;
2435 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2436 return INTEGER_PROMOTION_BADNESS
;
2438 return INTEGER_CONVERSION_BADNESS
;
2439 case TYPE_CODE_ENUM
:
2440 case TYPE_CODE_FLAGS
:
2441 case TYPE_CODE_CHAR
:
2442 case TYPE_CODE_RANGE
:
2443 case TYPE_CODE_BOOL
:
2444 return INTEGER_PROMOTION_BADNESS
;
2446 return INT_FLOAT_CONVERSION_BADNESS
;
2448 return NS_POINTER_CONVERSION_BADNESS
;
2450 return INCOMPATIBLE_TYPE_BADNESS
;
2453 case TYPE_CODE_ENUM
:
2454 switch (TYPE_CODE (arg
))
2457 case TYPE_CODE_CHAR
:
2458 case TYPE_CODE_RANGE
:
2459 case TYPE_CODE_BOOL
:
2460 case TYPE_CODE_ENUM
:
2461 return INTEGER_CONVERSION_BADNESS
;
2463 return INT_FLOAT_CONVERSION_BADNESS
;
2465 return INCOMPATIBLE_TYPE_BADNESS
;
2468 case TYPE_CODE_CHAR
:
2469 switch (TYPE_CODE (arg
))
2471 case TYPE_CODE_RANGE
:
2472 case TYPE_CODE_BOOL
:
2473 case TYPE_CODE_ENUM
:
2474 return INTEGER_CONVERSION_BADNESS
;
2476 return INT_FLOAT_CONVERSION_BADNESS
;
2478 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2479 return INTEGER_CONVERSION_BADNESS
;
2480 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2481 return INTEGER_PROMOTION_BADNESS
;
2482 /* >>> !! else fall through !! <<< */
2483 case TYPE_CODE_CHAR
:
2484 /* Deal with signed, unsigned, and plain chars for C++
2485 and with int cases falling through from previous case */
2486 if (TYPE_NOSIGN (parm
))
2488 if (TYPE_NOSIGN (arg
))
2491 return INTEGER_CONVERSION_BADNESS
;
2493 else if (TYPE_UNSIGNED (parm
))
2495 if (TYPE_UNSIGNED (arg
))
2498 return INTEGER_PROMOTION_BADNESS
;
2500 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2503 return INTEGER_CONVERSION_BADNESS
;
2505 return INCOMPATIBLE_TYPE_BADNESS
;
2508 case TYPE_CODE_RANGE
:
2509 switch (TYPE_CODE (arg
))
2512 case TYPE_CODE_CHAR
:
2513 case TYPE_CODE_RANGE
:
2514 case TYPE_CODE_BOOL
:
2515 case TYPE_CODE_ENUM
:
2516 return INTEGER_CONVERSION_BADNESS
;
2518 return INT_FLOAT_CONVERSION_BADNESS
;
2520 return INCOMPATIBLE_TYPE_BADNESS
;
2523 case TYPE_CODE_BOOL
:
2524 switch (TYPE_CODE (arg
))
2527 case TYPE_CODE_CHAR
:
2528 case TYPE_CODE_RANGE
:
2529 case TYPE_CODE_ENUM
:
2532 return BOOLEAN_CONVERSION_BADNESS
;
2533 case TYPE_CODE_BOOL
:
2536 return INCOMPATIBLE_TYPE_BADNESS
;
2540 switch (TYPE_CODE (arg
))
2543 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2544 return FLOAT_PROMOTION_BADNESS
;
2545 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2548 return FLOAT_CONVERSION_BADNESS
;
2550 case TYPE_CODE_BOOL
:
2551 case TYPE_CODE_ENUM
:
2552 case TYPE_CODE_RANGE
:
2553 case TYPE_CODE_CHAR
:
2554 return INT_FLOAT_CONVERSION_BADNESS
;
2556 return INCOMPATIBLE_TYPE_BADNESS
;
2559 case TYPE_CODE_COMPLEX
:
2560 switch (TYPE_CODE (arg
))
2561 { /* Strictly not needed for C++, but... */
2563 return FLOAT_PROMOTION_BADNESS
;
2564 case TYPE_CODE_COMPLEX
:
2567 return INCOMPATIBLE_TYPE_BADNESS
;
2570 case TYPE_CODE_STRUCT
:
2571 /* currently same as TYPE_CODE_CLASS */
2572 switch (TYPE_CODE (arg
))
2574 case TYPE_CODE_STRUCT
:
2575 /* Check for derivation */
2576 if (is_ancestor (parm
, arg
))
2577 return BASE_CONVERSION_BADNESS
;
2578 /* else fall through */
2580 return INCOMPATIBLE_TYPE_BADNESS
;
2583 case TYPE_CODE_UNION
:
2584 switch (TYPE_CODE (arg
))
2586 case TYPE_CODE_UNION
:
2588 return INCOMPATIBLE_TYPE_BADNESS
;
2591 case TYPE_CODE_MEMBERPTR
:
2592 switch (TYPE_CODE (arg
))
2595 return INCOMPATIBLE_TYPE_BADNESS
;
2598 case TYPE_CODE_METHOD
:
2599 switch (TYPE_CODE (arg
))
2603 return INCOMPATIBLE_TYPE_BADNESS
;
2607 switch (TYPE_CODE (arg
))
2611 return INCOMPATIBLE_TYPE_BADNESS
;
2616 switch (TYPE_CODE (arg
))
2620 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0), TYPE_FIELD_TYPE (arg
, 0));
2622 return INCOMPATIBLE_TYPE_BADNESS
;
2625 case TYPE_CODE_VOID
:
2627 return INCOMPATIBLE_TYPE_BADNESS
;
2628 } /* switch (TYPE_CODE (arg)) */
2632 /* End of functions for overload resolution */
2635 print_bit_vector (B_TYPE
*bits
, int nbits
)
2639 for (bitno
= 0; bitno
< nbits
; bitno
++)
2641 if ((bitno
% 8) == 0)
2643 puts_filtered (" ");
2645 if (B_TST (bits
, bitno
))
2646 printf_filtered (("1"));
2648 printf_filtered (("0"));
2652 /* Note the first arg should be the "this" pointer, we may not want to
2653 include it since we may get into a infinitely recursive situation. */
2656 print_arg_types (struct field
*args
, int nargs
, int spaces
)
2662 for (i
= 0; i
< nargs
; i
++)
2663 recursive_dump_type (args
[i
].type
, spaces
+ 2);
2668 dump_fn_fieldlists (struct type
*type
, int spaces
)
2674 printfi_filtered (spaces
, "fn_fieldlists ");
2675 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2676 printf_filtered ("\n");
2677 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2679 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2680 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2682 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2683 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2685 printf_filtered (_(") length %d\n"),
2686 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2687 for (overload_idx
= 0;
2688 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2691 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2693 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2694 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2696 printf_filtered (")\n");
2697 printfi_filtered (spaces
+ 8, "type ");
2698 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
2699 printf_filtered ("\n");
2701 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2704 printfi_filtered (spaces
+ 8, "args ");
2705 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
2706 printf_filtered ("\n");
2708 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2709 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
, overload_idx
)),
2711 printfi_filtered (spaces
+ 8, "fcontext ");
2712 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2714 printf_filtered ("\n");
2716 printfi_filtered (spaces
+ 8, "is_const %d\n",
2717 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2718 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2719 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2720 printfi_filtered (spaces
+ 8, "is_private %d\n",
2721 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2722 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2723 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2724 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2725 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2726 printfi_filtered (spaces
+ 8, "voffset %u\n",
2727 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2733 print_cplus_stuff (struct type
*type
, int spaces
)
2735 printfi_filtered (spaces
, "n_baseclasses %d\n",
2736 TYPE_N_BASECLASSES (type
));
2737 printfi_filtered (spaces
, "nfn_fields %d\n",
2738 TYPE_NFN_FIELDS (type
));
2739 printfi_filtered (spaces
, "nfn_fields_total %d\n",
2740 TYPE_NFN_FIELDS_TOTAL (type
));
2741 if (TYPE_N_BASECLASSES (type
) > 0)
2743 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2744 TYPE_N_BASECLASSES (type
));
2745 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
2746 printf_filtered (")");
2748 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2749 TYPE_N_BASECLASSES (type
));
2750 puts_filtered ("\n");
2752 if (TYPE_NFIELDS (type
) > 0)
2754 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2756 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
2757 TYPE_NFIELDS (type
));
2758 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
2759 printf_filtered (")");
2760 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2761 TYPE_NFIELDS (type
));
2762 puts_filtered ("\n");
2764 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2766 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
2767 TYPE_NFIELDS (type
));
2768 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
2769 printf_filtered (")");
2770 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2771 TYPE_NFIELDS (type
));
2772 puts_filtered ("\n");
2775 if (TYPE_NFN_FIELDS (type
) > 0)
2777 dump_fn_fieldlists (type
, spaces
);
2782 print_bound_type (int bt
)
2786 case BOUND_CANNOT_BE_DETERMINED
:
2787 printf_filtered ("(BOUND_CANNOT_BE_DETERMINED)");
2789 case BOUND_BY_REF_ON_STACK
:
2790 printf_filtered ("(BOUND_BY_REF_ON_STACK)");
2792 case BOUND_BY_VALUE_ON_STACK
:
2793 printf_filtered ("(BOUND_BY_VALUE_ON_STACK)");
2795 case BOUND_BY_REF_IN_REG
:
2796 printf_filtered ("(BOUND_BY_REF_IN_REG)");
2798 case BOUND_BY_VALUE_IN_REG
:
2799 printf_filtered ("(BOUND_BY_VALUE_IN_REG)");
2802 printf_filtered ("(BOUND_SIMPLE)");
2805 printf_filtered (_("(unknown bound type)"));
2810 static struct obstack dont_print_type_obstack
;
2813 recursive_dump_type (struct type
*type
, int spaces
)
2818 obstack_begin (&dont_print_type_obstack
, 0);
2820 if (TYPE_NFIELDS (type
) > 0
2821 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
2823 struct type
**first_dont_print
2824 = (struct type
**) obstack_base (&dont_print_type_obstack
);
2826 int i
= (struct type
**) obstack_next_free (&dont_print_type_obstack
)
2831 if (type
== first_dont_print
[i
])
2833 printfi_filtered (spaces
, "type node ");
2834 gdb_print_host_address (type
, gdb_stdout
);
2835 printf_filtered (_(" <same as already seen type>\n"));
2840 obstack_ptr_grow (&dont_print_type_obstack
, type
);
2843 printfi_filtered (spaces
, "type node ");
2844 gdb_print_host_address (type
, gdb_stdout
);
2845 printf_filtered ("\n");
2846 printfi_filtered (spaces
, "name '%s' (",
2847 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
2848 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
2849 printf_filtered (")\n");
2850 printfi_filtered (spaces
, "tagname '%s' (",
2851 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
2852 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
2853 printf_filtered (")\n");
2854 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
2855 switch (TYPE_CODE (type
))
2857 case TYPE_CODE_UNDEF
:
2858 printf_filtered ("(TYPE_CODE_UNDEF)");
2861 printf_filtered ("(TYPE_CODE_PTR)");
2863 case TYPE_CODE_ARRAY
:
2864 printf_filtered ("(TYPE_CODE_ARRAY)");
2866 case TYPE_CODE_STRUCT
:
2867 printf_filtered ("(TYPE_CODE_STRUCT)");
2869 case TYPE_CODE_UNION
:
2870 printf_filtered ("(TYPE_CODE_UNION)");
2872 case TYPE_CODE_ENUM
:
2873 printf_filtered ("(TYPE_CODE_ENUM)");
2875 case TYPE_CODE_FLAGS
:
2876 printf_filtered ("(TYPE_CODE_FLAGS)");
2878 case TYPE_CODE_FUNC
:
2879 printf_filtered ("(TYPE_CODE_FUNC)");
2882 printf_filtered ("(TYPE_CODE_INT)");
2885 printf_filtered ("(TYPE_CODE_FLT)");
2887 case TYPE_CODE_VOID
:
2888 printf_filtered ("(TYPE_CODE_VOID)");
2891 printf_filtered ("(TYPE_CODE_SET)");
2893 case TYPE_CODE_RANGE
:
2894 printf_filtered ("(TYPE_CODE_RANGE)");
2896 case TYPE_CODE_STRING
:
2897 printf_filtered ("(TYPE_CODE_STRING)");
2899 case TYPE_CODE_BITSTRING
:
2900 printf_filtered ("(TYPE_CODE_BITSTRING)");
2902 case TYPE_CODE_ERROR
:
2903 printf_filtered ("(TYPE_CODE_ERROR)");
2905 case TYPE_CODE_MEMBERPTR
:
2906 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
2908 case TYPE_CODE_METHODPTR
:
2909 printf_filtered ("(TYPE_CODE_METHODPTR)");
2911 case TYPE_CODE_METHOD
:
2912 printf_filtered ("(TYPE_CODE_METHOD)");
2915 printf_filtered ("(TYPE_CODE_REF)");
2917 case TYPE_CODE_CHAR
:
2918 printf_filtered ("(TYPE_CODE_CHAR)");
2920 case TYPE_CODE_BOOL
:
2921 printf_filtered ("(TYPE_CODE_BOOL)");
2923 case TYPE_CODE_COMPLEX
:
2924 printf_filtered ("(TYPE_CODE_COMPLEX)");
2926 case TYPE_CODE_TYPEDEF
:
2927 printf_filtered ("(TYPE_CODE_TYPEDEF)");
2929 case TYPE_CODE_TEMPLATE
:
2930 printf_filtered ("(TYPE_CODE_TEMPLATE)");
2932 case TYPE_CODE_TEMPLATE_ARG
:
2933 printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)");
2935 case TYPE_CODE_NAMESPACE
:
2936 printf_filtered ("(TYPE_CODE_NAMESPACE)");
2939 printf_filtered ("(UNKNOWN TYPE CODE)");
2942 puts_filtered ("\n");
2943 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
2944 printfi_filtered (spaces
, "upper_bound_type 0x%x ",
2945 TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
2946 print_bound_type (TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
2947 puts_filtered ("\n");
2948 printfi_filtered (spaces
, "lower_bound_type 0x%x ",
2949 TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
2950 print_bound_type (TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
2951 puts_filtered ("\n");
2952 printfi_filtered (spaces
, "objfile ");
2953 gdb_print_host_address (TYPE_OBJFILE (type
), gdb_stdout
);
2954 printf_filtered ("\n");
2955 printfi_filtered (spaces
, "target_type ");
2956 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
2957 printf_filtered ("\n");
2958 if (TYPE_TARGET_TYPE (type
) != NULL
)
2960 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
2962 printfi_filtered (spaces
, "pointer_type ");
2963 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
2964 printf_filtered ("\n");
2965 printfi_filtered (spaces
, "reference_type ");
2966 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
2967 printf_filtered ("\n");
2968 printfi_filtered (spaces
, "type_chain ");
2969 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
2970 printf_filtered ("\n");
2971 printfi_filtered (spaces
, "instance_flags 0x%x", TYPE_INSTANCE_FLAGS (type
));
2972 if (TYPE_CONST (type
))
2974 puts_filtered (" TYPE_FLAG_CONST");
2976 if (TYPE_VOLATILE (type
))
2978 puts_filtered (" TYPE_FLAG_VOLATILE");
2980 if (TYPE_CODE_SPACE (type
))
2982 puts_filtered (" TYPE_FLAG_CODE_SPACE");
2984 if (TYPE_DATA_SPACE (type
))
2986 puts_filtered (" TYPE_FLAG_DATA_SPACE");
2988 if (TYPE_ADDRESS_CLASS_1 (type
))
2990 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
2992 if (TYPE_ADDRESS_CLASS_2 (type
))
2994 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
2996 puts_filtered ("\n");
2997 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
2998 if (TYPE_UNSIGNED (type
))
3000 puts_filtered (" TYPE_FLAG_UNSIGNED");
3002 if (TYPE_NOSIGN (type
))
3004 puts_filtered (" TYPE_FLAG_NOSIGN");
3006 if (TYPE_STUB (type
))
3008 puts_filtered (" TYPE_FLAG_STUB");
3010 if (TYPE_TARGET_STUB (type
))
3012 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3014 if (TYPE_STATIC (type
))
3016 puts_filtered (" TYPE_FLAG_STATIC");
3018 if (TYPE_PROTOTYPED (type
))
3020 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3022 if (TYPE_INCOMPLETE (type
))
3024 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3026 if (TYPE_VARARGS (type
))
3028 puts_filtered (" TYPE_FLAG_VARARGS");
3030 /* This is used for things like AltiVec registers on ppc. Gcc emits
3031 an attribute for the array type, which tells whether or not we
3032 have a vector, instead of a regular array. */
3033 if (TYPE_VECTOR (type
))
3035 puts_filtered (" TYPE_FLAG_VECTOR");
3037 puts_filtered ("\n");
3038 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
3039 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
3040 puts_filtered ("\n");
3041 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
3043 printfi_filtered (spaces
+ 2,
3044 "[%d] bitpos %d bitsize %d type ",
3045 idx
, TYPE_FIELD_BITPOS (type
, idx
),
3046 TYPE_FIELD_BITSIZE (type
, idx
));
3047 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
3048 printf_filtered (" name '%s' (",
3049 TYPE_FIELD_NAME (type
, idx
) != NULL
3050 ? TYPE_FIELD_NAME (type
, idx
)
3052 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
3053 printf_filtered (")\n");
3054 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
3056 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
3059 printfi_filtered (spaces
, "vptr_basetype ");
3060 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
3061 puts_filtered ("\n");
3062 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
3064 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
3066 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
3067 switch (TYPE_CODE (type
))
3069 case TYPE_CODE_STRUCT
:
3070 printfi_filtered (spaces
, "cplus_stuff ");
3071 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
3072 puts_filtered ("\n");
3073 print_cplus_stuff (type
, spaces
);
3077 printfi_filtered (spaces
, "floatformat ");
3078 if (TYPE_FLOATFORMAT (type
) == NULL
)
3079 puts_filtered ("(null)");
3082 puts_filtered ("{ ");
3083 if (TYPE_FLOATFORMAT (type
)[0] == NULL
3084 || TYPE_FLOATFORMAT (type
)[0]->name
== NULL
)
3085 puts_filtered ("(null)");
3087 puts_filtered (TYPE_FLOATFORMAT (type
)[0]->name
);
3089 puts_filtered (", ");
3090 if (TYPE_FLOATFORMAT (type
)[1] == NULL
3091 || TYPE_FLOATFORMAT (type
)[1]->name
== NULL
)
3092 puts_filtered ("(null)");
3094 puts_filtered (TYPE_FLOATFORMAT (type
)[1]->name
);
3096 puts_filtered (" }");
3098 puts_filtered ("\n");
3102 /* We have to pick one of the union types to be able print and test
3103 the value. Pick cplus_struct_type, even though we know it isn't
3104 any particular one. */
3105 printfi_filtered (spaces
, "type_specific ");
3106 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
3107 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
3109 printf_filtered (_(" (unknown data form)"));
3111 printf_filtered ("\n");
3116 obstack_free (&dont_print_type_obstack
, NULL
);
3119 /* Trivial helpers for the libiberty hash table, for mapping one
3124 struct type
*old
, *new;
3128 type_pair_hash (const void *item
)
3130 const struct type_pair
*pair
= item
;
3131 return htab_hash_pointer (pair
->old
);
3135 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
3137 const struct type_pair
*lhs
= item_lhs
, *rhs
= item_rhs
;
3138 return lhs
->old
== rhs
->old
;
3141 /* Allocate the hash table used by copy_type_recursive to walk
3142 types without duplicates. We use OBJFILE's obstack, because
3143 OBJFILE is about to be deleted. */
3146 create_copied_types_hash (struct objfile
*objfile
)
3148 return htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
3149 NULL
, &objfile
->objfile_obstack
,
3150 hashtab_obstack_allocate
,
3151 dummy_obstack_deallocate
);
3154 /* Recursively copy (deep copy) TYPE, if it is associated with OBJFILE.
3155 Return a new type allocated using malloc, a saved type if we have already
3156 visited TYPE (using COPIED_TYPES), or TYPE if it is not associated with
3160 copy_type_recursive (struct objfile
*objfile
, struct type
*type
,
3161 htab_t copied_types
)
3163 struct type_pair
*stored
, pair
;
3165 struct type
*new_type
;
3167 if (TYPE_OBJFILE (type
) == NULL
)
3170 /* This type shouldn't be pointing to any types in other objfiles; if
3171 it did, the type might disappear unexpectedly. */
3172 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
3175 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
3177 return ((struct type_pair
*) *slot
)->new;
3179 new_type
= alloc_type (NULL
);
3181 /* We must add the new type to the hash table immediately, in case
3182 we encounter this type again during a recursive call below. */
3183 stored
= xmalloc (sizeof (struct type_pair
));
3185 stored
->new = new_type
;
3188 /* Copy the common fields of types. */
3189 TYPE_CODE (new_type
) = TYPE_CODE (type
);
3190 TYPE_ARRAY_UPPER_BOUND_TYPE (new_type
) = TYPE_ARRAY_UPPER_BOUND_TYPE (type
);
3191 TYPE_ARRAY_LOWER_BOUND_TYPE (new_type
) = TYPE_ARRAY_LOWER_BOUND_TYPE (type
);
3192 if (TYPE_NAME (type
))
3193 TYPE_NAME (new_type
) = xstrdup (TYPE_NAME (type
));
3194 if (TYPE_TAG_NAME (type
))
3195 TYPE_TAG_NAME (new_type
) = xstrdup (TYPE_TAG_NAME (type
));
3196 TYPE_FLAGS (new_type
) = TYPE_FLAGS (type
);
3197 TYPE_VPTR_FIELDNO (new_type
) = TYPE_VPTR_FIELDNO (type
);
3199 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
3200 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
3202 /* Copy the fields. */
3203 TYPE_NFIELDS (new_type
) = TYPE_NFIELDS (type
);
3204 if (TYPE_NFIELDS (type
))
3208 nfields
= TYPE_NFIELDS (type
);
3209 TYPE_FIELDS (new_type
) = xmalloc (sizeof (struct field
) * nfields
);
3210 for (i
= 0; i
< nfields
; i
++)
3212 TYPE_FIELD_ARTIFICIAL (new_type
, i
) = TYPE_FIELD_ARTIFICIAL (type
, i
);
3213 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
3214 if (TYPE_FIELD_TYPE (type
, i
))
3215 TYPE_FIELD_TYPE (new_type
, i
)
3216 = copy_type_recursive (objfile
, TYPE_FIELD_TYPE (type
, i
),
3218 if (TYPE_FIELD_NAME (type
, i
))
3219 TYPE_FIELD_NAME (new_type
, i
) = xstrdup (TYPE_FIELD_NAME (type
, i
));
3220 if (TYPE_FIELD_STATIC_HAS_ADDR (type
, i
))
3221 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type
, i
),
3222 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
3223 else if (TYPE_FIELD_STATIC (type
, i
))
3224 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type
, i
),
3225 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
, i
)));
3228 TYPE_FIELD_BITPOS (new_type
, i
) = TYPE_FIELD_BITPOS (type
, i
);
3229 TYPE_FIELD_STATIC_KIND (new_type
, i
) = 0;
3234 /* Copy pointers to other types. */
3235 if (TYPE_TARGET_TYPE (type
))
3236 TYPE_TARGET_TYPE (new_type
) = copy_type_recursive (objfile
,
3237 TYPE_TARGET_TYPE (type
),
3239 if (TYPE_VPTR_BASETYPE (type
))
3240 TYPE_VPTR_BASETYPE (new_type
) = copy_type_recursive (objfile
,
3241 TYPE_VPTR_BASETYPE (type
),
3243 /* Maybe copy the type_specific bits.
3245 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3246 base classes and methods. There's no fundamental reason why we
3247 can't, but at the moment it is not needed. */
3249 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
3250 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
3251 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3252 || TYPE_CODE (type
) == TYPE_CODE_UNION
3253 || TYPE_CODE (type
) == TYPE_CODE_TEMPLATE
3254 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
3255 INIT_CPLUS_SPECIFIC (new_type
);
3260 static struct type
*
3261 build_flt (int bit
, char *name
, const struct floatformat
**floatformats
)
3267 gdb_assert (floatformats
!= NULL
);
3268 gdb_assert (floatformats
[0] != NULL
&& floatformats
[1] != NULL
);
3269 bit
= floatformats
[0]->totalsize
;
3271 gdb_assert (bit
>= 0);
3273 t
= init_type (TYPE_CODE_FLT
, bit
/ TARGET_CHAR_BIT
, 0, name
, NULL
);
3274 TYPE_FLOATFORMAT (t
) = floatformats
;
3278 static struct gdbarch_data
*gdbtypes_data
;
3280 const struct builtin_type
*
3281 builtin_type (struct gdbarch
*gdbarch
)
3283 return gdbarch_data (gdbarch
, gdbtypes_data
);
3287 static struct type
*
3288 build_complex (int bit
, char *name
, struct type
*target_type
)
3291 if (bit
<= 0 || target_type
== builtin_type_error
)
3293 gdb_assert (builtin_type_error
!= NULL
);
3294 return builtin_type_error
;
3296 t
= init_type (TYPE_CODE_COMPLEX
, 2 * bit
/ TARGET_CHAR_BIT
,
3297 0, name
, (struct objfile
*) NULL
);
3298 TYPE_TARGET_TYPE (t
) = target_type
;
3303 gdbtypes_post_init (struct gdbarch
*gdbarch
)
3305 struct builtin_type
*builtin_type
3306 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
3308 builtin_type
->builtin_void
=
3309 init_type (TYPE_CODE_VOID
, 1,
3311 "void", (struct objfile
*) NULL
);
3312 builtin_type
->builtin_char
=
3313 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3315 | (gdbarch_char_signed (current_gdbarch
) ?
3316 0 : TYPE_FLAG_UNSIGNED
)),
3317 "char", (struct objfile
*) NULL
);
3318 builtin_type
->builtin_true_char
=
3319 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3321 "true character", (struct objfile
*) NULL
);
3322 builtin_type
->builtin_signed_char
=
3323 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3325 "signed char", (struct objfile
*) NULL
);
3326 builtin_type
->builtin_unsigned_char
=
3327 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3329 "unsigned char", (struct objfile
*) NULL
);
3330 builtin_type
->builtin_short
=
3332 (TYPE_CODE_INT
, gdbarch_short_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
3333 0, "short", (struct objfile
*) NULL
);
3334 builtin_type
->builtin_unsigned_short
=
3336 (TYPE_CODE_INT
, gdbarch_short_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
3337 TYPE_FLAG_UNSIGNED
, "unsigned short", (struct objfile
*) NULL
);
3338 builtin_type
->builtin_int
=
3340 (TYPE_CODE_INT
, gdbarch_int_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
3341 0, "int", (struct objfile
*) NULL
);
3342 builtin_type
->builtin_unsigned_int
=
3344 (TYPE_CODE_INT
, gdbarch_int_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
3345 TYPE_FLAG_UNSIGNED
, "unsigned int", (struct objfile
*) NULL
);
3346 builtin_type
->builtin_long
=
3348 (TYPE_CODE_INT
, gdbarch_long_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
3349 0, "long", (struct objfile
*) NULL
);
3350 builtin_type
->builtin_unsigned_long
=
3352 (TYPE_CODE_INT
, gdbarch_long_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
3353 TYPE_FLAG_UNSIGNED
, "unsigned long", (struct objfile
*) NULL
);
3354 builtin_type
->builtin_long_long
=
3355 init_type (TYPE_CODE_INT
,
3356 gdbarch_long_long_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
3357 0, "long long", (struct objfile
*) NULL
);
3358 builtin_type
->builtin_unsigned_long_long
=
3359 init_type (TYPE_CODE_INT
,
3360 gdbarch_long_long_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
3361 TYPE_FLAG_UNSIGNED
, "unsigned long long",
3362 (struct objfile
*) NULL
);
3363 builtin_type
->builtin_float
3364 = build_flt (gdbarch_float_bit (gdbarch
), "float",
3365 gdbarch_float_format (gdbarch
));
3366 builtin_type
->builtin_double
3367 = build_flt (gdbarch_double_bit (gdbarch
), "double",
3368 gdbarch_double_format (gdbarch
));
3369 builtin_type
->builtin_long_double
3370 = build_flt (gdbarch_long_double_bit (gdbarch
), "long double",
3371 gdbarch_long_double_format (gdbarch
));
3372 builtin_type
->builtin_complex
3373 = build_complex (gdbarch_float_bit (gdbarch
), "complex",
3374 builtin_type
->builtin_float
);
3375 builtin_type
->builtin_double_complex
3376 = build_complex (gdbarch_double_bit (gdbarch
), "double complex",
3377 builtin_type
->builtin_double
);
3378 builtin_type
->builtin_string
=
3379 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3381 "string", (struct objfile
*) NULL
);
3382 builtin_type
->builtin_bool
=
3383 init_type (TYPE_CODE_BOOL
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3385 "bool", (struct objfile
*) NULL
);
3387 /* Pointer/Address types. */
3389 /* NOTE: on some targets, addresses and pointers are not necessarily
3390 the same --- for example, on the D10V, pointers are 16 bits long,
3391 but addresses are 32 bits long. See doc/gdbint.texinfo,
3392 ``Pointers Are Not Always Addresses''.
3395 - gdb's `struct type' always describes the target's
3397 - gdb's `struct value' objects should always hold values in
3399 - gdb's CORE_ADDR values are addresses in the unified virtual
3400 address space that the assembler and linker work with. Thus,
3401 since target_read_memory takes a CORE_ADDR as an argument, it
3402 can access any memory on the target, even if the processor has
3403 separate code and data address spaces.
3406 - If v is a value holding a D10V code pointer, its contents are
3407 in target form: a big-endian address left-shifted two bits.
3408 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3409 sizeof (void *) == 2 on the target.
3411 In this context, builtin_type->CORE_ADDR is a bit odd: it's a
3412 target type for a value the target will never see. It's only
3413 used to hold the values of (typeless) linker symbols, which are
3414 indeed in the unified virtual address space. */
3415 builtin_type
->builtin_data_ptr
3416 = make_pointer_type (builtin_type
->builtin_void
, NULL
);
3417 builtin_type
->builtin_func_ptr
3418 = lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
3419 builtin_type
->builtin_core_addr
=
3420 init_type (TYPE_CODE_INT
, gdbarch_addr_bit (current_gdbarch
) / 8,
3422 "__CORE_ADDR", (struct objfile
*) NULL
);
3425 /* The following set of types is used for symbols with no
3426 debug information. */
3427 builtin_type
->nodebug_text_symbol
3428 = init_type (TYPE_CODE_FUNC
, 1, 0, "<text variable, no debug info>", NULL
);
3429 TYPE_TARGET_TYPE (builtin_type
->nodebug_text_symbol
)
3430 = builtin_type
->builtin_int
;
3431 builtin_type
->nodebug_data_symbol
3432 = init_type (TYPE_CODE_INT
, gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3433 "<data variable, no debug info>", NULL
);
3434 builtin_type
->nodebug_unknown_symbol
3435 = init_type (TYPE_CODE_INT
, 1, 0,
3436 "<variable (not text or data), no debug info>", NULL
);
3437 builtin_type
->nodebug_tls_symbol
3438 = init_type (TYPE_CODE_INT
, gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3439 "<thread local variable, no debug info>", NULL
);
3441 return builtin_type
;
3444 extern void _initialize_gdbtypes (void);
3446 _initialize_gdbtypes (void)
3448 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
3450 /* FIXME: The following types are architecture-neutral. However, they
3451 contain pointer_type and reference_type fields potentially caching
3452 pointer or reference types that *are* architecture dependent. */
3455 init_type (TYPE_CODE_INT
, 0 / 8,
3457 "int0_t", (struct objfile
*) NULL
);
3459 init_type (TYPE_CODE_INT
, 8 / 8,
3461 "int8_t", (struct objfile
*) NULL
);
3462 builtin_type_uint8
=
3463 init_type (TYPE_CODE_INT
, 8 / 8,
3465 "uint8_t", (struct objfile
*) NULL
);
3466 builtin_type_int16
=
3467 init_type (TYPE_CODE_INT
, 16 / 8,
3469 "int16_t", (struct objfile
*) NULL
);
3470 builtin_type_uint16
=
3471 init_type (TYPE_CODE_INT
, 16 / 8,
3473 "uint16_t", (struct objfile
*) NULL
);
3474 builtin_type_int32
=
3475 init_type (TYPE_CODE_INT
, 32 / 8,
3477 "int32_t", (struct objfile
*) NULL
);
3478 builtin_type_uint32
=
3479 init_type (TYPE_CODE_INT
, 32 / 8,
3481 "uint32_t", (struct objfile
*) NULL
);
3482 builtin_type_int64
=
3483 init_type (TYPE_CODE_INT
, 64 / 8,
3485 "int64_t", (struct objfile
*) NULL
);
3486 builtin_type_uint64
=
3487 init_type (TYPE_CODE_INT
, 64 / 8,
3489 "uint64_t", (struct objfile
*) NULL
);
3490 builtin_type_int128
=
3491 init_type (TYPE_CODE_INT
, 128 / 8,
3493 "int128_t", (struct objfile
*) NULL
);
3494 builtin_type_uint128
=
3495 init_type (TYPE_CODE_INT
, 128 / 8,
3497 "uint128_t", (struct objfile
*) NULL
);
3499 builtin_type_ieee_single
3500 = build_flt (-1, "builtin_type_ieee_single", floatformats_ieee_single
);
3501 builtin_type_ieee_double
3502 = build_flt (-1, "builtin_type_ieee_double", floatformats_ieee_double
);
3503 builtin_type_i387_ext
3504 = build_flt (-1, "builtin_type_i387_ext", floatformats_i387_ext
);
3505 builtin_type_m68881_ext
3506 = build_flt (-1, "builtin_type_m68881_ext", floatformats_m68881_ext
);
3507 builtin_type_arm_ext
3508 = build_flt (-1, "builtin_type_arm_ext", floatformats_arm_ext
);
3509 builtin_type_ia64_spill
3510 = build_flt (-1, "builtin_type_ia64_spill", floatformats_ia64_spill
);
3511 builtin_type_ia64_quad
3512 = build_flt (-1, "builtin_type_ia64_quad", floatformats_ia64_quad
);
3514 add_setshow_zinteger_cmd ("overload", no_class
, &overload_debug
, _("\
3515 Set debugging of C++ overloading."), _("\
3516 Show debugging of C++ overloading."), _("\
3517 When enabled, ranking of the functions is displayed."),
3519 show_overload_debug
,
3520 &setdebuglist
, &showdebuglist
);
3522 /* Add user knob for controlling resolution of opaque types */
3523 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
3524 &opaque_type_resolution
, _("\
3525 Set resolution of opaque struct/class/union types (if set before loading symbols)."), _("\
3526 Show resolution of opaque struct/class/union types (if set before loading symbols)."), NULL
,
3528 show_opaque_type_resolution
,
3529 &setlist
, &showlist
);