1 /* Support routines for manipulating internal types for GDB.
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
4 2002, 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 3 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, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
30 #include "expression.h"
35 #include "complaints.h"
39 #include "gdb_assert.h"
42 /* These variables point to the objects
43 representing the predefined C data types. */
45 struct type
*builtin_type_int0
;
46 struct type
*builtin_type_int8
;
47 struct type
*builtin_type_uint8
;
48 struct type
*builtin_type_int16
;
49 struct type
*builtin_type_uint16
;
50 struct type
*builtin_type_int32
;
51 struct type
*builtin_type_uint32
;
52 struct type
*builtin_type_int64
;
53 struct type
*builtin_type_uint64
;
54 struct type
*builtin_type_int128
;
55 struct type
*builtin_type_uint128
;
57 /* Floatformat pairs. */
58 const struct floatformat
*floatformats_ieee_single
[BFD_ENDIAN_UNKNOWN
] = {
59 &floatformat_ieee_single_big
,
60 &floatformat_ieee_single_little
62 const struct floatformat
*floatformats_ieee_double
[BFD_ENDIAN_UNKNOWN
] = {
63 &floatformat_ieee_double_big
,
64 &floatformat_ieee_double_little
66 const struct floatformat
*floatformats_ieee_double_littlebyte_bigword
[BFD_ENDIAN_UNKNOWN
] = {
67 &floatformat_ieee_double_big
,
68 &floatformat_ieee_double_littlebyte_bigword
70 const struct floatformat
*floatformats_i387_ext
[BFD_ENDIAN_UNKNOWN
] = {
71 &floatformat_i387_ext
,
74 const struct floatformat
*floatformats_m68881_ext
[BFD_ENDIAN_UNKNOWN
] = {
75 &floatformat_m68881_ext
,
76 &floatformat_m68881_ext
78 const struct floatformat
*floatformats_arm_ext
[BFD_ENDIAN_UNKNOWN
] = {
79 &floatformat_arm_ext_big
,
80 &floatformat_arm_ext_littlebyte_bigword
82 const struct floatformat
*floatformats_ia64_spill
[BFD_ENDIAN_UNKNOWN
] = {
83 &floatformat_ia64_spill_big
,
84 &floatformat_ia64_spill_little
86 const struct floatformat
*floatformats_ia64_quad
[BFD_ENDIAN_UNKNOWN
] = {
87 &floatformat_ia64_quad_big
,
88 &floatformat_ia64_quad_little
90 const struct floatformat
*floatformats_vax_f
[BFD_ENDIAN_UNKNOWN
] = {
94 const struct floatformat
*floatformats_vax_d
[BFD_ENDIAN_UNKNOWN
] = {
99 struct type
*builtin_type_ieee_single
;
100 struct type
*builtin_type_ieee_double
;
101 struct type
*builtin_type_i387_ext
;
102 struct type
*builtin_type_m68881_ext
;
103 struct type
*builtin_type_arm_ext
;
104 struct type
*builtin_type_ia64_spill
;
105 struct type
*builtin_type_ia64_quad
;
108 int opaque_type_resolution
= 1;
110 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
111 struct cmd_list_element
*c
,
114 fprintf_filtered (file
, _("\
115 Resolution of opaque struct/class/union types (if set before loading symbols) is %s.\n"),
119 int overload_debug
= 0;
121 show_overload_debug (struct ui_file
*file
, int from_tty
,
122 struct cmd_list_element
*c
, const char *value
)
124 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"),
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
144 structure 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,
240 and have new type. */
241 else if (*typeptr
== 0)
243 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
248 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
250 ntype
= alloc_type (TYPE_OBJFILE (type
));
254 else /* 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
270 TYPE_LENGTH (ntype
) =
271 gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
;
272 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
274 /* Mark pointers as unsigned. The target converts between pointers
275 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
276 gdbarch_address_to_pointer. */
277 TYPE_FLAGS (ntype
) |= TYPE_FLAG_UNSIGNED
;
279 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
280 TYPE_POINTER_TYPE (type
) = ntype
;
282 /* Update the length of all the other variants of this type. */
283 chain
= TYPE_CHAIN (ntype
);
284 while (chain
!= ntype
)
286 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
287 chain
= TYPE_CHAIN (chain
);
293 /* Given a type TYPE, return a type of pointers to that type.
294 May need to construct such a type if this is the first use. */
297 lookup_pointer_type (struct type
*type
)
299 return make_pointer_type (type
, (struct type
**) 0);
302 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
303 points to a pointer to memory where the reference type should be
304 stored. If *TYPEPTR is zero, update it to point to the reference
305 type we return. We allocate new memory if needed. */
308 make_reference_type (struct type
*type
, struct type
**typeptr
)
310 struct type
*ntype
; /* New type */
311 struct objfile
*objfile
;
314 ntype
= TYPE_REFERENCE_TYPE (type
);
319 return ntype
; /* Don't care about alloc,
320 and have new type. */
321 else if (*typeptr
== 0)
323 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
328 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
330 ntype
= alloc_type (TYPE_OBJFILE (type
));
334 else /* We have storage, but need to reset it. */
337 objfile
= TYPE_OBJFILE (ntype
);
338 chain
= TYPE_CHAIN (ntype
);
340 TYPE_CHAIN (ntype
) = chain
;
341 TYPE_OBJFILE (ntype
) = objfile
;
344 TYPE_TARGET_TYPE (ntype
) = type
;
345 TYPE_REFERENCE_TYPE (type
) = ntype
;
347 /* FIXME! Assume the machine has only one representation for
348 references, and that it matches the (only) representation for
351 TYPE_LENGTH (ntype
) = gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
;
352 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
354 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
355 TYPE_REFERENCE_TYPE (type
) = ntype
;
357 /* Update the length of all the other variants of this type. */
358 chain
= TYPE_CHAIN (ntype
);
359 while (chain
!= ntype
)
361 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
362 chain
= TYPE_CHAIN (chain
);
368 /* Same as above, but caller doesn't care about memory allocation
372 lookup_reference_type (struct type
*type
)
374 return make_reference_type (type
, (struct type
**) 0);
377 /* Lookup a function type that returns type TYPE. TYPEPTR, if
378 nonzero, points to a pointer to memory where the function type
379 should be stored. If *TYPEPTR is zero, update it to point to the
380 function type we return. We allocate new memory if needed. */
383 make_function_type (struct type
*type
, struct type
**typeptr
)
385 struct type
*ntype
; /* New type */
386 struct objfile
*objfile
;
388 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
390 ntype
= alloc_type (TYPE_OBJFILE (type
));
394 else /* We have storage, but need to reset it. */
397 objfile
= TYPE_OBJFILE (ntype
);
399 TYPE_OBJFILE (ntype
) = objfile
;
402 TYPE_TARGET_TYPE (ntype
) = type
;
404 TYPE_LENGTH (ntype
) = 1;
405 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
411 /* Given a type TYPE, return a type of functions that return that type.
412 May need to construct such a type if this is the first use. */
415 lookup_function_type (struct type
*type
)
417 return make_function_type (type
, (struct type
**) 0);
420 /* Identify address space identifier by name --
421 return the integer flag defined in gdbtypes.h. */
423 address_space_name_to_int (char *space_identifier
)
425 struct gdbarch
*gdbarch
= current_gdbarch
;
427 /* Check for known address space delimiters. */
428 if (!strcmp (space_identifier
, "code"))
429 return TYPE_FLAG_CODE_SPACE
;
430 else if (!strcmp (space_identifier
, "data"))
431 return TYPE_FLAG_DATA_SPACE
;
432 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
433 && gdbarch_address_class_name_to_type_flags (gdbarch
,
438 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
441 /* Identify address space identifier by integer flag as defined in
442 gdbtypes.h -- return the string version of the adress space name. */
445 address_space_int_to_name (int space_flag
)
447 struct gdbarch
*gdbarch
= current_gdbarch
;
448 if (space_flag
& TYPE_FLAG_CODE_SPACE
)
450 else if (space_flag
& TYPE_FLAG_DATA_SPACE
)
452 else if ((space_flag
& TYPE_FLAG_ADDRESS_CLASS_ALL
)
453 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
454 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
459 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
461 If STORAGE is non-NULL, create the new type instance there.
462 STORAGE must be in the same obstack as TYPE. */
465 make_qualified_type (struct type
*type
, int new_flags
,
466 struct type
*storage
)
472 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
474 ntype
= TYPE_CHAIN (ntype
);
475 } while (ntype
!= type
);
477 /* Create a new type instance. */
479 ntype
= alloc_type_instance (type
);
482 /* If STORAGE was provided, it had better be in the same objfile
483 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
484 if one objfile is freed and the other kept, we'd have
485 dangling pointers. */
486 gdb_assert (TYPE_OBJFILE (type
) == TYPE_OBJFILE (storage
));
489 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
490 TYPE_CHAIN (ntype
) = ntype
;
493 /* Pointers or references to the original type are not relevant to
495 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
496 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
498 /* Chain the new qualified type to the old type. */
499 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
500 TYPE_CHAIN (type
) = ntype
;
502 /* Now set the instance flags and return the new type. */
503 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
505 /* Set length of new type to that of the original type. */
506 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
511 /* Make an address-space-delimited variant of a type -- a type that
512 is identical to the one supplied except that it has an address
513 space attribute attached to it (such as "code" or "data").
515 The space attributes "code" and "data" are for Harvard
516 architectures. The address space attributes are for architectures
517 which have alternately sized pointers or pointers with alternate
521 make_type_with_address_space (struct type
*type
, int space_flag
)
524 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
525 & ~(TYPE_FLAG_CODE_SPACE
| TYPE_FLAG_DATA_SPACE
526 | TYPE_FLAG_ADDRESS_CLASS_ALL
))
529 return make_qualified_type (type
, new_flags
, NULL
);
532 /* Make a "c-v" variant of a type -- a type that is identical to the
533 one supplied except that it may have const or volatile attributes
534 CNST is a flag for setting the const attribute
535 VOLTL is a flag for setting the volatile attribute
536 TYPE is the base type whose variant we are creating.
538 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
539 storage to hold the new qualified type; *TYPEPTR and TYPE must be
540 in the same objfile. Otherwise, allocate fresh memory for the new
541 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
542 new type we construct. */
544 make_cv_type (int cnst
, int voltl
,
546 struct type
**typeptr
)
548 struct type
*ntype
; /* New type */
549 struct type
*tmp_type
= type
; /* tmp type */
550 struct objfile
*objfile
;
552 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
553 & ~(TYPE_FLAG_CONST
| TYPE_FLAG_VOLATILE
));
556 new_flags
|= TYPE_FLAG_CONST
;
559 new_flags
|= TYPE_FLAG_VOLATILE
;
561 if (typeptr
&& *typeptr
!= NULL
)
563 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
564 a C-V variant chain that threads across objfiles: if one
565 objfile gets freed, then the other has a broken C-V chain.
567 This code used to try to copy over the main type from TYPE to
568 *TYPEPTR if they were in different objfiles, but that's
569 wrong, too: TYPE may have a field list or member function
570 lists, which refer to types of their own, etc. etc. The
571 whole shebang would need to be copied over recursively; you
572 can't have inter-objfile pointers. The only thing to do is
573 to leave stub types as stub types, and look them up afresh by
574 name each time you encounter them. */
575 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
));
578 ntype
= make_qualified_type (type
, new_flags
,
579 typeptr
? *typeptr
: NULL
);
587 /* Replace the contents of ntype with the type *type. This changes the
588 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
589 the changes are propogated to all types in the TYPE_CHAIN.
591 In order to build recursive types, it's inevitable that we'll need
592 to update types in place --- but this sort of indiscriminate
593 smashing is ugly, and needs to be replaced with something more
594 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
595 clear if more steps are needed. */
597 replace_type (struct type
*ntype
, struct type
*type
)
601 /* These two types had better be in the same objfile. Otherwise,
602 the assignment of one type's main type structure to the other
603 will produce a type with references to objects (names; field
604 lists; etc.) allocated on an objfile other than its own. */
605 gdb_assert (TYPE_OBJFILE (ntype
) == TYPE_OBJFILE (ntype
));
607 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
609 /* The type length is not a part of the main type. Update it for
610 each type on the variant chain. */
613 /* Assert that this element of the chain has no address-class bits
614 set in its flags. Such type variants might have type lengths
615 which are supposed to be different from the non-address-class
616 variants. This assertion shouldn't ever be triggered because
617 symbol readers which do construct address-class variants don't
618 call replace_type(). */
619 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
621 TYPE_LENGTH (chain
) = TYPE_LENGTH (type
);
622 chain
= TYPE_CHAIN (chain
);
623 } while (ntype
!= chain
);
625 /* Assert that the two types have equivalent instance qualifiers.
626 This should be true for at least all of our debug readers. */
627 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
630 /* Implement direct support for MEMBER_TYPE in GNU C++.
631 May need to construct such a type if this is the first use.
632 The TYPE is the type of the member. The DOMAIN is the type
633 of the aggregate that the member belongs to. */
636 lookup_memberptr_type (struct type
*type
, struct type
*domain
)
640 mtype
= alloc_type (TYPE_OBJFILE (type
));
641 smash_to_memberptr_type (mtype
, domain
, type
);
645 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
648 lookup_methodptr_type (struct type
*to_type
)
652 mtype
= alloc_type (TYPE_OBJFILE (to_type
));
653 TYPE_TARGET_TYPE (mtype
) = to_type
;
654 TYPE_DOMAIN_TYPE (mtype
) = TYPE_DOMAIN_TYPE (to_type
);
655 TYPE_LENGTH (mtype
) = cplus_method_ptr_size ();
656 TYPE_CODE (mtype
) = TYPE_CODE_METHODPTR
;
660 /* Allocate a stub method whose return type is TYPE. This apparently
661 happens for speed of symbol reading, since parsing out the
662 arguments to the method is cpu-intensive, the way we are doing it.
663 So, we will fill in arguments later. This always returns a fresh
667 allocate_stub_method (struct type
*type
)
671 mtype
= init_type (TYPE_CODE_METHOD
, 1, TYPE_FLAG_STUB
, NULL
,
672 TYPE_OBJFILE (type
));
673 TYPE_TARGET_TYPE (mtype
) = type
;
674 /* _DOMAIN_TYPE (mtype) = unknown yet */
678 /* Create a range type using either a blank type supplied in
679 RESULT_TYPE, or creating a new type, inheriting the objfile from
682 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
683 to HIGH_BOUND, inclusive.
685 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
686 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
689 create_range_type (struct type
*result_type
, struct type
*index_type
,
690 int low_bound
, int high_bound
)
692 if (result_type
== NULL
)
694 result_type
= alloc_type (TYPE_OBJFILE (index_type
));
696 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
697 TYPE_TARGET_TYPE (result_type
) = index_type
;
698 if (TYPE_STUB (index_type
))
699 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
701 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
702 TYPE_NFIELDS (result_type
) = 2;
703 TYPE_FIELDS (result_type
) = (struct field
*)
704 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
705 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
706 TYPE_FIELD_BITPOS (result_type
, 0) = low_bound
;
707 TYPE_FIELD_BITPOS (result_type
, 1) = high_bound
;
710 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
712 return (result_type
);
715 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
716 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
717 bounds will fit in LONGEST), or -1 otherwise. */
720 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
722 CHECK_TYPEDEF (type
);
723 switch (TYPE_CODE (type
))
725 case TYPE_CODE_RANGE
:
726 *lowp
= TYPE_LOW_BOUND (type
);
727 *highp
= TYPE_HIGH_BOUND (type
);
730 if (TYPE_NFIELDS (type
) > 0)
732 /* The enums may not be sorted by value, so search all
736 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
737 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
739 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
740 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
741 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
742 *highp
= TYPE_FIELD_BITPOS (type
, i
);
745 /* Set unsigned indicator if warranted. */
748 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
762 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
764 if (!TYPE_UNSIGNED (type
))
766 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
770 /* ... fall through for unsigned ints ... */
773 /* This round-about calculation is to avoid shifting by
774 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
775 if TYPE_LENGTH (type) == sizeof (LONGEST). */
776 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
777 *highp
= (*highp
- 1) | *highp
;
784 /* Create an array type using either a blank type supplied in
785 RESULT_TYPE, or creating a new type, inheriting the objfile from
788 Elements will be of type ELEMENT_TYPE, the indices will be of type
791 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
792 sure it is TYPE_CODE_UNDEF before we bash it into an array
796 create_array_type (struct type
*result_type
,
797 struct type
*element_type
,
798 struct type
*range_type
)
800 LONGEST low_bound
, high_bound
;
802 if (result_type
== NULL
)
804 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
806 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
807 TYPE_TARGET_TYPE (result_type
) = element_type
;
808 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
809 low_bound
= high_bound
= 0;
810 CHECK_TYPEDEF (element_type
);
811 TYPE_LENGTH (result_type
) =
812 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
813 TYPE_NFIELDS (result_type
) = 1;
814 TYPE_FIELDS (result_type
) =
815 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
816 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
817 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
818 TYPE_VPTR_FIELDNO (result_type
) = -1;
820 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
821 if (TYPE_LENGTH (result_type
) == 0)
822 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
824 return (result_type
);
827 /* Create a string type using either a blank type supplied in
828 RESULT_TYPE, or creating a new type. String types are similar
829 enough to array of char types that we can use create_array_type to
830 build the basic type and then bash it into a string type.
832 For fixed length strings, the range type contains 0 as the lower
833 bound and the length of the string minus one as the upper bound.
835 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
836 sure it is TYPE_CODE_UNDEF before we bash it into a string
840 create_string_type (struct type
*result_type
,
841 struct type
*range_type
)
843 struct type
*string_char_type
;
845 string_char_type
= language_string_char_type (current_language
,
847 result_type
= create_array_type (result_type
,
850 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
851 return (result_type
);
855 create_set_type (struct type
*result_type
, struct type
*domain_type
)
857 if (result_type
== NULL
)
859 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
861 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
862 TYPE_NFIELDS (result_type
) = 1;
863 TYPE_FIELDS (result_type
) = (struct field
*)
864 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
865 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
867 if (!TYPE_STUB (domain_type
))
869 LONGEST low_bound
, high_bound
, bit_length
;
870 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
871 low_bound
= high_bound
= 0;
872 bit_length
= high_bound
- low_bound
+ 1;
873 TYPE_LENGTH (result_type
)
874 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
876 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
878 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
880 return (result_type
);
884 append_flags_type_flag (struct type
*type
, int bitpos
, char *name
)
886 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLAGS
);
887 gdb_assert (bitpos
< TYPE_NFIELDS (type
));
888 gdb_assert (bitpos
>= 0);
892 TYPE_FIELD_NAME (type
, bitpos
) = xstrdup (name
);
893 TYPE_FIELD_BITPOS (type
, bitpos
) = bitpos
;
897 /* Don't show this field to the user. */
898 TYPE_FIELD_BITPOS (type
, bitpos
) = -1;
903 init_flags_type (char *name
, int length
)
905 int nfields
= length
* TARGET_CHAR_BIT
;
908 type
= init_type (TYPE_CODE_FLAGS
, length
,
909 TYPE_FLAG_UNSIGNED
, name
, NULL
);
910 TYPE_NFIELDS (type
) = nfields
;
911 TYPE_FIELDS (type
) = TYPE_ALLOC (type
,
912 nfields
* sizeof (struct field
));
913 memset (TYPE_FIELDS (type
), 0, nfields
* sizeof (struct field
));
918 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
919 and any array types nested inside it. */
922 make_vector_type (struct type
*array_type
)
924 struct type
*inner_array
, *elt_type
;
927 /* Find the innermost array type, in case the array is
928 multi-dimensional. */
929 inner_array
= array_type
;
930 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
931 inner_array
= TYPE_TARGET_TYPE (inner_array
);
933 elt_type
= TYPE_TARGET_TYPE (inner_array
);
934 if (TYPE_CODE (elt_type
) == TYPE_CODE_INT
)
936 flags
= TYPE_INSTANCE_FLAGS (elt_type
) | TYPE_FLAG_NOTTEXT
;
937 elt_type
= make_qualified_type (elt_type
, flags
, NULL
);
938 TYPE_TARGET_TYPE (inner_array
) = elt_type
;
941 TYPE_FLAGS (array_type
) |= TYPE_FLAG_VECTOR
;
945 init_vector_type (struct type
*elt_type
, int n
)
947 struct type
*array_type
;
949 array_type
= create_array_type (0, elt_type
,
950 create_range_type (0,
953 make_vector_type (array_type
);
957 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
958 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
959 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
960 TYPE doesn't include the offset (that's the value of the MEMBER
961 itself), but does include the structure type into which it points
964 When "smashing" the type, we preserve the objfile that the old type
965 pointed to, since we aren't changing where the type is actually
969 smash_to_memberptr_type (struct type
*type
, struct type
*domain
,
970 struct type
*to_type
)
972 struct objfile
*objfile
;
974 objfile
= TYPE_OBJFILE (type
);
977 TYPE_OBJFILE (type
) = objfile
;
978 TYPE_TARGET_TYPE (type
) = to_type
;
979 TYPE_DOMAIN_TYPE (type
) = domain
;
980 /* Assume that a data member pointer is the same size as a normal
982 TYPE_LENGTH (type
) = gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
;
983 TYPE_CODE (type
) = TYPE_CODE_MEMBERPTR
;
986 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
987 METHOD just means `function that gets an extra "this" argument'.
989 When "smashing" the type, we preserve the objfile that the old type
990 pointed to, since we aren't changing where the type is actually
994 smash_to_method_type (struct type
*type
, struct type
*domain
,
995 struct type
*to_type
, struct field
*args
,
996 int nargs
, int varargs
)
998 struct objfile
*objfile
;
1000 objfile
= TYPE_OBJFILE (type
);
1003 TYPE_OBJFILE (type
) = objfile
;
1004 TYPE_TARGET_TYPE (type
) = to_type
;
1005 TYPE_DOMAIN_TYPE (type
) = domain
;
1006 TYPE_FIELDS (type
) = args
;
1007 TYPE_NFIELDS (type
) = nargs
;
1009 TYPE_FLAGS (type
) |= TYPE_FLAG_VARARGS
;
1010 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1011 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
1014 /* Return a typename for a struct/union/enum type without "struct ",
1015 "union ", or "enum ". If the type has a NULL name, return NULL. */
1018 type_name_no_tag (const struct type
*type
)
1020 if (TYPE_TAG_NAME (type
) != NULL
)
1021 return TYPE_TAG_NAME (type
);
1023 /* Is there code which expects this to return the name if there is
1024 no tag name? My guess is that this is mainly used for C++ in
1025 cases where the two will always be the same. */
1026 return TYPE_NAME (type
);
1029 /* Lookup a typedef or primitive type named NAME, visible in lexical
1030 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1031 suitably defined. */
1034 lookup_typename (char *name
, struct block
*block
, int noerr
)
1039 sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, 0,
1040 (struct symtab
**) NULL
);
1041 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1043 tmp
= language_lookup_primitive_type_by_name (current_language
,
1050 else if (!tmp
&& noerr
)
1056 error (_("No type named %s."), name
);
1059 return (SYMBOL_TYPE (sym
));
1063 lookup_unsigned_typename (char *name
)
1065 char *uns
= alloca (strlen (name
) + 10);
1067 strcpy (uns
, "unsigned ");
1068 strcpy (uns
+ 9, name
);
1069 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
1073 lookup_signed_typename (char *name
)
1076 char *uns
= alloca (strlen (name
) + 8);
1078 strcpy (uns
, "signed ");
1079 strcpy (uns
+ 7, name
);
1080 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
1081 /* If we don't find "signed FOO" just try again with plain "FOO". */
1084 return lookup_typename (name
, (struct block
*) NULL
, 0);
1087 /* Lookup a structure type named "struct NAME",
1088 visible in lexical block BLOCK. */
1091 lookup_struct (char *name
, struct block
*block
)
1095 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
1096 (struct symtab
**) NULL
);
1100 error (_("No struct type named %s."), name
);
1102 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1104 error (_("This context has class, union or enum %s, not a struct."),
1107 return (SYMBOL_TYPE (sym
));
1110 /* Lookup a union type named "union NAME",
1111 visible in lexical block BLOCK. */
1114 lookup_union (char *name
, struct block
*block
)
1119 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
1120 (struct symtab
**) NULL
);
1123 error (_("No union type named %s."), name
);
1125 t
= SYMBOL_TYPE (sym
);
1127 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1130 /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
1131 * a further "declared_type" field to discover it is really a union.
1133 if (HAVE_CPLUS_STRUCT (t
))
1134 if (TYPE_DECLARED_TYPE (t
) == DECLARED_TYPE_UNION
)
1137 /* If we get here, it's not a union. */
1138 error (_("This context has class, struct or enum %s, not a union."),
1143 /* Lookup an enum type named "enum NAME",
1144 visible in lexical block BLOCK. */
1147 lookup_enum (char *name
, struct block
*block
)
1151 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
1152 (struct symtab
**) NULL
);
1155 error (_("No enum type named %s."), name
);
1157 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1159 error (_("This context has class, struct or union %s, not an enum."),
1162 return (SYMBOL_TYPE (sym
));
1165 /* Lookup a template type named "template NAME<TYPE>",
1166 visible in lexical block BLOCK. */
1169 lookup_template_type (char *name
, struct type
*type
,
1170 struct block
*block
)
1173 char *nam
= (char *)
1174 alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1177 strcat (nam
, TYPE_NAME (type
));
1178 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1180 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0,
1181 (struct symtab
**) NULL
);
1185 error (_("No template type named %s."), name
);
1187 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1189 error (_("This context has class, union or enum %s, not a struct."),
1192 return (SYMBOL_TYPE (sym
));
1195 /* Given a type TYPE, lookup the type of the component of type named
1198 TYPE can be either a struct or union, or a pointer or reference to
1199 a struct or union. If it is a pointer or reference, its target
1200 type is automatically used. Thus '.' and '->' are interchangable,
1201 as specified for the definitions of the expression element types
1202 STRUCTOP_STRUCT and STRUCTOP_PTR.
1204 If NOERR is nonzero, return zero if NAME is not suitably defined.
1205 If NAME is the name of a baseclass type, return that type. */
1208 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
1214 CHECK_TYPEDEF (type
);
1215 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1216 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1218 type
= TYPE_TARGET_TYPE (type
);
1221 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1222 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1224 target_terminal_ours ();
1225 gdb_flush (gdb_stdout
);
1226 fprintf_unfiltered (gdb_stderr
, "Type ");
1227 type_print (type
, "", gdb_stderr
, -1);
1228 error (_(" is not a structure or union type."));
1232 /* FIXME: This change put in by Michael seems incorrect for the case
1233 where the structure tag name is the same as the member name.
1234 I.E. when doing "ptype bell->bar" for "struct foo { int bar; int
1235 foo; } bell;" Disabled by fnf. */
1239 typename
= type_name_no_tag (type
);
1240 if (typename
!= NULL
&& strcmp (typename
, name
) == 0)
1245 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1247 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1249 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1251 return TYPE_FIELD_TYPE (type
, i
);
1255 /* OK, it's not in this class. Recursively check the baseclasses. */
1256 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1260 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, 1);
1272 target_terminal_ours ();
1273 gdb_flush (gdb_stdout
);
1274 fprintf_unfiltered (gdb_stderr
, "Type ");
1275 type_print (type
, "", gdb_stderr
, -1);
1276 fprintf_unfiltered (gdb_stderr
, " has no component named ");
1277 fputs_filtered (name
, gdb_stderr
);
1279 return (struct type
*) -1; /* For lint */
1282 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
1283 valid. Callers should be aware that in some cases (for example,
1284 the type or one of its baseclasses is a stub type and we are
1285 debugging a .o file), this function will not be able to find the
1286 virtual function table pointer, and vptr_fieldno will remain -1 and
1287 vptr_basetype will remain NULL. */
1290 fill_in_vptr_fieldno (struct type
*type
)
1292 CHECK_TYPEDEF (type
);
1294 if (TYPE_VPTR_FIELDNO (type
) < 0)
1298 /* We must start at zero in case the first (and only) baseclass
1299 is virtual (and hence we cannot share the table pointer). */
1300 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1302 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
,
1304 fill_in_vptr_fieldno (baseclass
);
1305 if (TYPE_VPTR_FIELDNO (baseclass
) >= 0)
1307 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (baseclass
);
1308 TYPE_VPTR_BASETYPE (type
) = TYPE_VPTR_BASETYPE (baseclass
);
1315 /* Find the method and field indices for the destructor in class type T.
1316 Return 1 if the destructor was found, otherwise, return 0. */
1319 get_destructor_fn_field (struct type
*t
,
1325 for (i
= 0; i
< TYPE_NFN_FIELDS (t
); i
++)
1328 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1330 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (t
, i
); j
++)
1332 if (is_destructor_name (TYPE_FN_FIELD_PHYSNAME (f
, j
)) != 0)
1344 stub_noname_complaint (void)
1346 complaint (&symfile_complaints
, _("stub type has NULL name"));
1349 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1351 If this is a stubbed struct (i.e. declared as struct foo *), see if
1352 we can find a full definition in some other file. If so, copy this
1353 definition, so we can use it in future. There used to be a comment
1354 (but not any code) that if we don't find a full definition, we'd
1355 set a flag so we don't spend time in the future checking the same
1356 type. That would be a mistake, though--we might load in more
1357 symbols which contain a full definition for the type.
1359 This used to be coded as a macro, but I don't think it is called
1360 often enough to merit such treatment. */
1362 /* Find the real type of TYPE. This function returns the real type,
1363 after removing all layers of typedefs and completing opaque or stub
1364 types. Completion changes the TYPE argument, but stripping of
1365 typedefs does not. */
1368 check_typedef (struct type
*type
)
1370 struct type
*orig_type
= type
;
1371 int is_const
, is_volatile
;
1375 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1377 if (!TYPE_TARGET_TYPE (type
))
1382 /* It is dangerous to call lookup_symbol if we are currently
1383 reading a symtab. Infinite recursion is one danger. */
1384 if (currently_reading_symtab
)
1387 name
= type_name_no_tag (type
);
1388 /* FIXME: shouldn't we separately check the TYPE_NAME and
1389 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1390 VAR_DOMAIN as appropriate? (this code was written before
1391 TYPE_NAME and TYPE_TAG_NAME were separate). */
1394 stub_noname_complaint ();
1397 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0,
1398 (struct symtab
**) NULL
);
1400 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1401 else /* TYPE_CODE_UNDEF */
1402 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
);
1404 type
= TYPE_TARGET_TYPE (type
);
1407 is_const
= TYPE_CONST (type
);
1408 is_volatile
= TYPE_VOLATILE (type
);
1410 /* If this is a struct/class/union with no fields, then check
1411 whether a full definition exists somewhere else. This is for
1412 systems where a type definition with no fields is issued for such
1413 types, instead of identifying them as stub types in the first
1416 if (TYPE_IS_OPAQUE (type
)
1417 && opaque_type_resolution
1418 && !currently_reading_symtab
)
1420 char *name
= type_name_no_tag (type
);
1421 struct type
*newtype
;
1424 stub_noname_complaint ();
1427 newtype
= lookup_transparent_type (name
);
1431 /* If the resolved type and the stub are in the same
1432 objfile, then replace the stub type with the real deal.
1433 But if they're in separate objfiles, leave the stub
1434 alone; we'll just look up the transparent type every time
1435 we call check_typedef. We can't create pointers between
1436 types allocated to different objfiles, since they may
1437 have different lifetimes. Trying to copy NEWTYPE over to
1438 TYPE's objfile is pointless, too, since you'll have to
1439 move over any other types NEWTYPE refers to, which could
1440 be an unbounded amount of stuff. */
1441 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
1442 make_cv_type (is_const
, is_volatile
, newtype
, &type
);
1447 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1449 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1451 char *name
= type_name_no_tag (type
);
1452 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1453 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1454 as appropriate? (this code was written before TYPE_NAME and
1455 TYPE_TAG_NAME were separate). */
1459 stub_noname_complaint ();
1462 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
,
1463 0, (struct symtab
**) NULL
);
1466 /* Same as above for opaque types, we can replace the stub
1467 with the complete type only if they are int the same
1469 if (TYPE_OBJFILE (SYMBOL_TYPE(sym
)) == TYPE_OBJFILE (type
))
1470 make_cv_type (is_const
, is_volatile
,
1471 SYMBOL_TYPE (sym
), &type
);
1473 type
= SYMBOL_TYPE (sym
);
1477 if (TYPE_TARGET_STUB (type
))
1479 struct type
*range_type
;
1480 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1482 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1486 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1487 && TYPE_NFIELDS (type
) == 1
1488 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
1489 == TYPE_CODE_RANGE
))
1491 /* Now recompute the length of the array type, based on its
1492 number of elements and the target type's length. */
1493 TYPE_LENGTH (type
) =
1494 ((TYPE_FIELD_BITPOS (range_type
, 1)
1495 - TYPE_FIELD_BITPOS (range_type
, 0) + 1)
1496 * TYPE_LENGTH (target_type
));
1497 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1499 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1501 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1502 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1505 /* Cache TYPE_LENGTH for future use. */
1506 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1510 /* Parse a type expression in the string [P..P+LENGTH). If an error
1511 occurs, silently return builtin_type_void. */
1513 static struct type
*
1514 safe_parse_type (char *p
, int length
)
1516 struct ui_file
*saved_gdb_stderr
;
1519 /* Suppress error messages. */
1520 saved_gdb_stderr
= gdb_stderr
;
1521 gdb_stderr
= ui_file_new ();
1523 /* Call parse_and_eval_type() without fear of longjmp()s. */
1524 if (!gdb_parse_and_eval_type (p
, length
, &type
))
1525 type
= builtin_type_void
;
1527 /* Stop suppressing error messages. */
1528 ui_file_delete (gdb_stderr
);
1529 gdb_stderr
= saved_gdb_stderr
;
1534 /* Ugly hack to convert method stubs into method types.
1536 He ain't kiddin'. This demangles the name of the method into a
1537 string including argument types, parses out each argument type,
1538 generates a string casting a zero to that type, evaluates the
1539 string, and stuffs the resulting type into an argtype vector!!!
1540 Then it knows the type of the whole function (including argument
1541 types for overloading), which info used to be in the stab's but was
1542 removed to hack back the space required for them. */
1545 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1548 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1549 char *demangled_name
= cplus_demangle (mangled_name
,
1550 DMGL_PARAMS
| DMGL_ANSI
);
1551 char *argtypetext
, *p
;
1552 int depth
= 0, argcount
= 1;
1553 struct field
*argtypes
;
1556 /* Make sure we got back a function string that we can use. */
1558 p
= strchr (demangled_name
, '(');
1562 if (demangled_name
== NULL
|| p
== NULL
)
1563 error (_("Internal: Cannot demangle mangled name `%s'."),
1566 /* Now, read in the parameters that define this type. */
1571 if (*p
== '(' || *p
== '<')
1575 else if (*p
== ')' || *p
== '>')
1579 else if (*p
== ',' && depth
== 0)
1587 /* If we read one argument and it was ``void'', don't count it. */
1588 if (strncmp (argtypetext
, "(void)", 6) == 0)
1591 /* We need one extra slot, for the THIS pointer. */
1593 argtypes
= (struct field
*)
1594 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
1597 /* Add THIS pointer for non-static methods. */
1598 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1599 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
1603 argtypes
[0].type
= lookup_pointer_type (type
);
1607 if (*p
!= ')') /* () means no args, skip while */
1612 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1614 /* Avoid parsing of ellipsis, they will be handled below.
1615 Also avoid ``void'' as above. */
1616 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
1617 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
1619 argtypes
[argcount
].type
=
1620 safe_parse_type (argtypetext
, p
- argtypetext
);
1623 argtypetext
= p
+ 1;
1626 if (*p
== '(' || *p
== '<')
1630 else if (*p
== ')' || *p
== '>')
1639 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1641 /* Now update the old "stub" type into a real type. */
1642 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1643 TYPE_DOMAIN_TYPE (mtype
) = type
;
1644 TYPE_FIELDS (mtype
) = argtypes
;
1645 TYPE_NFIELDS (mtype
) = argcount
;
1646 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1647 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1649 TYPE_FLAGS (mtype
) |= TYPE_FLAG_VARARGS
;
1651 xfree (demangled_name
);
1654 /* This is the external interface to check_stub_method, above. This
1655 function unstubs all of the signatures for TYPE's METHOD_ID method
1656 name. After calling this function TYPE_FN_FIELD_STUB will be
1657 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1660 This function unfortunately can not die until stabs do. */
1663 check_stub_method_group (struct type
*type
, int method_id
)
1665 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
1666 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1667 int j
, found_stub
= 0;
1669 for (j
= 0; j
< len
; j
++)
1670 if (TYPE_FN_FIELD_STUB (f
, j
))
1673 check_stub_method (type
, method_id
, j
);
1676 /* GNU v3 methods with incorrect names were corrected when we read
1677 in type information, because it was cheaper to do it then. The
1678 only GNU v2 methods with incorrect method names are operators and
1679 destructors; destructors were also corrected when we read in type
1682 Therefore the only thing we need to handle here are v2 operator
1684 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
1687 char dem_opname
[256];
1689 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1691 dem_opname
, DMGL_ANSI
);
1693 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1697 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
1701 const struct cplus_struct_type cplus_struct_default
;
1704 allocate_cplus_struct_type (struct type
*type
)
1706 if (!HAVE_CPLUS_STRUCT (type
))
1708 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1709 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1710 *(TYPE_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1714 /* Helper function to initialize the standard scalar types.
1716 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy of
1717 the string pointed to by name in the objfile_obstack for that
1718 objfile, and initialize the type name to that copy. There are
1719 places (mipsread.c in particular, where init_type is called with a
1720 NULL value for NAME). */
1723 init_type (enum type_code code
, int length
, int flags
,
1724 char *name
, struct objfile
*objfile
)
1728 type
= alloc_type (objfile
);
1729 TYPE_CODE (type
) = code
;
1730 TYPE_LENGTH (type
) = length
;
1731 TYPE_FLAGS (type
) |= flags
;
1732 if ((name
!= NULL
) && (objfile
!= NULL
))
1734 TYPE_NAME (type
) = obsavestring (name
, strlen (name
),
1735 &objfile
->objfile_obstack
);
1739 TYPE_NAME (type
) = name
;
1744 if (name
&& strcmp (name
, "char") == 0)
1745 TYPE_FLAGS (type
) |= TYPE_FLAG_NOSIGN
;
1747 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
1748 || code
== TYPE_CODE_NAMESPACE
)
1750 INIT_CPLUS_SPECIFIC (type
);
1755 /* Helper function. Create an empty composite type. */
1758 init_composite_type (char *name
, enum type_code code
)
1761 gdb_assert (code
== TYPE_CODE_STRUCT
1762 || code
== TYPE_CODE_UNION
);
1763 t
= init_type (code
, 0, 0, NULL
, NULL
);
1764 TYPE_TAG_NAME (t
) = name
;
1768 /* Helper function. Append a field to a composite type. */
1771 append_composite_type_field (struct type
*t
, char *name
,
1775 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
1776 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
1777 sizeof (struct field
) * TYPE_NFIELDS (t
));
1778 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
1779 memset (f
, 0, sizeof f
[0]);
1780 FIELD_TYPE (f
[0]) = field
;
1781 FIELD_NAME (f
[0]) = name
;
1782 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1784 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
1785 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
1787 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
1789 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
1790 if (TYPE_NFIELDS (t
) > 1)
1792 FIELD_BITPOS (f
[0]) = (FIELD_BITPOS (f
[-1])
1793 + TYPE_LENGTH (field
) * TARGET_CHAR_BIT
);
1798 /* Look up a fundamental type for the specified objfile.
1799 May need to construct such a type if this is the first use.
1801 Some object file formats (ELF, COFF, etc) do not define fundamental
1802 types such as "int" or "double". Others (stabs for example), do
1803 define fundamental types.
1805 For the formats which don't provide fundamental types, gdb can
1806 create such types, using defaults reasonable for the current
1807 language and the current target machine.
1809 NOTE: This routine is obsolescent. Each debugging format reader
1810 should manage it's own fundamental types, either creating them from
1811 suitable defaults or reading them from the debugging information,
1812 whichever is appropriate. The DWARF reader has already been fixed
1813 to do this. Once the other readers are fixed, this routine will go
1814 away. Also note that fundamental types should be managed on a
1815 compilation unit basis in a multi-language environment, not on a
1816 linkage unit basis as is done here. */
1820 lookup_fundamental_type (struct objfile
*objfile
, int typeid)
1822 struct type
**typep
;
1825 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1827 error (_("internal error - invalid fundamental type id %d"),
1831 /* If this is the first time we need a fundamental type for this
1832 objfile then we need to initialize the vector of type
1835 if (objfile
->fundamental_types
== NULL
)
1837 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1838 objfile
->fundamental_types
= (struct type
**)
1839 obstack_alloc (&objfile
->objfile_obstack
, nbytes
);
1840 memset ((char *) objfile
->fundamental_types
, 0, nbytes
);
1841 OBJSTAT (objfile
, n_types
+= FT_NUM_MEMBERS
);
1844 /* Look for this particular type in the fundamental type vector. If
1845 one is not found, create and install one appropriate for the
1846 current language. */
1848 typep
= objfile
->fundamental_types
+ typeid;
1851 *typep
= create_fundamental_type (objfile
, typeid);
1858 can_dereference (struct type
*t
)
1860 /* FIXME: Should we return true for references as well as
1865 && TYPE_CODE (t
) == TYPE_CODE_PTR
1866 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1870 is_integral_type (struct type
*t
)
1875 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
1876 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
1877 || (TYPE_CODE (t
) == TYPE_CODE_FLAGS
)
1878 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
1879 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
1880 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
1883 /* Check whether BASE is an ancestor or base class or DCLASS
1884 Return 1 if so, and 0 if not.
1885 Note: callers may want to check for identity of the types before
1886 calling this function -- identical types are considered to satisfy
1887 the ancestor relationship even if they're identical. */
1890 is_ancestor (struct type
*base
, struct type
*dclass
)
1894 CHECK_TYPEDEF (base
);
1895 CHECK_TYPEDEF (dclass
);
1899 if (TYPE_NAME (base
) && TYPE_NAME (dclass
)
1900 && !strcmp (TYPE_NAME (base
), TYPE_NAME (dclass
)))
1903 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1904 if (is_ancestor (base
, TYPE_BASECLASS (dclass
, i
)))
1912 /* See whether DCLASS has a virtual table. This routine is aimed at
1913 the HP/Taligent ANSI C++ runtime model, and may not work with other
1914 runtime models. Return 1 => Yes, 0 => No. */
1917 has_vtable (struct type
*dclass
)
1919 /* In the HP ANSI C++ runtime model, a class has a vtable only if it
1920 has virtual functions or virtual bases. */
1924 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1927 /* First check for the presence of virtual bases. */
1928 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
1929 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1930 if (B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
))
1933 /* Next check for virtual functions. */
1934 if (TYPE_FN_FIELDLISTS (dclass
))
1935 for (i
= 0; i
< TYPE_NFN_FIELDS (dclass
); i
++)
1936 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, i
), 0))
1939 /* Recurse on non-virtual bases to see if any of them needs a
1941 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
1942 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1943 if ((!B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
))
1944 && (has_vtable (TYPE_FIELD_TYPE (dclass
, i
))))
1947 /* Well, maybe we don't need a virtual table. */
1951 /* Return a pointer to the "primary base class" of DCLASS.
1953 A NULL return indicates that DCLASS has no primary base, or that it
1954 couldn't be found (insufficient information).
1956 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
1957 and may not work with other runtime models. */
1960 primary_base_class (struct type
*dclass
)
1962 /* In HP ANSI C++'s runtime model, a "primary base class" of a class
1963 is the first directly inherited, non-virtual base class that
1964 requires a virtual table. */
1968 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1971 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1972 if (!TYPE_FIELD_VIRTUAL (dclass
, i
)
1973 && has_vtable (TYPE_FIELD_TYPE (dclass
, i
)))
1974 return TYPE_FIELD_TYPE (dclass
, i
);
1979 /* Global manipulated by virtual_base_list[_aux](). */
1981 static struct vbase
*current_vbase_list
= NULL
;
1983 /* Return a pointer to a null-terminated list of struct vbase items.
1984 The vbasetype pointer of each item in the list points to the type
1985 information for a virtual base of the argument DCLASS.
1987 Helper function for virtual_base_list().
1988 Note: the list goes backward, right-to-left.
1989 virtual_base_list() copies the items out in reverse order. */
1992 virtual_base_list_aux (struct type
*dclass
)
1994 struct vbase
*tmp_vbase
;
1997 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
2000 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2002 /* Recurse on this ancestor, first */
2003 virtual_base_list_aux (TYPE_FIELD_TYPE (dclass
, i
));
2005 /* If this current base is itself virtual, add it to the list */
2006 if (BASETYPE_VIA_VIRTUAL (dclass
, i
))
2008 struct type
*basetype
= TYPE_FIELD_TYPE (dclass
, i
);
2010 /* Check if base already recorded */
2011 tmp_vbase
= current_vbase_list
;
2014 if (tmp_vbase
->vbasetype
== basetype
)
2015 break; /* found it */
2016 tmp_vbase
= tmp_vbase
->next
;
2019 if (!tmp_vbase
) /* normal exit from loop */
2021 /* Allocate new item for this virtual base */
2022 tmp_vbase
= (struct vbase
*) xmalloc (sizeof (struct vbase
));
2024 /* Stick it on at the end of the list */
2025 tmp_vbase
->vbasetype
= basetype
;
2026 tmp_vbase
->next
= current_vbase_list
;
2027 current_vbase_list
= tmp_vbase
;
2030 } /* for loop over bases */
2034 /* Compute the list of virtual bases in the right order. Virtual
2035 bases are laid out in the object's memory area in order of their
2036 occurrence in a depth-first, left-to-right search through the
2039 Argument DCLASS is the type whose virtual bases are required.
2040 Return value is the address of a null-terminated array of pointers
2041 to struct type items.
2043 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
2044 and may not work with other runtime models.
2046 This routine merely hands off the argument to virtual_base_list_aux()
2047 and then copies the result into an array to save space. */
2049 static struct type
**
2050 virtual_base_list (struct type
*dclass
)
2052 struct vbase
*tmp_vbase
;
2053 struct vbase
*tmp_vbase_2
;
2056 struct type
**vbase_array
;
2058 current_vbase_list
= NULL
;
2059 virtual_base_list_aux (dclass
);
2061 for (i
= 0, tmp_vbase
= current_vbase_list
;
2063 i
++, tmp_vbase
= tmp_vbase
->next
)
2068 vbase_array
= (struct type
**)
2069 xmalloc ((count
+ 1) * sizeof (struct type
*));
2071 for (i
= count
- 1, tmp_vbase
= current_vbase_list
;
2073 tmp_vbase
= tmp_vbase
->next
)
2074 vbase_array
[i
] = tmp_vbase
->vbasetype
;
2076 /* Get rid of constructed chain. */
2077 tmp_vbase_2
= tmp_vbase
= current_vbase_list
;
2080 tmp_vbase
= tmp_vbase
->next
;
2081 xfree (tmp_vbase_2
);
2082 tmp_vbase_2
= tmp_vbase
;
2085 vbase_array
[count
] = NULL
;
2089 /* Return the length of the virtual base list of the type DCLASS. */
2092 virtual_base_list_length (struct type
*dclass
)
2095 struct vbase
*tmp_vbase
;
2097 current_vbase_list
= NULL
;
2098 virtual_base_list_aux (dclass
);
2100 for (i
= 0, tmp_vbase
= current_vbase_list
;
2102 i
++, tmp_vbase
= tmp_vbase
->next
)
2107 /* Return the number of elements of the virtual base list of the type
2108 DCLASS, ignoring those appearing in the primary base (and its
2109 primary base, recursively). */
2112 virtual_base_list_length_skip_primaries (struct type
*dclass
)
2115 struct vbase
*tmp_vbase
;
2116 struct type
*primary
;
2118 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
2121 return virtual_base_list_length (dclass
);
2123 current_vbase_list
= NULL
;
2124 virtual_base_list_aux (dclass
);
2126 for (i
= 0, tmp_vbase
= current_vbase_list
;
2128 tmp_vbase
= tmp_vbase
->next
)
2130 if (virtual_base_index (tmp_vbase
->vbasetype
, primary
) >= 0)
2137 /* Return the index (position) of type BASE, which is a virtual base
2138 class of DCLASS, in the latter's virtual base list. A return of -1
2139 indicates "not found" or a problem. */
2142 virtual_base_index (struct type
*base
, struct type
*dclass
)
2144 struct type
*vbase
, **vbase_list
;
2147 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
2148 || (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
2151 vbase_list
= virtual_base_list (dclass
);
2152 for (i
= 0, vbase
= vbase_list
[0];
2154 vbase
= vbase_list
[++i
])
2159 return vbase
? i
: -1;
2162 /* Return the index (position) of type BASE, which is a virtual base
2163 class of DCLASS, in the latter's virtual base list. Skip over all
2164 bases that may appear in the virtual base list of the primary base
2165 class of DCLASS (recursively). A return of -1 indicates "not
2166 found" or a problem. */
2169 virtual_base_index_skip_primaries (struct type
*base
,
2170 struct type
*dclass
)
2172 struct type
*vbase
, **vbase_list
;
2174 struct type
*primary
;
2176 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
2177 || (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
2180 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
2182 vbase_list
= virtual_base_list (dclass
);
2183 for (i
= 0, j
= -1, vbase
= vbase_list
[0];
2185 vbase
= vbase_list
[++i
])
2188 || (virtual_base_index_skip_primaries (vbase
, primary
) < 0))
2194 return vbase
? j
: -1;
2197 /* Return position of a derived class DCLASS in the list of primary
2198 bases starting with the remotest ancestor. Position returned is
2202 class_index_in_primary_list (struct type
*dclass
)
2204 struct type
*pbc
; /* primary base class */
2206 /* Simply recurse on primary base */
2207 pbc
= TYPE_PRIMARY_BASE (dclass
);
2209 return 1 + class_index_in_primary_list (pbc
);
2214 /* Return a count of the number of virtual functions a type has. This
2215 includes all the virtual functions it inherits from its base
2218 /* pai: FIXME This doesn't do the right thing: count redefined virtual
2219 functions only once (latest redefinition). */
2222 count_virtual_fns (struct type
*dclass
)
2224 int fn
, oi
; /* function and overloaded instance indices */
2225 int vfuncs
; /* count to return */
2227 /* recurse on bases that can share virtual table */
2228 struct type
*pbc
= primary_base_class (dclass
);
2230 vfuncs
= count_virtual_fns (pbc
);
2234 for (fn
= 0; fn
< TYPE_NFN_FIELDS (dclass
); fn
++)
2235 for (oi
= 0; oi
< TYPE_FN_FIELDLIST_LENGTH (dclass
, fn
); oi
++)
2236 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, fn
), oi
))
2244 /* Functions for overload resolution begin here */
2246 /* Compare two badness vectors A and B and return the result.
2247 0 => A and B are identical
2248 1 => A and B are incomparable
2249 2 => A is better than B
2250 3 => A is worse than B */
2253 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
2257 short found_pos
= 0; /* any positives in c? */
2258 short found_neg
= 0; /* any negatives in c? */
2260 /* differing lengths => incomparable */
2261 if (a
->length
!= b
->length
)
2264 /* Subtract b from a */
2265 for (i
= 0; i
< a
->length
; i
++)
2267 tmp
= a
->rank
[i
] - b
->rank
[i
];
2277 return 1; /* incomparable */
2279 return 3; /* A > B */
2285 return 2; /* A < B */
2287 return 0; /* A == B */
2291 /* Rank a function by comparing its parameter types (PARMS, length
2292 NPARMS), to the types of an argument list (ARGS, length NARGS).
2293 Return a pointer to a badness vector. This has NARGS + 1
2296 struct badness_vector
*
2297 rank_function (struct type
**parms
, int nparms
,
2298 struct type
**args
, int nargs
)
2301 struct badness_vector
*bv
;
2302 int min_len
= nparms
< nargs
? nparms
: nargs
;
2304 bv
= xmalloc (sizeof (struct badness_vector
));
2305 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank */
2306 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
2308 /* First compare the lengths of the supplied lists.
2309 If there is a mismatch, set it to a high value. */
2311 /* pai/1997-06-03 FIXME: when we have debug info about default
2312 arguments and ellipsis parameter lists, we should consider those
2313 and rank the length-match more finely. */
2315 LENGTH_MATCH (bv
) = (nargs
!= nparms
) ? LENGTH_MISMATCH_BADNESS
: 0;
2317 /* Now rank all the parameters of the candidate function */
2318 for (i
= 1; i
<= min_len
; i
++)
2319 bv
->rank
[i
] = rank_one_type (parms
[i
-1], args
[i
-1]);
2321 /* If more arguments than parameters, add dummy entries */
2322 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2323 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2328 /* Compare the names of two integer types, assuming that any sign
2329 qualifiers have been checked already. We do it this way because
2330 there may be an "int" in the name of one of the types. */
2333 integer_types_same_name_p (const char *first
, const char *second
)
2335 int first_p
, second_p
;
2337 /* If both are shorts, return 1; if neither is a short, keep
2339 first_p
= (strstr (first
, "short") != NULL
);
2340 second_p
= (strstr (second
, "short") != NULL
);
2341 if (first_p
&& second_p
)
2343 if (first_p
|| second_p
)
2346 /* Likewise for long. */
2347 first_p
= (strstr (first
, "long") != NULL
);
2348 second_p
= (strstr (second
, "long") != NULL
);
2349 if (first_p
&& second_p
)
2351 if (first_p
|| second_p
)
2354 /* Likewise for char. */
2355 first_p
= (strstr (first
, "char") != NULL
);
2356 second_p
= (strstr (second
, "char") != NULL
);
2357 if (first_p
&& second_p
)
2359 if (first_p
|| second_p
)
2362 /* They must both be ints. */
2366 /* Compare one type (PARM) for compatibility with another (ARG).
2367 * PARM is intended to be the parameter type of a function; and
2368 * ARG is the supplied argument's type. This function tests if
2369 * the latter can be converted to the former.
2371 * Return 0 if they are identical types;
2372 * Otherwise, return an integer which corresponds to how compatible
2373 * PARM is to ARG. The higher the return value, the worse the match.
2374 * Generally the "bad" conversions are all uniformly assigned a 100. */
2377 rank_one_type (struct type
*parm
, struct type
*arg
)
2379 /* Identical type pointers. */
2380 /* However, this still doesn't catch all cases of same type for arg
2381 and param. The reason is that builtin types are different from
2382 the same ones constructed from the object. */
2386 /* Resolve typedefs */
2387 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2388 parm
= check_typedef (parm
);
2389 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2390 arg
= check_typedef (arg
);
2393 Well, damnit, if the names are exactly the same, I'll say they
2394 are exactly the same. This happens when we generate method
2395 stubs. The types won't point to the same address, but they
2396 really are the same.
2399 if (TYPE_NAME (parm
) && TYPE_NAME (arg
)
2400 && !strcmp (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2403 /* Check if identical after resolving typedefs. */
2407 /* See through references, since we can almost make non-references
2409 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2410 return (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
))
2411 + REFERENCE_CONVERSION_BADNESS
);
2412 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2413 return (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
)
2414 + REFERENCE_CONVERSION_BADNESS
);
2416 /* Debugging only. */
2417 fprintf_filtered (gdb_stderr
,
2418 "------ Arg is %s [%d], parm is %s [%d]\n",
2419 TYPE_NAME (arg
), TYPE_CODE (arg
),
2420 TYPE_NAME (parm
), TYPE_CODE (parm
));
2422 /* x -> y means arg of type x being supplied for parameter of type y */
2424 switch (TYPE_CODE (parm
))
2427 switch (TYPE_CODE (arg
))
2430 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2431 return VOID_PTR_CONVERSION_BADNESS
;
2433 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2434 TYPE_TARGET_TYPE (arg
));
2435 case TYPE_CODE_ARRAY
:
2436 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2437 TYPE_TARGET_TYPE (arg
));
2438 case TYPE_CODE_FUNC
:
2439 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
);
2441 case TYPE_CODE_ENUM
:
2442 case TYPE_CODE_FLAGS
:
2443 case TYPE_CODE_CHAR
:
2444 case TYPE_CODE_RANGE
:
2445 case TYPE_CODE_BOOL
:
2446 return POINTER_CONVERSION_BADNESS
;
2448 return INCOMPATIBLE_TYPE_BADNESS
;
2450 case TYPE_CODE_ARRAY
:
2451 switch (TYPE_CODE (arg
))
2454 case TYPE_CODE_ARRAY
:
2455 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2456 TYPE_TARGET_TYPE (arg
));
2458 return INCOMPATIBLE_TYPE_BADNESS
;
2460 case TYPE_CODE_FUNC
:
2461 switch (TYPE_CODE (arg
))
2463 case TYPE_CODE_PTR
: /* funcptr -> func */
2464 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
));
2466 return INCOMPATIBLE_TYPE_BADNESS
;
2469 switch (TYPE_CODE (arg
))
2472 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2474 /* Deal with signed, unsigned, and plain chars and
2475 signed and unsigned ints. */
2476 if (TYPE_NOSIGN (parm
))
2478 /* This case only for character types */
2479 if (TYPE_NOSIGN (arg
))
2480 return 0; /* plain char -> plain char */
2481 else /* signed/unsigned char -> plain char */
2482 return INTEGER_CONVERSION_BADNESS
;
2484 else if (TYPE_UNSIGNED (parm
))
2486 if (TYPE_UNSIGNED (arg
))
2488 /* unsigned int -> unsigned int, or
2489 unsigned long -> unsigned long */
2490 if (integer_types_same_name_p (TYPE_NAME (parm
),
2493 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2495 && integer_types_same_name_p (TYPE_NAME (parm
),
2497 return INTEGER_PROMOTION_BADNESS
; /* unsigned int -> unsigned long */
2499 return INTEGER_CONVERSION_BADNESS
; /* unsigned long -> unsigned int */
2503 if (integer_types_same_name_p (TYPE_NAME (arg
),
2505 && integer_types_same_name_p (TYPE_NAME (parm
),
2507 return INTEGER_CONVERSION_BADNESS
; /* signed long -> unsigned int */
2509 return INTEGER_CONVERSION_BADNESS
; /* signed int/long -> unsigned int/long */
2512 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2514 if (integer_types_same_name_p (TYPE_NAME (parm
),
2517 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2519 && integer_types_same_name_p (TYPE_NAME (parm
),
2521 return INTEGER_PROMOTION_BADNESS
;
2523 return INTEGER_CONVERSION_BADNESS
;
2526 return INTEGER_CONVERSION_BADNESS
;
2528 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2529 return INTEGER_PROMOTION_BADNESS
;
2531 return INTEGER_CONVERSION_BADNESS
;
2532 case TYPE_CODE_ENUM
:
2533 case TYPE_CODE_FLAGS
:
2534 case TYPE_CODE_CHAR
:
2535 case TYPE_CODE_RANGE
:
2536 case TYPE_CODE_BOOL
:
2537 return INTEGER_PROMOTION_BADNESS
;
2539 return INT_FLOAT_CONVERSION_BADNESS
;
2541 return NS_POINTER_CONVERSION_BADNESS
;
2543 return INCOMPATIBLE_TYPE_BADNESS
;
2546 case TYPE_CODE_ENUM
:
2547 switch (TYPE_CODE (arg
))
2550 case TYPE_CODE_CHAR
:
2551 case TYPE_CODE_RANGE
:
2552 case TYPE_CODE_BOOL
:
2553 case TYPE_CODE_ENUM
:
2554 return INTEGER_CONVERSION_BADNESS
;
2556 return INT_FLOAT_CONVERSION_BADNESS
;
2558 return INCOMPATIBLE_TYPE_BADNESS
;
2561 case TYPE_CODE_CHAR
:
2562 switch (TYPE_CODE (arg
))
2564 case TYPE_CODE_RANGE
:
2565 case TYPE_CODE_BOOL
:
2566 case TYPE_CODE_ENUM
:
2567 return INTEGER_CONVERSION_BADNESS
;
2569 return INT_FLOAT_CONVERSION_BADNESS
;
2571 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2572 return INTEGER_CONVERSION_BADNESS
;
2573 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2574 return INTEGER_PROMOTION_BADNESS
;
2575 /* >>> !! else fall through !! <<< */
2576 case TYPE_CODE_CHAR
:
2577 /* Deal with signed, unsigned, and plain chars for C++ and
2578 with int cases falling through from previous case. */
2579 if (TYPE_NOSIGN (parm
))
2581 if (TYPE_NOSIGN (arg
))
2584 return INTEGER_CONVERSION_BADNESS
;
2586 else if (TYPE_UNSIGNED (parm
))
2588 if (TYPE_UNSIGNED (arg
))
2591 return INTEGER_PROMOTION_BADNESS
;
2593 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2596 return INTEGER_CONVERSION_BADNESS
;
2598 return INCOMPATIBLE_TYPE_BADNESS
;
2601 case TYPE_CODE_RANGE
:
2602 switch (TYPE_CODE (arg
))
2605 case TYPE_CODE_CHAR
:
2606 case TYPE_CODE_RANGE
:
2607 case TYPE_CODE_BOOL
:
2608 case TYPE_CODE_ENUM
:
2609 return INTEGER_CONVERSION_BADNESS
;
2611 return INT_FLOAT_CONVERSION_BADNESS
;
2613 return INCOMPATIBLE_TYPE_BADNESS
;
2616 case TYPE_CODE_BOOL
:
2617 switch (TYPE_CODE (arg
))
2620 case TYPE_CODE_CHAR
:
2621 case TYPE_CODE_RANGE
:
2622 case TYPE_CODE_ENUM
:
2625 return BOOLEAN_CONVERSION_BADNESS
;
2626 case TYPE_CODE_BOOL
:
2629 return INCOMPATIBLE_TYPE_BADNESS
;
2633 switch (TYPE_CODE (arg
))
2636 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2637 return FLOAT_PROMOTION_BADNESS
;
2638 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2641 return FLOAT_CONVERSION_BADNESS
;
2643 case TYPE_CODE_BOOL
:
2644 case TYPE_CODE_ENUM
:
2645 case TYPE_CODE_RANGE
:
2646 case TYPE_CODE_CHAR
:
2647 return INT_FLOAT_CONVERSION_BADNESS
;
2649 return INCOMPATIBLE_TYPE_BADNESS
;
2652 case TYPE_CODE_COMPLEX
:
2653 switch (TYPE_CODE (arg
))
2654 { /* Strictly not needed for C++, but... */
2656 return FLOAT_PROMOTION_BADNESS
;
2657 case TYPE_CODE_COMPLEX
:
2660 return INCOMPATIBLE_TYPE_BADNESS
;
2663 case TYPE_CODE_STRUCT
:
2664 /* currently same as TYPE_CODE_CLASS */
2665 switch (TYPE_CODE (arg
))
2667 case TYPE_CODE_STRUCT
:
2668 /* Check for derivation */
2669 if (is_ancestor (parm
, arg
))
2670 return BASE_CONVERSION_BADNESS
;
2671 /* else fall through */
2673 return INCOMPATIBLE_TYPE_BADNESS
;
2676 case TYPE_CODE_UNION
:
2677 switch (TYPE_CODE (arg
))
2679 case TYPE_CODE_UNION
:
2681 return INCOMPATIBLE_TYPE_BADNESS
;
2684 case TYPE_CODE_MEMBERPTR
:
2685 switch (TYPE_CODE (arg
))
2688 return INCOMPATIBLE_TYPE_BADNESS
;
2691 case TYPE_CODE_METHOD
:
2692 switch (TYPE_CODE (arg
))
2696 return INCOMPATIBLE_TYPE_BADNESS
;
2700 switch (TYPE_CODE (arg
))
2704 return INCOMPATIBLE_TYPE_BADNESS
;
2709 switch (TYPE_CODE (arg
))
2713 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0),
2714 TYPE_FIELD_TYPE (arg
, 0));
2716 return INCOMPATIBLE_TYPE_BADNESS
;
2719 case TYPE_CODE_VOID
:
2721 return INCOMPATIBLE_TYPE_BADNESS
;
2722 } /* switch (TYPE_CODE (arg)) */
2726 /* End of functions for overload resolution */
2729 print_bit_vector (B_TYPE
*bits
, int nbits
)
2733 for (bitno
= 0; bitno
< nbits
; bitno
++)
2735 if ((bitno
% 8) == 0)
2737 puts_filtered (" ");
2739 if (B_TST (bits
, bitno
))
2740 printf_filtered (("1"));
2742 printf_filtered (("0"));
2746 /* Note the first arg should be the "this" pointer, we may not want to
2747 include it since we may get into a infinitely recursive
2751 print_arg_types (struct field
*args
, int nargs
, int spaces
)
2757 for (i
= 0; i
< nargs
; i
++)
2758 recursive_dump_type (args
[i
].type
, spaces
+ 2);
2763 dump_fn_fieldlists (struct type
*type
, int spaces
)
2769 printfi_filtered (spaces
, "fn_fieldlists ");
2770 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2771 printf_filtered ("\n");
2772 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2774 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2775 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2777 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2778 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2780 printf_filtered (_(") length %d\n"),
2781 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2782 for (overload_idx
= 0;
2783 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2786 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2788 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2789 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2791 printf_filtered (")\n");
2792 printfi_filtered (spaces
+ 8, "type ");
2793 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2795 printf_filtered ("\n");
2797 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2800 printfi_filtered (spaces
+ 8, "args ");
2801 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2803 printf_filtered ("\n");
2805 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2806 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
,
2809 printfi_filtered (spaces
+ 8, "fcontext ");
2810 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2812 printf_filtered ("\n");
2814 printfi_filtered (spaces
+ 8, "is_const %d\n",
2815 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2816 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2817 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2818 printfi_filtered (spaces
+ 8, "is_private %d\n",
2819 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2820 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2821 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2822 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2823 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2824 printfi_filtered (spaces
+ 8, "voffset %u\n",
2825 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2831 print_cplus_stuff (struct type
*type
, int spaces
)
2833 printfi_filtered (spaces
, "n_baseclasses %d\n",
2834 TYPE_N_BASECLASSES (type
));
2835 printfi_filtered (spaces
, "nfn_fields %d\n",
2836 TYPE_NFN_FIELDS (type
));
2837 printfi_filtered (spaces
, "nfn_fields_total %d\n",
2838 TYPE_NFN_FIELDS_TOTAL (type
));
2839 if (TYPE_N_BASECLASSES (type
) > 0)
2841 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2842 TYPE_N_BASECLASSES (type
));
2843 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
2845 printf_filtered (")");
2847 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2848 TYPE_N_BASECLASSES (type
));
2849 puts_filtered ("\n");
2851 if (TYPE_NFIELDS (type
) > 0)
2853 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2855 printfi_filtered (spaces
,
2856 "private_field_bits (%d bits at *",
2857 TYPE_NFIELDS (type
));
2858 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
2860 printf_filtered (")");
2861 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2862 TYPE_NFIELDS (type
));
2863 puts_filtered ("\n");
2865 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2867 printfi_filtered (spaces
,
2868 "protected_field_bits (%d bits at *",
2869 TYPE_NFIELDS (type
));
2870 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
2872 printf_filtered (")");
2873 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2874 TYPE_NFIELDS (type
));
2875 puts_filtered ("\n");
2878 if (TYPE_NFN_FIELDS (type
) > 0)
2880 dump_fn_fieldlists (type
, spaces
);
2885 print_bound_type (int bt
)
2889 case BOUND_CANNOT_BE_DETERMINED
:
2890 printf_filtered ("(BOUND_CANNOT_BE_DETERMINED)");
2892 case BOUND_BY_REF_ON_STACK
:
2893 printf_filtered ("(BOUND_BY_REF_ON_STACK)");
2895 case BOUND_BY_VALUE_ON_STACK
:
2896 printf_filtered ("(BOUND_BY_VALUE_ON_STACK)");
2898 case BOUND_BY_REF_IN_REG
:
2899 printf_filtered ("(BOUND_BY_REF_IN_REG)");
2901 case BOUND_BY_VALUE_IN_REG
:
2902 printf_filtered ("(BOUND_BY_VALUE_IN_REG)");
2905 printf_filtered ("(BOUND_SIMPLE)");
2908 printf_filtered (_("(unknown bound type)"));
2913 static struct obstack dont_print_type_obstack
;
2916 recursive_dump_type (struct type
*type
, int spaces
)
2921 obstack_begin (&dont_print_type_obstack
, 0);
2923 if (TYPE_NFIELDS (type
) > 0
2924 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
2926 struct type
**first_dont_print
2927 = (struct type
**) obstack_base (&dont_print_type_obstack
);
2929 int i
= (struct type
**)
2930 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
2934 if (type
== first_dont_print
[i
])
2936 printfi_filtered (spaces
, "type node ");
2937 gdb_print_host_address (type
, gdb_stdout
);
2938 printf_filtered (_(" <same as already seen type>\n"));
2943 obstack_ptr_grow (&dont_print_type_obstack
, type
);
2946 printfi_filtered (spaces
, "type node ");
2947 gdb_print_host_address (type
, gdb_stdout
);
2948 printf_filtered ("\n");
2949 printfi_filtered (spaces
, "name '%s' (",
2950 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
2951 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
2952 printf_filtered (")\n");
2953 printfi_filtered (spaces
, "tagname '%s' (",
2954 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
2955 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
2956 printf_filtered (")\n");
2957 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
2958 switch (TYPE_CODE (type
))
2960 case TYPE_CODE_UNDEF
:
2961 printf_filtered ("(TYPE_CODE_UNDEF)");
2964 printf_filtered ("(TYPE_CODE_PTR)");
2966 case TYPE_CODE_ARRAY
:
2967 printf_filtered ("(TYPE_CODE_ARRAY)");
2969 case TYPE_CODE_STRUCT
:
2970 printf_filtered ("(TYPE_CODE_STRUCT)");
2972 case TYPE_CODE_UNION
:
2973 printf_filtered ("(TYPE_CODE_UNION)");
2975 case TYPE_CODE_ENUM
:
2976 printf_filtered ("(TYPE_CODE_ENUM)");
2978 case TYPE_CODE_FLAGS
:
2979 printf_filtered ("(TYPE_CODE_FLAGS)");
2981 case TYPE_CODE_FUNC
:
2982 printf_filtered ("(TYPE_CODE_FUNC)");
2985 printf_filtered ("(TYPE_CODE_INT)");
2988 printf_filtered ("(TYPE_CODE_FLT)");
2990 case TYPE_CODE_VOID
:
2991 printf_filtered ("(TYPE_CODE_VOID)");
2994 printf_filtered ("(TYPE_CODE_SET)");
2996 case TYPE_CODE_RANGE
:
2997 printf_filtered ("(TYPE_CODE_RANGE)");
2999 case TYPE_CODE_STRING
:
3000 printf_filtered ("(TYPE_CODE_STRING)");
3002 case TYPE_CODE_BITSTRING
:
3003 printf_filtered ("(TYPE_CODE_BITSTRING)");
3005 case TYPE_CODE_ERROR
:
3006 printf_filtered ("(TYPE_CODE_ERROR)");
3008 case TYPE_CODE_MEMBERPTR
:
3009 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
3011 case TYPE_CODE_METHODPTR
:
3012 printf_filtered ("(TYPE_CODE_METHODPTR)");
3014 case TYPE_CODE_METHOD
:
3015 printf_filtered ("(TYPE_CODE_METHOD)");
3018 printf_filtered ("(TYPE_CODE_REF)");
3020 case TYPE_CODE_CHAR
:
3021 printf_filtered ("(TYPE_CODE_CHAR)");
3023 case TYPE_CODE_BOOL
:
3024 printf_filtered ("(TYPE_CODE_BOOL)");
3026 case TYPE_CODE_COMPLEX
:
3027 printf_filtered ("(TYPE_CODE_COMPLEX)");
3029 case TYPE_CODE_TYPEDEF
:
3030 printf_filtered ("(TYPE_CODE_TYPEDEF)");
3032 case TYPE_CODE_TEMPLATE
:
3033 printf_filtered ("(TYPE_CODE_TEMPLATE)");
3035 case TYPE_CODE_TEMPLATE_ARG
:
3036 printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)");
3038 case TYPE_CODE_NAMESPACE
:
3039 printf_filtered ("(TYPE_CODE_NAMESPACE)");
3042 printf_filtered ("(UNKNOWN TYPE CODE)");
3045 puts_filtered ("\n");
3046 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
3047 printfi_filtered (spaces
, "upper_bound_type 0x%x ",
3048 TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
3049 print_bound_type (TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
3050 puts_filtered ("\n");
3051 printfi_filtered (spaces
, "lower_bound_type 0x%x ",
3052 TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
3053 print_bound_type (TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
3054 puts_filtered ("\n");
3055 printfi_filtered (spaces
, "objfile ");
3056 gdb_print_host_address (TYPE_OBJFILE (type
), gdb_stdout
);
3057 printf_filtered ("\n");
3058 printfi_filtered (spaces
, "target_type ");
3059 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
3060 printf_filtered ("\n");
3061 if (TYPE_TARGET_TYPE (type
) != NULL
)
3063 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
3065 printfi_filtered (spaces
, "pointer_type ");
3066 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
3067 printf_filtered ("\n");
3068 printfi_filtered (spaces
, "reference_type ");
3069 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
3070 printf_filtered ("\n");
3071 printfi_filtered (spaces
, "type_chain ");
3072 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
3073 printf_filtered ("\n");
3074 printfi_filtered (spaces
, "instance_flags 0x%x",
3075 TYPE_INSTANCE_FLAGS (type
));
3076 if (TYPE_CONST (type
))
3078 puts_filtered (" TYPE_FLAG_CONST");
3080 if (TYPE_VOLATILE (type
))
3082 puts_filtered (" TYPE_FLAG_VOLATILE");
3084 if (TYPE_CODE_SPACE (type
))
3086 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3088 if (TYPE_DATA_SPACE (type
))
3090 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3092 if (TYPE_ADDRESS_CLASS_1 (type
))
3094 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3096 if (TYPE_ADDRESS_CLASS_2 (type
))
3098 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3100 puts_filtered ("\n");
3101 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
3102 if (TYPE_UNSIGNED (type
))
3104 puts_filtered (" TYPE_FLAG_UNSIGNED");
3106 if (TYPE_NOSIGN (type
))
3108 puts_filtered (" TYPE_FLAG_NOSIGN");
3110 if (TYPE_STUB (type
))
3112 puts_filtered (" TYPE_FLAG_STUB");
3114 if (TYPE_TARGET_STUB (type
))
3116 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3118 if (TYPE_STATIC (type
))
3120 puts_filtered (" TYPE_FLAG_STATIC");
3122 if (TYPE_PROTOTYPED (type
))
3124 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3126 if (TYPE_INCOMPLETE (type
))
3128 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3130 if (TYPE_VARARGS (type
))
3132 puts_filtered (" TYPE_FLAG_VARARGS");
3134 /* This is used for things like AltiVec registers on ppc. Gcc emits
3135 an attribute for the array type, which tells whether or not we
3136 have a vector, instead of a regular array. */
3137 if (TYPE_VECTOR (type
))
3139 puts_filtered (" TYPE_FLAG_VECTOR");
3141 puts_filtered ("\n");
3142 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
3143 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
3144 puts_filtered ("\n");
3145 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
3147 printfi_filtered (spaces
+ 2,
3148 "[%d] bitpos %d bitsize %d type ",
3149 idx
, TYPE_FIELD_BITPOS (type
, idx
),
3150 TYPE_FIELD_BITSIZE (type
, idx
));
3151 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
3152 printf_filtered (" name '%s' (",
3153 TYPE_FIELD_NAME (type
, idx
) != NULL
3154 ? TYPE_FIELD_NAME (type
, idx
)
3156 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
3157 printf_filtered (")\n");
3158 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
3160 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
3163 printfi_filtered (spaces
, "vptr_basetype ");
3164 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
3165 puts_filtered ("\n");
3166 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
3168 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
3170 printfi_filtered (spaces
, "vptr_fieldno %d\n",
3171 TYPE_VPTR_FIELDNO (type
));
3172 switch (TYPE_CODE (type
))
3174 case TYPE_CODE_STRUCT
:
3175 printfi_filtered (spaces
, "cplus_stuff ");
3176 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
),
3178 puts_filtered ("\n");
3179 print_cplus_stuff (type
, spaces
);
3183 printfi_filtered (spaces
, "floatformat ");
3184 if (TYPE_FLOATFORMAT (type
) == NULL
)
3185 puts_filtered ("(null)");
3188 puts_filtered ("{ ");
3189 if (TYPE_FLOATFORMAT (type
)[0] == NULL
3190 || TYPE_FLOATFORMAT (type
)[0]->name
== NULL
)
3191 puts_filtered ("(null)");
3193 puts_filtered (TYPE_FLOATFORMAT (type
)[0]->name
);
3195 puts_filtered (", ");
3196 if (TYPE_FLOATFORMAT (type
)[1] == NULL
3197 || TYPE_FLOATFORMAT (type
)[1]->name
== NULL
)
3198 puts_filtered ("(null)");
3200 puts_filtered (TYPE_FLOATFORMAT (type
)[1]->name
);
3202 puts_filtered (" }");
3204 puts_filtered ("\n");
3208 /* We have to pick one of the union types to be able print and
3209 test the value. Pick cplus_struct_type, even though we know
3210 it isn't any particular one. */
3211 printfi_filtered (spaces
, "type_specific ");
3212 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
3213 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
3215 printf_filtered (_(" (unknown data form)"));
3217 printf_filtered ("\n");
3222 obstack_free (&dont_print_type_obstack
, NULL
);
3225 /* Trivial helpers for the libiberty hash table, for mapping one
3230 struct type
*old
, *new;
3234 type_pair_hash (const void *item
)
3236 const struct type_pair
*pair
= item
;
3237 return htab_hash_pointer (pair
->old
);
3241 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
3243 const struct type_pair
*lhs
= item_lhs
, *rhs
= item_rhs
;
3244 return lhs
->old
== rhs
->old
;
3247 /* Allocate the hash table used by copy_type_recursive to walk
3248 types without duplicates. We use OBJFILE's obstack, because
3249 OBJFILE is about to be deleted. */
3252 create_copied_types_hash (struct objfile
*objfile
)
3254 return htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
3255 NULL
, &objfile
->objfile_obstack
,
3256 hashtab_obstack_allocate
,
3257 dummy_obstack_deallocate
);
3260 /* Recursively copy (deep copy) TYPE, if it is associated with
3261 OBJFILE. Return a new type allocated using malloc, a saved type if
3262 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
3263 not associated with OBJFILE. */
3266 copy_type_recursive (struct objfile
*objfile
,
3268 htab_t copied_types
)
3270 struct type_pair
*stored
, pair
;
3272 struct type
*new_type
;
3274 if (TYPE_OBJFILE (type
) == NULL
)
3277 /* This type shouldn't be pointing to any types in other objfiles;
3278 if it did, the type might disappear unexpectedly. */
3279 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
3282 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
3284 return ((struct type_pair
*) *slot
)->new;
3286 new_type
= alloc_type (NULL
);
3288 /* We must add the new type to the hash table immediately, in case
3289 we encounter this type again during a recursive call below. */
3290 stored
= xmalloc (sizeof (struct type_pair
));
3292 stored
->new = new_type
;
3295 /* Copy the common fields of types. */
3296 TYPE_CODE (new_type
) = TYPE_CODE (type
);
3297 TYPE_ARRAY_UPPER_BOUND_TYPE (new_type
) =
3298 TYPE_ARRAY_UPPER_BOUND_TYPE (type
);
3299 TYPE_ARRAY_LOWER_BOUND_TYPE (new_type
) =
3300 TYPE_ARRAY_LOWER_BOUND_TYPE (type
);
3301 if (TYPE_NAME (type
))
3302 TYPE_NAME (new_type
) = xstrdup (TYPE_NAME (type
));
3303 if (TYPE_TAG_NAME (type
))
3304 TYPE_TAG_NAME (new_type
) = xstrdup (TYPE_TAG_NAME (type
));
3305 TYPE_FLAGS (new_type
) = TYPE_FLAGS (type
);
3306 TYPE_VPTR_FIELDNO (new_type
) = TYPE_VPTR_FIELDNO (type
);
3308 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
3309 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
3311 /* Copy the fields. */
3312 TYPE_NFIELDS (new_type
) = TYPE_NFIELDS (type
);
3313 if (TYPE_NFIELDS (type
))
3317 nfields
= TYPE_NFIELDS (type
);
3318 TYPE_FIELDS (new_type
) = xmalloc (sizeof (struct field
) * nfields
);
3319 for (i
= 0; i
< nfields
; i
++)
3321 TYPE_FIELD_ARTIFICIAL (new_type
, i
) =
3322 TYPE_FIELD_ARTIFICIAL (type
, i
);
3323 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
3324 if (TYPE_FIELD_TYPE (type
, i
))
3325 TYPE_FIELD_TYPE (new_type
, i
)
3326 = copy_type_recursive (objfile
, TYPE_FIELD_TYPE (type
, i
),
3328 if (TYPE_FIELD_NAME (type
, i
))
3329 TYPE_FIELD_NAME (new_type
, i
) =
3330 xstrdup (TYPE_FIELD_NAME (type
, i
));
3331 if (TYPE_FIELD_STATIC_HAS_ADDR (type
, i
))
3332 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type
, i
),
3333 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
3334 else if (TYPE_FIELD_STATIC (type
, i
))
3335 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type
, i
),
3336 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
,
3340 TYPE_FIELD_BITPOS (new_type
, i
) =
3341 TYPE_FIELD_BITPOS (type
, i
);
3342 TYPE_FIELD_STATIC_KIND (new_type
, i
) = 0;
3347 /* Copy pointers to other types. */
3348 if (TYPE_TARGET_TYPE (type
))
3349 TYPE_TARGET_TYPE (new_type
) =
3350 copy_type_recursive (objfile
,
3351 TYPE_TARGET_TYPE (type
),
3353 if (TYPE_VPTR_BASETYPE (type
))
3354 TYPE_VPTR_BASETYPE (new_type
) =
3355 copy_type_recursive (objfile
,
3356 TYPE_VPTR_BASETYPE (type
),
3358 /* Maybe copy the type_specific bits.
3360 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3361 base classes and methods. There's no fundamental reason why we
3362 can't, but at the moment it is not needed. */
3364 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
3365 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
3366 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3367 || TYPE_CODE (type
) == TYPE_CODE_UNION
3368 || TYPE_CODE (type
) == TYPE_CODE_TEMPLATE
3369 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
3370 INIT_CPLUS_SPECIFIC (new_type
);
3375 static struct type
*
3376 build_flt (int bit
, char *name
, const struct floatformat
**floatformats
)
3382 gdb_assert (floatformats
!= NULL
);
3383 gdb_assert (floatformats
[0] != NULL
&& floatformats
[1] != NULL
);
3384 bit
= floatformats
[0]->totalsize
;
3386 gdb_assert (bit
>= 0);
3388 t
= init_type (TYPE_CODE_FLT
, bit
/ TARGET_CHAR_BIT
, 0, name
, NULL
);
3389 TYPE_FLOATFORMAT (t
) = floatformats
;
3393 static struct gdbarch_data
*gdbtypes_data
;
3395 const struct builtin_type
*
3396 builtin_type (struct gdbarch
*gdbarch
)
3398 return gdbarch_data (gdbarch
, gdbtypes_data
);
3402 static struct type
*
3403 build_complex (int bit
, char *name
, struct type
*target_type
)
3406 if (bit
<= 0 || target_type
== builtin_type_error
)
3408 gdb_assert (builtin_type_error
!= NULL
);
3409 return builtin_type_error
;
3411 t
= init_type (TYPE_CODE_COMPLEX
, 2 * bit
/ TARGET_CHAR_BIT
,
3412 0, name
, (struct objfile
*) NULL
);
3413 TYPE_TARGET_TYPE (t
) = target_type
;
3418 gdbtypes_post_init (struct gdbarch
*gdbarch
)
3420 struct builtin_type
*builtin_type
3421 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
3423 builtin_type
->builtin_void
=
3424 init_type (TYPE_CODE_VOID
, 1,
3426 "void", (struct objfile
*) NULL
);
3427 builtin_type
->builtin_char
=
3428 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3430 | (gdbarch_char_signed (current_gdbarch
) ?
3431 0 : TYPE_FLAG_UNSIGNED
)),
3432 "char", (struct objfile
*) NULL
);
3433 builtin_type
->builtin_true_char
=
3434 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3436 "true character", (struct objfile
*) NULL
);
3437 builtin_type
->builtin_true_unsigned_char
=
3438 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3440 "true character", (struct objfile
*) NULL
);
3441 builtin_type
->builtin_signed_char
=
3442 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3444 "signed char", (struct objfile
*) NULL
);
3445 builtin_type
->builtin_unsigned_char
=
3446 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3448 "unsigned char", (struct objfile
*) NULL
);
3449 builtin_type
->builtin_short
=
3450 init_type (TYPE_CODE_INT
,
3451 gdbarch_short_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
3452 0, "short", (struct objfile
*) NULL
);
3453 builtin_type
->builtin_unsigned_short
=
3454 init_type (TYPE_CODE_INT
,
3455 gdbarch_short_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
3456 TYPE_FLAG_UNSIGNED
, "unsigned short",
3457 (struct objfile
*) NULL
);
3458 builtin_type
->builtin_int
=
3459 init_type (TYPE_CODE_INT
,
3460 gdbarch_int_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
3461 0, "int", (struct objfile
*) NULL
);
3462 builtin_type
->builtin_unsigned_int
=
3463 init_type (TYPE_CODE_INT
,
3464 gdbarch_int_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
3465 TYPE_FLAG_UNSIGNED
, "unsigned int",
3466 (struct objfile
*) NULL
);
3467 builtin_type
->builtin_long
=
3468 init_type (TYPE_CODE_INT
,
3469 gdbarch_long_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
3470 0, "long", (struct objfile
*) NULL
);
3471 builtin_type
->builtin_unsigned_long
=
3472 init_type (TYPE_CODE_INT
,
3473 gdbarch_long_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
3474 TYPE_FLAG_UNSIGNED
, "unsigned long",
3475 (struct objfile
*) NULL
);
3476 builtin_type
->builtin_long_long
=
3477 init_type (TYPE_CODE_INT
,
3478 gdbarch_long_long_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
3479 0, "long long", (struct objfile
*) NULL
);
3480 builtin_type
->builtin_unsigned_long_long
=
3481 init_type (TYPE_CODE_INT
,
3482 gdbarch_long_long_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
3483 TYPE_FLAG_UNSIGNED
, "unsigned long long",
3484 (struct objfile
*) NULL
);
3485 builtin_type
->builtin_float
3486 = build_flt (gdbarch_float_bit (gdbarch
), "float",
3487 gdbarch_float_format (gdbarch
));
3488 builtin_type
->builtin_double
3489 = build_flt (gdbarch_double_bit (gdbarch
), "double",
3490 gdbarch_double_format (gdbarch
));
3491 builtin_type
->builtin_long_double
3492 = build_flt (gdbarch_long_double_bit (gdbarch
), "long double",
3493 gdbarch_long_double_format (gdbarch
));
3494 builtin_type
->builtin_complex
3495 = build_complex (gdbarch_float_bit (gdbarch
), "complex",
3496 builtin_type
->builtin_float
);
3497 builtin_type
->builtin_double_complex
3498 = build_complex (gdbarch_double_bit (gdbarch
), "double complex",
3499 builtin_type
->builtin_double
);
3500 builtin_type
->builtin_string
=
3501 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3503 "string", (struct objfile
*) NULL
);
3504 builtin_type
->builtin_bool
=
3505 init_type (TYPE_CODE_BOOL
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3507 "bool", (struct objfile
*) NULL
);
3509 /* Pointer/Address types. */
3511 /* NOTE: on some targets, addresses and pointers are not necessarily
3512 the same --- for example, on the D10V, pointers are 16 bits long,
3513 but addresses are 32 bits long. See doc/gdbint.texinfo,
3514 ``Pointers Are Not Always Addresses''.
3517 - gdb's `struct type' always describes the target's
3519 - gdb's `struct value' objects should always hold values in
3521 - gdb's CORE_ADDR values are addresses in the unified virtual
3522 address space that the assembler and linker work with. Thus,
3523 since target_read_memory takes a CORE_ADDR as an argument, it
3524 can access any memory on the target, even if the processor has
3525 separate code and data address spaces.
3528 - If v is a value holding a D10V code pointer, its contents are
3529 in target form: a big-endian address left-shifted two bits.
3530 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3531 sizeof (void *) == 2 on the target.
3533 In this context, builtin_type->CORE_ADDR is a bit odd: it's a
3534 target type for a value the target will never see. It's only
3535 used to hold the values of (typeless) linker symbols, which are
3536 indeed in the unified virtual address space. */
3538 builtin_type
->builtin_data_ptr
=
3539 make_pointer_type (builtin_type
->builtin_void
, NULL
);
3540 builtin_type
->builtin_func_ptr
=
3541 lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
3542 builtin_type
->builtin_core_addr
=
3543 init_type (TYPE_CODE_INT
,
3544 gdbarch_addr_bit (current_gdbarch
) / 8,
3546 "__CORE_ADDR", (struct objfile
*) NULL
);
3549 /* The following set of types is used for symbols with no
3550 debug information. */
3551 builtin_type
->nodebug_text_symbol
=
3552 init_type (TYPE_CODE_FUNC
, 1, 0,
3553 "<text variable, no debug info>", NULL
);
3554 TYPE_TARGET_TYPE (builtin_type
->nodebug_text_symbol
) =
3555 builtin_type
->builtin_int
;
3556 builtin_type
->nodebug_data_symbol
=
3557 init_type (TYPE_CODE_INT
,
3558 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3559 "<data variable, no debug info>", NULL
);
3560 builtin_type
->nodebug_unknown_symbol
=
3561 init_type (TYPE_CODE_INT
, 1, 0,
3562 "<variable (not text or data), no debug info>", NULL
);
3563 builtin_type
->nodebug_tls_symbol
=
3564 init_type (TYPE_CODE_INT
,
3565 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3566 "<thread local variable, no debug info>", NULL
);
3568 return builtin_type
;
3571 extern void _initialize_gdbtypes (void);
3573 _initialize_gdbtypes (void)
3575 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
3577 /* FIXME: The following types are architecture-neutral. However,
3578 they contain pointer_type and reference_type fields potentially
3579 caching pointer or reference types that *are* architecture
3583 init_type (TYPE_CODE_INT
, 0 / 8,
3585 "int0_t", (struct objfile
*) NULL
);
3587 init_type (TYPE_CODE_INT
, 8 / 8,
3589 "int8_t", (struct objfile
*) NULL
);
3590 builtin_type_uint8
=
3591 init_type (TYPE_CODE_INT
, 8 / 8,
3592 TYPE_FLAG_UNSIGNED
| TYPE_FLAG_NOTTEXT
,
3593 "uint8_t", (struct objfile
*) NULL
);
3594 builtin_type_int16
=
3595 init_type (TYPE_CODE_INT
, 16 / 8,
3597 "int16_t", (struct objfile
*) NULL
);
3598 builtin_type_uint16
=
3599 init_type (TYPE_CODE_INT
, 16 / 8,
3601 "uint16_t", (struct objfile
*) NULL
);
3602 builtin_type_int32
=
3603 init_type (TYPE_CODE_INT
, 32 / 8,
3605 "int32_t", (struct objfile
*) NULL
);
3606 builtin_type_uint32
=
3607 init_type (TYPE_CODE_INT
, 32 / 8,
3609 "uint32_t", (struct objfile
*) NULL
);
3610 builtin_type_int64
=
3611 init_type (TYPE_CODE_INT
, 64 / 8,
3613 "int64_t", (struct objfile
*) NULL
);
3614 builtin_type_uint64
=
3615 init_type (TYPE_CODE_INT
, 64 / 8,
3617 "uint64_t", (struct objfile
*) NULL
);
3618 builtin_type_int128
=
3619 init_type (TYPE_CODE_INT
, 128 / 8,
3621 "int128_t", (struct objfile
*) NULL
);
3622 builtin_type_uint128
=
3623 init_type (TYPE_CODE_INT
, 128 / 8,
3625 "uint128_t", (struct objfile
*) NULL
);
3627 builtin_type_ieee_single
=
3628 build_flt (-1, "builtin_type_ieee_single", floatformats_ieee_single
);
3629 builtin_type_ieee_double
=
3630 build_flt (-1, "builtin_type_ieee_double", floatformats_ieee_double
);
3631 builtin_type_i387_ext
=
3632 build_flt (-1, "builtin_type_i387_ext", floatformats_i387_ext
);
3633 builtin_type_m68881_ext
=
3634 build_flt (-1, "builtin_type_m68881_ext", floatformats_m68881_ext
);
3635 builtin_type_arm_ext
=
3636 build_flt (-1, "builtin_type_arm_ext", floatformats_arm_ext
);
3637 builtin_type_ia64_spill
=
3638 build_flt (-1, "builtin_type_ia64_spill", floatformats_ia64_spill
);
3639 builtin_type_ia64_quad
=
3640 build_flt (-1, "builtin_type_ia64_quad", floatformats_ia64_quad
);
3642 add_setshow_zinteger_cmd ("overload", no_class
, &overload_debug
, _("\
3643 Set debugging of C++ overloading."), _("\
3644 Show debugging of C++ overloading."), _("\
3645 When enabled, ranking of the functions is displayed."),
3647 show_overload_debug
,
3648 &setdebuglist
, &showdebuglist
);
3650 /* Add user knob for controlling resolution of opaque types. */
3651 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
3652 &opaque_type_resolution
, _("\
3653 Set resolution of opaque struct/class/union types (if set before loading symbols)."), _("\
3654 Show resolution of opaque struct/class/union types (if set before loading symbols)."), NULL
,
3656 show_opaque_type_resolution
,
3657 &setlist
, &showlist
);