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
] = {
98 const struct floatformat
*floatformats_ibm_long_double
[BFD_ENDIAN_UNKNOWN
] = {
99 &floatformat_ibm_long_double
,
100 &floatformat_ibm_long_double
103 struct type
*builtin_type_ieee_single
;
104 struct type
*builtin_type_ieee_double
;
105 struct type
*builtin_type_i387_ext
;
106 struct type
*builtin_type_m68881_ext
;
107 struct type
*builtin_type_arm_ext
;
108 struct type
*builtin_type_ia64_spill
;
109 struct type
*builtin_type_ia64_quad
;
112 int opaque_type_resolution
= 1;
114 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
115 struct cmd_list_element
*c
,
118 fprintf_filtered (file
, _("\
119 Resolution of opaque struct/class/union types (if set before loading symbols) is %s.\n"),
123 int overload_debug
= 0;
125 show_overload_debug (struct ui_file
*file
, int from_tty
,
126 struct cmd_list_element
*c
, const char *value
)
128 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"),
136 }; /* Maximum extension is 128! FIXME */
138 static void print_bit_vector (B_TYPE
*, int);
139 static void print_arg_types (struct field
*, int, int);
140 static void dump_fn_fieldlists (struct type
*, int);
141 static void print_cplus_stuff (struct type
*, int);
144 /* Alloc a new type structure and fill it with some defaults. If
145 OBJFILE is non-NULL, then allocate the space for the type structure
146 in that objfile's objfile_obstack. Otherwise allocate the new type
147 structure by xmalloc () (for permanent types). */
150 alloc_type (struct objfile
*objfile
)
154 /* Alloc the structure and start off with all fields zeroed. */
158 type
= xmalloc (sizeof (struct type
));
159 memset (type
, 0, sizeof (struct type
));
160 TYPE_MAIN_TYPE (type
) = xmalloc (sizeof (struct main_type
));
164 type
= obstack_alloc (&objfile
->objfile_obstack
,
165 sizeof (struct type
));
166 memset (type
, 0, sizeof (struct type
));
167 TYPE_MAIN_TYPE (type
) = obstack_alloc (&objfile
->objfile_obstack
,
168 sizeof (struct main_type
));
169 OBJSTAT (objfile
, n_types
++);
171 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
173 /* Initialize the fields that might not be zero. */
175 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
176 TYPE_OBJFILE (type
) = objfile
;
177 TYPE_VPTR_FIELDNO (type
) = -1;
178 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
183 /* Alloc a new type instance structure, fill it with some defaults,
184 and point it at OLDTYPE. Allocate the new type instance from the
185 same place as OLDTYPE. */
188 alloc_type_instance (struct type
*oldtype
)
192 /* Allocate the structure. */
194 if (TYPE_OBJFILE (oldtype
) == NULL
)
196 type
= xmalloc (sizeof (struct type
));
197 memset (type
, 0, sizeof (struct type
));
201 type
= obstack_alloc (&TYPE_OBJFILE (oldtype
)->objfile_obstack
,
202 sizeof (struct type
));
203 memset (type
, 0, sizeof (struct type
));
205 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
207 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
212 /* Clear all remnants of the previous type at TYPE, in preparation for
213 replacing it with something else. */
215 smash_type (struct type
*type
)
217 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
219 /* For now, delete the rings. */
220 TYPE_CHAIN (type
) = type
;
222 /* For now, leave the pointer/reference types alone. */
225 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
226 to a pointer to memory where the pointer type should be stored.
227 If *TYPEPTR is zero, update it to point to the pointer type we return.
228 We allocate new memory if needed. */
231 make_pointer_type (struct type
*type
, struct type
**typeptr
)
233 struct type
*ntype
; /* New type */
234 struct objfile
*objfile
;
237 ntype
= TYPE_POINTER_TYPE (type
);
242 return ntype
; /* Don't care about alloc,
243 and have new type. */
244 else if (*typeptr
== 0)
246 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
251 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
253 ntype
= alloc_type (TYPE_OBJFILE (type
));
257 else /* We have storage, but need to reset it. */
260 objfile
= TYPE_OBJFILE (ntype
);
261 chain
= TYPE_CHAIN (ntype
);
263 TYPE_CHAIN (ntype
) = chain
;
264 TYPE_OBJFILE (ntype
) = objfile
;
267 TYPE_TARGET_TYPE (ntype
) = type
;
268 TYPE_POINTER_TYPE (type
) = ntype
;
270 /* FIXME! Assume the machine has only one representation for
273 TYPE_LENGTH (ntype
) =
274 gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
;
275 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
277 /* Mark pointers as unsigned. The target converts between pointers
278 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
279 gdbarch_address_to_pointer. */
280 TYPE_FLAGS (ntype
) |= TYPE_FLAG_UNSIGNED
;
282 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
283 TYPE_POINTER_TYPE (type
) = ntype
;
285 /* Update the length of all the other variants of this type. */
286 chain
= TYPE_CHAIN (ntype
);
287 while (chain
!= ntype
)
289 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
290 chain
= TYPE_CHAIN (chain
);
296 /* Given a type TYPE, return a type of pointers to that type.
297 May need to construct such a type if this is the first use. */
300 lookup_pointer_type (struct type
*type
)
302 return make_pointer_type (type
, (struct type
**) 0);
305 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
306 points to a pointer to memory where the reference type should be
307 stored. If *TYPEPTR is zero, update it to point to the reference
308 type we return. We allocate new memory if needed. */
311 make_reference_type (struct type
*type
, struct type
**typeptr
)
313 struct type
*ntype
; /* New type */
314 struct objfile
*objfile
;
317 ntype
= TYPE_REFERENCE_TYPE (type
);
322 return ntype
; /* Don't care about alloc,
323 and have new type. */
324 else if (*typeptr
== 0)
326 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
331 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
333 ntype
= alloc_type (TYPE_OBJFILE (type
));
337 else /* We have storage, but need to reset it. */
340 objfile
= TYPE_OBJFILE (ntype
);
341 chain
= TYPE_CHAIN (ntype
);
343 TYPE_CHAIN (ntype
) = chain
;
344 TYPE_OBJFILE (ntype
) = objfile
;
347 TYPE_TARGET_TYPE (ntype
) = type
;
348 TYPE_REFERENCE_TYPE (type
) = ntype
;
350 /* FIXME! Assume the machine has only one representation for
351 references, and that it matches the (only) representation for
354 TYPE_LENGTH (ntype
) = gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
;
355 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
357 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
358 TYPE_REFERENCE_TYPE (type
) = ntype
;
360 /* Update the length of all the other variants of this type. */
361 chain
= TYPE_CHAIN (ntype
);
362 while (chain
!= ntype
)
364 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
365 chain
= TYPE_CHAIN (chain
);
371 /* Same as above, but caller doesn't care about memory allocation
375 lookup_reference_type (struct type
*type
)
377 return make_reference_type (type
, (struct type
**) 0);
380 /* Lookup a function type that returns type TYPE. TYPEPTR, if
381 nonzero, points to a pointer to memory where the function type
382 should be stored. If *TYPEPTR is zero, update it to point to the
383 function type we return. We allocate new memory if needed. */
386 make_function_type (struct type
*type
, struct type
**typeptr
)
388 struct type
*ntype
; /* New type */
389 struct objfile
*objfile
;
391 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
393 ntype
= alloc_type (TYPE_OBJFILE (type
));
397 else /* We have storage, but need to reset it. */
400 objfile
= TYPE_OBJFILE (ntype
);
402 TYPE_OBJFILE (ntype
) = objfile
;
405 TYPE_TARGET_TYPE (ntype
) = type
;
407 TYPE_LENGTH (ntype
) = 1;
408 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
414 /* Given a type TYPE, return a type of functions that return that type.
415 May need to construct such a type if this is the first use. */
418 lookup_function_type (struct type
*type
)
420 return make_function_type (type
, (struct type
**) 0);
423 /* Identify address space identifier by name --
424 return the integer flag defined in gdbtypes.h. */
426 address_space_name_to_int (char *space_identifier
)
428 struct gdbarch
*gdbarch
= current_gdbarch
;
430 /* Check for known address space delimiters. */
431 if (!strcmp (space_identifier
, "code"))
432 return TYPE_FLAG_CODE_SPACE
;
433 else if (!strcmp (space_identifier
, "data"))
434 return TYPE_FLAG_DATA_SPACE
;
435 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
436 && gdbarch_address_class_name_to_type_flags (gdbarch
,
441 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
444 /* Identify address space identifier by integer flag as defined in
445 gdbtypes.h -- return the string version of the adress space name. */
448 address_space_int_to_name (int space_flag
)
450 struct gdbarch
*gdbarch
= current_gdbarch
;
451 if (space_flag
& TYPE_FLAG_CODE_SPACE
)
453 else if (space_flag
& TYPE_FLAG_DATA_SPACE
)
455 else if ((space_flag
& TYPE_FLAG_ADDRESS_CLASS_ALL
)
456 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
457 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
462 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
464 If STORAGE is non-NULL, create the new type instance there.
465 STORAGE must be in the same obstack as TYPE. */
468 make_qualified_type (struct type
*type
, int new_flags
,
469 struct type
*storage
)
475 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
477 ntype
= TYPE_CHAIN (ntype
);
478 } while (ntype
!= type
);
480 /* Create a new type instance. */
482 ntype
= alloc_type_instance (type
);
485 /* If STORAGE was provided, it had better be in the same objfile
486 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
487 if one objfile is freed and the other kept, we'd have
488 dangling pointers. */
489 gdb_assert (TYPE_OBJFILE (type
) == TYPE_OBJFILE (storage
));
492 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
493 TYPE_CHAIN (ntype
) = ntype
;
496 /* Pointers or references to the original type are not relevant to
498 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
499 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
501 /* Chain the new qualified type to the old type. */
502 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
503 TYPE_CHAIN (type
) = ntype
;
505 /* Now set the instance flags and return the new type. */
506 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
508 /* Set length of new type to that of the original type. */
509 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
514 /* Make an address-space-delimited variant of a type -- a type that
515 is identical to the one supplied except that it has an address
516 space attribute attached to it (such as "code" or "data").
518 The space attributes "code" and "data" are for Harvard
519 architectures. The address space attributes are for architectures
520 which have alternately sized pointers or pointers with alternate
524 make_type_with_address_space (struct type
*type
, int space_flag
)
527 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
528 & ~(TYPE_FLAG_CODE_SPACE
| TYPE_FLAG_DATA_SPACE
529 | TYPE_FLAG_ADDRESS_CLASS_ALL
))
532 return make_qualified_type (type
, new_flags
, NULL
);
535 /* Make a "c-v" variant of a type -- a type that is identical to the
536 one supplied except that it may have const or volatile attributes
537 CNST is a flag for setting the const attribute
538 VOLTL is a flag for setting the volatile attribute
539 TYPE is the base type whose variant we are creating.
541 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
542 storage to hold the new qualified type; *TYPEPTR and TYPE must be
543 in the same objfile. Otherwise, allocate fresh memory for the new
544 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
545 new type we construct. */
547 make_cv_type (int cnst
, int voltl
,
549 struct type
**typeptr
)
551 struct type
*ntype
; /* New type */
552 struct type
*tmp_type
= type
; /* tmp type */
553 struct objfile
*objfile
;
555 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
556 & ~(TYPE_FLAG_CONST
| TYPE_FLAG_VOLATILE
));
559 new_flags
|= TYPE_FLAG_CONST
;
562 new_flags
|= TYPE_FLAG_VOLATILE
;
564 if (typeptr
&& *typeptr
!= NULL
)
566 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
567 a C-V variant chain that threads across objfiles: if one
568 objfile gets freed, then the other has a broken C-V chain.
570 This code used to try to copy over the main type from TYPE to
571 *TYPEPTR if they were in different objfiles, but that's
572 wrong, too: TYPE may have a field list or member function
573 lists, which refer to types of their own, etc. etc. The
574 whole shebang would need to be copied over recursively; you
575 can't have inter-objfile pointers. The only thing to do is
576 to leave stub types as stub types, and look them up afresh by
577 name each time you encounter them. */
578 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
));
581 ntype
= make_qualified_type (type
, new_flags
,
582 typeptr
? *typeptr
: NULL
);
590 /* Replace the contents of ntype with the type *type. This changes the
591 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
592 the changes are propogated to all types in the TYPE_CHAIN.
594 In order to build recursive types, it's inevitable that we'll need
595 to update types in place --- but this sort of indiscriminate
596 smashing is ugly, and needs to be replaced with something more
597 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
598 clear if more steps are needed. */
600 replace_type (struct type
*ntype
, struct type
*type
)
604 /* These two types had better be in the same objfile. Otherwise,
605 the assignment of one type's main type structure to the other
606 will produce a type with references to objects (names; field
607 lists; etc.) allocated on an objfile other than its own. */
608 gdb_assert (TYPE_OBJFILE (ntype
) == TYPE_OBJFILE (ntype
));
610 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
612 /* The type length is not a part of the main type. Update it for
613 each type on the variant chain. */
616 /* Assert that this element of the chain has no address-class bits
617 set in its flags. Such type variants might have type lengths
618 which are supposed to be different from the non-address-class
619 variants. This assertion shouldn't ever be triggered because
620 symbol readers which do construct address-class variants don't
621 call replace_type(). */
622 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
624 TYPE_LENGTH (chain
) = TYPE_LENGTH (type
);
625 chain
= TYPE_CHAIN (chain
);
626 } while (ntype
!= chain
);
628 /* Assert that the two types have equivalent instance qualifiers.
629 This should be true for at least all of our debug readers. */
630 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
633 /* Implement direct support for MEMBER_TYPE in GNU C++.
634 May need to construct such a type if this is the first use.
635 The TYPE is the type of the member. The DOMAIN is the type
636 of the aggregate that the member belongs to. */
639 lookup_memberptr_type (struct type
*type
, struct type
*domain
)
643 mtype
= alloc_type (TYPE_OBJFILE (type
));
644 smash_to_memberptr_type (mtype
, domain
, type
);
648 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
651 lookup_methodptr_type (struct type
*to_type
)
655 mtype
= alloc_type (TYPE_OBJFILE (to_type
));
656 TYPE_TARGET_TYPE (mtype
) = to_type
;
657 TYPE_DOMAIN_TYPE (mtype
) = TYPE_DOMAIN_TYPE (to_type
);
658 TYPE_LENGTH (mtype
) = cplus_method_ptr_size ();
659 TYPE_CODE (mtype
) = TYPE_CODE_METHODPTR
;
663 /* Allocate a stub method whose return type is TYPE. This apparently
664 happens for speed of symbol reading, since parsing out the
665 arguments to the method is cpu-intensive, the way we are doing it.
666 So, we will fill in arguments later. This always returns a fresh
670 allocate_stub_method (struct type
*type
)
674 mtype
= init_type (TYPE_CODE_METHOD
, 1, TYPE_FLAG_STUB
, NULL
,
675 TYPE_OBJFILE (type
));
676 TYPE_TARGET_TYPE (mtype
) = type
;
677 /* _DOMAIN_TYPE (mtype) = unknown yet */
681 /* Create a range type using either a blank type supplied in
682 RESULT_TYPE, or creating a new type, inheriting the objfile from
685 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
686 to HIGH_BOUND, inclusive.
688 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
689 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
692 create_range_type (struct type
*result_type
, struct type
*index_type
,
693 int low_bound
, int high_bound
)
695 if (result_type
== NULL
)
697 result_type
= alloc_type (TYPE_OBJFILE (index_type
));
699 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
700 TYPE_TARGET_TYPE (result_type
) = index_type
;
701 if (TYPE_STUB (index_type
))
702 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
704 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
705 TYPE_NFIELDS (result_type
) = 2;
706 TYPE_FIELDS (result_type
) = (struct field
*)
707 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
708 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
709 TYPE_FIELD_BITPOS (result_type
, 0) = low_bound
;
710 TYPE_FIELD_BITPOS (result_type
, 1) = high_bound
;
713 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
715 return (result_type
);
718 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
719 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
720 bounds will fit in LONGEST), or -1 otherwise. */
723 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
725 CHECK_TYPEDEF (type
);
726 switch (TYPE_CODE (type
))
728 case TYPE_CODE_RANGE
:
729 *lowp
= TYPE_LOW_BOUND (type
);
730 *highp
= TYPE_HIGH_BOUND (type
);
733 if (TYPE_NFIELDS (type
) > 0)
735 /* The enums may not be sorted by value, so search all
739 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
740 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
742 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
743 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
744 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
745 *highp
= TYPE_FIELD_BITPOS (type
, i
);
748 /* Set unsigned indicator if warranted. */
751 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
765 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
767 if (!TYPE_UNSIGNED (type
))
769 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
773 /* ... fall through for unsigned ints ... */
776 /* This round-about calculation is to avoid shifting by
777 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
778 if TYPE_LENGTH (type) == sizeof (LONGEST). */
779 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
780 *highp
= (*highp
- 1) | *highp
;
787 /* Create an array type using either a blank type supplied in
788 RESULT_TYPE, or creating a new type, inheriting the objfile from
791 Elements will be of type ELEMENT_TYPE, the indices will be of type
794 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
795 sure it is TYPE_CODE_UNDEF before we bash it into an array
799 create_array_type (struct type
*result_type
,
800 struct type
*element_type
,
801 struct type
*range_type
)
803 LONGEST low_bound
, high_bound
;
805 if (result_type
== NULL
)
807 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
809 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
810 TYPE_TARGET_TYPE (result_type
) = element_type
;
811 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
812 low_bound
= high_bound
= 0;
813 CHECK_TYPEDEF (element_type
);
814 TYPE_LENGTH (result_type
) =
815 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
816 TYPE_NFIELDS (result_type
) = 1;
817 TYPE_FIELDS (result_type
) =
818 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
819 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
820 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
821 TYPE_VPTR_FIELDNO (result_type
) = -1;
823 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
824 if (TYPE_LENGTH (result_type
) == 0)
825 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
827 return (result_type
);
830 /* Create a string type using either a blank type supplied in
831 RESULT_TYPE, or creating a new type. String types are similar
832 enough to array of char types that we can use create_array_type to
833 build the basic type and then bash it into a string type.
835 For fixed length strings, the range type contains 0 as the lower
836 bound and the length of the string minus one as the upper bound.
838 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
839 sure it is TYPE_CODE_UNDEF before we bash it into a string
843 create_string_type (struct type
*result_type
,
844 struct type
*range_type
)
846 struct type
*string_char_type
;
848 string_char_type
= language_string_char_type (current_language
,
850 result_type
= create_array_type (result_type
,
853 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
854 return (result_type
);
858 create_set_type (struct type
*result_type
, struct type
*domain_type
)
860 if (result_type
== NULL
)
862 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
864 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
865 TYPE_NFIELDS (result_type
) = 1;
866 TYPE_FIELDS (result_type
) = (struct field
*)
867 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
868 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
870 if (!TYPE_STUB (domain_type
))
872 LONGEST low_bound
, high_bound
, bit_length
;
873 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
874 low_bound
= high_bound
= 0;
875 bit_length
= high_bound
- low_bound
+ 1;
876 TYPE_LENGTH (result_type
)
877 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
879 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
881 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
883 return (result_type
);
887 append_flags_type_flag (struct type
*type
, int bitpos
, char *name
)
889 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLAGS
);
890 gdb_assert (bitpos
< TYPE_NFIELDS (type
));
891 gdb_assert (bitpos
>= 0);
895 TYPE_FIELD_NAME (type
, bitpos
) = xstrdup (name
);
896 TYPE_FIELD_BITPOS (type
, bitpos
) = bitpos
;
900 /* Don't show this field to the user. */
901 TYPE_FIELD_BITPOS (type
, bitpos
) = -1;
906 init_flags_type (char *name
, int length
)
908 int nfields
= length
* TARGET_CHAR_BIT
;
911 type
= init_type (TYPE_CODE_FLAGS
, length
,
912 TYPE_FLAG_UNSIGNED
, name
, NULL
);
913 TYPE_NFIELDS (type
) = nfields
;
914 TYPE_FIELDS (type
) = TYPE_ALLOC (type
,
915 nfields
* sizeof (struct field
));
916 memset (TYPE_FIELDS (type
), 0, nfields
* sizeof (struct field
));
921 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
922 and any array types nested inside it. */
925 make_vector_type (struct type
*array_type
)
927 struct type
*inner_array
, *elt_type
;
930 /* Find the innermost array type, in case the array is
931 multi-dimensional. */
932 inner_array
= array_type
;
933 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
934 inner_array
= TYPE_TARGET_TYPE (inner_array
);
936 elt_type
= TYPE_TARGET_TYPE (inner_array
);
937 if (TYPE_CODE (elt_type
) == TYPE_CODE_INT
)
939 flags
= TYPE_INSTANCE_FLAGS (elt_type
) | TYPE_FLAG_NOTTEXT
;
940 elt_type
= make_qualified_type (elt_type
, flags
, NULL
);
941 TYPE_TARGET_TYPE (inner_array
) = elt_type
;
944 TYPE_FLAGS (array_type
) |= TYPE_FLAG_VECTOR
;
948 init_vector_type (struct type
*elt_type
, int n
)
950 struct type
*array_type
;
952 array_type
= create_array_type (0, elt_type
,
953 create_range_type (0,
956 make_vector_type (array_type
);
960 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
961 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
962 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
963 TYPE doesn't include the offset (that's the value of the MEMBER
964 itself), but does include the structure type into which it points
967 When "smashing" the type, we preserve the objfile that the old type
968 pointed to, since we aren't changing where the type is actually
972 smash_to_memberptr_type (struct type
*type
, struct type
*domain
,
973 struct type
*to_type
)
975 struct objfile
*objfile
;
977 objfile
= TYPE_OBJFILE (type
);
980 TYPE_OBJFILE (type
) = objfile
;
981 TYPE_TARGET_TYPE (type
) = to_type
;
982 TYPE_DOMAIN_TYPE (type
) = domain
;
983 /* Assume that a data member pointer is the same size as a normal
985 TYPE_LENGTH (type
) = gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
;
986 TYPE_CODE (type
) = TYPE_CODE_MEMBERPTR
;
989 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
990 METHOD just means `function that gets an extra "this" argument'.
992 When "smashing" the type, we preserve the objfile that the old type
993 pointed to, since we aren't changing where the type is actually
997 smash_to_method_type (struct type
*type
, struct type
*domain
,
998 struct type
*to_type
, struct field
*args
,
999 int nargs
, int varargs
)
1001 struct objfile
*objfile
;
1003 objfile
= TYPE_OBJFILE (type
);
1006 TYPE_OBJFILE (type
) = objfile
;
1007 TYPE_TARGET_TYPE (type
) = to_type
;
1008 TYPE_DOMAIN_TYPE (type
) = domain
;
1009 TYPE_FIELDS (type
) = args
;
1010 TYPE_NFIELDS (type
) = nargs
;
1012 TYPE_FLAGS (type
) |= TYPE_FLAG_VARARGS
;
1013 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1014 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
1017 /* Return a typename for a struct/union/enum type without "struct ",
1018 "union ", or "enum ". If the type has a NULL name, return NULL. */
1021 type_name_no_tag (const struct type
*type
)
1023 if (TYPE_TAG_NAME (type
) != NULL
)
1024 return TYPE_TAG_NAME (type
);
1026 /* Is there code which expects this to return the name if there is
1027 no tag name? My guess is that this is mainly used for C++ in
1028 cases where the two will always be the same. */
1029 return TYPE_NAME (type
);
1032 /* Lookup a typedef or primitive type named NAME, visible in lexical
1033 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1034 suitably defined. */
1037 lookup_typename (char *name
, struct block
*block
, int noerr
)
1042 sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, 0,
1043 (struct symtab
**) NULL
);
1044 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1046 tmp
= language_lookup_primitive_type_by_name (current_language
,
1053 else if (!tmp
&& noerr
)
1059 error (_("No type named %s."), name
);
1062 return (SYMBOL_TYPE (sym
));
1066 lookup_unsigned_typename (char *name
)
1068 char *uns
= alloca (strlen (name
) + 10);
1070 strcpy (uns
, "unsigned ");
1071 strcpy (uns
+ 9, name
);
1072 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
1076 lookup_signed_typename (char *name
)
1079 char *uns
= alloca (strlen (name
) + 8);
1081 strcpy (uns
, "signed ");
1082 strcpy (uns
+ 7, name
);
1083 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
1084 /* If we don't find "signed FOO" just try again with plain "FOO". */
1087 return lookup_typename (name
, (struct block
*) NULL
, 0);
1090 /* Lookup a structure type named "struct NAME",
1091 visible in lexical block BLOCK. */
1094 lookup_struct (char *name
, struct block
*block
)
1098 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
1099 (struct symtab
**) NULL
);
1103 error (_("No struct type named %s."), name
);
1105 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1107 error (_("This context has class, union or enum %s, not a struct."),
1110 return (SYMBOL_TYPE (sym
));
1113 /* Lookup a union type named "union NAME",
1114 visible in lexical block BLOCK. */
1117 lookup_union (char *name
, struct block
*block
)
1122 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
1123 (struct symtab
**) NULL
);
1126 error (_("No union type named %s."), name
);
1128 t
= SYMBOL_TYPE (sym
);
1130 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1133 /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
1134 * a further "declared_type" field to discover it is really a union.
1136 if (HAVE_CPLUS_STRUCT (t
))
1137 if (TYPE_DECLARED_TYPE (t
) == DECLARED_TYPE_UNION
)
1140 /* If we get here, it's not a union. */
1141 error (_("This context has class, struct or enum %s, not a union."),
1146 /* Lookup an enum type named "enum NAME",
1147 visible in lexical block BLOCK. */
1150 lookup_enum (char *name
, struct block
*block
)
1154 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
1155 (struct symtab
**) NULL
);
1158 error (_("No enum type named %s."), name
);
1160 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1162 error (_("This context has class, struct or union %s, not an enum."),
1165 return (SYMBOL_TYPE (sym
));
1168 /* Lookup a template type named "template NAME<TYPE>",
1169 visible in lexical block BLOCK. */
1172 lookup_template_type (char *name
, struct type
*type
,
1173 struct block
*block
)
1176 char *nam
= (char *)
1177 alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1180 strcat (nam
, TYPE_NAME (type
));
1181 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1183 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0,
1184 (struct symtab
**) NULL
);
1188 error (_("No template type named %s."), name
);
1190 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1192 error (_("This context has class, union or enum %s, not a struct."),
1195 return (SYMBOL_TYPE (sym
));
1198 /* Given a type TYPE, lookup the type of the component of type named
1201 TYPE can be either a struct or union, or a pointer or reference to
1202 a struct or union. If it is a pointer or reference, its target
1203 type is automatically used. Thus '.' and '->' are interchangable,
1204 as specified for the definitions of the expression element types
1205 STRUCTOP_STRUCT and STRUCTOP_PTR.
1207 If NOERR is nonzero, return zero if NAME is not suitably defined.
1208 If NAME is the name of a baseclass type, return that type. */
1211 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
1217 CHECK_TYPEDEF (type
);
1218 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1219 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1221 type
= TYPE_TARGET_TYPE (type
);
1224 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1225 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1227 target_terminal_ours ();
1228 gdb_flush (gdb_stdout
);
1229 fprintf_unfiltered (gdb_stderr
, "Type ");
1230 type_print (type
, "", gdb_stderr
, -1);
1231 error (_(" is not a structure or union type."));
1235 /* FIXME: This change put in by Michael seems incorrect for the case
1236 where the structure tag name is the same as the member name.
1237 I.E. when doing "ptype bell->bar" for "struct foo { int bar; int
1238 foo; } bell;" Disabled by fnf. */
1242 typename
= type_name_no_tag (type
);
1243 if (typename
!= NULL
&& strcmp (typename
, name
) == 0)
1248 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1250 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1252 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1254 return TYPE_FIELD_TYPE (type
, i
);
1258 /* OK, it's not in this class. Recursively check the baseclasses. */
1259 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1263 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, 1);
1275 target_terminal_ours ();
1276 gdb_flush (gdb_stdout
);
1277 fprintf_unfiltered (gdb_stderr
, "Type ");
1278 type_print (type
, "", gdb_stderr
, -1);
1279 fprintf_unfiltered (gdb_stderr
, " has no component named ");
1280 fputs_filtered (name
, gdb_stderr
);
1282 return (struct type
*) -1; /* For lint */
1285 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
1286 valid. Callers should be aware that in some cases (for example,
1287 the type or one of its baseclasses is a stub type and we are
1288 debugging a .o file), this function will not be able to find the
1289 virtual function table pointer, and vptr_fieldno will remain -1 and
1290 vptr_basetype will remain NULL. */
1293 fill_in_vptr_fieldno (struct type
*type
)
1295 CHECK_TYPEDEF (type
);
1297 if (TYPE_VPTR_FIELDNO (type
) < 0)
1301 /* We must start at zero in case the first (and only) baseclass
1302 is virtual (and hence we cannot share the table pointer). */
1303 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1305 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
,
1307 fill_in_vptr_fieldno (baseclass
);
1308 if (TYPE_VPTR_FIELDNO (baseclass
) >= 0)
1310 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (baseclass
);
1311 TYPE_VPTR_BASETYPE (type
) = TYPE_VPTR_BASETYPE (baseclass
);
1318 /* Find the method and field indices for the destructor in class type T.
1319 Return 1 if the destructor was found, otherwise, return 0. */
1322 get_destructor_fn_field (struct type
*t
,
1328 for (i
= 0; i
< TYPE_NFN_FIELDS (t
); i
++)
1331 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1333 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (t
, i
); j
++)
1335 if (is_destructor_name (TYPE_FN_FIELD_PHYSNAME (f
, j
)) != 0)
1347 stub_noname_complaint (void)
1349 complaint (&symfile_complaints
, _("stub type has NULL name"));
1352 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1354 If this is a stubbed struct (i.e. declared as struct foo *), see if
1355 we can find a full definition in some other file. If so, copy this
1356 definition, so we can use it in future. There used to be a comment
1357 (but not any code) that if we don't find a full definition, we'd
1358 set a flag so we don't spend time in the future checking the same
1359 type. That would be a mistake, though--we might load in more
1360 symbols which contain a full definition for the type.
1362 This used to be coded as a macro, but I don't think it is called
1363 often enough to merit such treatment. */
1365 /* Find the real type of TYPE. This function returns the real type,
1366 after removing all layers of typedefs and completing opaque or stub
1367 types. Completion changes the TYPE argument, but stripping of
1368 typedefs does not. */
1371 check_typedef (struct type
*type
)
1373 struct type
*orig_type
= type
;
1374 int is_const
, is_volatile
;
1378 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1380 if (!TYPE_TARGET_TYPE (type
))
1385 /* It is dangerous to call lookup_symbol if we are currently
1386 reading a symtab. Infinite recursion is one danger. */
1387 if (currently_reading_symtab
)
1390 name
= type_name_no_tag (type
);
1391 /* FIXME: shouldn't we separately check the TYPE_NAME and
1392 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1393 VAR_DOMAIN as appropriate? (this code was written before
1394 TYPE_NAME and TYPE_TAG_NAME were separate). */
1397 stub_noname_complaint ();
1400 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0,
1401 (struct symtab
**) NULL
);
1403 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1404 else /* TYPE_CODE_UNDEF */
1405 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
);
1407 type
= TYPE_TARGET_TYPE (type
);
1410 is_const
= TYPE_CONST (type
);
1411 is_volatile
= TYPE_VOLATILE (type
);
1413 /* If this is a struct/class/union with no fields, then check
1414 whether a full definition exists somewhere else. This is for
1415 systems where a type definition with no fields is issued for such
1416 types, instead of identifying them as stub types in the first
1419 if (TYPE_IS_OPAQUE (type
)
1420 && opaque_type_resolution
1421 && !currently_reading_symtab
)
1423 char *name
= type_name_no_tag (type
);
1424 struct type
*newtype
;
1427 stub_noname_complaint ();
1430 newtype
= lookup_transparent_type (name
);
1434 /* If the resolved type and the stub are in the same
1435 objfile, then replace the stub type with the real deal.
1436 But if they're in separate objfiles, leave the stub
1437 alone; we'll just look up the transparent type every time
1438 we call check_typedef. We can't create pointers between
1439 types allocated to different objfiles, since they may
1440 have different lifetimes. Trying to copy NEWTYPE over to
1441 TYPE's objfile is pointless, too, since you'll have to
1442 move over any other types NEWTYPE refers to, which could
1443 be an unbounded amount of stuff. */
1444 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
1445 make_cv_type (is_const
, is_volatile
, newtype
, &type
);
1450 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1452 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1454 char *name
= type_name_no_tag (type
);
1455 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1456 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1457 as appropriate? (this code was written before TYPE_NAME and
1458 TYPE_TAG_NAME were separate). */
1462 stub_noname_complaint ();
1465 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
,
1466 0, (struct symtab
**) NULL
);
1469 /* Same as above for opaque types, we can replace the stub
1470 with the complete type only if they are int the same
1472 if (TYPE_OBJFILE (SYMBOL_TYPE(sym
)) == TYPE_OBJFILE (type
))
1473 make_cv_type (is_const
, is_volatile
,
1474 SYMBOL_TYPE (sym
), &type
);
1476 type
= SYMBOL_TYPE (sym
);
1480 if (TYPE_TARGET_STUB (type
))
1482 struct type
*range_type
;
1483 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1485 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1489 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1490 && TYPE_NFIELDS (type
) == 1
1491 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
1492 == TYPE_CODE_RANGE
))
1494 /* Now recompute the length of the array type, based on its
1495 number of elements and the target type's length. */
1496 TYPE_LENGTH (type
) =
1497 ((TYPE_FIELD_BITPOS (range_type
, 1)
1498 - TYPE_FIELD_BITPOS (range_type
, 0) + 1)
1499 * TYPE_LENGTH (target_type
));
1500 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1502 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1504 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1505 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1508 /* Cache TYPE_LENGTH for future use. */
1509 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1513 /* Parse a type expression in the string [P..P+LENGTH). If an error
1514 occurs, silently return builtin_type_void. */
1516 static struct type
*
1517 safe_parse_type (char *p
, int length
)
1519 struct ui_file
*saved_gdb_stderr
;
1522 /* Suppress error messages. */
1523 saved_gdb_stderr
= gdb_stderr
;
1524 gdb_stderr
= ui_file_new ();
1526 /* Call parse_and_eval_type() without fear of longjmp()s. */
1527 if (!gdb_parse_and_eval_type (p
, length
, &type
))
1528 type
= builtin_type_void
;
1530 /* Stop suppressing error messages. */
1531 ui_file_delete (gdb_stderr
);
1532 gdb_stderr
= saved_gdb_stderr
;
1537 /* Ugly hack to convert method stubs into method types.
1539 He ain't kiddin'. This demangles the name of the method into a
1540 string including argument types, parses out each argument type,
1541 generates a string casting a zero to that type, evaluates the
1542 string, and stuffs the resulting type into an argtype vector!!!
1543 Then it knows the type of the whole function (including argument
1544 types for overloading), which info used to be in the stab's but was
1545 removed to hack back the space required for them. */
1548 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1551 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1552 char *demangled_name
= cplus_demangle (mangled_name
,
1553 DMGL_PARAMS
| DMGL_ANSI
);
1554 char *argtypetext
, *p
;
1555 int depth
= 0, argcount
= 1;
1556 struct field
*argtypes
;
1559 /* Make sure we got back a function string that we can use. */
1561 p
= strchr (demangled_name
, '(');
1565 if (demangled_name
== NULL
|| p
== NULL
)
1566 error (_("Internal: Cannot demangle mangled name `%s'."),
1569 /* Now, read in the parameters that define this type. */
1574 if (*p
== '(' || *p
== '<')
1578 else if (*p
== ')' || *p
== '>')
1582 else if (*p
== ',' && depth
== 0)
1590 /* If we read one argument and it was ``void'', don't count it. */
1591 if (strncmp (argtypetext
, "(void)", 6) == 0)
1594 /* We need one extra slot, for the THIS pointer. */
1596 argtypes
= (struct field
*)
1597 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
1600 /* Add THIS pointer for non-static methods. */
1601 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1602 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
1606 argtypes
[0].type
= lookup_pointer_type (type
);
1610 if (*p
!= ')') /* () means no args, skip while */
1615 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1617 /* Avoid parsing of ellipsis, they will be handled below.
1618 Also avoid ``void'' as above. */
1619 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
1620 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
1622 argtypes
[argcount
].type
=
1623 safe_parse_type (argtypetext
, p
- argtypetext
);
1626 argtypetext
= p
+ 1;
1629 if (*p
== '(' || *p
== '<')
1633 else if (*p
== ')' || *p
== '>')
1642 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1644 /* Now update the old "stub" type into a real type. */
1645 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1646 TYPE_DOMAIN_TYPE (mtype
) = type
;
1647 TYPE_FIELDS (mtype
) = argtypes
;
1648 TYPE_NFIELDS (mtype
) = argcount
;
1649 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1650 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1652 TYPE_FLAGS (mtype
) |= TYPE_FLAG_VARARGS
;
1654 xfree (demangled_name
);
1657 /* This is the external interface to check_stub_method, above. This
1658 function unstubs all of the signatures for TYPE's METHOD_ID method
1659 name. After calling this function TYPE_FN_FIELD_STUB will be
1660 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1663 This function unfortunately can not die until stabs do. */
1666 check_stub_method_group (struct type
*type
, int method_id
)
1668 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
1669 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1670 int j
, found_stub
= 0;
1672 for (j
= 0; j
< len
; j
++)
1673 if (TYPE_FN_FIELD_STUB (f
, j
))
1676 check_stub_method (type
, method_id
, j
);
1679 /* GNU v3 methods with incorrect names were corrected when we read
1680 in type information, because it was cheaper to do it then. The
1681 only GNU v2 methods with incorrect method names are operators and
1682 destructors; destructors were also corrected when we read in type
1685 Therefore the only thing we need to handle here are v2 operator
1687 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
1690 char dem_opname
[256];
1692 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1694 dem_opname
, DMGL_ANSI
);
1696 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1700 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
1704 const struct cplus_struct_type cplus_struct_default
;
1707 allocate_cplus_struct_type (struct type
*type
)
1709 if (!HAVE_CPLUS_STRUCT (type
))
1711 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1712 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1713 *(TYPE_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1717 /* Helper function to initialize the standard scalar types.
1719 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy of
1720 the string pointed to by name in the objfile_obstack for that
1721 objfile, and initialize the type name to that copy. There are
1722 places (mipsread.c in particular, where init_type is called with a
1723 NULL value for NAME). */
1726 init_type (enum type_code code
, int length
, int flags
,
1727 char *name
, struct objfile
*objfile
)
1731 type
= alloc_type (objfile
);
1732 TYPE_CODE (type
) = code
;
1733 TYPE_LENGTH (type
) = length
;
1734 TYPE_FLAGS (type
) |= flags
;
1735 if ((name
!= NULL
) && (objfile
!= NULL
))
1737 TYPE_NAME (type
) = obsavestring (name
, strlen (name
),
1738 &objfile
->objfile_obstack
);
1742 TYPE_NAME (type
) = name
;
1747 if (name
&& strcmp (name
, "char") == 0)
1748 TYPE_FLAGS (type
) |= TYPE_FLAG_NOSIGN
;
1750 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
1751 || code
== TYPE_CODE_NAMESPACE
)
1753 INIT_CPLUS_SPECIFIC (type
);
1758 /* Helper function. Create an empty composite type. */
1761 init_composite_type (char *name
, enum type_code code
)
1764 gdb_assert (code
== TYPE_CODE_STRUCT
1765 || code
== TYPE_CODE_UNION
);
1766 t
= init_type (code
, 0, 0, NULL
, NULL
);
1767 TYPE_TAG_NAME (t
) = name
;
1771 /* Helper function. Append a field to a composite type. */
1774 append_composite_type_field (struct type
*t
, char *name
,
1778 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
1779 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
1780 sizeof (struct field
) * TYPE_NFIELDS (t
));
1781 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
1782 memset (f
, 0, sizeof f
[0]);
1783 FIELD_TYPE (f
[0]) = field
;
1784 FIELD_NAME (f
[0]) = name
;
1785 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1787 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
1788 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
1790 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
1792 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
1793 if (TYPE_NFIELDS (t
) > 1)
1795 FIELD_BITPOS (f
[0]) = (FIELD_BITPOS (f
[-1])
1796 + TYPE_LENGTH (field
) * TARGET_CHAR_BIT
);
1802 can_dereference (struct type
*t
)
1804 /* FIXME: Should we return true for references as well as
1809 && TYPE_CODE (t
) == TYPE_CODE_PTR
1810 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1814 is_integral_type (struct type
*t
)
1819 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
1820 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
1821 || (TYPE_CODE (t
) == TYPE_CODE_FLAGS
)
1822 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
1823 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
1824 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
1827 /* Check whether BASE is an ancestor or base class or DCLASS
1828 Return 1 if so, and 0 if not.
1829 Note: callers may want to check for identity of the types before
1830 calling this function -- identical types are considered to satisfy
1831 the ancestor relationship even if they're identical. */
1834 is_ancestor (struct type
*base
, struct type
*dclass
)
1838 CHECK_TYPEDEF (base
);
1839 CHECK_TYPEDEF (dclass
);
1843 if (TYPE_NAME (base
) && TYPE_NAME (dclass
)
1844 && !strcmp (TYPE_NAME (base
), TYPE_NAME (dclass
)))
1847 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1848 if (is_ancestor (base
, TYPE_BASECLASS (dclass
, i
)))
1856 /* Functions for overload resolution begin here */
1858 /* Compare two badness vectors A and B and return the result.
1859 0 => A and B are identical
1860 1 => A and B are incomparable
1861 2 => A is better than B
1862 3 => A is worse than B */
1865 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
1869 short found_pos
= 0; /* any positives in c? */
1870 short found_neg
= 0; /* any negatives in c? */
1872 /* differing lengths => incomparable */
1873 if (a
->length
!= b
->length
)
1876 /* Subtract b from a */
1877 for (i
= 0; i
< a
->length
; i
++)
1879 tmp
= a
->rank
[i
] - b
->rank
[i
];
1889 return 1; /* incomparable */
1891 return 3; /* A > B */
1897 return 2; /* A < B */
1899 return 0; /* A == B */
1903 /* Rank a function by comparing its parameter types (PARMS, length
1904 NPARMS), to the types of an argument list (ARGS, length NARGS).
1905 Return a pointer to a badness vector. This has NARGS + 1
1908 struct badness_vector
*
1909 rank_function (struct type
**parms
, int nparms
,
1910 struct type
**args
, int nargs
)
1913 struct badness_vector
*bv
;
1914 int min_len
= nparms
< nargs
? nparms
: nargs
;
1916 bv
= xmalloc (sizeof (struct badness_vector
));
1917 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank */
1918 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
1920 /* First compare the lengths of the supplied lists.
1921 If there is a mismatch, set it to a high value. */
1923 /* pai/1997-06-03 FIXME: when we have debug info about default
1924 arguments and ellipsis parameter lists, we should consider those
1925 and rank the length-match more finely. */
1927 LENGTH_MATCH (bv
) = (nargs
!= nparms
) ? LENGTH_MISMATCH_BADNESS
: 0;
1929 /* Now rank all the parameters of the candidate function */
1930 for (i
= 1; i
<= min_len
; i
++)
1931 bv
->rank
[i
] = rank_one_type (parms
[i
-1], args
[i
-1]);
1933 /* If more arguments than parameters, add dummy entries */
1934 for (i
= min_len
+ 1; i
<= nargs
; i
++)
1935 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
1940 /* Compare the names of two integer types, assuming that any sign
1941 qualifiers have been checked already. We do it this way because
1942 there may be an "int" in the name of one of the types. */
1945 integer_types_same_name_p (const char *first
, const char *second
)
1947 int first_p
, second_p
;
1949 /* If both are shorts, return 1; if neither is a short, keep
1951 first_p
= (strstr (first
, "short") != NULL
);
1952 second_p
= (strstr (second
, "short") != NULL
);
1953 if (first_p
&& second_p
)
1955 if (first_p
|| second_p
)
1958 /* Likewise for long. */
1959 first_p
= (strstr (first
, "long") != NULL
);
1960 second_p
= (strstr (second
, "long") != NULL
);
1961 if (first_p
&& second_p
)
1963 if (first_p
|| second_p
)
1966 /* Likewise for char. */
1967 first_p
= (strstr (first
, "char") != NULL
);
1968 second_p
= (strstr (second
, "char") != NULL
);
1969 if (first_p
&& second_p
)
1971 if (first_p
|| second_p
)
1974 /* They must both be ints. */
1978 /* Compare one type (PARM) for compatibility with another (ARG).
1979 * PARM is intended to be the parameter type of a function; and
1980 * ARG is the supplied argument's type. This function tests if
1981 * the latter can be converted to the former.
1983 * Return 0 if they are identical types;
1984 * Otherwise, return an integer which corresponds to how compatible
1985 * PARM is to ARG. The higher the return value, the worse the match.
1986 * Generally the "bad" conversions are all uniformly assigned a 100. */
1989 rank_one_type (struct type
*parm
, struct type
*arg
)
1991 /* Identical type pointers. */
1992 /* However, this still doesn't catch all cases of same type for arg
1993 and param. The reason is that builtin types are different from
1994 the same ones constructed from the object. */
1998 /* Resolve typedefs */
1999 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2000 parm
= check_typedef (parm
);
2001 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2002 arg
= check_typedef (arg
);
2005 Well, damnit, if the names are exactly the same, I'll say they
2006 are exactly the same. This happens when we generate method
2007 stubs. The types won't point to the same address, but they
2008 really are the same.
2011 if (TYPE_NAME (parm
) && TYPE_NAME (arg
)
2012 && !strcmp (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2015 /* Check if identical after resolving typedefs. */
2019 /* See through references, since we can almost make non-references
2021 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2022 return (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
))
2023 + REFERENCE_CONVERSION_BADNESS
);
2024 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2025 return (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
)
2026 + REFERENCE_CONVERSION_BADNESS
);
2028 /* Debugging only. */
2029 fprintf_filtered (gdb_stderr
,
2030 "------ Arg is %s [%d], parm is %s [%d]\n",
2031 TYPE_NAME (arg
), TYPE_CODE (arg
),
2032 TYPE_NAME (parm
), TYPE_CODE (parm
));
2034 /* x -> y means arg of type x being supplied for parameter of type y */
2036 switch (TYPE_CODE (parm
))
2039 switch (TYPE_CODE (arg
))
2042 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2043 return VOID_PTR_CONVERSION_BADNESS
;
2045 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2046 TYPE_TARGET_TYPE (arg
));
2047 case TYPE_CODE_ARRAY
:
2048 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2049 TYPE_TARGET_TYPE (arg
));
2050 case TYPE_CODE_FUNC
:
2051 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
);
2053 case TYPE_CODE_ENUM
:
2054 case TYPE_CODE_FLAGS
:
2055 case TYPE_CODE_CHAR
:
2056 case TYPE_CODE_RANGE
:
2057 case TYPE_CODE_BOOL
:
2058 return POINTER_CONVERSION_BADNESS
;
2060 return INCOMPATIBLE_TYPE_BADNESS
;
2062 case TYPE_CODE_ARRAY
:
2063 switch (TYPE_CODE (arg
))
2066 case TYPE_CODE_ARRAY
:
2067 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2068 TYPE_TARGET_TYPE (arg
));
2070 return INCOMPATIBLE_TYPE_BADNESS
;
2072 case TYPE_CODE_FUNC
:
2073 switch (TYPE_CODE (arg
))
2075 case TYPE_CODE_PTR
: /* funcptr -> func */
2076 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
));
2078 return INCOMPATIBLE_TYPE_BADNESS
;
2081 switch (TYPE_CODE (arg
))
2084 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2086 /* Deal with signed, unsigned, and plain chars and
2087 signed and unsigned ints. */
2088 if (TYPE_NOSIGN (parm
))
2090 /* This case only for character types */
2091 if (TYPE_NOSIGN (arg
))
2092 return 0; /* plain char -> plain char */
2093 else /* signed/unsigned char -> plain char */
2094 return INTEGER_CONVERSION_BADNESS
;
2096 else if (TYPE_UNSIGNED (parm
))
2098 if (TYPE_UNSIGNED (arg
))
2100 /* unsigned int -> unsigned int, or
2101 unsigned long -> unsigned long */
2102 if (integer_types_same_name_p (TYPE_NAME (parm
),
2105 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2107 && integer_types_same_name_p (TYPE_NAME (parm
),
2109 return INTEGER_PROMOTION_BADNESS
; /* unsigned int -> unsigned long */
2111 return INTEGER_CONVERSION_BADNESS
; /* unsigned long -> unsigned int */
2115 if (integer_types_same_name_p (TYPE_NAME (arg
),
2117 && integer_types_same_name_p (TYPE_NAME (parm
),
2119 return INTEGER_CONVERSION_BADNESS
; /* signed long -> unsigned int */
2121 return INTEGER_CONVERSION_BADNESS
; /* signed int/long -> unsigned int/long */
2124 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2126 if (integer_types_same_name_p (TYPE_NAME (parm
),
2129 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2131 && integer_types_same_name_p (TYPE_NAME (parm
),
2133 return INTEGER_PROMOTION_BADNESS
;
2135 return INTEGER_CONVERSION_BADNESS
;
2138 return INTEGER_CONVERSION_BADNESS
;
2140 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2141 return INTEGER_PROMOTION_BADNESS
;
2143 return INTEGER_CONVERSION_BADNESS
;
2144 case TYPE_CODE_ENUM
:
2145 case TYPE_CODE_FLAGS
:
2146 case TYPE_CODE_CHAR
:
2147 case TYPE_CODE_RANGE
:
2148 case TYPE_CODE_BOOL
:
2149 return INTEGER_PROMOTION_BADNESS
;
2151 return INT_FLOAT_CONVERSION_BADNESS
;
2153 return NS_POINTER_CONVERSION_BADNESS
;
2155 return INCOMPATIBLE_TYPE_BADNESS
;
2158 case TYPE_CODE_ENUM
:
2159 switch (TYPE_CODE (arg
))
2162 case TYPE_CODE_CHAR
:
2163 case TYPE_CODE_RANGE
:
2164 case TYPE_CODE_BOOL
:
2165 case TYPE_CODE_ENUM
:
2166 return INTEGER_CONVERSION_BADNESS
;
2168 return INT_FLOAT_CONVERSION_BADNESS
;
2170 return INCOMPATIBLE_TYPE_BADNESS
;
2173 case TYPE_CODE_CHAR
:
2174 switch (TYPE_CODE (arg
))
2176 case TYPE_CODE_RANGE
:
2177 case TYPE_CODE_BOOL
:
2178 case TYPE_CODE_ENUM
:
2179 return INTEGER_CONVERSION_BADNESS
;
2181 return INT_FLOAT_CONVERSION_BADNESS
;
2183 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2184 return INTEGER_CONVERSION_BADNESS
;
2185 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2186 return INTEGER_PROMOTION_BADNESS
;
2187 /* >>> !! else fall through !! <<< */
2188 case TYPE_CODE_CHAR
:
2189 /* Deal with signed, unsigned, and plain chars for C++ and
2190 with int cases falling through from previous case. */
2191 if (TYPE_NOSIGN (parm
))
2193 if (TYPE_NOSIGN (arg
))
2196 return INTEGER_CONVERSION_BADNESS
;
2198 else if (TYPE_UNSIGNED (parm
))
2200 if (TYPE_UNSIGNED (arg
))
2203 return INTEGER_PROMOTION_BADNESS
;
2205 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2208 return INTEGER_CONVERSION_BADNESS
;
2210 return INCOMPATIBLE_TYPE_BADNESS
;
2213 case TYPE_CODE_RANGE
:
2214 switch (TYPE_CODE (arg
))
2217 case TYPE_CODE_CHAR
:
2218 case TYPE_CODE_RANGE
:
2219 case TYPE_CODE_BOOL
:
2220 case TYPE_CODE_ENUM
:
2221 return INTEGER_CONVERSION_BADNESS
;
2223 return INT_FLOAT_CONVERSION_BADNESS
;
2225 return INCOMPATIBLE_TYPE_BADNESS
;
2228 case TYPE_CODE_BOOL
:
2229 switch (TYPE_CODE (arg
))
2232 case TYPE_CODE_CHAR
:
2233 case TYPE_CODE_RANGE
:
2234 case TYPE_CODE_ENUM
:
2237 return BOOLEAN_CONVERSION_BADNESS
;
2238 case TYPE_CODE_BOOL
:
2241 return INCOMPATIBLE_TYPE_BADNESS
;
2245 switch (TYPE_CODE (arg
))
2248 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2249 return FLOAT_PROMOTION_BADNESS
;
2250 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2253 return FLOAT_CONVERSION_BADNESS
;
2255 case TYPE_CODE_BOOL
:
2256 case TYPE_CODE_ENUM
:
2257 case TYPE_CODE_RANGE
:
2258 case TYPE_CODE_CHAR
:
2259 return INT_FLOAT_CONVERSION_BADNESS
;
2261 return INCOMPATIBLE_TYPE_BADNESS
;
2264 case TYPE_CODE_COMPLEX
:
2265 switch (TYPE_CODE (arg
))
2266 { /* Strictly not needed for C++, but... */
2268 return FLOAT_PROMOTION_BADNESS
;
2269 case TYPE_CODE_COMPLEX
:
2272 return INCOMPATIBLE_TYPE_BADNESS
;
2275 case TYPE_CODE_STRUCT
:
2276 /* currently same as TYPE_CODE_CLASS */
2277 switch (TYPE_CODE (arg
))
2279 case TYPE_CODE_STRUCT
:
2280 /* Check for derivation */
2281 if (is_ancestor (parm
, arg
))
2282 return BASE_CONVERSION_BADNESS
;
2283 /* else fall through */
2285 return INCOMPATIBLE_TYPE_BADNESS
;
2288 case TYPE_CODE_UNION
:
2289 switch (TYPE_CODE (arg
))
2291 case TYPE_CODE_UNION
:
2293 return INCOMPATIBLE_TYPE_BADNESS
;
2296 case TYPE_CODE_MEMBERPTR
:
2297 switch (TYPE_CODE (arg
))
2300 return INCOMPATIBLE_TYPE_BADNESS
;
2303 case TYPE_CODE_METHOD
:
2304 switch (TYPE_CODE (arg
))
2308 return INCOMPATIBLE_TYPE_BADNESS
;
2312 switch (TYPE_CODE (arg
))
2316 return INCOMPATIBLE_TYPE_BADNESS
;
2321 switch (TYPE_CODE (arg
))
2325 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0),
2326 TYPE_FIELD_TYPE (arg
, 0));
2328 return INCOMPATIBLE_TYPE_BADNESS
;
2331 case TYPE_CODE_VOID
:
2333 return INCOMPATIBLE_TYPE_BADNESS
;
2334 } /* switch (TYPE_CODE (arg)) */
2338 /* End of functions for overload resolution */
2341 print_bit_vector (B_TYPE
*bits
, int nbits
)
2345 for (bitno
= 0; bitno
< nbits
; bitno
++)
2347 if ((bitno
% 8) == 0)
2349 puts_filtered (" ");
2351 if (B_TST (bits
, bitno
))
2352 printf_filtered (("1"));
2354 printf_filtered (("0"));
2358 /* Note the first arg should be the "this" pointer, we may not want to
2359 include it since we may get into a infinitely recursive
2363 print_arg_types (struct field
*args
, int nargs
, int spaces
)
2369 for (i
= 0; i
< nargs
; i
++)
2370 recursive_dump_type (args
[i
].type
, spaces
+ 2);
2375 dump_fn_fieldlists (struct type
*type
, int spaces
)
2381 printfi_filtered (spaces
, "fn_fieldlists ");
2382 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2383 printf_filtered ("\n");
2384 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2386 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2387 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2389 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2390 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2392 printf_filtered (_(") length %d\n"),
2393 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2394 for (overload_idx
= 0;
2395 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2398 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2400 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2401 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2403 printf_filtered (")\n");
2404 printfi_filtered (spaces
+ 8, "type ");
2405 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2407 printf_filtered ("\n");
2409 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2412 printfi_filtered (spaces
+ 8, "args ");
2413 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2415 printf_filtered ("\n");
2417 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2418 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
,
2421 printfi_filtered (spaces
+ 8, "fcontext ");
2422 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2424 printf_filtered ("\n");
2426 printfi_filtered (spaces
+ 8, "is_const %d\n",
2427 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2428 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2429 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2430 printfi_filtered (spaces
+ 8, "is_private %d\n",
2431 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2432 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2433 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2434 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2435 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2436 printfi_filtered (spaces
+ 8, "voffset %u\n",
2437 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2443 print_cplus_stuff (struct type
*type
, int spaces
)
2445 printfi_filtered (spaces
, "n_baseclasses %d\n",
2446 TYPE_N_BASECLASSES (type
));
2447 printfi_filtered (spaces
, "nfn_fields %d\n",
2448 TYPE_NFN_FIELDS (type
));
2449 printfi_filtered (spaces
, "nfn_fields_total %d\n",
2450 TYPE_NFN_FIELDS_TOTAL (type
));
2451 if (TYPE_N_BASECLASSES (type
) > 0)
2453 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2454 TYPE_N_BASECLASSES (type
));
2455 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
2457 printf_filtered (")");
2459 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2460 TYPE_N_BASECLASSES (type
));
2461 puts_filtered ("\n");
2463 if (TYPE_NFIELDS (type
) > 0)
2465 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2467 printfi_filtered (spaces
,
2468 "private_field_bits (%d bits at *",
2469 TYPE_NFIELDS (type
));
2470 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
2472 printf_filtered (")");
2473 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2474 TYPE_NFIELDS (type
));
2475 puts_filtered ("\n");
2477 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2479 printfi_filtered (spaces
,
2480 "protected_field_bits (%d bits at *",
2481 TYPE_NFIELDS (type
));
2482 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
2484 printf_filtered (")");
2485 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2486 TYPE_NFIELDS (type
));
2487 puts_filtered ("\n");
2490 if (TYPE_NFN_FIELDS (type
) > 0)
2492 dump_fn_fieldlists (type
, spaces
);
2497 print_bound_type (int bt
)
2501 case BOUND_CANNOT_BE_DETERMINED
:
2502 printf_filtered ("(BOUND_CANNOT_BE_DETERMINED)");
2504 case BOUND_BY_REF_ON_STACK
:
2505 printf_filtered ("(BOUND_BY_REF_ON_STACK)");
2507 case BOUND_BY_VALUE_ON_STACK
:
2508 printf_filtered ("(BOUND_BY_VALUE_ON_STACK)");
2510 case BOUND_BY_REF_IN_REG
:
2511 printf_filtered ("(BOUND_BY_REF_IN_REG)");
2513 case BOUND_BY_VALUE_IN_REG
:
2514 printf_filtered ("(BOUND_BY_VALUE_IN_REG)");
2517 printf_filtered ("(BOUND_SIMPLE)");
2520 printf_filtered (_("(unknown bound type)"));
2525 static struct obstack dont_print_type_obstack
;
2528 recursive_dump_type (struct type
*type
, int spaces
)
2533 obstack_begin (&dont_print_type_obstack
, 0);
2535 if (TYPE_NFIELDS (type
) > 0
2536 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
2538 struct type
**first_dont_print
2539 = (struct type
**) obstack_base (&dont_print_type_obstack
);
2541 int i
= (struct type
**)
2542 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
2546 if (type
== first_dont_print
[i
])
2548 printfi_filtered (spaces
, "type node ");
2549 gdb_print_host_address (type
, gdb_stdout
);
2550 printf_filtered (_(" <same as already seen type>\n"));
2555 obstack_ptr_grow (&dont_print_type_obstack
, type
);
2558 printfi_filtered (spaces
, "type node ");
2559 gdb_print_host_address (type
, gdb_stdout
);
2560 printf_filtered ("\n");
2561 printfi_filtered (spaces
, "name '%s' (",
2562 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
2563 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
2564 printf_filtered (")\n");
2565 printfi_filtered (spaces
, "tagname '%s' (",
2566 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
2567 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
2568 printf_filtered (")\n");
2569 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
2570 switch (TYPE_CODE (type
))
2572 case TYPE_CODE_UNDEF
:
2573 printf_filtered ("(TYPE_CODE_UNDEF)");
2576 printf_filtered ("(TYPE_CODE_PTR)");
2578 case TYPE_CODE_ARRAY
:
2579 printf_filtered ("(TYPE_CODE_ARRAY)");
2581 case TYPE_CODE_STRUCT
:
2582 printf_filtered ("(TYPE_CODE_STRUCT)");
2584 case TYPE_CODE_UNION
:
2585 printf_filtered ("(TYPE_CODE_UNION)");
2587 case TYPE_CODE_ENUM
:
2588 printf_filtered ("(TYPE_CODE_ENUM)");
2590 case TYPE_CODE_FLAGS
:
2591 printf_filtered ("(TYPE_CODE_FLAGS)");
2593 case TYPE_CODE_FUNC
:
2594 printf_filtered ("(TYPE_CODE_FUNC)");
2597 printf_filtered ("(TYPE_CODE_INT)");
2600 printf_filtered ("(TYPE_CODE_FLT)");
2602 case TYPE_CODE_VOID
:
2603 printf_filtered ("(TYPE_CODE_VOID)");
2606 printf_filtered ("(TYPE_CODE_SET)");
2608 case TYPE_CODE_RANGE
:
2609 printf_filtered ("(TYPE_CODE_RANGE)");
2611 case TYPE_CODE_STRING
:
2612 printf_filtered ("(TYPE_CODE_STRING)");
2614 case TYPE_CODE_BITSTRING
:
2615 printf_filtered ("(TYPE_CODE_BITSTRING)");
2617 case TYPE_CODE_ERROR
:
2618 printf_filtered ("(TYPE_CODE_ERROR)");
2620 case TYPE_CODE_MEMBERPTR
:
2621 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
2623 case TYPE_CODE_METHODPTR
:
2624 printf_filtered ("(TYPE_CODE_METHODPTR)");
2626 case TYPE_CODE_METHOD
:
2627 printf_filtered ("(TYPE_CODE_METHOD)");
2630 printf_filtered ("(TYPE_CODE_REF)");
2632 case TYPE_CODE_CHAR
:
2633 printf_filtered ("(TYPE_CODE_CHAR)");
2635 case TYPE_CODE_BOOL
:
2636 printf_filtered ("(TYPE_CODE_BOOL)");
2638 case TYPE_CODE_COMPLEX
:
2639 printf_filtered ("(TYPE_CODE_COMPLEX)");
2641 case TYPE_CODE_TYPEDEF
:
2642 printf_filtered ("(TYPE_CODE_TYPEDEF)");
2644 case TYPE_CODE_TEMPLATE
:
2645 printf_filtered ("(TYPE_CODE_TEMPLATE)");
2647 case TYPE_CODE_TEMPLATE_ARG
:
2648 printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)");
2650 case TYPE_CODE_NAMESPACE
:
2651 printf_filtered ("(TYPE_CODE_NAMESPACE)");
2654 printf_filtered ("(UNKNOWN TYPE CODE)");
2657 puts_filtered ("\n");
2658 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
2659 printfi_filtered (spaces
, "upper_bound_type 0x%x ",
2660 TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
2661 print_bound_type (TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
2662 puts_filtered ("\n");
2663 printfi_filtered (spaces
, "lower_bound_type 0x%x ",
2664 TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
2665 print_bound_type (TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
2666 puts_filtered ("\n");
2667 printfi_filtered (spaces
, "objfile ");
2668 gdb_print_host_address (TYPE_OBJFILE (type
), gdb_stdout
);
2669 printf_filtered ("\n");
2670 printfi_filtered (spaces
, "target_type ");
2671 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
2672 printf_filtered ("\n");
2673 if (TYPE_TARGET_TYPE (type
) != NULL
)
2675 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
2677 printfi_filtered (spaces
, "pointer_type ");
2678 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
2679 printf_filtered ("\n");
2680 printfi_filtered (spaces
, "reference_type ");
2681 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
2682 printf_filtered ("\n");
2683 printfi_filtered (spaces
, "type_chain ");
2684 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
2685 printf_filtered ("\n");
2686 printfi_filtered (spaces
, "instance_flags 0x%x",
2687 TYPE_INSTANCE_FLAGS (type
));
2688 if (TYPE_CONST (type
))
2690 puts_filtered (" TYPE_FLAG_CONST");
2692 if (TYPE_VOLATILE (type
))
2694 puts_filtered (" TYPE_FLAG_VOLATILE");
2696 if (TYPE_CODE_SPACE (type
))
2698 puts_filtered (" TYPE_FLAG_CODE_SPACE");
2700 if (TYPE_DATA_SPACE (type
))
2702 puts_filtered (" TYPE_FLAG_DATA_SPACE");
2704 if (TYPE_ADDRESS_CLASS_1 (type
))
2706 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
2708 if (TYPE_ADDRESS_CLASS_2 (type
))
2710 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
2712 puts_filtered ("\n");
2713 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
2714 if (TYPE_UNSIGNED (type
))
2716 puts_filtered (" TYPE_FLAG_UNSIGNED");
2718 if (TYPE_NOSIGN (type
))
2720 puts_filtered (" TYPE_FLAG_NOSIGN");
2722 if (TYPE_STUB (type
))
2724 puts_filtered (" TYPE_FLAG_STUB");
2726 if (TYPE_TARGET_STUB (type
))
2728 puts_filtered (" TYPE_FLAG_TARGET_STUB");
2730 if (TYPE_STATIC (type
))
2732 puts_filtered (" TYPE_FLAG_STATIC");
2734 if (TYPE_PROTOTYPED (type
))
2736 puts_filtered (" TYPE_FLAG_PROTOTYPED");
2738 if (TYPE_INCOMPLETE (type
))
2740 puts_filtered (" TYPE_FLAG_INCOMPLETE");
2742 if (TYPE_VARARGS (type
))
2744 puts_filtered (" TYPE_FLAG_VARARGS");
2746 /* This is used for things like AltiVec registers on ppc. Gcc emits
2747 an attribute for the array type, which tells whether or not we
2748 have a vector, instead of a regular array. */
2749 if (TYPE_VECTOR (type
))
2751 puts_filtered (" TYPE_FLAG_VECTOR");
2753 puts_filtered ("\n");
2754 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
2755 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
2756 puts_filtered ("\n");
2757 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
2759 printfi_filtered (spaces
+ 2,
2760 "[%d] bitpos %d bitsize %d type ",
2761 idx
, TYPE_FIELD_BITPOS (type
, idx
),
2762 TYPE_FIELD_BITSIZE (type
, idx
));
2763 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
2764 printf_filtered (" name '%s' (",
2765 TYPE_FIELD_NAME (type
, idx
) != NULL
2766 ? TYPE_FIELD_NAME (type
, idx
)
2768 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
2769 printf_filtered (")\n");
2770 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
2772 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
2775 printfi_filtered (spaces
, "vptr_basetype ");
2776 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
2777 puts_filtered ("\n");
2778 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
2780 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
2782 printfi_filtered (spaces
, "vptr_fieldno %d\n",
2783 TYPE_VPTR_FIELDNO (type
));
2784 switch (TYPE_CODE (type
))
2786 case TYPE_CODE_STRUCT
:
2787 printfi_filtered (spaces
, "cplus_stuff ");
2788 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
),
2790 puts_filtered ("\n");
2791 print_cplus_stuff (type
, spaces
);
2795 printfi_filtered (spaces
, "floatformat ");
2796 if (TYPE_FLOATFORMAT (type
) == NULL
)
2797 puts_filtered ("(null)");
2800 puts_filtered ("{ ");
2801 if (TYPE_FLOATFORMAT (type
)[0] == NULL
2802 || TYPE_FLOATFORMAT (type
)[0]->name
== NULL
)
2803 puts_filtered ("(null)");
2805 puts_filtered (TYPE_FLOATFORMAT (type
)[0]->name
);
2807 puts_filtered (", ");
2808 if (TYPE_FLOATFORMAT (type
)[1] == NULL
2809 || TYPE_FLOATFORMAT (type
)[1]->name
== NULL
)
2810 puts_filtered ("(null)");
2812 puts_filtered (TYPE_FLOATFORMAT (type
)[1]->name
);
2814 puts_filtered (" }");
2816 puts_filtered ("\n");
2820 /* We have to pick one of the union types to be able print and
2821 test the value. Pick cplus_struct_type, even though we know
2822 it isn't any particular one. */
2823 printfi_filtered (spaces
, "type_specific ");
2824 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
2825 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
2827 printf_filtered (_(" (unknown data form)"));
2829 printf_filtered ("\n");
2834 obstack_free (&dont_print_type_obstack
, NULL
);
2837 /* Trivial helpers for the libiberty hash table, for mapping one
2842 struct type
*old
, *new;
2846 type_pair_hash (const void *item
)
2848 const struct type_pair
*pair
= item
;
2849 return htab_hash_pointer (pair
->old
);
2853 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
2855 const struct type_pair
*lhs
= item_lhs
, *rhs
= item_rhs
;
2856 return lhs
->old
== rhs
->old
;
2859 /* Allocate the hash table used by copy_type_recursive to walk
2860 types without duplicates. We use OBJFILE's obstack, because
2861 OBJFILE is about to be deleted. */
2864 create_copied_types_hash (struct objfile
*objfile
)
2866 return htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
2867 NULL
, &objfile
->objfile_obstack
,
2868 hashtab_obstack_allocate
,
2869 dummy_obstack_deallocate
);
2872 /* Recursively copy (deep copy) TYPE, if it is associated with
2873 OBJFILE. Return a new type allocated using malloc, a saved type if
2874 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
2875 not associated with OBJFILE. */
2878 copy_type_recursive (struct objfile
*objfile
,
2880 htab_t copied_types
)
2882 struct type_pair
*stored
, pair
;
2884 struct type
*new_type
;
2886 if (TYPE_OBJFILE (type
) == NULL
)
2889 /* This type shouldn't be pointing to any types in other objfiles;
2890 if it did, the type might disappear unexpectedly. */
2891 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
2894 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
2896 return ((struct type_pair
*) *slot
)->new;
2898 new_type
= alloc_type (NULL
);
2900 /* We must add the new type to the hash table immediately, in case
2901 we encounter this type again during a recursive call below. */
2902 stored
= xmalloc (sizeof (struct type_pair
));
2904 stored
->new = new_type
;
2907 /* Copy the common fields of types. */
2908 TYPE_CODE (new_type
) = TYPE_CODE (type
);
2909 TYPE_ARRAY_UPPER_BOUND_TYPE (new_type
) =
2910 TYPE_ARRAY_UPPER_BOUND_TYPE (type
);
2911 TYPE_ARRAY_LOWER_BOUND_TYPE (new_type
) =
2912 TYPE_ARRAY_LOWER_BOUND_TYPE (type
);
2913 if (TYPE_NAME (type
))
2914 TYPE_NAME (new_type
) = xstrdup (TYPE_NAME (type
));
2915 if (TYPE_TAG_NAME (type
))
2916 TYPE_TAG_NAME (new_type
) = xstrdup (TYPE_TAG_NAME (type
));
2917 TYPE_FLAGS (new_type
) = TYPE_FLAGS (type
);
2918 TYPE_VPTR_FIELDNO (new_type
) = TYPE_VPTR_FIELDNO (type
);
2920 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
2921 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
2923 /* Copy the fields. */
2924 TYPE_NFIELDS (new_type
) = TYPE_NFIELDS (type
);
2925 if (TYPE_NFIELDS (type
))
2929 nfields
= TYPE_NFIELDS (type
);
2930 TYPE_FIELDS (new_type
) = xmalloc (sizeof (struct field
) * nfields
);
2931 for (i
= 0; i
< nfields
; i
++)
2933 TYPE_FIELD_ARTIFICIAL (new_type
, i
) =
2934 TYPE_FIELD_ARTIFICIAL (type
, i
);
2935 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
2936 if (TYPE_FIELD_TYPE (type
, i
))
2937 TYPE_FIELD_TYPE (new_type
, i
)
2938 = copy_type_recursive (objfile
, TYPE_FIELD_TYPE (type
, i
),
2940 if (TYPE_FIELD_NAME (type
, i
))
2941 TYPE_FIELD_NAME (new_type
, i
) =
2942 xstrdup (TYPE_FIELD_NAME (type
, i
));
2943 if (TYPE_FIELD_STATIC_HAS_ADDR (type
, i
))
2944 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type
, i
),
2945 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
2946 else if (TYPE_FIELD_STATIC (type
, i
))
2947 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type
, i
),
2948 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
,
2952 TYPE_FIELD_BITPOS (new_type
, i
) =
2953 TYPE_FIELD_BITPOS (type
, i
);
2954 TYPE_FIELD_STATIC_KIND (new_type
, i
) = 0;
2959 /* Copy pointers to other types. */
2960 if (TYPE_TARGET_TYPE (type
))
2961 TYPE_TARGET_TYPE (new_type
) =
2962 copy_type_recursive (objfile
,
2963 TYPE_TARGET_TYPE (type
),
2965 if (TYPE_VPTR_BASETYPE (type
))
2966 TYPE_VPTR_BASETYPE (new_type
) =
2967 copy_type_recursive (objfile
,
2968 TYPE_VPTR_BASETYPE (type
),
2970 /* Maybe copy the type_specific bits.
2972 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
2973 base classes and methods. There's no fundamental reason why we
2974 can't, but at the moment it is not needed. */
2976 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
2977 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
2978 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2979 || TYPE_CODE (type
) == TYPE_CODE_UNION
2980 || TYPE_CODE (type
) == TYPE_CODE_TEMPLATE
2981 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
2982 INIT_CPLUS_SPECIFIC (new_type
);
2987 static struct type
*
2988 build_flt (int bit
, char *name
, const struct floatformat
**floatformats
)
2994 gdb_assert (floatformats
!= NULL
);
2995 gdb_assert (floatformats
[0] != NULL
&& floatformats
[1] != NULL
);
2996 bit
= floatformats
[0]->totalsize
;
2998 gdb_assert (bit
>= 0);
3000 t
= init_type (TYPE_CODE_FLT
, bit
/ TARGET_CHAR_BIT
, 0, name
, NULL
);
3001 TYPE_FLOATFORMAT (t
) = floatformats
;
3005 static struct gdbarch_data
*gdbtypes_data
;
3007 const struct builtin_type
*
3008 builtin_type (struct gdbarch
*gdbarch
)
3010 return gdbarch_data (gdbarch
, gdbtypes_data
);
3014 static struct type
*
3015 build_complex (int bit
, char *name
, struct type
*target_type
)
3018 if (bit
<= 0 || target_type
== builtin_type_error
)
3020 gdb_assert (builtin_type_error
!= NULL
);
3021 return builtin_type_error
;
3023 t
= init_type (TYPE_CODE_COMPLEX
, 2 * bit
/ TARGET_CHAR_BIT
,
3024 0, name
, (struct objfile
*) NULL
);
3025 TYPE_TARGET_TYPE (t
) = target_type
;
3030 gdbtypes_post_init (struct gdbarch
*gdbarch
)
3032 struct builtin_type
*builtin_type
3033 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
3035 builtin_type
->builtin_void
=
3036 init_type (TYPE_CODE_VOID
, 1,
3038 "void", (struct objfile
*) NULL
);
3039 builtin_type
->builtin_char
=
3040 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3042 | (gdbarch_char_signed (gdbarch
) ? 0 : TYPE_FLAG_UNSIGNED
)),
3043 "char", (struct objfile
*) NULL
);
3044 builtin_type
->builtin_true_char
=
3045 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3047 "true character", (struct objfile
*) NULL
);
3048 builtin_type
->builtin_true_unsigned_char
=
3049 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3051 "true character", (struct objfile
*) NULL
);
3052 builtin_type
->builtin_signed_char
=
3053 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3055 "signed char", (struct objfile
*) NULL
);
3056 builtin_type
->builtin_unsigned_char
=
3057 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3059 "unsigned char", (struct objfile
*) NULL
);
3060 builtin_type
->builtin_short
=
3061 init_type (TYPE_CODE_INT
,
3062 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3063 0, "short", (struct objfile
*) NULL
);
3064 builtin_type
->builtin_unsigned_short
=
3065 init_type (TYPE_CODE_INT
,
3066 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3067 TYPE_FLAG_UNSIGNED
, "unsigned short",
3068 (struct objfile
*) NULL
);
3069 builtin_type
->builtin_int
=
3070 init_type (TYPE_CODE_INT
,
3071 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3072 0, "int", (struct objfile
*) NULL
);
3073 builtin_type
->builtin_unsigned_int
=
3074 init_type (TYPE_CODE_INT
,
3075 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3076 TYPE_FLAG_UNSIGNED
, "unsigned int",
3077 (struct objfile
*) NULL
);
3078 builtin_type
->builtin_long
=
3079 init_type (TYPE_CODE_INT
,
3080 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3081 0, "long", (struct objfile
*) NULL
);
3082 builtin_type
->builtin_unsigned_long
=
3083 init_type (TYPE_CODE_INT
,
3084 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3085 TYPE_FLAG_UNSIGNED
, "unsigned long",
3086 (struct objfile
*) NULL
);
3087 builtin_type
->builtin_long_long
=
3088 init_type (TYPE_CODE_INT
,
3089 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3090 0, "long long", (struct objfile
*) NULL
);
3091 builtin_type
->builtin_unsigned_long_long
=
3092 init_type (TYPE_CODE_INT
,
3093 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3094 TYPE_FLAG_UNSIGNED
, "unsigned long long",
3095 (struct objfile
*) NULL
);
3096 builtin_type
->builtin_float
3097 = build_flt (gdbarch_float_bit (gdbarch
), "float",
3098 gdbarch_float_format (gdbarch
));
3099 builtin_type
->builtin_double
3100 = build_flt (gdbarch_double_bit (gdbarch
), "double",
3101 gdbarch_double_format (gdbarch
));
3102 builtin_type
->builtin_long_double
3103 = build_flt (gdbarch_long_double_bit (gdbarch
), "long double",
3104 gdbarch_long_double_format (gdbarch
));
3105 builtin_type
->builtin_complex
3106 = build_complex (gdbarch_float_bit (gdbarch
), "complex",
3107 builtin_type
->builtin_float
);
3108 builtin_type
->builtin_double_complex
3109 = build_complex (gdbarch_double_bit (gdbarch
), "double complex",
3110 builtin_type
->builtin_double
);
3111 builtin_type
->builtin_string
=
3112 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3114 "string", (struct objfile
*) NULL
);
3115 builtin_type
->builtin_bool
=
3116 init_type (TYPE_CODE_BOOL
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3118 "bool", (struct objfile
*) NULL
);
3120 /* The following three are about decimal floating point types, which
3121 are 32-bits, 64-bits and 128-bits respectively. */
3122 builtin_type
->builtin_decfloat
3123 = init_type (TYPE_CODE_DECFLOAT
, 32 / 8,
3125 "decimal float", (struct objfile
*) NULL
);
3126 builtin_type
->builtin_decdouble
3127 = init_type (TYPE_CODE_DECFLOAT
, 64 / 8,
3129 "decimal double", (struct objfile
*) NULL
);
3130 builtin_type
->builtin_declong
3131 = init_type (TYPE_CODE_DECFLOAT
, 128 / 8,
3133 "decimal long double", (struct objfile
*) NULL
);
3135 /* Pointer/Address types. */
3137 /* NOTE: on some targets, addresses and pointers are not necessarily
3138 the same --- for example, on the D10V, pointers are 16 bits long,
3139 but addresses are 32 bits long. See doc/gdbint.texinfo,
3140 ``Pointers Are Not Always Addresses''.
3143 - gdb's `struct type' always describes the target's
3145 - gdb's `struct value' objects should always hold values in
3147 - gdb's CORE_ADDR values are addresses in the unified virtual
3148 address space that the assembler and linker work with. Thus,
3149 since target_read_memory takes a CORE_ADDR as an argument, it
3150 can access any memory on the target, even if the processor has
3151 separate code and data address spaces.
3154 - If v is a value holding a D10V code pointer, its contents are
3155 in target form: a big-endian address left-shifted two bits.
3156 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3157 sizeof (void *) == 2 on the target.
3159 In this context, builtin_type->CORE_ADDR is a bit odd: it's a
3160 target type for a value the target will never see. It's only
3161 used to hold the values of (typeless) linker symbols, which are
3162 indeed in the unified virtual address space. */
3164 builtin_type
->builtin_data_ptr
=
3165 make_pointer_type (builtin_type
->builtin_void
, NULL
);
3166 builtin_type
->builtin_func_ptr
=
3167 lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
3168 builtin_type
->builtin_core_addr
=
3169 init_type (TYPE_CODE_INT
,
3170 gdbarch_addr_bit (gdbarch
) / 8,
3172 "__CORE_ADDR", (struct objfile
*) NULL
);
3175 /* The following set of types is used for symbols with no
3176 debug information. */
3177 builtin_type
->nodebug_text_symbol
=
3178 init_type (TYPE_CODE_FUNC
, 1, 0,
3179 "<text variable, no debug info>", NULL
);
3180 TYPE_TARGET_TYPE (builtin_type
->nodebug_text_symbol
) =
3181 builtin_type
->builtin_int
;
3182 builtin_type
->nodebug_data_symbol
=
3183 init_type (TYPE_CODE_INT
,
3184 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3185 "<data variable, no debug info>", NULL
);
3186 builtin_type
->nodebug_unknown_symbol
=
3187 init_type (TYPE_CODE_INT
, 1, 0,
3188 "<variable (not text or data), no debug info>", NULL
);
3189 builtin_type
->nodebug_tls_symbol
=
3190 init_type (TYPE_CODE_INT
,
3191 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3192 "<thread local variable, no debug info>", NULL
);
3194 return builtin_type
;
3197 extern void _initialize_gdbtypes (void);
3199 _initialize_gdbtypes (void)
3201 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
3203 /* FIXME: The following types are architecture-neutral. However,
3204 they contain pointer_type and reference_type fields potentially
3205 caching pointer or reference types that *are* architecture
3209 init_type (TYPE_CODE_INT
, 0 / 8,
3211 "int0_t", (struct objfile
*) NULL
);
3213 init_type (TYPE_CODE_INT
, 8 / 8,
3215 "int8_t", (struct objfile
*) NULL
);
3216 builtin_type_uint8
=
3217 init_type (TYPE_CODE_INT
, 8 / 8,
3218 TYPE_FLAG_UNSIGNED
| TYPE_FLAG_NOTTEXT
,
3219 "uint8_t", (struct objfile
*) NULL
);
3220 builtin_type_int16
=
3221 init_type (TYPE_CODE_INT
, 16 / 8,
3223 "int16_t", (struct objfile
*) NULL
);
3224 builtin_type_uint16
=
3225 init_type (TYPE_CODE_INT
, 16 / 8,
3227 "uint16_t", (struct objfile
*) NULL
);
3228 builtin_type_int32
=
3229 init_type (TYPE_CODE_INT
, 32 / 8,
3231 "int32_t", (struct objfile
*) NULL
);
3232 builtin_type_uint32
=
3233 init_type (TYPE_CODE_INT
, 32 / 8,
3235 "uint32_t", (struct objfile
*) NULL
);
3236 builtin_type_int64
=
3237 init_type (TYPE_CODE_INT
, 64 / 8,
3239 "int64_t", (struct objfile
*) NULL
);
3240 builtin_type_uint64
=
3241 init_type (TYPE_CODE_INT
, 64 / 8,
3243 "uint64_t", (struct objfile
*) NULL
);
3244 builtin_type_int128
=
3245 init_type (TYPE_CODE_INT
, 128 / 8,
3247 "int128_t", (struct objfile
*) NULL
);
3248 builtin_type_uint128
=
3249 init_type (TYPE_CODE_INT
, 128 / 8,
3251 "uint128_t", (struct objfile
*) NULL
);
3253 builtin_type_ieee_single
=
3254 build_flt (-1, "builtin_type_ieee_single", floatformats_ieee_single
);
3255 builtin_type_ieee_double
=
3256 build_flt (-1, "builtin_type_ieee_double", floatformats_ieee_double
);
3257 builtin_type_i387_ext
=
3258 build_flt (-1, "builtin_type_i387_ext", floatformats_i387_ext
);
3259 builtin_type_m68881_ext
=
3260 build_flt (-1, "builtin_type_m68881_ext", floatformats_m68881_ext
);
3261 builtin_type_arm_ext
=
3262 build_flt (-1, "builtin_type_arm_ext", floatformats_arm_ext
);
3263 builtin_type_ia64_spill
=
3264 build_flt (-1, "builtin_type_ia64_spill", floatformats_ia64_spill
);
3265 builtin_type_ia64_quad
=
3266 build_flt (-1, "builtin_type_ia64_quad", floatformats_ia64_quad
);
3268 add_setshow_zinteger_cmd ("overload", no_class
, &overload_debug
, _("\
3269 Set debugging of C++ overloading."), _("\
3270 Show debugging of C++ overloading."), _("\
3271 When enabled, ranking of the functions is displayed."),
3273 show_overload_debug
,
3274 &setdebuglist
, &showdebuglist
);
3276 /* Add user knob for controlling resolution of opaque types. */
3277 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
3278 &opaque_type_resolution
, _("\
3279 Set resolution of opaque struct/class/union types (if set before loading symbols)."), _("\
3280 Show resolution of opaque struct/class/union types (if set before loading symbols)."), NULL
,
3282 show_opaque_type_resolution
,
3283 &setlist
, &showlist
);