1 /* Support routines for manipulating internal types for GDB.
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
4 2003, 2004, 2005, 2006, 2007, 2008 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 /* Be careful when setting the array length. Ada arrays can be
815 empty arrays with the high_bound being smaller than the low_bound.
816 In such cases, the array length should be zero. */
817 if (high_bound
< low_bound
)
818 TYPE_LENGTH (result_type
) = 0;
820 TYPE_LENGTH (result_type
) =
821 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
822 TYPE_NFIELDS (result_type
) = 1;
823 TYPE_FIELDS (result_type
) =
824 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
825 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
826 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
827 TYPE_VPTR_FIELDNO (result_type
) = -1;
829 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
830 if (TYPE_LENGTH (result_type
) == 0)
831 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
833 return (result_type
);
836 /* Create a string type using either a blank type supplied in
837 RESULT_TYPE, or creating a new type. String types are similar
838 enough to array of char types that we can use create_array_type to
839 build the basic type and then bash it into a string type.
841 For fixed length strings, the range type contains 0 as the lower
842 bound and the length of the string minus one as the upper bound.
844 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
845 sure it is TYPE_CODE_UNDEF before we bash it into a string
849 create_string_type (struct type
*result_type
,
850 struct type
*range_type
)
852 struct type
*string_char_type
;
854 string_char_type
= language_string_char_type (current_language
,
856 result_type
= create_array_type (result_type
,
859 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
860 return (result_type
);
864 create_set_type (struct type
*result_type
, struct type
*domain_type
)
866 if (result_type
== NULL
)
868 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
870 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
871 TYPE_NFIELDS (result_type
) = 1;
872 TYPE_FIELDS (result_type
) = (struct field
*)
873 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
874 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
876 if (!TYPE_STUB (domain_type
))
878 LONGEST low_bound
, high_bound
, bit_length
;
879 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
880 low_bound
= high_bound
= 0;
881 bit_length
= high_bound
- low_bound
+ 1;
882 TYPE_LENGTH (result_type
)
883 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
885 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
887 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
889 return (result_type
);
893 append_flags_type_flag (struct type
*type
, int bitpos
, char *name
)
895 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLAGS
);
896 gdb_assert (bitpos
< TYPE_NFIELDS (type
));
897 gdb_assert (bitpos
>= 0);
901 TYPE_FIELD_NAME (type
, bitpos
) = xstrdup (name
);
902 TYPE_FIELD_BITPOS (type
, bitpos
) = bitpos
;
906 /* Don't show this field to the user. */
907 TYPE_FIELD_BITPOS (type
, bitpos
) = -1;
912 init_flags_type (char *name
, int length
)
914 int nfields
= length
* TARGET_CHAR_BIT
;
917 type
= init_type (TYPE_CODE_FLAGS
, length
,
918 TYPE_FLAG_UNSIGNED
, name
, NULL
);
919 TYPE_NFIELDS (type
) = nfields
;
920 TYPE_FIELDS (type
) = TYPE_ALLOC (type
,
921 nfields
* sizeof (struct field
));
922 memset (TYPE_FIELDS (type
), 0, nfields
* sizeof (struct field
));
927 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
928 and any array types nested inside it. */
931 make_vector_type (struct type
*array_type
)
933 struct type
*inner_array
, *elt_type
;
936 /* Find the innermost array type, in case the array is
937 multi-dimensional. */
938 inner_array
= array_type
;
939 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
940 inner_array
= TYPE_TARGET_TYPE (inner_array
);
942 elt_type
= TYPE_TARGET_TYPE (inner_array
);
943 if (TYPE_CODE (elt_type
) == TYPE_CODE_INT
)
945 flags
= TYPE_INSTANCE_FLAGS (elt_type
) | TYPE_FLAG_NOTTEXT
;
946 elt_type
= make_qualified_type (elt_type
, flags
, NULL
);
947 TYPE_TARGET_TYPE (inner_array
) = elt_type
;
950 TYPE_FLAGS (array_type
) |= TYPE_FLAG_VECTOR
;
954 init_vector_type (struct type
*elt_type
, int n
)
956 struct type
*array_type
;
958 array_type
= create_array_type (0, elt_type
,
959 create_range_type (0,
962 make_vector_type (array_type
);
966 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
967 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
968 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
969 TYPE doesn't include the offset (that's the value of the MEMBER
970 itself), but does include the structure type into which it points
973 When "smashing" the type, we preserve the objfile that the old type
974 pointed to, since we aren't changing where the type is actually
978 smash_to_memberptr_type (struct type
*type
, struct type
*domain
,
979 struct type
*to_type
)
981 struct objfile
*objfile
;
983 objfile
= TYPE_OBJFILE (type
);
986 TYPE_OBJFILE (type
) = objfile
;
987 TYPE_TARGET_TYPE (type
) = to_type
;
988 TYPE_DOMAIN_TYPE (type
) = domain
;
989 /* Assume that a data member pointer is the same size as a normal
991 TYPE_LENGTH (type
) = gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
;
992 TYPE_CODE (type
) = TYPE_CODE_MEMBERPTR
;
995 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
996 METHOD just means `function that gets an extra "this" argument'.
998 When "smashing" the type, we preserve the objfile that the old type
999 pointed to, since we aren't changing where the type is actually
1003 smash_to_method_type (struct type
*type
, struct type
*domain
,
1004 struct type
*to_type
, struct field
*args
,
1005 int nargs
, int varargs
)
1007 struct objfile
*objfile
;
1009 objfile
= TYPE_OBJFILE (type
);
1012 TYPE_OBJFILE (type
) = objfile
;
1013 TYPE_TARGET_TYPE (type
) = to_type
;
1014 TYPE_DOMAIN_TYPE (type
) = domain
;
1015 TYPE_FIELDS (type
) = args
;
1016 TYPE_NFIELDS (type
) = nargs
;
1018 TYPE_FLAGS (type
) |= TYPE_FLAG_VARARGS
;
1019 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1020 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
1023 /* Return a typename for a struct/union/enum type without "struct ",
1024 "union ", or "enum ". If the type has a NULL name, return NULL. */
1027 type_name_no_tag (const struct type
*type
)
1029 if (TYPE_TAG_NAME (type
) != NULL
)
1030 return TYPE_TAG_NAME (type
);
1032 /* Is there code which expects this to return the name if there is
1033 no tag name? My guess is that this is mainly used for C++ in
1034 cases where the two will always be the same. */
1035 return TYPE_NAME (type
);
1038 /* Lookup a typedef or primitive type named NAME, visible in lexical
1039 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1040 suitably defined. */
1043 lookup_typename (char *name
, struct block
*block
, int noerr
)
1048 sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, 0);
1049 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1051 tmp
= language_lookup_primitive_type_by_name (current_language
,
1058 else if (!tmp
&& noerr
)
1064 error (_("No type named %s."), name
);
1067 return (SYMBOL_TYPE (sym
));
1071 lookup_unsigned_typename (char *name
)
1073 char *uns
= alloca (strlen (name
) + 10);
1075 strcpy (uns
, "unsigned ");
1076 strcpy (uns
+ 9, name
);
1077 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
1081 lookup_signed_typename (char *name
)
1084 char *uns
= alloca (strlen (name
) + 8);
1086 strcpy (uns
, "signed ");
1087 strcpy (uns
+ 7, name
);
1088 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
1089 /* If we don't find "signed FOO" just try again with plain "FOO". */
1092 return lookup_typename (name
, (struct block
*) NULL
, 0);
1095 /* Lookup a structure type named "struct NAME",
1096 visible in lexical block BLOCK. */
1099 lookup_struct (char *name
, struct block
*block
)
1103 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1107 error (_("No struct type named %s."), name
);
1109 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1111 error (_("This context has class, union or enum %s, not a struct."),
1114 return (SYMBOL_TYPE (sym
));
1117 /* Lookup a union type named "union NAME",
1118 visible in lexical block BLOCK. */
1121 lookup_union (char *name
, struct block
*block
)
1126 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1129 error (_("No union type named %s."), name
);
1131 t
= SYMBOL_TYPE (sym
);
1133 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1136 /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
1137 * a further "declared_type" field to discover it is really a union.
1139 if (HAVE_CPLUS_STRUCT (t
))
1140 if (TYPE_DECLARED_TYPE (t
) == DECLARED_TYPE_UNION
)
1143 /* If we get here, it's not a union. */
1144 error (_("This context has class, struct or enum %s, not a union."),
1149 /* Lookup an enum type named "enum NAME",
1150 visible in lexical block BLOCK. */
1153 lookup_enum (char *name
, struct block
*block
)
1157 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1160 error (_("No enum type named %s."), name
);
1162 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1164 error (_("This context has class, struct or union %s, not an enum."),
1167 return (SYMBOL_TYPE (sym
));
1170 /* Lookup a template type named "template NAME<TYPE>",
1171 visible in lexical block BLOCK. */
1174 lookup_template_type (char *name
, struct type
*type
,
1175 struct block
*block
)
1178 char *nam
= (char *)
1179 alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1182 strcat (nam
, TYPE_NAME (type
));
1183 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1185 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0);
1189 error (_("No template type named %s."), name
);
1191 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1193 error (_("This context has class, union or enum %s, not a struct."),
1196 return (SYMBOL_TYPE (sym
));
1199 /* Given a type TYPE, lookup the type of the component of type named
1202 TYPE can be either a struct or union, or a pointer or reference to
1203 a struct or union. If it is a pointer or reference, its target
1204 type is automatically used. Thus '.' and '->' are interchangable,
1205 as specified for the definitions of the expression element types
1206 STRUCTOP_STRUCT and STRUCTOP_PTR.
1208 If NOERR is nonzero, return zero if NAME is not suitably defined.
1209 If NAME is the name of a baseclass type, return that type. */
1212 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
1218 CHECK_TYPEDEF (type
);
1219 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1220 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1222 type
= TYPE_TARGET_TYPE (type
);
1225 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1226 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1228 target_terminal_ours ();
1229 gdb_flush (gdb_stdout
);
1230 fprintf_unfiltered (gdb_stderr
, "Type ");
1231 type_print (type
, "", gdb_stderr
, -1);
1232 error (_(" is not a structure or union type."));
1236 /* FIXME: This change put in by Michael seems incorrect for the case
1237 where the structure tag name is the same as the member name.
1238 I.E. when doing "ptype bell->bar" for "struct foo { int bar; int
1239 foo; } bell;" Disabled by fnf. */
1243 typename
= type_name_no_tag (type
);
1244 if (typename
!= NULL
&& strcmp (typename
, name
) == 0)
1249 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1251 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1253 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1255 return TYPE_FIELD_TYPE (type
, i
);
1259 /* OK, it's not in this class. Recursively check the baseclasses. */
1260 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1264 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, 1);
1276 target_terminal_ours ();
1277 gdb_flush (gdb_stdout
);
1278 fprintf_unfiltered (gdb_stderr
, "Type ");
1279 type_print (type
, "", gdb_stderr
, -1);
1280 fprintf_unfiltered (gdb_stderr
, " has no component named ");
1281 fputs_filtered (name
, gdb_stderr
);
1283 return (struct type
*) -1; /* For lint */
1286 /* Lookup the vptr basetype/fieldno values for TYPE.
1287 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1288 vptr_fieldno. Also, if found and basetype is from the same objfile,
1290 If not found, return -1 and ignore BASETYPEP.
1291 Callers should be aware that in some cases (for example,
1292 the type or one of its baseclasses is a stub type and we are
1293 debugging a .o file), this function will not be able to find the
1294 virtual function table pointer, and vptr_fieldno will remain -1 and
1295 vptr_basetype will remain NULL or incomplete. */
1298 get_vptr_fieldno (struct type
*type
, struct type
**basetypep
)
1300 CHECK_TYPEDEF (type
);
1302 if (TYPE_VPTR_FIELDNO (type
) < 0)
1306 /* We must start at zero in case the first (and only) baseclass
1307 is virtual (and hence we cannot share the table pointer). */
1308 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1310 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1312 struct type
*basetype
;
1314 fieldno
= get_vptr_fieldno (baseclass
, &basetype
);
1317 /* If the type comes from a different objfile we can't cache
1318 it, it may have a different lifetime. PR 2384 */
1319 if (TYPE_OBJFILE (type
) == TYPE_OBJFILE (baseclass
))
1321 TYPE_VPTR_FIELDNO (type
) = fieldno
;
1322 TYPE_VPTR_BASETYPE (type
) = basetype
;
1325 *basetypep
= basetype
;
1336 *basetypep
= TYPE_VPTR_BASETYPE (type
);
1337 return TYPE_VPTR_FIELDNO (type
);
1341 /* Find the method and field indices for the destructor in class type T.
1342 Return 1 if the destructor was found, otherwise, return 0. */
1345 get_destructor_fn_field (struct type
*t
,
1351 for (i
= 0; i
< TYPE_NFN_FIELDS (t
); i
++)
1354 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1356 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (t
, i
); j
++)
1358 if (is_destructor_name (TYPE_FN_FIELD_PHYSNAME (f
, j
)) != 0)
1370 stub_noname_complaint (void)
1372 complaint (&symfile_complaints
, _("stub type has NULL name"));
1375 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1377 If this is a stubbed struct (i.e. declared as struct foo *), see if
1378 we can find a full definition in some other file. If so, copy this
1379 definition, so we can use it in future. There used to be a comment
1380 (but not any code) that if we don't find a full definition, we'd
1381 set a flag so we don't spend time in the future checking the same
1382 type. That would be a mistake, though--we might load in more
1383 symbols which contain a full definition for the type.
1385 This used to be coded as a macro, but I don't think it is called
1386 often enough to merit such treatment. */
1388 /* Find the real type of TYPE. This function returns the real type,
1389 after removing all layers of typedefs and completing opaque or stub
1390 types. Completion changes the TYPE argument, but stripping of
1391 typedefs does not. */
1394 check_typedef (struct type
*type
)
1396 struct type
*orig_type
= type
;
1397 int is_const
, is_volatile
;
1401 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1403 if (!TYPE_TARGET_TYPE (type
))
1408 /* It is dangerous to call lookup_symbol if we are currently
1409 reading a symtab. Infinite recursion is one danger. */
1410 if (currently_reading_symtab
)
1413 name
= type_name_no_tag (type
);
1414 /* FIXME: shouldn't we separately check the TYPE_NAME and
1415 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1416 VAR_DOMAIN as appropriate? (this code was written before
1417 TYPE_NAME and TYPE_TAG_NAME were separate). */
1420 stub_noname_complaint ();
1423 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1425 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1426 else /* TYPE_CODE_UNDEF */
1427 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
);
1429 type
= TYPE_TARGET_TYPE (type
);
1432 is_const
= TYPE_CONST (type
);
1433 is_volatile
= TYPE_VOLATILE (type
);
1435 /* If this is a struct/class/union with no fields, then check
1436 whether a full definition exists somewhere else. This is for
1437 systems where a type definition with no fields is issued for such
1438 types, instead of identifying them as stub types in the first
1441 if (TYPE_IS_OPAQUE (type
)
1442 && opaque_type_resolution
1443 && !currently_reading_symtab
)
1445 char *name
= type_name_no_tag (type
);
1446 struct type
*newtype
;
1449 stub_noname_complaint ();
1452 newtype
= lookup_transparent_type (name
);
1456 /* If the resolved type and the stub are in the same
1457 objfile, then replace the stub type with the real deal.
1458 But if they're in separate objfiles, leave the stub
1459 alone; we'll just look up the transparent type every time
1460 we call check_typedef. We can't create pointers between
1461 types allocated to different objfiles, since they may
1462 have different lifetimes. Trying to copy NEWTYPE over to
1463 TYPE's objfile is pointless, too, since you'll have to
1464 move over any other types NEWTYPE refers to, which could
1465 be an unbounded amount of stuff. */
1466 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
1467 make_cv_type (is_const
, is_volatile
, newtype
, &type
);
1472 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1474 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1476 char *name
= type_name_no_tag (type
);
1477 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1478 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1479 as appropriate? (this code was written before TYPE_NAME and
1480 TYPE_TAG_NAME were separate). */
1484 stub_noname_complaint ();
1487 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1490 /* Same as above for opaque types, we can replace the stub
1491 with the complete type only if they are int the same
1493 if (TYPE_OBJFILE (SYMBOL_TYPE(sym
)) == TYPE_OBJFILE (type
))
1494 make_cv_type (is_const
, is_volatile
,
1495 SYMBOL_TYPE (sym
), &type
);
1497 type
= SYMBOL_TYPE (sym
);
1501 if (TYPE_TARGET_STUB (type
))
1503 struct type
*range_type
;
1504 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1506 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1510 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1511 && TYPE_NFIELDS (type
) == 1
1512 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
1513 == TYPE_CODE_RANGE
))
1515 /* Now recompute the length of the array type, based on its
1516 number of elements and the target type's length.
1517 Watch out for Ada null Ada arrays where the high bound
1518 is smaller than the low bound. */
1519 const int low_bound
= TYPE_FIELD_BITPOS (range_type
, 0);
1520 const int high_bound
= TYPE_FIELD_BITPOS (range_type
, 1);
1523 if (high_bound
< low_bound
)
1526 nb_elements
= high_bound
- low_bound
+ 1;
1528 TYPE_LENGTH (type
) = nb_elements
* TYPE_LENGTH (target_type
);
1529 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1531 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1533 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1534 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1537 /* Cache TYPE_LENGTH for future use. */
1538 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1542 /* Parse a type expression in the string [P..P+LENGTH). If an error
1543 occurs, silently return builtin_type_void. */
1545 static struct type
*
1546 safe_parse_type (char *p
, int length
)
1548 struct ui_file
*saved_gdb_stderr
;
1551 /* Suppress error messages. */
1552 saved_gdb_stderr
= gdb_stderr
;
1553 gdb_stderr
= ui_file_new ();
1555 /* Call parse_and_eval_type() without fear of longjmp()s. */
1556 if (!gdb_parse_and_eval_type (p
, length
, &type
))
1557 type
= builtin_type_void
;
1559 /* Stop suppressing error messages. */
1560 ui_file_delete (gdb_stderr
);
1561 gdb_stderr
= saved_gdb_stderr
;
1566 /* Ugly hack to convert method stubs into method types.
1568 He ain't kiddin'. This demangles the name of the method into a
1569 string including argument types, parses out each argument type,
1570 generates a string casting a zero to that type, evaluates the
1571 string, and stuffs the resulting type into an argtype vector!!!
1572 Then it knows the type of the whole function (including argument
1573 types for overloading), which info used to be in the stab's but was
1574 removed to hack back the space required for them. */
1577 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1580 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1581 char *demangled_name
= cplus_demangle (mangled_name
,
1582 DMGL_PARAMS
| DMGL_ANSI
);
1583 char *argtypetext
, *p
;
1584 int depth
= 0, argcount
= 1;
1585 struct field
*argtypes
;
1588 /* Make sure we got back a function string that we can use. */
1590 p
= strchr (demangled_name
, '(');
1594 if (demangled_name
== NULL
|| p
== NULL
)
1595 error (_("Internal: Cannot demangle mangled name `%s'."),
1598 /* Now, read in the parameters that define this type. */
1603 if (*p
== '(' || *p
== '<')
1607 else if (*p
== ')' || *p
== '>')
1611 else if (*p
== ',' && depth
== 0)
1619 /* If we read one argument and it was ``void'', don't count it. */
1620 if (strncmp (argtypetext
, "(void)", 6) == 0)
1623 /* We need one extra slot, for the THIS pointer. */
1625 argtypes
= (struct field
*)
1626 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
1629 /* Add THIS pointer for non-static methods. */
1630 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1631 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
1635 argtypes
[0].type
= lookup_pointer_type (type
);
1639 if (*p
!= ')') /* () means no args, skip while */
1644 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1646 /* Avoid parsing of ellipsis, they will be handled below.
1647 Also avoid ``void'' as above. */
1648 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
1649 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
1651 argtypes
[argcount
].type
=
1652 safe_parse_type (argtypetext
, p
- argtypetext
);
1655 argtypetext
= p
+ 1;
1658 if (*p
== '(' || *p
== '<')
1662 else if (*p
== ')' || *p
== '>')
1671 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1673 /* Now update the old "stub" type into a real type. */
1674 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1675 TYPE_DOMAIN_TYPE (mtype
) = type
;
1676 TYPE_FIELDS (mtype
) = argtypes
;
1677 TYPE_NFIELDS (mtype
) = argcount
;
1678 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1679 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1681 TYPE_FLAGS (mtype
) |= TYPE_FLAG_VARARGS
;
1683 xfree (demangled_name
);
1686 /* This is the external interface to check_stub_method, above. This
1687 function unstubs all of the signatures for TYPE's METHOD_ID method
1688 name. After calling this function TYPE_FN_FIELD_STUB will be
1689 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1692 This function unfortunately can not die until stabs do. */
1695 check_stub_method_group (struct type
*type
, int method_id
)
1697 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
1698 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1699 int j
, found_stub
= 0;
1701 for (j
= 0; j
< len
; j
++)
1702 if (TYPE_FN_FIELD_STUB (f
, j
))
1705 check_stub_method (type
, method_id
, j
);
1708 /* GNU v3 methods with incorrect names were corrected when we read
1709 in type information, because it was cheaper to do it then. The
1710 only GNU v2 methods with incorrect method names are operators and
1711 destructors; destructors were also corrected when we read in type
1714 Therefore the only thing we need to handle here are v2 operator
1716 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
1719 char dem_opname
[256];
1721 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1723 dem_opname
, DMGL_ANSI
);
1725 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1729 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
1733 const struct cplus_struct_type cplus_struct_default
;
1736 allocate_cplus_struct_type (struct type
*type
)
1738 if (!HAVE_CPLUS_STRUCT (type
))
1740 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1741 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1742 *(TYPE_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1746 /* Helper function to initialize the standard scalar types.
1748 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy of
1749 the string pointed to by name in the objfile_obstack for that
1750 objfile, and initialize the type name to that copy. There are
1751 places (mipsread.c in particular, where init_type is called with a
1752 NULL value for NAME). */
1755 init_type (enum type_code code
, int length
, int flags
,
1756 char *name
, struct objfile
*objfile
)
1760 type
= alloc_type (objfile
);
1761 TYPE_CODE (type
) = code
;
1762 TYPE_LENGTH (type
) = length
;
1763 TYPE_FLAGS (type
) |= flags
;
1764 if ((name
!= NULL
) && (objfile
!= NULL
))
1766 TYPE_NAME (type
) = obsavestring (name
, strlen (name
),
1767 &objfile
->objfile_obstack
);
1771 TYPE_NAME (type
) = name
;
1776 if (name
&& strcmp (name
, "char") == 0)
1777 TYPE_FLAGS (type
) |= TYPE_FLAG_NOSIGN
;
1779 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
1780 || code
== TYPE_CODE_NAMESPACE
)
1782 INIT_CPLUS_SPECIFIC (type
);
1787 /* Helper function. Create an empty composite type. */
1790 init_composite_type (char *name
, enum type_code code
)
1793 gdb_assert (code
== TYPE_CODE_STRUCT
1794 || code
== TYPE_CODE_UNION
);
1795 t
= init_type (code
, 0, 0, NULL
, NULL
);
1796 TYPE_TAG_NAME (t
) = name
;
1800 /* Helper function. Append a field to a composite type. */
1803 append_composite_type_field (struct type
*t
, char *name
,
1807 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
1808 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
1809 sizeof (struct field
) * TYPE_NFIELDS (t
));
1810 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
1811 memset (f
, 0, sizeof f
[0]);
1812 FIELD_TYPE (f
[0]) = field
;
1813 FIELD_NAME (f
[0]) = name
;
1814 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1816 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
1817 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
1819 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
1821 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
1822 if (TYPE_NFIELDS (t
) > 1)
1824 FIELD_BITPOS (f
[0]) = (FIELD_BITPOS (f
[-1])
1825 + TYPE_LENGTH (field
) * TARGET_CHAR_BIT
);
1831 can_dereference (struct type
*t
)
1833 /* FIXME: Should we return true for references as well as
1838 && TYPE_CODE (t
) == TYPE_CODE_PTR
1839 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1843 is_integral_type (struct type
*t
)
1848 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
1849 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
1850 || (TYPE_CODE (t
) == TYPE_CODE_FLAGS
)
1851 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
1852 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
1853 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
1856 /* Check whether BASE is an ancestor or base class or DCLASS
1857 Return 1 if so, and 0 if not.
1858 Note: callers may want to check for identity of the types before
1859 calling this function -- identical types are considered to satisfy
1860 the ancestor relationship even if they're identical. */
1863 is_ancestor (struct type
*base
, struct type
*dclass
)
1867 CHECK_TYPEDEF (base
);
1868 CHECK_TYPEDEF (dclass
);
1872 if (TYPE_NAME (base
) && TYPE_NAME (dclass
)
1873 && !strcmp (TYPE_NAME (base
), TYPE_NAME (dclass
)))
1876 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1877 if (is_ancestor (base
, TYPE_BASECLASS (dclass
, i
)))
1885 /* Functions for overload resolution begin here */
1887 /* Compare two badness vectors A and B and return the result.
1888 0 => A and B are identical
1889 1 => A and B are incomparable
1890 2 => A is better than B
1891 3 => A is worse than B */
1894 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
1898 short found_pos
= 0; /* any positives in c? */
1899 short found_neg
= 0; /* any negatives in c? */
1901 /* differing lengths => incomparable */
1902 if (a
->length
!= b
->length
)
1905 /* Subtract b from a */
1906 for (i
= 0; i
< a
->length
; i
++)
1908 tmp
= a
->rank
[i
] - b
->rank
[i
];
1918 return 1; /* incomparable */
1920 return 3; /* A > B */
1926 return 2; /* A < B */
1928 return 0; /* A == B */
1932 /* Rank a function by comparing its parameter types (PARMS, length
1933 NPARMS), to the types of an argument list (ARGS, length NARGS).
1934 Return a pointer to a badness vector. This has NARGS + 1
1937 struct badness_vector
*
1938 rank_function (struct type
**parms
, int nparms
,
1939 struct type
**args
, int nargs
)
1942 struct badness_vector
*bv
;
1943 int min_len
= nparms
< nargs
? nparms
: nargs
;
1945 bv
= xmalloc (sizeof (struct badness_vector
));
1946 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank */
1947 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
1949 /* First compare the lengths of the supplied lists.
1950 If there is a mismatch, set it to a high value. */
1952 /* pai/1997-06-03 FIXME: when we have debug info about default
1953 arguments and ellipsis parameter lists, we should consider those
1954 and rank the length-match more finely. */
1956 LENGTH_MATCH (bv
) = (nargs
!= nparms
) ? LENGTH_MISMATCH_BADNESS
: 0;
1958 /* Now rank all the parameters of the candidate function */
1959 for (i
= 1; i
<= min_len
; i
++)
1960 bv
->rank
[i
] = rank_one_type (parms
[i
-1], args
[i
-1]);
1962 /* If more arguments than parameters, add dummy entries */
1963 for (i
= min_len
+ 1; i
<= nargs
; i
++)
1964 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
1969 /* Compare the names of two integer types, assuming that any sign
1970 qualifiers have been checked already. We do it this way because
1971 there may be an "int" in the name of one of the types. */
1974 integer_types_same_name_p (const char *first
, const char *second
)
1976 int first_p
, second_p
;
1978 /* If both are shorts, return 1; if neither is a short, keep
1980 first_p
= (strstr (first
, "short") != NULL
);
1981 second_p
= (strstr (second
, "short") != NULL
);
1982 if (first_p
&& second_p
)
1984 if (first_p
|| second_p
)
1987 /* Likewise for long. */
1988 first_p
= (strstr (first
, "long") != NULL
);
1989 second_p
= (strstr (second
, "long") != NULL
);
1990 if (first_p
&& second_p
)
1992 if (first_p
|| second_p
)
1995 /* Likewise for char. */
1996 first_p
= (strstr (first
, "char") != NULL
);
1997 second_p
= (strstr (second
, "char") != NULL
);
1998 if (first_p
&& second_p
)
2000 if (first_p
|| second_p
)
2003 /* They must both be ints. */
2007 /* Compare one type (PARM) for compatibility with another (ARG).
2008 * PARM is intended to be the parameter type of a function; and
2009 * ARG is the supplied argument's type. This function tests if
2010 * the latter can be converted to the former.
2012 * Return 0 if they are identical types;
2013 * Otherwise, return an integer which corresponds to how compatible
2014 * PARM is to ARG. The higher the return value, the worse the match.
2015 * Generally the "bad" conversions are all uniformly assigned a 100. */
2018 rank_one_type (struct type
*parm
, struct type
*arg
)
2020 /* Identical type pointers. */
2021 /* However, this still doesn't catch all cases of same type for arg
2022 and param. The reason is that builtin types are different from
2023 the same ones constructed from the object. */
2027 /* Resolve typedefs */
2028 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2029 parm
= check_typedef (parm
);
2030 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2031 arg
= check_typedef (arg
);
2034 Well, damnit, if the names are exactly the same, I'll say they
2035 are exactly the same. This happens when we generate method
2036 stubs. The types won't point to the same address, but they
2037 really are the same.
2040 if (TYPE_NAME (parm
) && TYPE_NAME (arg
)
2041 && !strcmp (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2044 /* Check if identical after resolving typedefs. */
2048 /* See through references, since we can almost make non-references
2050 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2051 return (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
))
2052 + REFERENCE_CONVERSION_BADNESS
);
2053 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2054 return (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
)
2055 + REFERENCE_CONVERSION_BADNESS
);
2057 /* Debugging only. */
2058 fprintf_filtered (gdb_stderr
,
2059 "------ Arg is %s [%d], parm is %s [%d]\n",
2060 TYPE_NAME (arg
), TYPE_CODE (arg
),
2061 TYPE_NAME (parm
), TYPE_CODE (parm
));
2063 /* x -> y means arg of type x being supplied for parameter of type y */
2065 switch (TYPE_CODE (parm
))
2068 switch (TYPE_CODE (arg
))
2071 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2072 return VOID_PTR_CONVERSION_BADNESS
;
2074 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2075 TYPE_TARGET_TYPE (arg
));
2076 case TYPE_CODE_ARRAY
:
2077 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2078 TYPE_TARGET_TYPE (arg
));
2079 case TYPE_CODE_FUNC
:
2080 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
);
2082 case TYPE_CODE_ENUM
:
2083 case TYPE_CODE_FLAGS
:
2084 case TYPE_CODE_CHAR
:
2085 case TYPE_CODE_RANGE
:
2086 case TYPE_CODE_BOOL
:
2087 return POINTER_CONVERSION_BADNESS
;
2089 return INCOMPATIBLE_TYPE_BADNESS
;
2091 case TYPE_CODE_ARRAY
:
2092 switch (TYPE_CODE (arg
))
2095 case TYPE_CODE_ARRAY
:
2096 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2097 TYPE_TARGET_TYPE (arg
));
2099 return INCOMPATIBLE_TYPE_BADNESS
;
2101 case TYPE_CODE_FUNC
:
2102 switch (TYPE_CODE (arg
))
2104 case TYPE_CODE_PTR
: /* funcptr -> func */
2105 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
));
2107 return INCOMPATIBLE_TYPE_BADNESS
;
2110 switch (TYPE_CODE (arg
))
2113 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2115 /* Deal with signed, unsigned, and plain chars and
2116 signed and unsigned ints. */
2117 if (TYPE_NOSIGN (parm
))
2119 /* This case only for character types */
2120 if (TYPE_NOSIGN (arg
))
2121 return 0; /* plain char -> plain char */
2122 else /* signed/unsigned char -> plain char */
2123 return INTEGER_CONVERSION_BADNESS
;
2125 else if (TYPE_UNSIGNED (parm
))
2127 if (TYPE_UNSIGNED (arg
))
2129 /* unsigned int -> unsigned int, or
2130 unsigned long -> unsigned long */
2131 if (integer_types_same_name_p (TYPE_NAME (parm
),
2134 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2136 && integer_types_same_name_p (TYPE_NAME (parm
),
2138 return INTEGER_PROMOTION_BADNESS
; /* unsigned int -> unsigned long */
2140 return INTEGER_CONVERSION_BADNESS
; /* unsigned long -> unsigned int */
2144 if (integer_types_same_name_p (TYPE_NAME (arg
),
2146 && integer_types_same_name_p (TYPE_NAME (parm
),
2148 return INTEGER_CONVERSION_BADNESS
; /* signed long -> unsigned int */
2150 return INTEGER_CONVERSION_BADNESS
; /* signed int/long -> unsigned int/long */
2153 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2155 if (integer_types_same_name_p (TYPE_NAME (parm
),
2158 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2160 && integer_types_same_name_p (TYPE_NAME (parm
),
2162 return INTEGER_PROMOTION_BADNESS
;
2164 return INTEGER_CONVERSION_BADNESS
;
2167 return INTEGER_CONVERSION_BADNESS
;
2169 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2170 return INTEGER_PROMOTION_BADNESS
;
2172 return INTEGER_CONVERSION_BADNESS
;
2173 case TYPE_CODE_ENUM
:
2174 case TYPE_CODE_FLAGS
:
2175 case TYPE_CODE_CHAR
:
2176 case TYPE_CODE_RANGE
:
2177 case TYPE_CODE_BOOL
:
2178 return INTEGER_PROMOTION_BADNESS
;
2180 return INT_FLOAT_CONVERSION_BADNESS
;
2182 return NS_POINTER_CONVERSION_BADNESS
;
2184 return INCOMPATIBLE_TYPE_BADNESS
;
2187 case TYPE_CODE_ENUM
:
2188 switch (TYPE_CODE (arg
))
2191 case TYPE_CODE_CHAR
:
2192 case TYPE_CODE_RANGE
:
2193 case TYPE_CODE_BOOL
:
2194 case TYPE_CODE_ENUM
:
2195 return INTEGER_CONVERSION_BADNESS
;
2197 return INT_FLOAT_CONVERSION_BADNESS
;
2199 return INCOMPATIBLE_TYPE_BADNESS
;
2202 case TYPE_CODE_CHAR
:
2203 switch (TYPE_CODE (arg
))
2205 case TYPE_CODE_RANGE
:
2206 case TYPE_CODE_BOOL
:
2207 case TYPE_CODE_ENUM
:
2208 return INTEGER_CONVERSION_BADNESS
;
2210 return INT_FLOAT_CONVERSION_BADNESS
;
2212 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2213 return INTEGER_CONVERSION_BADNESS
;
2214 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2215 return INTEGER_PROMOTION_BADNESS
;
2216 /* >>> !! else fall through !! <<< */
2217 case TYPE_CODE_CHAR
:
2218 /* Deal with signed, unsigned, and plain chars for C++ and
2219 with int cases falling through from previous case. */
2220 if (TYPE_NOSIGN (parm
))
2222 if (TYPE_NOSIGN (arg
))
2225 return INTEGER_CONVERSION_BADNESS
;
2227 else if (TYPE_UNSIGNED (parm
))
2229 if (TYPE_UNSIGNED (arg
))
2232 return INTEGER_PROMOTION_BADNESS
;
2234 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2237 return INTEGER_CONVERSION_BADNESS
;
2239 return INCOMPATIBLE_TYPE_BADNESS
;
2242 case TYPE_CODE_RANGE
:
2243 switch (TYPE_CODE (arg
))
2246 case TYPE_CODE_CHAR
:
2247 case TYPE_CODE_RANGE
:
2248 case TYPE_CODE_BOOL
:
2249 case TYPE_CODE_ENUM
:
2250 return INTEGER_CONVERSION_BADNESS
;
2252 return INT_FLOAT_CONVERSION_BADNESS
;
2254 return INCOMPATIBLE_TYPE_BADNESS
;
2257 case TYPE_CODE_BOOL
:
2258 switch (TYPE_CODE (arg
))
2261 case TYPE_CODE_CHAR
:
2262 case TYPE_CODE_RANGE
:
2263 case TYPE_CODE_ENUM
:
2266 return BOOLEAN_CONVERSION_BADNESS
;
2267 case TYPE_CODE_BOOL
:
2270 return INCOMPATIBLE_TYPE_BADNESS
;
2274 switch (TYPE_CODE (arg
))
2277 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2278 return FLOAT_PROMOTION_BADNESS
;
2279 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2282 return FLOAT_CONVERSION_BADNESS
;
2284 case TYPE_CODE_BOOL
:
2285 case TYPE_CODE_ENUM
:
2286 case TYPE_CODE_RANGE
:
2287 case TYPE_CODE_CHAR
:
2288 return INT_FLOAT_CONVERSION_BADNESS
;
2290 return INCOMPATIBLE_TYPE_BADNESS
;
2293 case TYPE_CODE_COMPLEX
:
2294 switch (TYPE_CODE (arg
))
2295 { /* Strictly not needed for C++, but... */
2297 return FLOAT_PROMOTION_BADNESS
;
2298 case TYPE_CODE_COMPLEX
:
2301 return INCOMPATIBLE_TYPE_BADNESS
;
2304 case TYPE_CODE_STRUCT
:
2305 /* currently same as TYPE_CODE_CLASS */
2306 switch (TYPE_CODE (arg
))
2308 case TYPE_CODE_STRUCT
:
2309 /* Check for derivation */
2310 if (is_ancestor (parm
, arg
))
2311 return BASE_CONVERSION_BADNESS
;
2312 /* else fall through */
2314 return INCOMPATIBLE_TYPE_BADNESS
;
2317 case TYPE_CODE_UNION
:
2318 switch (TYPE_CODE (arg
))
2320 case TYPE_CODE_UNION
:
2322 return INCOMPATIBLE_TYPE_BADNESS
;
2325 case TYPE_CODE_MEMBERPTR
:
2326 switch (TYPE_CODE (arg
))
2329 return INCOMPATIBLE_TYPE_BADNESS
;
2332 case TYPE_CODE_METHOD
:
2333 switch (TYPE_CODE (arg
))
2337 return INCOMPATIBLE_TYPE_BADNESS
;
2341 switch (TYPE_CODE (arg
))
2345 return INCOMPATIBLE_TYPE_BADNESS
;
2350 switch (TYPE_CODE (arg
))
2354 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0),
2355 TYPE_FIELD_TYPE (arg
, 0));
2357 return INCOMPATIBLE_TYPE_BADNESS
;
2360 case TYPE_CODE_VOID
:
2362 return INCOMPATIBLE_TYPE_BADNESS
;
2363 } /* switch (TYPE_CODE (arg)) */
2367 /* End of functions for overload resolution */
2370 print_bit_vector (B_TYPE
*bits
, int nbits
)
2374 for (bitno
= 0; bitno
< nbits
; bitno
++)
2376 if ((bitno
% 8) == 0)
2378 puts_filtered (" ");
2380 if (B_TST (bits
, bitno
))
2381 printf_filtered (("1"));
2383 printf_filtered (("0"));
2387 /* Note the first arg should be the "this" pointer, we may not want to
2388 include it since we may get into a infinitely recursive
2392 print_arg_types (struct field
*args
, int nargs
, int spaces
)
2398 for (i
= 0; i
< nargs
; i
++)
2399 recursive_dump_type (args
[i
].type
, spaces
+ 2);
2404 dump_fn_fieldlists (struct type
*type
, int spaces
)
2410 printfi_filtered (spaces
, "fn_fieldlists ");
2411 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2412 printf_filtered ("\n");
2413 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2415 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2416 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2418 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2419 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2421 printf_filtered (_(") length %d\n"),
2422 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2423 for (overload_idx
= 0;
2424 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2427 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2429 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2430 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2432 printf_filtered (")\n");
2433 printfi_filtered (spaces
+ 8, "type ");
2434 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2436 printf_filtered ("\n");
2438 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2441 printfi_filtered (spaces
+ 8, "args ");
2442 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2444 printf_filtered ("\n");
2446 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2447 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
,
2450 printfi_filtered (spaces
+ 8, "fcontext ");
2451 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2453 printf_filtered ("\n");
2455 printfi_filtered (spaces
+ 8, "is_const %d\n",
2456 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2457 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2458 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2459 printfi_filtered (spaces
+ 8, "is_private %d\n",
2460 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2461 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2462 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2463 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2464 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2465 printfi_filtered (spaces
+ 8, "voffset %u\n",
2466 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2472 print_cplus_stuff (struct type
*type
, int spaces
)
2474 printfi_filtered (spaces
, "n_baseclasses %d\n",
2475 TYPE_N_BASECLASSES (type
));
2476 printfi_filtered (spaces
, "nfn_fields %d\n",
2477 TYPE_NFN_FIELDS (type
));
2478 printfi_filtered (spaces
, "nfn_fields_total %d\n",
2479 TYPE_NFN_FIELDS_TOTAL (type
));
2480 if (TYPE_N_BASECLASSES (type
) > 0)
2482 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2483 TYPE_N_BASECLASSES (type
));
2484 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
2486 printf_filtered (")");
2488 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2489 TYPE_N_BASECLASSES (type
));
2490 puts_filtered ("\n");
2492 if (TYPE_NFIELDS (type
) > 0)
2494 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2496 printfi_filtered (spaces
,
2497 "private_field_bits (%d bits at *",
2498 TYPE_NFIELDS (type
));
2499 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
2501 printf_filtered (")");
2502 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2503 TYPE_NFIELDS (type
));
2504 puts_filtered ("\n");
2506 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2508 printfi_filtered (spaces
,
2509 "protected_field_bits (%d bits at *",
2510 TYPE_NFIELDS (type
));
2511 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
2513 printf_filtered (")");
2514 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2515 TYPE_NFIELDS (type
));
2516 puts_filtered ("\n");
2519 if (TYPE_NFN_FIELDS (type
) > 0)
2521 dump_fn_fieldlists (type
, spaces
);
2526 print_bound_type (int bt
)
2530 case BOUND_CANNOT_BE_DETERMINED
:
2531 printf_filtered ("(BOUND_CANNOT_BE_DETERMINED)");
2533 case BOUND_BY_REF_ON_STACK
:
2534 printf_filtered ("(BOUND_BY_REF_ON_STACK)");
2536 case BOUND_BY_VALUE_ON_STACK
:
2537 printf_filtered ("(BOUND_BY_VALUE_ON_STACK)");
2539 case BOUND_BY_REF_IN_REG
:
2540 printf_filtered ("(BOUND_BY_REF_IN_REG)");
2542 case BOUND_BY_VALUE_IN_REG
:
2543 printf_filtered ("(BOUND_BY_VALUE_IN_REG)");
2546 printf_filtered ("(BOUND_SIMPLE)");
2549 printf_filtered (_("(unknown bound type)"));
2554 static struct obstack dont_print_type_obstack
;
2557 recursive_dump_type (struct type
*type
, int spaces
)
2562 obstack_begin (&dont_print_type_obstack
, 0);
2564 if (TYPE_NFIELDS (type
) > 0
2565 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
2567 struct type
**first_dont_print
2568 = (struct type
**) obstack_base (&dont_print_type_obstack
);
2570 int i
= (struct type
**)
2571 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
2575 if (type
== first_dont_print
[i
])
2577 printfi_filtered (spaces
, "type node ");
2578 gdb_print_host_address (type
, gdb_stdout
);
2579 printf_filtered (_(" <same as already seen type>\n"));
2584 obstack_ptr_grow (&dont_print_type_obstack
, type
);
2587 printfi_filtered (spaces
, "type node ");
2588 gdb_print_host_address (type
, gdb_stdout
);
2589 printf_filtered ("\n");
2590 printfi_filtered (spaces
, "name '%s' (",
2591 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
2592 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
2593 printf_filtered (")\n");
2594 printfi_filtered (spaces
, "tagname '%s' (",
2595 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
2596 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
2597 printf_filtered (")\n");
2598 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
2599 switch (TYPE_CODE (type
))
2601 case TYPE_CODE_UNDEF
:
2602 printf_filtered ("(TYPE_CODE_UNDEF)");
2605 printf_filtered ("(TYPE_CODE_PTR)");
2607 case TYPE_CODE_ARRAY
:
2608 printf_filtered ("(TYPE_CODE_ARRAY)");
2610 case TYPE_CODE_STRUCT
:
2611 printf_filtered ("(TYPE_CODE_STRUCT)");
2613 case TYPE_CODE_UNION
:
2614 printf_filtered ("(TYPE_CODE_UNION)");
2616 case TYPE_CODE_ENUM
:
2617 printf_filtered ("(TYPE_CODE_ENUM)");
2619 case TYPE_CODE_FLAGS
:
2620 printf_filtered ("(TYPE_CODE_FLAGS)");
2622 case TYPE_CODE_FUNC
:
2623 printf_filtered ("(TYPE_CODE_FUNC)");
2626 printf_filtered ("(TYPE_CODE_INT)");
2629 printf_filtered ("(TYPE_CODE_FLT)");
2631 case TYPE_CODE_VOID
:
2632 printf_filtered ("(TYPE_CODE_VOID)");
2635 printf_filtered ("(TYPE_CODE_SET)");
2637 case TYPE_CODE_RANGE
:
2638 printf_filtered ("(TYPE_CODE_RANGE)");
2640 case TYPE_CODE_STRING
:
2641 printf_filtered ("(TYPE_CODE_STRING)");
2643 case TYPE_CODE_BITSTRING
:
2644 printf_filtered ("(TYPE_CODE_BITSTRING)");
2646 case TYPE_CODE_ERROR
:
2647 printf_filtered ("(TYPE_CODE_ERROR)");
2649 case TYPE_CODE_MEMBERPTR
:
2650 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
2652 case TYPE_CODE_METHODPTR
:
2653 printf_filtered ("(TYPE_CODE_METHODPTR)");
2655 case TYPE_CODE_METHOD
:
2656 printf_filtered ("(TYPE_CODE_METHOD)");
2659 printf_filtered ("(TYPE_CODE_REF)");
2661 case TYPE_CODE_CHAR
:
2662 printf_filtered ("(TYPE_CODE_CHAR)");
2664 case TYPE_CODE_BOOL
:
2665 printf_filtered ("(TYPE_CODE_BOOL)");
2667 case TYPE_CODE_COMPLEX
:
2668 printf_filtered ("(TYPE_CODE_COMPLEX)");
2670 case TYPE_CODE_TYPEDEF
:
2671 printf_filtered ("(TYPE_CODE_TYPEDEF)");
2673 case TYPE_CODE_TEMPLATE
:
2674 printf_filtered ("(TYPE_CODE_TEMPLATE)");
2676 case TYPE_CODE_TEMPLATE_ARG
:
2677 printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)");
2679 case TYPE_CODE_NAMESPACE
:
2680 printf_filtered ("(TYPE_CODE_NAMESPACE)");
2683 printf_filtered ("(UNKNOWN TYPE CODE)");
2686 puts_filtered ("\n");
2687 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
2688 printfi_filtered (spaces
, "upper_bound_type 0x%x ",
2689 TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
2690 print_bound_type (TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
2691 puts_filtered ("\n");
2692 printfi_filtered (spaces
, "lower_bound_type 0x%x ",
2693 TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
2694 print_bound_type (TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
2695 puts_filtered ("\n");
2696 printfi_filtered (spaces
, "objfile ");
2697 gdb_print_host_address (TYPE_OBJFILE (type
), gdb_stdout
);
2698 printf_filtered ("\n");
2699 printfi_filtered (spaces
, "target_type ");
2700 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
2701 printf_filtered ("\n");
2702 if (TYPE_TARGET_TYPE (type
) != NULL
)
2704 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
2706 printfi_filtered (spaces
, "pointer_type ");
2707 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
2708 printf_filtered ("\n");
2709 printfi_filtered (spaces
, "reference_type ");
2710 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
2711 printf_filtered ("\n");
2712 printfi_filtered (spaces
, "type_chain ");
2713 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
2714 printf_filtered ("\n");
2715 printfi_filtered (spaces
, "instance_flags 0x%x",
2716 TYPE_INSTANCE_FLAGS (type
));
2717 if (TYPE_CONST (type
))
2719 puts_filtered (" TYPE_FLAG_CONST");
2721 if (TYPE_VOLATILE (type
))
2723 puts_filtered (" TYPE_FLAG_VOLATILE");
2725 if (TYPE_CODE_SPACE (type
))
2727 puts_filtered (" TYPE_FLAG_CODE_SPACE");
2729 if (TYPE_DATA_SPACE (type
))
2731 puts_filtered (" TYPE_FLAG_DATA_SPACE");
2733 if (TYPE_ADDRESS_CLASS_1 (type
))
2735 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
2737 if (TYPE_ADDRESS_CLASS_2 (type
))
2739 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
2741 puts_filtered ("\n");
2742 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
2743 if (TYPE_UNSIGNED (type
))
2745 puts_filtered (" TYPE_FLAG_UNSIGNED");
2747 if (TYPE_NOSIGN (type
))
2749 puts_filtered (" TYPE_FLAG_NOSIGN");
2751 if (TYPE_STUB (type
))
2753 puts_filtered (" TYPE_FLAG_STUB");
2755 if (TYPE_TARGET_STUB (type
))
2757 puts_filtered (" TYPE_FLAG_TARGET_STUB");
2759 if (TYPE_STATIC (type
))
2761 puts_filtered (" TYPE_FLAG_STATIC");
2763 if (TYPE_PROTOTYPED (type
))
2765 puts_filtered (" TYPE_FLAG_PROTOTYPED");
2767 if (TYPE_INCOMPLETE (type
))
2769 puts_filtered (" TYPE_FLAG_INCOMPLETE");
2771 if (TYPE_VARARGS (type
))
2773 puts_filtered (" TYPE_FLAG_VARARGS");
2775 /* This is used for things like AltiVec registers on ppc. Gcc emits
2776 an attribute for the array type, which tells whether or not we
2777 have a vector, instead of a regular array. */
2778 if (TYPE_VECTOR (type
))
2780 puts_filtered (" TYPE_FLAG_VECTOR");
2782 puts_filtered ("\n");
2783 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
2784 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
2785 puts_filtered ("\n");
2786 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
2788 printfi_filtered (spaces
+ 2,
2789 "[%d] bitpos %d bitsize %d type ",
2790 idx
, TYPE_FIELD_BITPOS (type
, idx
),
2791 TYPE_FIELD_BITSIZE (type
, idx
));
2792 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
2793 printf_filtered (" name '%s' (",
2794 TYPE_FIELD_NAME (type
, idx
) != NULL
2795 ? TYPE_FIELD_NAME (type
, idx
)
2797 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
2798 printf_filtered (")\n");
2799 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
2801 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
2804 printfi_filtered (spaces
, "vptr_basetype ");
2805 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
2806 puts_filtered ("\n");
2807 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
2809 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
2811 printfi_filtered (spaces
, "vptr_fieldno %d\n",
2812 TYPE_VPTR_FIELDNO (type
));
2813 switch (TYPE_CODE (type
))
2815 case TYPE_CODE_STRUCT
:
2816 printfi_filtered (spaces
, "cplus_stuff ");
2817 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
),
2819 puts_filtered ("\n");
2820 print_cplus_stuff (type
, spaces
);
2824 printfi_filtered (spaces
, "floatformat ");
2825 if (TYPE_FLOATFORMAT (type
) == NULL
)
2826 puts_filtered ("(null)");
2829 puts_filtered ("{ ");
2830 if (TYPE_FLOATFORMAT (type
)[0] == NULL
2831 || TYPE_FLOATFORMAT (type
)[0]->name
== NULL
)
2832 puts_filtered ("(null)");
2834 puts_filtered (TYPE_FLOATFORMAT (type
)[0]->name
);
2836 puts_filtered (", ");
2837 if (TYPE_FLOATFORMAT (type
)[1] == NULL
2838 || TYPE_FLOATFORMAT (type
)[1]->name
== NULL
)
2839 puts_filtered ("(null)");
2841 puts_filtered (TYPE_FLOATFORMAT (type
)[1]->name
);
2843 puts_filtered (" }");
2845 puts_filtered ("\n");
2849 /* We have to pick one of the union types to be able print and
2850 test the value. Pick cplus_struct_type, even though we know
2851 it isn't any particular one. */
2852 printfi_filtered (spaces
, "type_specific ");
2853 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
2854 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
2856 printf_filtered (_(" (unknown data form)"));
2858 printf_filtered ("\n");
2863 obstack_free (&dont_print_type_obstack
, NULL
);
2866 /* Trivial helpers for the libiberty hash table, for mapping one
2871 struct type
*old
, *new;
2875 type_pair_hash (const void *item
)
2877 const struct type_pair
*pair
= item
;
2878 return htab_hash_pointer (pair
->old
);
2882 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
2884 const struct type_pair
*lhs
= item_lhs
, *rhs
= item_rhs
;
2885 return lhs
->old
== rhs
->old
;
2888 /* Allocate the hash table used by copy_type_recursive to walk
2889 types without duplicates. We use OBJFILE's obstack, because
2890 OBJFILE is about to be deleted. */
2893 create_copied_types_hash (struct objfile
*objfile
)
2895 return htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
2896 NULL
, &objfile
->objfile_obstack
,
2897 hashtab_obstack_allocate
,
2898 dummy_obstack_deallocate
);
2901 /* Recursively copy (deep copy) TYPE, if it is associated with
2902 OBJFILE. Return a new type allocated using malloc, a saved type if
2903 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
2904 not associated with OBJFILE. */
2907 copy_type_recursive (struct objfile
*objfile
,
2909 htab_t copied_types
)
2911 struct type_pair
*stored
, pair
;
2913 struct type
*new_type
;
2915 if (TYPE_OBJFILE (type
) == NULL
)
2918 /* This type shouldn't be pointing to any types in other objfiles;
2919 if it did, the type might disappear unexpectedly. */
2920 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
2923 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
2925 return ((struct type_pair
*) *slot
)->new;
2927 new_type
= alloc_type (NULL
);
2929 /* We must add the new type to the hash table immediately, in case
2930 we encounter this type again during a recursive call below. */
2931 stored
= xmalloc (sizeof (struct type_pair
));
2933 stored
->new = new_type
;
2936 /* Copy the common fields of types. */
2937 TYPE_CODE (new_type
) = TYPE_CODE (type
);
2938 TYPE_ARRAY_UPPER_BOUND_TYPE (new_type
) =
2939 TYPE_ARRAY_UPPER_BOUND_TYPE (type
);
2940 TYPE_ARRAY_LOWER_BOUND_TYPE (new_type
) =
2941 TYPE_ARRAY_LOWER_BOUND_TYPE (type
);
2942 if (TYPE_NAME (type
))
2943 TYPE_NAME (new_type
) = xstrdup (TYPE_NAME (type
));
2944 if (TYPE_TAG_NAME (type
))
2945 TYPE_TAG_NAME (new_type
) = xstrdup (TYPE_TAG_NAME (type
));
2946 TYPE_FLAGS (new_type
) = TYPE_FLAGS (type
);
2947 TYPE_VPTR_FIELDNO (new_type
) = TYPE_VPTR_FIELDNO (type
);
2949 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
2950 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
2952 /* Copy the fields. */
2953 TYPE_NFIELDS (new_type
) = TYPE_NFIELDS (type
);
2954 if (TYPE_NFIELDS (type
))
2958 nfields
= TYPE_NFIELDS (type
);
2959 TYPE_FIELDS (new_type
) = xmalloc (sizeof (struct field
) * nfields
);
2960 for (i
= 0; i
< nfields
; i
++)
2962 TYPE_FIELD_ARTIFICIAL (new_type
, i
) =
2963 TYPE_FIELD_ARTIFICIAL (type
, i
);
2964 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
2965 if (TYPE_FIELD_TYPE (type
, i
))
2966 TYPE_FIELD_TYPE (new_type
, i
)
2967 = copy_type_recursive (objfile
, TYPE_FIELD_TYPE (type
, i
),
2969 if (TYPE_FIELD_NAME (type
, i
))
2970 TYPE_FIELD_NAME (new_type
, i
) =
2971 xstrdup (TYPE_FIELD_NAME (type
, i
));
2972 if (TYPE_FIELD_STATIC_HAS_ADDR (type
, i
))
2973 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type
, i
),
2974 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
2975 else if (TYPE_FIELD_STATIC (type
, i
))
2976 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type
, i
),
2977 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
,
2981 TYPE_FIELD_BITPOS (new_type
, i
) =
2982 TYPE_FIELD_BITPOS (type
, i
);
2983 TYPE_FIELD_STATIC_KIND (new_type
, i
) = 0;
2988 /* Copy pointers to other types. */
2989 if (TYPE_TARGET_TYPE (type
))
2990 TYPE_TARGET_TYPE (new_type
) =
2991 copy_type_recursive (objfile
,
2992 TYPE_TARGET_TYPE (type
),
2994 if (TYPE_VPTR_BASETYPE (type
))
2995 TYPE_VPTR_BASETYPE (new_type
) =
2996 copy_type_recursive (objfile
,
2997 TYPE_VPTR_BASETYPE (type
),
2999 /* Maybe copy the type_specific bits.
3001 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3002 base classes and methods. There's no fundamental reason why we
3003 can't, but at the moment it is not needed. */
3005 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
3006 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
3007 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3008 || TYPE_CODE (type
) == TYPE_CODE_UNION
3009 || TYPE_CODE (type
) == TYPE_CODE_TEMPLATE
3010 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
3011 INIT_CPLUS_SPECIFIC (new_type
);
3016 static struct type
*
3017 build_flt (int bit
, char *name
, const struct floatformat
**floatformats
)
3023 gdb_assert (floatformats
!= NULL
);
3024 gdb_assert (floatformats
[0] != NULL
&& floatformats
[1] != NULL
);
3025 bit
= floatformats
[0]->totalsize
;
3027 gdb_assert (bit
>= 0);
3029 t
= init_type (TYPE_CODE_FLT
, bit
/ TARGET_CHAR_BIT
, 0, name
, NULL
);
3030 TYPE_FLOATFORMAT (t
) = floatformats
;
3034 static struct gdbarch_data
*gdbtypes_data
;
3036 const struct builtin_type
*
3037 builtin_type (struct gdbarch
*gdbarch
)
3039 return gdbarch_data (gdbarch
, gdbtypes_data
);
3043 static struct type
*
3044 build_complex (int bit
, char *name
, struct type
*target_type
)
3047 if (bit
<= 0 || target_type
== builtin_type_error
)
3049 gdb_assert (builtin_type_error
!= NULL
);
3050 return builtin_type_error
;
3052 t
= init_type (TYPE_CODE_COMPLEX
, 2 * bit
/ TARGET_CHAR_BIT
,
3053 0, name
, (struct objfile
*) NULL
);
3054 TYPE_TARGET_TYPE (t
) = target_type
;
3059 gdbtypes_post_init (struct gdbarch
*gdbarch
)
3061 struct builtin_type
*builtin_type
3062 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
3064 builtin_type
->builtin_void
=
3065 init_type (TYPE_CODE_VOID
, 1,
3067 "void", (struct objfile
*) NULL
);
3068 builtin_type
->builtin_char
=
3069 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3071 | (gdbarch_char_signed (gdbarch
) ? 0 : TYPE_FLAG_UNSIGNED
)),
3072 "char", (struct objfile
*) NULL
);
3073 builtin_type
->builtin_true_char
=
3074 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3076 "true character", (struct objfile
*) NULL
);
3077 builtin_type
->builtin_true_unsigned_char
=
3078 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3080 "true character", (struct objfile
*) NULL
);
3081 builtin_type
->builtin_signed_char
=
3082 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3084 "signed char", (struct objfile
*) NULL
);
3085 builtin_type
->builtin_unsigned_char
=
3086 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3088 "unsigned char", (struct objfile
*) NULL
);
3089 builtin_type
->builtin_short
=
3090 init_type (TYPE_CODE_INT
,
3091 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3092 0, "short", (struct objfile
*) NULL
);
3093 builtin_type
->builtin_unsigned_short
=
3094 init_type (TYPE_CODE_INT
,
3095 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3096 TYPE_FLAG_UNSIGNED
, "unsigned short",
3097 (struct objfile
*) NULL
);
3098 builtin_type
->builtin_int
=
3099 init_type (TYPE_CODE_INT
,
3100 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3101 0, "int", (struct objfile
*) NULL
);
3102 builtin_type
->builtin_unsigned_int
=
3103 init_type (TYPE_CODE_INT
,
3104 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3105 TYPE_FLAG_UNSIGNED
, "unsigned int",
3106 (struct objfile
*) NULL
);
3107 builtin_type
->builtin_long
=
3108 init_type (TYPE_CODE_INT
,
3109 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3110 0, "long", (struct objfile
*) NULL
);
3111 builtin_type
->builtin_unsigned_long
=
3112 init_type (TYPE_CODE_INT
,
3113 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3114 TYPE_FLAG_UNSIGNED
, "unsigned long",
3115 (struct objfile
*) NULL
);
3116 builtin_type
->builtin_long_long
=
3117 init_type (TYPE_CODE_INT
,
3118 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3119 0, "long long", (struct objfile
*) NULL
);
3120 builtin_type
->builtin_unsigned_long_long
=
3121 init_type (TYPE_CODE_INT
,
3122 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3123 TYPE_FLAG_UNSIGNED
, "unsigned long long",
3124 (struct objfile
*) NULL
);
3125 builtin_type
->builtin_float
3126 = build_flt (gdbarch_float_bit (gdbarch
), "float",
3127 gdbarch_float_format (gdbarch
));
3128 builtin_type
->builtin_double
3129 = build_flt (gdbarch_double_bit (gdbarch
), "double",
3130 gdbarch_double_format (gdbarch
));
3131 builtin_type
->builtin_long_double
3132 = build_flt (gdbarch_long_double_bit (gdbarch
), "long double",
3133 gdbarch_long_double_format (gdbarch
));
3134 builtin_type
->builtin_complex
3135 = build_complex (gdbarch_float_bit (gdbarch
), "complex",
3136 builtin_type
->builtin_float
);
3137 builtin_type
->builtin_double_complex
3138 = build_complex (gdbarch_double_bit (gdbarch
), "double complex",
3139 builtin_type
->builtin_double
);
3140 builtin_type
->builtin_string
=
3141 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3143 "string", (struct objfile
*) NULL
);
3144 builtin_type
->builtin_bool
=
3145 init_type (TYPE_CODE_BOOL
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3147 "bool", (struct objfile
*) NULL
);
3149 /* The following three are about decimal floating point types, which
3150 are 32-bits, 64-bits and 128-bits respectively. */
3151 builtin_type
->builtin_decfloat
3152 = init_type (TYPE_CODE_DECFLOAT
, 32 / 8,
3154 "_Decimal32", (struct objfile
*) NULL
);
3155 builtin_type
->builtin_decdouble
3156 = init_type (TYPE_CODE_DECFLOAT
, 64 / 8,
3158 "_Decimal64", (struct objfile
*) NULL
);
3159 builtin_type
->builtin_declong
3160 = init_type (TYPE_CODE_DECFLOAT
, 128 / 8,
3162 "_Decimal128", (struct objfile
*) NULL
);
3164 /* Pointer/Address types. */
3166 /* NOTE: on some targets, addresses and pointers are not necessarily
3167 the same --- for example, on the D10V, pointers are 16 bits long,
3168 but addresses are 32 bits long. See doc/gdbint.texinfo,
3169 ``Pointers Are Not Always Addresses''.
3172 - gdb's `struct type' always describes the target's
3174 - gdb's `struct value' objects should always hold values in
3176 - gdb's CORE_ADDR values are addresses in the unified virtual
3177 address space that the assembler and linker work with. Thus,
3178 since target_read_memory takes a CORE_ADDR as an argument, it
3179 can access any memory on the target, even if the processor has
3180 separate code and data address spaces.
3183 - If v is a value holding a D10V code pointer, its contents are
3184 in target form: a big-endian address left-shifted two bits.
3185 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3186 sizeof (void *) == 2 on the target.
3188 In this context, builtin_type->CORE_ADDR is a bit odd: it's a
3189 target type for a value the target will never see. It's only
3190 used to hold the values of (typeless) linker symbols, which are
3191 indeed in the unified virtual address space. */
3193 builtin_type
->builtin_data_ptr
=
3194 make_pointer_type (builtin_type
->builtin_void
, NULL
);
3195 builtin_type
->builtin_func_ptr
=
3196 lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
3197 builtin_type
->builtin_core_addr
=
3198 init_type (TYPE_CODE_INT
,
3199 gdbarch_addr_bit (gdbarch
) / 8,
3201 "__CORE_ADDR", (struct objfile
*) NULL
);
3204 /* The following set of types is used for symbols with no
3205 debug information. */
3206 builtin_type
->nodebug_text_symbol
=
3207 init_type (TYPE_CODE_FUNC
, 1, 0,
3208 "<text variable, no debug info>", NULL
);
3209 TYPE_TARGET_TYPE (builtin_type
->nodebug_text_symbol
) =
3210 builtin_type
->builtin_int
;
3211 builtin_type
->nodebug_data_symbol
=
3212 init_type (TYPE_CODE_INT
,
3213 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3214 "<data variable, no debug info>", NULL
);
3215 builtin_type
->nodebug_unknown_symbol
=
3216 init_type (TYPE_CODE_INT
, 1, 0,
3217 "<variable (not text or data), no debug info>", NULL
);
3218 builtin_type
->nodebug_tls_symbol
=
3219 init_type (TYPE_CODE_INT
,
3220 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3221 "<thread local variable, no debug info>", NULL
);
3223 return builtin_type
;
3226 extern void _initialize_gdbtypes (void);
3228 _initialize_gdbtypes (void)
3230 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
3232 /* FIXME: The following types are architecture-neutral. However,
3233 they contain pointer_type and reference_type fields potentially
3234 caching pointer or reference types that *are* architecture
3238 init_type (TYPE_CODE_INT
, 0 / 8,
3240 "int0_t", (struct objfile
*) NULL
);
3242 init_type (TYPE_CODE_INT
, 8 / 8,
3244 "int8_t", (struct objfile
*) NULL
);
3245 builtin_type_uint8
=
3246 init_type (TYPE_CODE_INT
, 8 / 8,
3247 TYPE_FLAG_UNSIGNED
| TYPE_FLAG_NOTTEXT
,
3248 "uint8_t", (struct objfile
*) NULL
);
3249 builtin_type_int16
=
3250 init_type (TYPE_CODE_INT
, 16 / 8,
3252 "int16_t", (struct objfile
*) NULL
);
3253 builtin_type_uint16
=
3254 init_type (TYPE_CODE_INT
, 16 / 8,
3256 "uint16_t", (struct objfile
*) NULL
);
3257 builtin_type_int32
=
3258 init_type (TYPE_CODE_INT
, 32 / 8,
3260 "int32_t", (struct objfile
*) NULL
);
3261 builtin_type_uint32
=
3262 init_type (TYPE_CODE_INT
, 32 / 8,
3264 "uint32_t", (struct objfile
*) NULL
);
3265 builtin_type_int64
=
3266 init_type (TYPE_CODE_INT
, 64 / 8,
3268 "int64_t", (struct objfile
*) NULL
);
3269 builtin_type_uint64
=
3270 init_type (TYPE_CODE_INT
, 64 / 8,
3272 "uint64_t", (struct objfile
*) NULL
);
3273 builtin_type_int128
=
3274 init_type (TYPE_CODE_INT
, 128 / 8,
3276 "int128_t", (struct objfile
*) NULL
);
3277 builtin_type_uint128
=
3278 init_type (TYPE_CODE_INT
, 128 / 8,
3280 "uint128_t", (struct objfile
*) NULL
);
3282 builtin_type_ieee_single
=
3283 build_flt (-1, "builtin_type_ieee_single", floatformats_ieee_single
);
3284 builtin_type_ieee_double
=
3285 build_flt (-1, "builtin_type_ieee_double", floatformats_ieee_double
);
3286 builtin_type_i387_ext
=
3287 build_flt (-1, "builtin_type_i387_ext", floatformats_i387_ext
);
3288 builtin_type_m68881_ext
=
3289 build_flt (-1, "builtin_type_m68881_ext", floatformats_m68881_ext
);
3290 builtin_type_arm_ext
=
3291 build_flt (-1, "builtin_type_arm_ext", floatformats_arm_ext
);
3292 builtin_type_ia64_spill
=
3293 build_flt (-1, "builtin_type_ia64_spill", floatformats_ia64_spill
);
3294 builtin_type_ia64_quad
=
3295 build_flt (-1, "builtin_type_ia64_quad", floatformats_ia64_quad
);
3297 add_setshow_zinteger_cmd ("overload", no_class
, &overload_debug
, _("\
3298 Set debugging of C++ overloading."), _("\
3299 Show debugging of C++ overloading."), _("\
3300 When enabled, ranking of the functions is displayed."),
3302 show_overload_debug
,
3303 &setdebuglist
, &showdebuglist
);
3305 /* Add user knob for controlling resolution of opaque types. */
3306 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
3307 &opaque_type_resolution
, _("\
3308 Set resolution of opaque struct/class/union types (if set before loading symbols)."), _("\
3309 Show resolution of opaque struct/class/union types (if set before loading symbols)."), NULL
,
3311 show_opaque_type_resolution
,
3312 &setlist
, &showlist
);