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
;
111 /* Platform-neutral void type. */
112 struct type
*builtin_type_void
;
114 /* Platform-neutral character types. */
115 struct type
*builtin_type_true_char
;
116 struct type
*builtin_type_true_unsigned_char
;
119 int opaque_type_resolution
= 1;
121 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
122 struct cmd_list_element
*c
,
125 fprintf_filtered (file
, _("\
126 Resolution of opaque struct/class/union types (if set before loading symbols) is %s.\n"),
130 int overload_debug
= 0;
132 show_overload_debug (struct ui_file
*file
, int from_tty
,
133 struct cmd_list_element
*c
, const char *value
)
135 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"),
143 }; /* Maximum extension is 128! FIXME */
145 static void print_bit_vector (B_TYPE
*, int);
146 static void print_arg_types (struct field
*, int, int);
147 static void dump_fn_fieldlists (struct type
*, int);
148 static void print_cplus_stuff (struct type
*, int);
151 /* Alloc a new type structure and fill it with some defaults. If
152 OBJFILE is non-NULL, then allocate the space for the type structure
153 in that objfile's objfile_obstack. Otherwise allocate the new type
154 structure by xmalloc () (for permanent types). */
157 alloc_type (struct objfile
*objfile
)
161 /* Alloc the structure and start off with all fields zeroed. */
165 type
= xmalloc (sizeof (struct type
));
166 memset (type
, 0, sizeof (struct type
));
167 TYPE_MAIN_TYPE (type
) = xmalloc (sizeof (struct main_type
));
171 type
= obstack_alloc (&objfile
->objfile_obstack
,
172 sizeof (struct type
));
173 memset (type
, 0, sizeof (struct type
));
174 TYPE_MAIN_TYPE (type
) = obstack_alloc (&objfile
->objfile_obstack
,
175 sizeof (struct main_type
));
176 OBJSTAT (objfile
, n_types
++);
178 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
180 /* Initialize the fields that might not be zero. */
182 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
183 TYPE_OBJFILE (type
) = objfile
;
184 TYPE_VPTR_FIELDNO (type
) = -1;
185 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
190 /* Alloc a new type instance structure, fill it with some defaults,
191 and point it at OLDTYPE. Allocate the new type instance from the
192 same place as OLDTYPE. */
195 alloc_type_instance (struct type
*oldtype
)
199 /* Allocate the structure. */
201 if (TYPE_OBJFILE (oldtype
) == NULL
)
203 type
= xmalloc (sizeof (struct type
));
204 memset (type
, 0, sizeof (struct type
));
208 type
= obstack_alloc (&TYPE_OBJFILE (oldtype
)->objfile_obstack
,
209 sizeof (struct type
));
210 memset (type
, 0, sizeof (struct type
));
212 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
214 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
219 /* Clear all remnants of the previous type at TYPE, in preparation for
220 replacing it with something else. */
222 smash_type (struct type
*type
)
224 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
226 /* For now, delete the rings. */
227 TYPE_CHAIN (type
) = type
;
229 /* For now, leave the pointer/reference types alone. */
232 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
233 to a pointer to memory where the pointer type should be stored.
234 If *TYPEPTR is zero, update it to point to the pointer type we return.
235 We allocate new memory if needed. */
238 make_pointer_type (struct type
*type
, struct type
**typeptr
)
240 struct type
*ntype
; /* New type */
241 struct objfile
*objfile
;
244 ntype
= TYPE_POINTER_TYPE (type
);
249 return ntype
; /* Don't care about alloc,
250 and have new type. */
251 else if (*typeptr
== 0)
253 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
258 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
260 ntype
= alloc_type (TYPE_OBJFILE (type
));
264 else /* We have storage, but need to reset it. */
267 objfile
= TYPE_OBJFILE (ntype
);
268 chain
= TYPE_CHAIN (ntype
);
270 TYPE_CHAIN (ntype
) = chain
;
271 TYPE_OBJFILE (ntype
) = objfile
;
274 TYPE_TARGET_TYPE (ntype
) = type
;
275 TYPE_POINTER_TYPE (type
) = ntype
;
277 /* FIXME! Assume the machine has only one representation for
280 TYPE_LENGTH (ntype
) =
281 gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
;
282 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
284 /* Mark pointers as unsigned. The target converts between pointers
285 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
286 gdbarch_address_to_pointer. */
287 TYPE_UNSIGNED (ntype
) = 1;
289 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
290 TYPE_POINTER_TYPE (type
) = ntype
;
292 /* Update the length of all the other variants of this type. */
293 chain
= TYPE_CHAIN (ntype
);
294 while (chain
!= ntype
)
296 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
297 chain
= TYPE_CHAIN (chain
);
303 /* Given a type TYPE, return a type of pointers to that type.
304 May need to construct such a type if this is the first use. */
307 lookup_pointer_type (struct type
*type
)
309 return make_pointer_type (type
, (struct type
**) 0);
312 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
313 points to a pointer to memory where the reference type should be
314 stored. If *TYPEPTR is zero, update it to point to the reference
315 type we return. We allocate new memory if needed. */
318 make_reference_type (struct type
*type
, struct type
**typeptr
)
320 struct type
*ntype
; /* New type */
321 struct objfile
*objfile
;
324 ntype
= TYPE_REFERENCE_TYPE (type
);
329 return ntype
; /* Don't care about alloc,
330 and have new type. */
331 else if (*typeptr
== 0)
333 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
338 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
340 ntype
= alloc_type (TYPE_OBJFILE (type
));
344 else /* We have storage, but need to reset it. */
347 objfile
= TYPE_OBJFILE (ntype
);
348 chain
= TYPE_CHAIN (ntype
);
350 TYPE_CHAIN (ntype
) = chain
;
351 TYPE_OBJFILE (ntype
) = objfile
;
354 TYPE_TARGET_TYPE (ntype
) = type
;
355 TYPE_REFERENCE_TYPE (type
) = ntype
;
357 /* FIXME! Assume the machine has only one representation for
358 references, and that it matches the (only) representation for
361 TYPE_LENGTH (ntype
) = gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
;
362 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
364 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
365 TYPE_REFERENCE_TYPE (type
) = ntype
;
367 /* Update the length of all the other variants of this type. */
368 chain
= TYPE_CHAIN (ntype
);
369 while (chain
!= ntype
)
371 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
372 chain
= TYPE_CHAIN (chain
);
378 /* Same as above, but caller doesn't care about memory allocation
382 lookup_reference_type (struct type
*type
)
384 return make_reference_type (type
, (struct type
**) 0);
387 /* Lookup a function type that returns type TYPE. TYPEPTR, if
388 nonzero, points to a pointer to memory where the function type
389 should be stored. If *TYPEPTR is zero, update it to point to the
390 function type we return. We allocate new memory if needed. */
393 make_function_type (struct type
*type
, struct type
**typeptr
)
395 struct type
*ntype
; /* New type */
396 struct objfile
*objfile
;
398 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
400 ntype
= alloc_type (TYPE_OBJFILE (type
));
404 else /* We have storage, but need to reset it. */
407 objfile
= TYPE_OBJFILE (ntype
);
409 TYPE_OBJFILE (ntype
) = objfile
;
412 TYPE_TARGET_TYPE (ntype
) = type
;
414 TYPE_LENGTH (ntype
) = 1;
415 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
421 /* Given a type TYPE, return a type of functions that return that type.
422 May need to construct such a type if this is the first use. */
425 lookup_function_type (struct type
*type
)
427 return make_function_type (type
, (struct type
**) 0);
430 /* Identify address space identifier by name --
431 return the integer flag defined in gdbtypes.h. */
433 address_space_name_to_int (char *space_identifier
)
435 struct gdbarch
*gdbarch
= current_gdbarch
;
437 /* Check for known address space delimiters. */
438 if (!strcmp (space_identifier
, "code"))
439 return TYPE_INSTANCE_FLAG_CODE_SPACE
;
440 else if (!strcmp (space_identifier
, "data"))
441 return TYPE_INSTANCE_FLAG_DATA_SPACE
;
442 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
443 && gdbarch_address_class_name_to_type_flags (gdbarch
,
448 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
451 /* Identify address space identifier by integer flag as defined in
452 gdbtypes.h -- return the string version of the adress space name. */
455 address_space_int_to_name (int space_flag
)
457 struct gdbarch
*gdbarch
= current_gdbarch
;
458 if (space_flag
& TYPE_INSTANCE_FLAG_CODE_SPACE
)
460 else if (space_flag
& TYPE_INSTANCE_FLAG_DATA_SPACE
)
462 else if ((space_flag
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
463 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
464 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
469 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
471 If STORAGE is non-NULL, create the new type instance there.
472 STORAGE must be in the same obstack as TYPE. */
475 make_qualified_type (struct type
*type
, int new_flags
,
476 struct type
*storage
)
482 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
484 ntype
= TYPE_CHAIN (ntype
);
485 } while (ntype
!= type
);
487 /* Create a new type instance. */
489 ntype
= alloc_type_instance (type
);
492 /* If STORAGE was provided, it had better be in the same objfile
493 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
494 if one objfile is freed and the other kept, we'd have
495 dangling pointers. */
496 gdb_assert (TYPE_OBJFILE (type
) == TYPE_OBJFILE (storage
));
499 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
500 TYPE_CHAIN (ntype
) = ntype
;
503 /* Pointers or references to the original type are not relevant to
505 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
506 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
508 /* Chain the new qualified type to the old type. */
509 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
510 TYPE_CHAIN (type
) = ntype
;
512 /* Now set the instance flags and return the new type. */
513 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
515 /* Set length of new type to that of the original type. */
516 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
521 /* Make an address-space-delimited variant of a type -- a type that
522 is identical to the one supplied except that it has an address
523 space attribute attached to it (such as "code" or "data").
525 The space attributes "code" and "data" are for Harvard
526 architectures. The address space attributes are for architectures
527 which have alternately sized pointers or pointers with alternate
531 make_type_with_address_space (struct type
*type
, int space_flag
)
534 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
535 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
536 | TYPE_INSTANCE_FLAG_DATA_SPACE
537 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
))
540 return make_qualified_type (type
, new_flags
, NULL
);
543 /* Make a "c-v" variant of a type -- a type that is identical to the
544 one supplied except that it may have const or volatile attributes
545 CNST is a flag for setting the const attribute
546 VOLTL is a flag for setting the volatile attribute
547 TYPE is the base type whose variant we are creating.
549 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
550 storage to hold the new qualified type; *TYPEPTR and TYPE must be
551 in the same objfile. Otherwise, allocate fresh memory for the new
552 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
553 new type we construct. */
555 make_cv_type (int cnst
, int voltl
,
557 struct type
**typeptr
)
559 struct type
*ntype
; /* New type */
560 struct type
*tmp_type
= type
; /* tmp type */
561 struct objfile
*objfile
;
563 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
564 & ~(TYPE_INSTANCE_FLAG_CONST
| TYPE_INSTANCE_FLAG_VOLATILE
));
567 new_flags
|= TYPE_INSTANCE_FLAG_CONST
;
570 new_flags
|= TYPE_INSTANCE_FLAG_VOLATILE
;
572 if (typeptr
&& *typeptr
!= NULL
)
574 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
575 a C-V variant chain that threads across objfiles: if one
576 objfile gets freed, then the other has a broken C-V chain.
578 This code used to try to copy over the main type from TYPE to
579 *TYPEPTR if they were in different objfiles, but that's
580 wrong, too: TYPE may have a field list or member function
581 lists, which refer to types of their own, etc. etc. The
582 whole shebang would need to be copied over recursively; you
583 can't have inter-objfile pointers. The only thing to do is
584 to leave stub types as stub types, and look them up afresh by
585 name each time you encounter them. */
586 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
));
589 ntype
= make_qualified_type (type
, new_flags
,
590 typeptr
? *typeptr
: NULL
);
598 /* Replace the contents of ntype with the type *type. This changes the
599 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
600 the changes are propogated to all types in the TYPE_CHAIN.
602 In order to build recursive types, it's inevitable that we'll need
603 to update types in place --- but this sort of indiscriminate
604 smashing is ugly, and needs to be replaced with something more
605 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
606 clear if more steps are needed. */
608 replace_type (struct type
*ntype
, struct type
*type
)
612 /* These two types had better be in the same objfile. Otherwise,
613 the assignment of one type's main type structure to the other
614 will produce a type with references to objects (names; field
615 lists; etc.) allocated on an objfile other than its own. */
616 gdb_assert (TYPE_OBJFILE (ntype
) == TYPE_OBJFILE (ntype
));
618 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
620 /* The type length is not a part of the main type. Update it for
621 each type on the variant chain. */
624 /* Assert that this element of the chain has no address-class bits
625 set in its flags. Such type variants might have type lengths
626 which are supposed to be different from the non-address-class
627 variants. This assertion shouldn't ever be triggered because
628 symbol readers which do construct address-class variants don't
629 call replace_type(). */
630 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
632 TYPE_LENGTH (chain
) = TYPE_LENGTH (type
);
633 chain
= TYPE_CHAIN (chain
);
634 } while (ntype
!= chain
);
636 /* Assert that the two types have equivalent instance qualifiers.
637 This should be true for at least all of our debug readers. */
638 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
641 /* Implement direct support for MEMBER_TYPE in GNU C++.
642 May need to construct such a type if this is the first use.
643 The TYPE is the type of the member. The DOMAIN is the type
644 of the aggregate that the member belongs to. */
647 lookup_memberptr_type (struct type
*type
, struct type
*domain
)
651 mtype
= alloc_type (TYPE_OBJFILE (type
));
652 smash_to_memberptr_type (mtype
, domain
, type
);
656 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
659 lookup_methodptr_type (struct type
*to_type
)
663 mtype
= alloc_type (TYPE_OBJFILE (to_type
));
664 TYPE_TARGET_TYPE (mtype
) = to_type
;
665 TYPE_DOMAIN_TYPE (mtype
) = TYPE_DOMAIN_TYPE (to_type
);
666 TYPE_LENGTH (mtype
) = cplus_method_ptr_size (to_type
);
667 TYPE_CODE (mtype
) = TYPE_CODE_METHODPTR
;
671 /* Allocate a stub method whose return type is TYPE. This apparently
672 happens for speed of symbol reading, since parsing out the
673 arguments to the method is cpu-intensive, the way we are doing it.
674 So, we will fill in arguments later. This always returns a fresh
678 allocate_stub_method (struct type
*type
)
682 mtype
= init_type (TYPE_CODE_METHOD
, 1, TYPE_FLAG_STUB
, NULL
,
683 TYPE_OBJFILE (type
));
684 TYPE_TARGET_TYPE (mtype
) = type
;
685 /* _DOMAIN_TYPE (mtype) = unknown yet */
689 /* Create a range type using either a blank type supplied in
690 RESULT_TYPE, or creating a new type, inheriting the objfile from
693 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
694 to HIGH_BOUND, inclusive.
696 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
697 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
700 create_range_type (struct type
*result_type
, struct type
*index_type
,
701 int low_bound
, int high_bound
)
703 if (result_type
== NULL
)
705 result_type
= alloc_type (TYPE_OBJFILE (index_type
));
707 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
708 TYPE_TARGET_TYPE (result_type
) = index_type
;
709 if (TYPE_STUB (index_type
))
710 TYPE_TARGET_STUB (result_type
) = 1;
712 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
713 TYPE_NFIELDS (result_type
) = 2;
714 TYPE_FIELDS (result_type
) = (struct field
*)
715 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
716 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
717 TYPE_FIELD_BITPOS (result_type
, 0) = low_bound
;
718 TYPE_FIELD_BITPOS (result_type
, 1) = high_bound
;
721 TYPE_UNSIGNED (result_type
) = 1;
723 return (result_type
);
726 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
727 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
728 bounds will fit in LONGEST), or -1 otherwise. */
731 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
733 CHECK_TYPEDEF (type
);
734 switch (TYPE_CODE (type
))
736 case TYPE_CODE_RANGE
:
737 *lowp
= TYPE_LOW_BOUND (type
);
738 *highp
= TYPE_HIGH_BOUND (type
);
741 if (TYPE_NFIELDS (type
) > 0)
743 /* The enums may not be sorted by value, so search all
747 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
748 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
750 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
751 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
752 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
753 *highp
= TYPE_FIELD_BITPOS (type
, i
);
756 /* Set unsigned indicator if warranted. */
759 TYPE_UNSIGNED (type
) = 1;
773 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
775 if (!TYPE_UNSIGNED (type
))
777 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
781 /* ... fall through for unsigned ints ... */
784 /* This round-about calculation is to avoid shifting by
785 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
786 if TYPE_LENGTH (type) == sizeof (LONGEST). */
787 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
788 *highp
= (*highp
- 1) | *highp
;
795 /* Create an array type using either a blank type supplied in
796 RESULT_TYPE, or creating a new type, inheriting the objfile from
799 Elements will be of type ELEMENT_TYPE, the indices will be of type
802 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
803 sure it is TYPE_CODE_UNDEF before we bash it into an array
807 create_array_type (struct type
*result_type
,
808 struct type
*element_type
,
809 struct type
*range_type
)
811 LONGEST low_bound
, high_bound
;
813 if (result_type
== NULL
)
815 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
817 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
818 TYPE_TARGET_TYPE (result_type
) = element_type
;
819 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
820 low_bound
= high_bound
= 0;
821 CHECK_TYPEDEF (element_type
);
822 /* Be careful when setting the array length. Ada arrays can be
823 empty arrays with the high_bound being smaller than the low_bound.
824 In such cases, the array length should be zero. */
825 if (high_bound
< low_bound
)
826 TYPE_LENGTH (result_type
) = 0;
828 TYPE_LENGTH (result_type
) =
829 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
830 TYPE_NFIELDS (result_type
) = 1;
831 TYPE_FIELDS (result_type
) =
832 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
833 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
834 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
835 TYPE_VPTR_FIELDNO (result_type
) = -1;
837 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
838 if (TYPE_LENGTH (result_type
) == 0)
839 TYPE_TARGET_STUB (result_type
) = 1;
841 return (result_type
);
844 /* Create a string type using either a blank type supplied in
845 RESULT_TYPE, or creating a new type. String types are similar
846 enough to array of char types that we can use create_array_type to
847 build the basic type and then bash it into a string type.
849 For fixed length strings, the range type contains 0 as the lower
850 bound and the length of the string minus one as the upper bound.
852 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
853 sure it is TYPE_CODE_UNDEF before we bash it into a string
857 create_string_type (struct type
*result_type
,
858 struct type
*range_type
)
860 struct type
*string_char_type
;
862 string_char_type
= language_string_char_type (current_language
,
864 result_type
= create_array_type (result_type
,
867 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
868 return (result_type
);
872 create_set_type (struct type
*result_type
, struct type
*domain_type
)
874 if (result_type
== NULL
)
876 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
878 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
879 TYPE_NFIELDS (result_type
) = 1;
880 TYPE_FIELDS (result_type
) = (struct field
*)
881 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
882 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
884 if (!TYPE_STUB (domain_type
))
886 LONGEST low_bound
, high_bound
, bit_length
;
887 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
888 low_bound
= high_bound
= 0;
889 bit_length
= high_bound
- low_bound
+ 1;
890 TYPE_LENGTH (result_type
)
891 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
893 TYPE_UNSIGNED (result_type
) = 1;
895 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
897 return (result_type
);
901 append_flags_type_flag (struct type
*type
, int bitpos
, char *name
)
903 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLAGS
);
904 gdb_assert (bitpos
< TYPE_NFIELDS (type
));
905 gdb_assert (bitpos
>= 0);
909 TYPE_FIELD_NAME (type
, bitpos
) = xstrdup (name
);
910 TYPE_FIELD_BITPOS (type
, bitpos
) = bitpos
;
914 /* Don't show this field to the user. */
915 TYPE_FIELD_BITPOS (type
, bitpos
) = -1;
920 init_flags_type (char *name
, int length
)
922 int nfields
= length
* TARGET_CHAR_BIT
;
925 type
= init_type (TYPE_CODE_FLAGS
, length
,
926 TYPE_FLAG_UNSIGNED
, name
, NULL
);
927 TYPE_NFIELDS (type
) = nfields
;
928 TYPE_FIELDS (type
) = TYPE_ALLOC (type
,
929 nfields
* sizeof (struct field
));
930 memset (TYPE_FIELDS (type
), 0, nfields
* sizeof (struct field
));
935 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
936 and any array types nested inside it. */
939 make_vector_type (struct type
*array_type
)
941 struct type
*inner_array
, *elt_type
;
944 /* Find the innermost array type, in case the array is
945 multi-dimensional. */
946 inner_array
= array_type
;
947 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
948 inner_array
= TYPE_TARGET_TYPE (inner_array
);
950 elt_type
= TYPE_TARGET_TYPE (inner_array
);
951 if (TYPE_CODE (elt_type
) == TYPE_CODE_INT
)
953 flags
= TYPE_INSTANCE_FLAGS (elt_type
) | TYPE_FLAG_NOTTEXT
;
954 elt_type
= make_qualified_type (elt_type
, flags
, NULL
);
955 TYPE_TARGET_TYPE (inner_array
) = elt_type
;
958 TYPE_VECTOR (array_type
) = 1;
962 init_vector_type (struct type
*elt_type
, int n
)
964 struct type
*array_type
;
966 array_type
= create_array_type (0, elt_type
,
967 create_range_type (0,
970 make_vector_type (array_type
);
974 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
975 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
976 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
977 TYPE doesn't include the offset (that's the value of the MEMBER
978 itself), but does include the structure type into which it points
981 When "smashing" the type, we preserve the objfile that the old type
982 pointed to, since we aren't changing where the type is actually
986 smash_to_memberptr_type (struct type
*type
, struct type
*domain
,
987 struct type
*to_type
)
989 struct objfile
*objfile
;
991 objfile
= TYPE_OBJFILE (type
);
994 TYPE_OBJFILE (type
) = objfile
;
995 TYPE_TARGET_TYPE (type
) = to_type
;
996 TYPE_DOMAIN_TYPE (type
) = domain
;
997 /* Assume that a data member pointer is the same size as a normal
999 TYPE_LENGTH (type
) = gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
;
1000 TYPE_CODE (type
) = TYPE_CODE_MEMBERPTR
;
1003 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
1004 METHOD just means `function that gets an extra "this" argument'.
1006 When "smashing" the type, we preserve the objfile that the old type
1007 pointed to, since we aren't changing where the type is actually
1011 smash_to_method_type (struct type
*type
, struct type
*domain
,
1012 struct type
*to_type
, struct field
*args
,
1013 int nargs
, int varargs
)
1015 struct objfile
*objfile
;
1017 objfile
= TYPE_OBJFILE (type
);
1020 TYPE_OBJFILE (type
) = objfile
;
1021 TYPE_TARGET_TYPE (type
) = to_type
;
1022 TYPE_DOMAIN_TYPE (type
) = domain
;
1023 TYPE_FIELDS (type
) = args
;
1024 TYPE_NFIELDS (type
) = nargs
;
1026 TYPE_VARARGS (type
) = 1;
1027 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1028 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
1031 /* Return a typename for a struct/union/enum type without "struct ",
1032 "union ", or "enum ". If the type has a NULL name, return NULL. */
1035 type_name_no_tag (const struct type
*type
)
1037 if (TYPE_TAG_NAME (type
) != NULL
)
1038 return TYPE_TAG_NAME (type
);
1040 /* Is there code which expects this to return the name if there is
1041 no tag name? My guess is that this is mainly used for C++ in
1042 cases where the two will always be the same. */
1043 return TYPE_NAME (type
);
1046 /* Lookup a typedef or primitive type named NAME, visible in lexical
1047 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1048 suitably defined. */
1051 lookup_typename (char *name
, struct block
*block
, int noerr
)
1056 sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, 0);
1057 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1059 tmp
= language_lookup_primitive_type_by_name (current_language
,
1066 else if (!tmp
&& noerr
)
1072 error (_("No type named %s."), name
);
1075 return (SYMBOL_TYPE (sym
));
1079 lookup_unsigned_typename (char *name
)
1081 char *uns
= alloca (strlen (name
) + 10);
1083 strcpy (uns
, "unsigned ");
1084 strcpy (uns
+ 9, name
);
1085 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
1089 lookup_signed_typename (char *name
)
1092 char *uns
= alloca (strlen (name
) + 8);
1094 strcpy (uns
, "signed ");
1095 strcpy (uns
+ 7, name
);
1096 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
1097 /* If we don't find "signed FOO" just try again with plain "FOO". */
1100 return lookup_typename (name
, (struct block
*) NULL
, 0);
1103 /* Lookup a structure type named "struct NAME",
1104 visible in lexical block BLOCK. */
1107 lookup_struct (char *name
, struct block
*block
)
1111 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1115 error (_("No struct type named %s."), name
);
1117 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1119 error (_("This context has class, union or enum %s, not a struct."),
1122 return (SYMBOL_TYPE (sym
));
1125 /* Lookup a union type named "union NAME",
1126 visible in lexical block BLOCK. */
1129 lookup_union (char *name
, struct block
*block
)
1134 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1137 error (_("No union type named %s."), name
);
1139 t
= SYMBOL_TYPE (sym
);
1141 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1144 /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
1145 * a further "declared_type" field to discover it is really a union.
1147 if (HAVE_CPLUS_STRUCT (t
))
1148 if (TYPE_DECLARED_TYPE (t
) == DECLARED_TYPE_UNION
)
1151 /* If we get here, it's not a union. */
1152 error (_("This context has class, struct or enum %s, not a union."),
1157 /* Lookup an enum type named "enum NAME",
1158 visible in lexical block BLOCK. */
1161 lookup_enum (char *name
, struct block
*block
)
1165 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1168 error (_("No enum type named %s."), name
);
1170 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1172 error (_("This context has class, struct or union %s, not an enum."),
1175 return (SYMBOL_TYPE (sym
));
1178 /* Lookup a template type named "template NAME<TYPE>",
1179 visible in lexical block BLOCK. */
1182 lookup_template_type (char *name
, struct type
*type
,
1183 struct block
*block
)
1186 char *nam
= (char *)
1187 alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1190 strcat (nam
, TYPE_NAME (type
));
1191 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1193 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0);
1197 error (_("No template type named %s."), name
);
1199 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1201 error (_("This context has class, union or enum %s, not a struct."),
1204 return (SYMBOL_TYPE (sym
));
1207 /* Given a type TYPE, lookup the type of the component of type named
1210 TYPE can be either a struct or union, or a pointer or reference to
1211 a struct or union. If it is a pointer or reference, its target
1212 type is automatically used. Thus '.' and '->' are interchangable,
1213 as specified for the definitions of the expression element types
1214 STRUCTOP_STRUCT and STRUCTOP_PTR.
1216 If NOERR is nonzero, return zero if NAME is not suitably defined.
1217 If NAME is the name of a baseclass type, return that type. */
1220 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
1226 CHECK_TYPEDEF (type
);
1227 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1228 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1230 type
= TYPE_TARGET_TYPE (type
);
1233 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1234 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1236 target_terminal_ours ();
1237 gdb_flush (gdb_stdout
);
1238 fprintf_unfiltered (gdb_stderr
, "Type ");
1239 type_print (type
, "", gdb_stderr
, -1);
1240 error (_(" is not a structure or union type."));
1244 /* FIXME: This change put in by Michael seems incorrect for the case
1245 where the structure tag name is the same as the member name.
1246 I.E. when doing "ptype bell->bar" for "struct foo { int bar; int
1247 foo; } bell;" Disabled by fnf. */
1251 typename
= type_name_no_tag (type
);
1252 if (typename
!= NULL
&& strcmp (typename
, name
) == 0)
1257 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1259 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1261 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1263 return TYPE_FIELD_TYPE (type
, i
);
1267 /* OK, it's not in this class. Recursively check the baseclasses. */
1268 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1272 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, 1);
1284 target_terminal_ours ();
1285 gdb_flush (gdb_stdout
);
1286 fprintf_unfiltered (gdb_stderr
, "Type ");
1287 type_print (type
, "", gdb_stderr
, -1);
1288 fprintf_unfiltered (gdb_stderr
, " has no component named ");
1289 fputs_filtered (name
, gdb_stderr
);
1291 return (struct type
*) -1; /* For lint */
1294 /* Lookup the vptr basetype/fieldno values for TYPE.
1295 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1296 vptr_fieldno. Also, if found and basetype is from the same objfile,
1298 If not found, return -1 and ignore BASETYPEP.
1299 Callers should be aware that in some cases (for example,
1300 the type or one of its baseclasses is a stub type and we are
1301 debugging a .o file), this function will not be able to find the
1302 virtual function table pointer, and vptr_fieldno will remain -1 and
1303 vptr_basetype will remain NULL or incomplete. */
1306 get_vptr_fieldno (struct type
*type
, struct type
**basetypep
)
1308 CHECK_TYPEDEF (type
);
1310 if (TYPE_VPTR_FIELDNO (type
) < 0)
1314 /* We must start at zero in case the first (and only) baseclass
1315 is virtual (and hence we cannot share the table pointer). */
1316 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1318 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1320 struct type
*basetype
;
1322 fieldno
= get_vptr_fieldno (baseclass
, &basetype
);
1325 /* If the type comes from a different objfile we can't cache
1326 it, it may have a different lifetime. PR 2384 */
1327 if (TYPE_OBJFILE (type
) == TYPE_OBJFILE (baseclass
))
1329 TYPE_VPTR_FIELDNO (type
) = fieldno
;
1330 TYPE_VPTR_BASETYPE (type
) = basetype
;
1333 *basetypep
= basetype
;
1344 *basetypep
= TYPE_VPTR_BASETYPE (type
);
1345 return TYPE_VPTR_FIELDNO (type
);
1349 /* Find the method and field indices for the destructor in class type T.
1350 Return 1 if the destructor was found, otherwise, return 0. */
1353 get_destructor_fn_field (struct type
*t
,
1359 for (i
= 0; i
< TYPE_NFN_FIELDS (t
); i
++)
1362 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1364 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (t
, i
); j
++)
1366 if (is_destructor_name (TYPE_FN_FIELD_PHYSNAME (f
, j
)) != 0)
1378 stub_noname_complaint (void)
1380 complaint (&symfile_complaints
, _("stub type has NULL name"));
1383 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1385 If this is a stubbed struct (i.e. declared as struct foo *), see if
1386 we can find a full definition in some other file. If so, copy this
1387 definition, so we can use it in future. There used to be a comment
1388 (but not any code) that if we don't find a full definition, we'd
1389 set a flag so we don't spend time in the future checking the same
1390 type. That would be a mistake, though--we might load in more
1391 symbols which contain a full definition for the type.
1393 This used to be coded as a macro, but I don't think it is called
1394 often enough to merit such treatment. */
1396 /* Find the real type of TYPE. This function returns the real type,
1397 after removing all layers of typedefs and completing opaque or stub
1398 types. Completion changes the TYPE argument, but stripping of
1399 typedefs does not. */
1402 check_typedef (struct type
*type
)
1404 struct type
*orig_type
= type
;
1405 int is_const
, is_volatile
;
1409 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1411 if (!TYPE_TARGET_TYPE (type
))
1416 /* It is dangerous to call lookup_symbol if we are currently
1417 reading a symtab. Infinite recursion is one danger. */
1418 if (currently_reading_symtab
)
1421 name
= type_name_no_tag (type
);
1422 /* FIXME: shouldn't we separately check the TYPE_NAME and
1423 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1424 VAR_DOMAIN as appropriate? (this code was written before
1425 TYPE_NAME and TYPE_TAG_NAME were separate). */
1428 stub_noname_complaint ();
1431 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1433 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1434 else /* TYPE_CODE_UNDEF */
1435 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
);
1437 type
= TYPE_TARGET_TYPE (type
);
1440 is_const
= TYPE_CONST (type
);
1441 is_volatile
= TYPE_VOLATILE (type
);
1443 /* If this is a struct/class/union with no fields, then check
1444 whether a full definition exists somewhere else. This is for
1445 systems where a type definition with no fields is issued for such
1446 types, instead of identifying them as stub types in the first
1449 if (TYPE_IS_OPAQUE (type
)
1450 && opaque_type_resolution
1451 && !currently_reading_symtab
)
1453 char *name
= type_name_no_tag (type
);
1454 struct type
*newtype
;
1457 stub_noname_complaint ();
1460 newtype
= lookup_transparent_type (name
);
1464 /* If the resolved type and the stub are in the same
1465 objfile, then replace the stub type with the real deal.
1466 But if they're in separate objfiles, leave the stub
1467 alone; we'll just look up the transparent type every time
1468 we call check_typedef. We can't create pointers between
1469 types allocated to different objfiles, since they may
1470 have different lifetimes. Trying to copy NEWTYPE over to
1471 TYPE's objfile is pointless, too, since you'll have to
1472 move over any other types NEWTYPE refers to, which could
1473 be an unbounded amount of stuff. */
1474 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
1475 make_cv_type (is_const
, is_volatile
, newtype
, &type
);
1480 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1482 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1484 char *name
= type_name_no_tag (type
);
1485 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1486 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1487 as appropriate? (this code was written before TYPE_NAME and
1488 TYPE_TAG_NAME were separate). */
1492 stub_noname_complaint ();
1495 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1498 /* Same as above for opaque types, we can replace the stub
1499 with the complete type only if they are int the same
1501 if (TYPE_OBJFILE (SYMBOL_TYPE(sym
)) == TYPE_OBJFILE (type
))
1502 make_cv_type (is_const
, is_volatile
,
1503 SYMBOL_TYPE (sym
), &type
);
1505 type
= SYMBOL_TYPE (sym
);
1509 if (TYPE_TARGET_STUB (type
))
1511 struct type
*range_type
;
1512 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1514 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1518 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1519 && TYPE_NFIELDS (type
) == 1
1520 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
1521 == TYPE_CODE_RANGE
))
1523 /* Now recompute the length of the array type, based on its
1524 number of elements and the target type's length.
1525 Watch out for Ada null Ada arrays where the high bound
1526 is smaller than the low bound. */
1527 const int low_bound
= TYPE_FIELD_BITPOS (range_type
, 0);
1528 const int high_bound
= TYPE_FIELD_BITPOS (range_type
, 1);
1531 if (high_bound
< low_bound
)
1534 nb_elements
= high_bound
- low_bound
+ 1;
1536 TYPE_LENGTH (type
) = nb_elements
* TYPE_LENGTH (target_type
);
1537 TYPE_TARGET_STUB (type
) = 0;
1539 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1541 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1542 TYPE_TARGET_STUB (type
) = 0;
1545 /* Cache TYPE_LENGTH for future use. */
1546 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1550 /* Parse a type expression in the string [P..P+LENGTH). If an error
1551 occurs, silently return builtin_type_void. */
1553 static struct type
*
1554 safe_parse_type (char *p
, int length
)
1556 struct ui_file
*saved_gdb_stderr
;
1559 /* Suppress error messages. */
1560 saved_gdb_stderr
= gdb_stderr
;
1561 gdb_stderr
= ui_file_new ();
1563 /* Call parse_and_eval_type() without fear of longjmp()s. */
1564 if (!gdb_parse_and_eval_type (p
, length
, &type
))
1565 type
= builtin_type_void
;
1567 /* Stop suppressing error messages. */
1568 ui_file_delete (gdb_stderr
);
1569 gdb_stderr
= saved_gdb_stderr
;
1574 /* Ugly hack to convert method stubs into method types.
1576 He ain't kiddin'. This demangles the name of the method into a
1577 string including argument types, parses out each argument type,
1578 generates a string casting a zero to that type, evaluates the
1579 string, and stuffs the resulting type into an argtype vector!!!
1580 Then it knows the type of the whole function (including argument
1581 types for overloading), which info used to be in the stab's but was
1582 removed to hack back the space required for them. */
1585 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1588 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1589 char *demangled_name
= cplus_demangle (mangled_name
,
1590 DMGL_PARAMS
| DMGL_ANSI
);
1591 char *argtypetext
, *p
;
1592 int depth
= 0, argcount
= 1;
1593 struct field
*argtypes
;
1596 /* Make sure we got back a function string that we can use. */
1598 p
= strchr (demangled_name
, '(');
1602 if (demangled_name
== NULL
|| p
== NULL
)
1603 error (_("Internal: Cannot demangle mangled name `%s'."),
1606 /* Now, read in the parameters that define this type. */
1611 if (*p
== '(' || *p
== '<')
1615 else if (*p
== ')' || *p
== '>')
1619 else if (*p
== ',' && depth
== 0)
1627 /* If we read one argument and it was ``void'', don't count it. */
1628 if (strncmp (argtypetext
, "(void)", 6) == 0)
1631 /* We need one extra slot, for the THIS pointer. */
1633 argtypes
= (struct field
*)
1634 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
1637 /* Add THIS pointer for non-static methods. */
1638 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1639 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
1643 argtypes
[0].type
= lookup_pointer_type (type
);
1647 if (*p
!= ')') /* () means no args, skip while */
1652 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1654 /* Avoid parsing of ellipsis, they will be handled below.
1655 Also avoid ``void'' as above. */
1656 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
1657 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
1659 argtypes
[argcount
].type
=
1660 safe_parse_type (argtypetext
, p
- argtypetext
);
1663 argtypetext
= p
+ 1;
1666 if (*p
== '(' || *p
== '<')
1670 else if (*p
== ')' || *p
== '>')
1679 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1681 /* Now update the old "stub" type into a real type. */
1682 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1683 TYPE_DOMAIN_TYPE (mtype
) = type
;
1684 TYPE_FIELDS (mtype
) = argtypes
;
1685 TYPE_NFIELDS (mtype
) = argcount
;
1686 TYPE_STUB (mtype
) = 0;
1687 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1689 TYPE_VARARGS (mtype
) = 1;
1691 xfree (demangled_name
);
1694 /* This is the external interface to check_stub_method, above. This
1695 function unstubs all of the signatures for TYPE's METHOD_ID method
1696 name. After calling this function TYPE_FN_FIELD_STUB will be
1697 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1700 This function unfortunately can not die until stabs do. */
1703 check_stub_method_group (struct type
*type
, int method_id
)
1705 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
1706 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1707 int j
, found_stub
= 0;
1709 for (j
= 0; j
< len
; j
++)
1710 if (TYPE_FN_FIELD_STUB (f
, j
))
1713 check_stub_method (type
, method_id
, j
);
1716 /* GNU v3 methods with incorrect names were corrected when we read
1717 in type information, because it was cheaper to do it then. The
1718 only GNU v2 methods with incorrect method names are operators and
1719 destructors; destructors were also corrected when we read in type
1722 Therefore the only thing we need to handle here are v2 operator
1724 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
1727 char dem_opname
[256];
1729 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1731 dem_opname
, DMGL_ANSI
);
1733 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1737 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
1741 const struct cplus_struct_type cplus_struct_default
;
1744 allocate_cplus_struct_type (struct type
*type
)
1746 if (!HAVE_CPLUS_STRUCT (type
))
1748 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1749 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1750 *(TYPE_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1754 /* Helper function to initialize the standard scalar types.
1756 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy of
1757 the string pointed to by name in the objfile_obstack for that
1758 objfile, and initialize the type name to that copy. There are
1759 places (mipsread.c in particular, where init_type is called with a
1760 NULL value for NAME). */
1763 init_type (enum type_code code
, int length
, int flags
,
1764 char *name
, struct objfile
*objfile
)
1768 type
= alloc_type (objfile
);
1769 TYPE_CODE (type
) = code
;
1770 TYPE_LENGTH (type
) = length
;
1772 gdb_assert (!(flags
& (TYPE_FLAG_MIN
- 1)));
1773 if (flags
& TYPE_FLAG_UNSIGNED
)
1774 TYPE_UNSIGNED (type
) = 1;
1775 if (flags
& TYPE_FLAG_NOSIGN
)
1776 TYPE_NOSIGN (type
) = 1;
1777 if (flags
& TYPE_FLAG_STUB
)
1778 TYPE_STUB (type
) = 1;
1779 if (flags
& TYPE_FLAG_TARGET_STUB
)
1780 TYPE_TARGET_STUB (type
) = 1;
1781 if (flags
& TYPE_FLAG_STATIC
)
1782 TYPE_STATIC (type
) = 1;
1783 if (flags
& TYPE_FLAG_PROTOTYPED
)
1784 TYPE_PROTOTYPED (type
) = 1;
1785 if (flags
& TYPE_FLAG_INCOMPLETE
)
1786 TYPE_INCOMPLETE (type
) = 1;
1787 if (flags
& TYPE_FLAG_VARARGS
)
1788 TYPE_VARARGS (type
) = 1;
1789 if (flags
& TYPE_FLAG_VECTOR
)
1790 TYPE_VECTOR (type
) = 1;
1791 if (flags
& TYPE_FLAG_STUB_SUPPORTED
)
1792 TYPE_STUB_SUPPORTED (type
) = 1;
1793 if (flags
& TYPE_FLAG_NOTTEXT
)
1794 TYPE_NOTTEXT (type
) = 1;
1795 if (flags
& TYPE_FLAG_FIXED_INSTANCE
)
1796 TYPE_FIXED_INSTANCE (type
) = 1;
1798 if ((name
!= NULL
) && (objfile
!= NULL
))
1800 TYPE_NAME (type
) = obsavestring (name
, strlen (name
),
1801 &objfile
->objfile_obstack
);
1805 TYPE_NAME (type
) = name
;
1810 if (name
&& strcmp (name
, "char") == 0)
1811 TYPE_NOSIGN (type
) = 1;
1813 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
1814 || code
== TYPE_CODE_NAMESPACE
)
1816 INIT_CPLUS_SPECIFIC (type
);
1821 /* Helper function. Create an empty composite type. */
1824 init_composite_type (char *name
, enum type_code code
)
1827 gdb_assert (code
== TYPE_CODE_STRUCT
1828 || code
== TYPE_CODE_UNION
);
1829 t
= init_type (code
, 0, 0, NULL
, NULL
);
1830 TYPE_TAG_NAME (t
) = name
;
1834 /* Helper function. Append a field to a composite type. */
1837 append_composite_type_field (struct type
*t
, char *name
,
1841 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
1842 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
1843 sizeof (struct field
) * TYPE_NFIELDS (t
));
1844 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
1845 memset (f
, 0, sizeof f
[0]);
1846 FIELD_TYPE (f
[0]) = field
;
1847 FIELD_NAME (f
[0]) = name
;
1848 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1850 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
1851 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
1853 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
1855 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
1856 if (TYPE_NFIELDS (t
) > 1)
1858 FIELD_BITPOS (f
[0]) = (FIELD_BITPOS (f
[-1])
1859 + TYPE_LENGTH (field
) * TARGET_CHAR_BIT
);
1865 can_dereference (struct type
*t
)
1867 /* FIXME: Should we return true for references as well as
1872 && TYPE_CODE (t
) == TYPE_CODE_PTR
1873 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1877 is_integral_type (struct type
*t
)
1882 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
1883 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
1884 || (TYPE_CODE (t
) == TYPE_CODE_FLAGS
)
1885 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
1886 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
1887 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
1890 /* Check whether BASE is an ancestor or base class or DCLASS
1891 Return 1 if so, and 0 if not.
1892 Note: callers may want to check for identity of the types before
1893 calling this function -- identical types are considered to satisfy
1894 the ancestor relationship even if they're identical. */
1897 is_ancestor (struct type
*base
, struct type
*dclass
)
1901 CHECK_TYPEDEF (base
);
1902 CHECK_TYPEDEF (dclass
);
1906 if (TYPE_NAME (base
) && TYPE_NAME (dclass
)
1907 && !strcmp (TYPE_NAME (base
), TYPE_NAME (dclass
)))
1910 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1911 if (is_ancestor (base
, TYPE_BASECLASS (dclass
, i
)))
1919 /* Functions for overload resolution begin here */
1921 /* Compare two badness vectors A and B and return the result.
1922 0 => A and B are identical
1923 1 => A and B are incomparable
1924 2 => A is better than B
1925 3 => A is worse than B */
1928 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
1932 short found_pos
= 0; /* any positives in c? */
1933 short found_neg
= 0; /* any negatives in c? */
1935 /* differing lengths => incomparable */
1936 if (a
->length
!= b
->length
)
1939 /* Subtract b from a */
1940 for (i
= 0; i
< a
->length
; i
++)
1942 tmp
= a
->rank
[i
] - b
->rank
[i
];
1952 return 1; /* incomparable */
1954 return 3; /* A > B */
1960 return 2; /* A < B */
1962 return 0; /* A == B */
1966 /* Rank a function by comparing its parameter types (PARMS, length
1967 NPARMS), to the types of an argument list (ARGS, length NARGS).
1968 Return a pointer to a badness vector. This has NARGS + 1
1971 struct badness_vector
*
1972 rank_function (struct type
**parms
, int nparms
,
1973 struct type
**args
, int nargs
)
1976 struct badness_vector
*bv
;
1977 int min_len
= nparms
< nargs
? nparms
: nargs
;
1979 bv
= xmalloc (sizeof (struct badness_vector
));
1980 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank */
1981 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
1983 /* First compare the lengths of the supplied lists.
1984 If there is a mismatch, set it to a high value. */
1986 /* pai/1997-06-03 FIXME: when we have debug info about default
1987 arguments and ellipsis parameter lists, we should consider those
1988 and rank the length-match more finely. */
1990 LENGTH_MATCH (bv
) = (nargs
!= nparms
) ? LENGTH_MISMATCH_BADNESS
: 0;
1992 /* Now rank all the parameters of the candidate function */
1993 for (i
= 1; i
<= min_len
; i
++)
1994 bv
->rank
[i
] = rank_one_type (parms
[i
-1], args
[i
-1]);
1996 /* If more arguments than parameters, add dummy entries */
1997 for (i
= min_len
+ 1; i
<= nargs
; i
++)
1998 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2003 /* Compare the names of two integer types, assuming that any sign
2004 qualifiers have been checked already. We do it this way because
2005 there may be an "int" in the name of one of the types. */
2008 integer_types_same_name_p (const char *first
, const char *second
)
2010 int first_p
, second_p
;
2012 /* If both are shorts, return 1; if neither is a short, keep
2014 first_p
= (strstr (first
, "short") != NULL
);
2015 second_p
= (strstr (second
, "short") != NULL
);
2016 if (first_p
&& second_p
)
2018 if (first_p
|| second_p
)
2021 /* Likewise for long. */
2022 first_p
= (strstr (first
, "long") != NULL
);
2023 second_p
= (strstr (second
, "long") != NULL
);
2024 if (first_p
&& second_p
)
2026 if (first_p
|| second_p
)
2029 /* Likewise for char. */
2030 first_p
= (strstr (first
, "char") != NULL
);
2031 second_p
= (strstr (second
, "char") != NULL
);
2032 if (first_p
&& second_p
)
2034 if (first_p
|| second_p
)
2037 /* They must both be ints. */
2041 /* Compare one type (PARM) for compatibility with another (ARG).
2042 * PARM is intended to be the parameter type of a function; and
2043 * ARG is the supplied argument's type. This function tests if
2044 * the latter can be converted to the former.
2046 * Return 0 if they are identical types;
2047 * Otherwise, return an integer which corresponds to how compatible
2048 * PARM is to ARG. The higher the return value, the worse the match.
2049 * Generally the "bad" conversions are all uniformly assigned a 100. */
2052 rank_one_type (struct type
*parm
, struct type
*arg
)
2054 /* Identical type pointers. */
2055 /* However, this still doesn't catch all cases of same type for arg
2056 and param. The reason is that builtin types are different from
2057 the same ones constructed from the object. */
2061 /* Resolve typedefs */
2062 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2063 parm
= check_typedef (parm
);
2064 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2065 arg
= check_typedef (arg
);
2068 Well, damnit, if the names are exactly the same, I'll say they
2069 are exactly the same. This happens when we generate method
2070 stubs. The types won't point to the same address, but they
2071 really are the same.
2074 if (TYPE_NAME (parm
) && TYPE_NAME (arg
)
2075 && !strcmp (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2078 /* Check if identical after resolving typedefs. */
2082 /* See through references, since we can almost make non-references
2084 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2085 return (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
))
2086 + REFERENCE_CONVERSION_BADNESS
);
2087 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2088 return (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
)
2089 + REFERENCE_CONVERSION_BADNESS
);
2091 /* Debugging only. */
2092 fprintf_filtered (gdb_stderr
,
2093 "------ Arg is %s [%d], parm is %s [%d]\n",
2094 TYPE_NAME (arg
), TYPE_CODE (arg
),
2095 TYPE_NAME (parm
), TYPE_CODE (parm
));
2097 /* x -> y means arg of type x being supplied for parameter of type y */
2099 switch (TYPE_CODE (parm
))
2102 switch (TYPE_CODE (arg
))
2105 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2106 return VOID_PTR_CONVERSION_BADNESS
;
2108 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2109 TYPE_TARGET_TYPE (arg
));
2110 case TYPE_CODE_ARRAY
:
2111 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2112 TYPE_TARGET_TYPE (arg
));
2113 case TYPE_CODE_FUNC
:
2114 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
);
2116 case TYPE_CODE_ENUM
:
2117 case TYPE_CODE_FLAGS
:
2118 case TYPE_CODE_CHAR
:
2119 case TYPE_CODE_RANGE
:
2120 case TYPE_CODE_BOOL
:
2121 return POINTER_CONVERSION_BADNESS
;
2123 return INCOMPATIBLE_TYPE_BADNESS
;
2125 case TYPE_CODE_ARRAY
:
2126 switch (TYPE_CODE (arg
))
2129 case TYPE_CODE_ARRAY
:
2130 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2131 TYPE_TARGET_TYPE (arg
));
2133 return INCOMPATIBLE_TYPE_BADNESS
;
2135 case TYPE_CODE_FUNC
:
2136 switch (TYPE_CODE (arg
))
2138 case TYPE_CODE_PTR
: /* funcptr -> func */
2139 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
));
2141 return INCOMPATIBLE_TYPE_BADNESS
;
2144 switch (TYPE_CODE (arg
))
2147 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2149 /* Deal with signed, unsigned, and plain chars and
2150 signed and unsigned ints. */
2151 if (TYPE_NOSIGN (parm
))
2153 /* This case only for character types */
2154 if (TYPE_NOSIGN (arg
))
2155 return 0; /* plain char -> plain char */
2156 else /* signed/unsigned char -> plain char */
2157 return INTEGER_CONVERSION_BADNESS
;
2159 else if (TYPE_UNSIGNED (parm
))
2161 if (TYPE_UNSIGNED (arg
))
2163 /* unsigned int -> unsigned int, or
2164 unsigned long -> unsigned long */
2165 if (integer_types_same_name_p (TYPE_NAME (parm
),
2168 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2170 && integer_types_same_name_p (TYPE_NAME (parm
),
2172 return INTEGER_PROMOTION_BADNESS
; /* unsigned int -> unsigned long */
2174 return INTEGER_CONVERSION_BADNESS
; /* unsigned long -> unsigned int */
2178 if (integer_types_same_name_p (TYPE_NAME (arg
),
2180 && integer_types_same_name_p (TYPE_NAME (parm
),
2182 return INTEGER_CONVERSION_BADNESS
; /* signed long -> unsigned int */
2184 return INTEGER_CONVERSION_BADNESS
; /* signed int/long -> unsigned int/long */
2187 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2189 if (integer_types_same_name_p (TYPE_NAME (parm
),
2192 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2194 && integer_types_same_name_p (TYPE_NAME (parm
),
2196 return INTEGER_PROMOTION_BADNESS
;
2198 return INTEGER_CONVERSION_BADNESS
;
2201 return INTEGER_CONVERSION_BADNESS
;
2203 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2204 return INTEGER_PROMOTION_BADNESS
;
2206 return INTEGER_CONVERSION_BADNESS
;
2207 case TYPE_CODE_ENUM
:
2208 case TYPE_CODE_FLAGS
:
2209 case TYPE_CODE_CHAR
:
2210 case TYPE_CODE_RANGE
:
2211 case TYPE_CODE_BOOL
:
2212 return INTEGER_PROMOTION_BADNESS
;
2214 return INT_FLOAT_CONVERSION_BADNESS
;
2216 return NS_POINTER_CONVERSION_BADNESS
;
2218 return INCOMPATIBLE_TYPE_BADNESS
;
2221 case TYPE_CODE_ENUM
:
2222 switch (TYPE_CODE (arg
))
2225 case TYPE_CODE_CHAR
:
2226 case TYPE_CODE_RANGE
:
2227 case TYPE_CODE_BOOL
:
2228 case TYPE_CODE_ENUM
:
2229 return INTEGER_CONVERSION_BADNESS
;
2231 return INT_FLOAT_CONVERSION_BADNESS
;
2233 return INCOMPATIBLE_TYPE_BADNESS
;
2236 case TYPE_CODE_CHAR
:
2237 switch (TYPE_CODE (arg
))
2239 case TYPE_CODE_RANGE
:
2240 case TYPE_CODE_BOOL
:
2241 case TYPE_CODE_ENUM
:
2242 return INTEGER_CONVERSION_BADNESS
;
2244 return INT_FLOAT_CONVERSION_BADNESS
;
2246 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2247 return INTEGER_CONVERSION_BADNESS
;
2248 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2249 return INTEGER_PROMOTION_BADNESS
;
2250 /* >>> !! else fall through !! <<< */
2251 case TYPE_CODE_CHAR
:
2252 /* Deal with signed, unsigned, and plain chars for C++ and
2253 with int cases falling through from previous case. */
2254 if (TYPE_NOSIGN (parm
))
2256 if (TYPE_NOSIGN (arg
))
2259 return INTEGER_CONVERSION_BADNESS
;
2261 else if (TYPE_UNSIGNED (parm
))
2263 if (TYPE_UNSIGNED (arg
))
2266 return INTEGER_PROMOTION_BADNESS
;
2268 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2271 return INTEGER_CONVERSION_BADNESS
;
2273 return INCOMPATIBLE_TYPE_BADNESS
;
2276 case TYPE_CODE_RANGE
:
2277 switch (TYPE_CODE (arg
))
2280 case TYPE_CODE_CHAR
:
2281 case TYPE_CODE_RANGE
:
2282 case TYPE_CODE_BOOL
:
2283 case TYPE_CODE_ENUM
:
2284 return INTEGER_CONVERSION_BADNESS
;
2286 return INT_FLOAT_CONVERSION_BADNESS
;
2288 return INCOMPATIBLE_TYPE_BADNESS
;
2291 case TYPE_CODE_BOOL
:
2292 switch (TYPE_CODE (arg
))
2295 case TYPE_CODE_CHAR
:
2296 case TYPE_CODE_RANGE
:
2297 case TYPE_CODE_ENUM
:
2300 return BOOLEAN_CONVERSION_BADNESS
;
2301 case TYPE_CODE_BOOL
:
2304 return INCOMPATIBLE_TYPE_BADNESS
;
2308 switch (TYPE_CODE (arg
))
2311 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2312 return FLOAT_PROMOTION_BADNESS
;
2313 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2316 return FLOAT_CONVERSION_BADNESS
;
2318 case TYPE_CODE_BOOL
:
2319 case TYPE_CODE_ENUM
:
2320 case TYPE_CODE_RANGE
:
2321 case TYPE_CODE_CHAR
:
2322 return INT_FLOAT_CONVERSION_BADNESS
;
2324 return INCOMPATIBLE_TYPE_BADNESS
;
2327 case TYPE_CODE_COMPLEX
:
2328 switch (TYPE_CODE (arg
))
2329 { /* Strictly not needed for C++, but... */
2331 return FLOAT_PROMOTION_BADNESS
;
2332 case TYPE_CODE_COMPLEX
:
2335 return INCOMPATIBLE_TYPE_BADNESS
;
2338 case TYPE_CODE_STRUCT
:
2339 /* currently same as TYPE_CODE_CLASS */
2340 switch (TYPE_CODE (arg
))
2342 case TYPE_CODE_STRUCT
:
2343 /* Check for derivation */
2344 if (is_ancestor (parm
, arg
))
2345 return BASE_CONVERSION_BADNESS
;
2346 /* else fall through */
2348 return INCOMPATIBLE_TYPE_BADNESS
;
2351 case TYPE_CODE_UNION
:
2352 switch (TYPE_CODE (arg
))
2354 case TYPE_CODE_UNION
:
2356 return INCOMPATIBLE_TYPE_BADNESS
;
2359 case TYPE_CODE_MEMBERPTR
:
2360 switch (TYPE_CODE (arg
))
2363 return INCOMPATIBLE_TYPE_BADNESS
;
2366 case TYPE_CODE_METHOD
:
2367 switch (TYPE_CODE (arg
))
2371 return INCOMPATIBLE_TYPE_BADNESS
;
2375 switch (TYPE_CODE (arg
))
2379 return INCOMPATIBLE_TYPE_BADNESS
;
2384 switch (TYPE_CODE (arg
))
2388 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0),
2389 TYPE_FIELD_TYPE (arg
, 0));
2391 return INCOMPATIBLE_TYPE_BADNESS
;
2394 case TYPE_CODE_VOID
:
2396 return INCOMPATIBLE_TYPE_BADNESS
;
2397 } /* switch (TYPE_CODE (arg)) */
2401 /* End of functions for overload resolution */
2404 print_bit_vector (B_TYPE
*bits
, int nbits
)
2408 for (bitno
= 0; bitno
< nbits
; bitno
++)
2410 if ((bitno
% 8) == 0)
2412 puts_filtered (" ");
2414 if (B_TST (bits
, bitno
))
2415 printf_filtered (("1"));
2417 printf_filtered (("0"));
2421 /* Note the first arg should be the "this" pointer, we may not want to
2422 include it since we may get into a infinitely recursive
2426 print_arg_types (struct field
*args
, int nargs
, int spaces
)
2432 for (i
= 0; i
< nargs
; i
++)
2433 recursive_dump_type (args
[i
].type
, spaces
+ 2);
2438 dump_fn_fieldlists (struct type
*type
, int spaces
)
2444 printfi_filtered (spaces
, "fn_fieldlists ");
2445 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2446 printf_filtered ("\n");
2447 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2449 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2450 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2452 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2453 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2455 printf_filtered (_(") length %d\n"),
2456 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2457 for (overload_idx
= 0;
2458 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2461 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2463 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2464 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2466 printf_filtered (")\n");
2467 printfi_filtered (spaces
+ 8, "type ");
2468 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2470 printf_filtered ("\n");
2472 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2475 printfi_filtered (spaces
+ 8, "args ");
2476 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2478 printf_filtered ("\n");
2480 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2481 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
,
2484 printfi_filtered (spaces
+ 8, "fcontext ");
2485 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2487 printf_filtered ("\n");
2489 printfi_filtered (spaces
+ 8, "is_const %d\n",
2490 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2491 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2492 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2493 printfi_filtered (spaces
+ 8, "is_private %d\n",
2494 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2495 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2496 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2497 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2498 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2499 printfi_filtered (spaces
+ 8, "voffset %u\n",
2500 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2506 print_cplus_stuff (struct type
*type
, int spaces
)
2508 printfi_filtered (spaces
, "n_baseclasses %d\n",
2509 TYPE_N_BASECLASSES (type
));
2510 printfi_filtered (spaces
, "nfn_fields %d\n",
2511 TYPE_NFN_FIELDS (type
));
2512 printfi_filtered (spaces
, "nfn_fields_total %d\n",
2513 TYPE_NFN_FIELDS_TOTAL (type
));
2514 if (TYPE_N_BASECLASSES (type
) > 0)
2516 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2517 TYPE_N_BASECLASSES (type
));
2518 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
2520 printf_filtered (")");
2522 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2523 TYPE_N_BASECLASSES (type
));
2524 puts_filtered ("\n");
2526 if (TYPE_NFIELDS (type
) > 0)
2528 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2530 printfi_filtered (spaces
,
2531 "private_field_bits (%d bits at *",
2532 TYPE_NFIELDS (type
));
2533 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
2535 printf_filtered (")");
2536 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2537 TYPE_NFIELDS (type
));
2538 puts_filtered ("\n");
2540 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2542 printfi_filtered (spaces
,
2543 "protected_field_bits (%d bits at *",
2544 TYPE_NFIELDS (type
));
2545 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
2547 printf_filtered (")");
2548 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2549 TYPE_NFIELDS (type
));
2550 puts_filtered ("\n");
2553 if (TYPE_NFN_FIELDS (type
) > 0)
2555 dump_fn_fieldlists (type
, spaces
);
2559 static struct obstack dont_print_type_obstack
;
2562 recursive_dump_type (struct type
*type
, int spaces
)
2567 obstack_begin (&dont_print_type_obstack
, 0);
2569 if (TYPE_NFIELDS (type
) > 0
2570 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
2572 struct type
**first_dont_print
2573 = (struct type
**) obstack_base (&dont_print_type_obstack
);
2575 int i
= (struct type
**)
2576 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
2580 if (type
== first_dont_print
[i
])
2582 printfi_filtered (spaces
, "type node ");
2583 gdb_print_host_address (type
, gdb_stdout
);
2584 printf_filtered (_(" <same as already seen type>\n"));
2589 obstack_ptr_grow (&dont_print_type_obstack
, type
);
2592 printfi_filtered (spaces
, "type node ");
2593 gdb_print_host_address (type
, gdb_stdout
);
2594 printf_filtered ("\n");
2595 printfi_filtered (spaces
, "name '%s' (",
2596 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
2597 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
2598 printf_filtered (")\n");
2599 printfi_filtered (spaces
, "tagname '%s' (",
2600 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
2601 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
2602 printf_filtered (")\n");
2603 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
2604 switch (TYPE_CODE (type
))
2606 case TYPE_CODE_UNDEF
:
2607 printf_filtered ("(TYPE_CODE_UNDEF)");
2610 printf_filtered ("(TYPE_CODE_PTR)");
2612 case TYPE_CODE_ARRAY
:
2613 printf_filtered ("(TYPE_CODE_ARRAY)");
2615 case TYPE_CODE_STRUCT
:
2616 printf_filtered ("(TYPE_CODE_STRUCT)");
2618 case TYPE_CODE_UNION
:
2619 printf_filtered ("(TYPE_CODE_UNION)");
2621 case TYPE_CODE_ENUM
:
2622 printf_filtered ("(TYPE_CODE_ENUM)");
2624 case TYPE_CODE_FLAGS
:
2625 printf_filtered ("(TYPE_CODE_FLAGS)");
2627 case TYPE_CODE_FUNC
:
2628 printf_filtered ("(TYPE_CODE_FUNC)");
2631 printf_filtered ("(TYPE_CODE_INT)");
2634 printf_filtered ("(TYPE_CODE_FLT)");
2636 case TYPE_CODE_VOID
:
2637 printf_filtered ("(TYPE_CODE_VOID)");
2640 printf_filtered ("(TYPE_CODE_SET)");
2642 case TYPE_CODE_RANGE
:
2643 printf_filtered ("(TYPE_CODE_RANGE)");
2645 case TYPE_CODE_STRING
:
2646 printf_filtered ("(TYPE_CODE_STRING)");
2648 case TYPE_CODE_BITSTRING
:
2649 printf_filtered ("(TYPE_CODE_BITSTRING)");
2651 case TYPE_CODE_ERROR
:
2652 printf_filtered ("(TYPE_CODE_ERROR)");
2654 case TYPE_CODE_MEMBERPTR
:
2655 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
2657 case TYPE_CODE_METHODPTR
:
2658 printf_filtered ("(TYPE_CODE_METHODPTR)");
2660 case TYPE_CODE_METHOD
:
2661 printf_filtered ("(TYPE_CODE_METHOD)");
2664 printf_filtered ("(TYPE_CODE_REF)");
2666 case TYPE_CODE_CHAR
:
2667 printf_filtered ("(TYPE_CODE_CHAR)");
2669 case TYPE_CODE_BOOL
:
2670 printf_filtered ("(TYPE_CODE_BOOL)");
2672 case TYPE_CODE_COMPLEX
:
2673 printf_filtered ("(TYPE_CODE_COMPLEX)");
2675 case TYPE_CODE_TYPEDEF
:
2676 printf_filtered ("(TYPE_CODE_TYPEDEF)");
2678 case TYPE_CODE_TEMPLATE
:
2679 printf_filtered ("(TYPE_CODE_TEMPLATE)");
2681 case TYPE_CODE_TEMPLATE_ARG
:
2682 printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)");
2684 case TYPE_CODE_NAMESPACE
:
2685 printf_filtered ("(TYPE_CODE_NAMESPACE)");
2688 printf_filtered ("(UNKNOWN TYPE CODE)");
2691 puts_filtered ("\n");
2692 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
2693 printfi_filtered (spaces
, "objfile ");
2694 gdb_print_host_address (TYPE_OBJFILE (type
), gdb_stdout
);
2695 printf_filtered ("\n");
2696 printfi_filtered (spaces
, "target_type ");
2697 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
2698 printf_filtered ("\n");
2699 if (TYPE_TARGET_TYPE (type
) != NULL
)
2701 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
2703 printfi_filtered (spaces
, "pointer_type ");
2704 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
2705 printf_filtered ("\n");
2706 printfi_filtered (spaces
, "reference_type ");
2707 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
2708 printf_filtered ("\n");
2709 printfi_filtered (spaces
, "type_chain ");
2710 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
2711 printf_filtered ("\n");
2712 printfi_filtered (spaces
, "instance_flags 0x%x",
2713 TYPE_INSTANCE_FLAGS (type
));
2714 if (TYPE_CONST (type
))
2716 puts_filtered (" TYPE_FLAG_CONST");
2718 if (TYPE_VOLATILE (type
))
2720 puts_filtered (" TYPE_FLAG_VOLATILE");
2722 if (TYPE_CODE_SPACE (type
))
2724 puts_filtered (" TYPE_FLAG_CODE_SPACE");
2726 if (TYPE_DATA_SPACE (type
))
2728 puts_filtered (" TYPE_FLAG_DATA_SPACE");
2730 if (TYPE_ADDRESS_CLASS_1 (type
))
2732 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
2734 if (TYPE_ADDRESS_CLASS_2 (type
))
2736 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
2738 puts_filtered ("\n");
2740 printfi_filtered (spaces
, "flags");
2741 if (TYPE_UNSIGNED (type
))
2743 puts_filtered (" TYPE_FLAG_UNSIGNED");
2745 if (TYPE_NOSIGN (type
))
2747 puts_filtered (" TYPE_FLAG_NOSIGN");
2749 if (TYPE_STUB (type
))
2751 puts_filtered (" TYPE_FLAG_STUB");
2753 if (TYPE_TARGET_STUB (type
))
2755 puts_filtered (" TYPE_FLAG_TARGET_STUB");
2757 if (TYPE_STATIC (type
))
2759 puts_filtered (" TYPE_FLAG_STATIC");
2761 if (TYPE_PROTOTYPED (type
))
2763 puts_filtered (" TYPE_FLAG_PROTOTYPED");
2765 if (TYPE_INCOMPLETE (type
))
2767 puts_filtered (" TYPE_FLAG_INCOMPLETE");
2769 if (TYPE_VARARGS (type
))
2771 puts_filtered (" TYPE_FLAG_VARARGS");
2773 /* This is used for things like AltiVec registers on ppc. Gcc emits
2774 an attribute for the array type, which tells whether or not we
2775 have a vector, instead of a regular array. */
2776 if (TYPE_VECTOR (type
))
2778 puts_filtered (" TYPE_FLAG_VECTOR");
2780 if (TYPE_FIXED_INSTANCE (type
))
2782 puts_filtered (" TYPE_FIXED_INSTANCE");
2784 if (TYPE_STUB_SUPPORTED (type
))
2786 puts_filtered (" TYPE_STUB_SUPPORTED");
2788 if (TYPE_NOTTEXT (type
))
2790 puts_filtered (" TYPE_NOTTEXT");
2792 puts_filtered ("\n");
2793 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
2794 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
2795 puts_filtered ("\n");
2796 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
2798 printfi_filtered (spaces
+ 2,
2799 "[%d] bitpos %d bitsize %d type ",
2800 idx
, TYPE_FIELD_BITPOS (type
, idx
),
2801 TYPE_FIELD_BITSIZE (type
, idx
));
2802 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
2803 printf_filtered (" name '%s' (",
2804 TYPE_FIELD_NAME (type
, idx
) != NULL
2805 ? TYPE_FIELD_NAME (type
, idx
)
2807 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
2808 printf_filtered (")\n");
2809 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
2811 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
2814 printfi_filtered (spaces
, "vptr_basetype ");
2815 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
2816 puts_filtered ("\n");
2817 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
2819 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
2821 printfi_filtered (spaces
, "vptr_fieldno %d\n",
2822 TYPE_VPTR_FIELDNO (type
));
2823 switch (TYPE_CODE (type
))
2825 case TYPE_CODE_STRUCT
:
2826 printfi_filtered (spaces
, "cplus_stuff ");
2827 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
),
2829 puts_filtered ("\n");
2830 print_cplus_stuff (type
, spaces
);
2834 printfi_filtered (spaces
, "floatformat ");
2835 if (TYPE_FLOATFORMAT (type
) == NULL
)
2836 puts_filtered ("(null)");
2839 puts_filtered ("{ ");
2840 if (TYPE_FLOATFORMAT (type
)[0] == NULL
2841 || TYPE_FLOATFORMAT (type
)[0]->name
== NULL
)
2842 puts_filtered ("(null)");
2844 puts_filtered (TYPE_FLOATFORMAT (type
)[0]->name
);
2846 puts_filtered (", ");
2847 if (TYPE_FLOATFORMAT (type
)[1] == NULL
2848 || TYPE_FLOATFORMAT (type
)[1]->name
== NULL
)
2849 puts_filtered ("(null)");
2851 puts_filtered (TYPE_FLOATFORMAT (type
)[1]->name
);
2853 puts_filtered (" }");
2855 puts_filtered ("\n");
2859 /* We have to pick one of the union types to be able print and
2860 test the value. Pick cplus_struct_type, even though we know
2861 it isn't any particular one. */
2862 printfi_filtered (spaces
, "type_specific ");
2863 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
2864 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
2866 printf_filtered (_(" (unknown data form)"));
2868 printf_filtered ("\n");
2873 obstack_free (&dont_print_type_obstack
, NULL
);
2876 /* Trivial helpers for the libiberty hash table, for mapping one
2881 struct type
*old
, *new;
2885 type_pair_hash (const void *item
)
2887 const struct type_pair
*pair
= item
;
2888 return htab_hash_pointer (pair
->old
);
2892 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
2894 const struct type_pair
*lhs
= item_lhs
, *rhs
= item_rhs
;
2895 return lhs
->old
== rhs
->old
;
2898 /* Allocate the hash table used by copy_type_recursive to walk
2899 types without duplicates. We use OBJFILE's obstack, because
2900 OBJFILE is about to be deleted. */
2903 create_copied_types_hash (struct objfile
*objfile
)
2905 return htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
2906 NULL
, &objfile
->objfile_obstack
,
2907 hashtab_obstack_allocate
,
2908 dummy_obstack_deallocate
);
2911 /* Recursively copy (deep copy) TYPE, if it is associated with
2912 OBJFILE. Return a new type allocated using malloc, a saved type if
2913 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
2914 not associated with OBJFILE. */
2917 copy_type_recursive (struct objfile
*objfile
,
2919 htab_t copied_types
)
2921 struct type_pair
*stored
, pair
;
2923 struct type
*new_type
;
2925 if (TYPE_OBJFILE (type
) == NULL
)
2928 /* This type shouldn't be pointing to any types in other objfiles;
2929 if it did, the type might disappear unexpectedly. */
2930 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
2933 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
2935 return ((struct type_pair
*) *slot
)->new;
2937 new_type
= alloc_type (NULL
);
2939 /* We must add the new type to the hash table immediately, in case
2940 we encounter this type again during a recursive call below. */
2941 stored
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct type_pair
));
2943 stored
->new = new_type
;
2946 /* Copy the common fields of types. For the main type, we simply
2947 copy the entire thing and then update specific fields as needed. */
2948 *TYPE_MAIN_TYPE (new_type
) = *TYPE_MAIN_TYPE (type
);
2949 TYPE_OBJFILE (new_type
) = NULL
;
2951 if (TYPE_NAME (type
))
2952 TYPE_NAME (new_type
) = xstrdup (TYPE_NAME (type
));
2953 if (TYPE_TAG_NAME (type
))
2954 TYPE_TAG_NAME (new_type
) = xstrdup (TYPE_TAG_NAME (type
));
2956 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
2957 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
2959 /* Copy the fields. */
2960 if (TYPE_NFIELDS (type
))
2964 nfields
= TYPE_NFIELDS (type
);
2965 TYPE_FIELDS (new_type
) = xmalloc (sizeof (struct field
) * nfields
);
2966 for (i
= 0; i
< nfields
; i
++)
2968 TYPE_FIELD_ARTIFICIAL (new_type
, i
) =
2969 TYPE_FIELD_ARTIFICIAL (type
, i
);
2970 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
2971 if (TYPE_FIELD_TYPE (type
, i
))
2972 TYPE_FIELD_TYPE (new_type
, i
)
2973 = copy_type_recursive (objfile
, TYPE_FIELD_TYPE (type
, i
),
2975 if (TYPE_FIELD_NAME (type
, i
))
2976 TYPE_FIELD_NAME (new_type
, i
) =
2977 xstrdup (TYPE_FIELD_NAME (type
, i
));
2978 if (TYPE_FIELD_STATIC_HAS_ADDR (type
, i
))
2979 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type
, i
),
2980 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
2981 else if (TYPE_FIELD_STATIC (type
, i
))
2982 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type
, i
),
2983 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
,
2987 TYPE_FIELD_BITPOS (new_type
, i
) =
2988 TYPE_FIELD_BITPOS (type
, i
);
2989 TYPE_FIELD_STATIC_KIND (new_type
, i
) = 0;
2994 /* Copy pointers to other types. */
2995 if (TYPE_TARGET_TYPE (type
))
2996 TYPE_TARGET_TYPE (new_type
) =
2997 copy_type_recursive (objfile
,
2998 TYPE_TARGET_TYPE (type
),
3000 if (TYPE_VPTR_BASETYPE (type
))
3001 TYPE_VPTR_BASETYPE (new_type
) =
3002 copy_type_recursive (objfile
,
3003 TYPE_VPTR_BASETYPE (type
),
3005 /* Maybe copy the type_specific bits.
3007 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3008 base classes and methods. There's no fundamental reason why we
3009 can't, but at the moment it is not needed. */
3011 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
3012 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
3013 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3014 || TYPE_CODE (type
) == TYPE_CODE_UNION
3015 || TYPE_CODE (type
) == TYPE_CODE_TEMPLATE
3016 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
3017 INIT_CPLUS_SPECIFIC (new_type
);
3022 static struct type
*
3023 build_flt (int bit
, char *name
, const struct floatformat
**floatformats
)
3029 gdb_assert (floatformats
!= NULL
);
3030 gdb_assert (floatformats
[0] != NULL
&& floatformats
[1] != NULL
);
3031 bit
= floatformats
[0]->totalsize
;
3033 gdb_assert (bit
>= 0);
3035 t
= init_type (TYPE_CODE_FLT
, bit
/ TARGET_CHAR_BIT
, 0, name
, NULL
);
3036 TYPE_FLOATFORMAT (t
) = floatformats
;
3040 static struct gdbarch_data
*gdbtypes_data
;
3042 const struct builtin_type
*
3043 builtin_type (struct gdbarch
*gdbarch
)
3045 return gdbarch_data (gdbarch
, gdbtypes_data
);
3049 static struct type
*
3050 build_complex (int bit
, char *name
, struct type
*target_type
)
3053 if (bit
<= 0 || target_type
== builtin_type_error
)
3055 gdb_assert (builtin_type_error
!= NULL
);
3056 return builtin_type_error
;
3058 t
= init_type (TYPE_CODE_COMPLEX
, 2 * bit
/ TARGET_CHAR_BIT
,
3059 0, name
, (struct objfile
*) NULL
);
3060 TYPE_TARGET_TYPE (t
) = target_type
;
3065 gdbtypes_post_init (struct gdbarch
*gdbarch
)
3067 struct builtin_type
*builtin_type
3068 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
3070 builtin_type
->builtin_void
=
3071 init_type (TYPE_CODE_VOID
, 1,
3073 "void", (struct objfile
*) NULL
);
3074 builtin_type
->builtin_char
=
3075 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3077 | (gdbarch_char_signed (gdbarch
) ? 0 : TYPE_FLAG_UNSIGNED
)),
3078 "char", (struct objfile
*) NULL
);
3079 builtin_type
->builtin_signed_char
=
3080 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3082 "signed char", (struct objfile
*) NULL
);
3083 builtin_type
->builtin_unsigned_char
=
3084 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3086 "unsigned char", (struct objfile
*) NULL
);
3087 builtin_type
->builtin_short
=
3088 init_type (TYPE_CODE_INT
,
3089 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3090 0, "short", (struct objfile
*) NULL
);
3091 builtin_type
->builtin_unsigned_short
=
3092 init_type (TYPE_CODE_INT
,
3093 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3094 TYPE_FLAG_UNSIGNED
, "unsigned short",
3095 (struct objfile
*) NULL
);
3096 builtin_type
->builtin_int
=
3097 init_type (TYPE_CODE_INT
,
3098 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3099 0, "int", (struct objfile
*) NULL
);
3100 builtin_type
->builtin_unsigned_int
=
3101 init_type (TYPE_CODE_INT
,
3102 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3103 TYPE_FLAG_UNSIGNED
, "unsigned int",
3104 (struct objfile
*) NULL
);
3105 builtin_type
->builtin_long
=
3106 init_type (TYPE_CODE_INT
,
3107 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3108 0, "long", (struct objfile
*) NULL
);
3109 builtin_type
->builtin_unsigned_long
=
3110 init_type (TYPE_CODE_INT
,
3111 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3112 TYPE_FLAG_UNSIGNED
, "unsigned long",
3113 (struct objfile
*) NULL
);
3114 builtin_type
->builtin_long_long
=
3115 init_type (TYPE_CODE_INT
,
3116 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3117 0, "long long", (struct objfile
*) NULL
);
3118 builtin_type
->builtin_unsigned_long_long
=
3119 init_type (TYPE_CODE_INT
,
3120 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3121 TYPE_FLAG_UNSIGNED
, "unsigned long long",
3122 (struct objfile
*) NULL
);
3123 builtin_type
->builtin_float
3124 = build_flt (gdbarch_float_bit (gdbarch
), "float",
3125 gdbarch_float_format (gdbarch
));
3126 builtin_type
->builtin_double
3127 = build_flt (gdbarch_double_bit (gdbarch
), "double",
3128 gdbarch_double_format (gdbarch
));
3129 builtin_type
->builtin_long_double
3130 = build_flt (gdbarch_long_double_bit (gdbarch
), "long double",
3131 gdbarch_long_double_format (gdbarch
));
3132 builtin_type
->builtin_complex
3133 = build_complex (gdbarch_float_bit (gdbarch
), "complex",
3134 builtin_type
->builtin_float
);
3135 builtin_type
->builtin_double_complex
3136 = build_complex (gdbarch_double_bit (gdbarch
), "double complex",
3137 builtin_type
->builtin_double
);
3138 builtin_type
->builtin_string
=
3139 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3141 "string", (struct objfile
*) NULL
);
3142 builtin_type
->builtin_bool
=
3143 init_type (TYPE_CODE_BOOL
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3145 "bool", (struct objfile
*) NULL
);
3147 /* The following three are about decimal floating point types, which
3148 are 32-bits, 64-bits and 128-bits respectively. */
3149 builtin_type
->builtin_decfloat
3150 = init_type (TYPE_CODE_DECFLOAT
, 32 / 8,
3152 "_Decimal32", (struct objfile
*) NULL
);
3153 builtin_type
->builtin_decdouble
3154 = init_type (TYPE_CODE_DECFLOAT
, 64 / 8,
3156 "_Decimal64", (struct objfile
*) NULL
);
3157 builtin_type
->builtin_declong
3158 = init_type (TYPE_CODE_DECFLOAT
, 128 / 8,
3160 "_Decimal128", (struct objfile
*) NULL
);
3162 /* Pointer/Address types. */
3164 /* NOTE: on some targets, addresses and pointers are not necessarily
3165 the same --- for example, on the D10V, pointers are 16 bits long,
3166 but addresses are 32 bits long. See doc/gdbint.texinfo,
3167 ``Pointers Are Not Always Addresses''.
3170 - gdb's `struct type' always describes the target's
3172 - gdb's `struct value' objects should always hold values in
3174 - gdb's CORE_ADDR values are addresses in the unified virtual
3175 address space that the assembler and linker work with. Thus,
3176 since target_read_memory takes a CORE_ADDR as an argument, it
3177 can access any memory on the target, even if the processor has
3178 separate code and data address spaces.
3181 - If v is a value holding a D10V code pointer, its contents are
3182 in target form: a big-endian address left-shifted two bits.
3183 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3184 sizeof (void *) == 2 on the target.
3186 In this context, builtin_type->CORE_ADDR is a bit odd: it's a
3187 target type for a value the target will never see. It's only
3188 used to hold the values of (typeless) linker symbols, which are
3189 indeed in the unified virtual address space. */
3191 builtin_type
->builtin_data_ptr
=
3192 make_pointer_type (builtin_type
->builtin_void
, NULL
);
3193 builtin_type
->builtin_func_ptr
=
3194 lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
3195 builtin_type
->builtin_core_addr
=
3196 init_type (TYPE_CODE_INT
,
3197 gdbarch_addr_bit (gdbarch
) / 8,
3199 "__CORE_ADDR", (struct objfile
*) NULL
);
3202 /* The following set of types is used for symbols with no
3203 debug information. */
3204 builtin_type
->nodebug_text_symbol
=
3205 init_type (TYPE_CODE_FUNC
, 1, 0,
3206 "<text variable, no debug info>", NULL
);
3207 TYPE_TARGET_TYPE (builtin_type
->nodebug_text_symbol
) =
3208 builtin_type
->builtin_int
;
3209 builtin_type
->nodebug_data_symbol
=
3210 init_type (TYPE_CODE_INT
,
3211 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3212 "<data variable, no debug info>", NULL
);
3213 builtin_type
->nodebug_unknown_symbol
=
3214 init_type (TYPE_CODE_INT
, 1, 0,
3215 "<variable (not text or data), no debug info>", NULL
);
3216 builtin_type
->nodebug_tls_symbol
=
3217 init_type (TYPE_CODE_INT
,
3218 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3219 "<thread local variable, no debug info>", NULL
);
3221 return builtin_type
;
3224 extern void _initialize_gdbtypes (void);
3226 _initialize_gdbtypes (void)
3228 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
3230 /* FIXME: The following types are architecture-neutral. However,
3231 they contain pointer_type and reference_type fields potentially
3232 caching pointer or reference types that *are* architecture
3236 init_type (TYPE_CODE_INT
, 0 / 8,
3238 "int0_t", (struct objfile
*) NULL
);
3240 init_type (TYPE_CODE_INT
, 8 / 8,
3242 "int8_t", (struct objfile
*) NULL
);
3243 builtin_type_uint8
=
3244 init_type (TYPE_CODE_INT
, 8 / 8,
3245 TYPE_FLAG_UNSIGNED
| TYPE_FLAG_NOTTEXT
,
3246 "uint8_t", (struct objfile
*) NULL
);
3247 builtin_type_int16
=
3248 init_type (TYPE_CODE_INT
, 16 / 8,
3250 "int16_t", (struct objfile
*) NULL
);
3251 builtin_type_uint16
=
3252 init_type (TYPE_CODE_INT
, 16 / 8,
3254 "uint16_t", (struct objfile
*) NULL
);
3255 builtin_type_int32
=
3256 init_type (TYPE_CODE_INT
, 32 / 8,
3258 "int32_t", (struct objfile
*) NULL
);
3259 builtin_type_uint32
=
3260 init_type (TYPE_CODE_INT
, 32 / 8,
3262 "uint32_t", (struct objfile
*) NULL
);
3263 builtin_type_int64
=
3264 init_type (TYPE_CODE_INT
, 64 / 8,
3266 "int64_t", (struct objfile
*) NULL
);
3267 builtin_type_uint64
=
3268 init_type (TYPE_CODE_INT
, 64 / 8,
3270 "uint64_t", (struct objfile
*) NULL
);
3271 builtin_type_int128
=
3272 init_type (TYPE_CODE_INT
, 128 / 8,
3274 "int128_t", (struct objfile
*) NULL
);
3275 builtin_type_uint128
=
3276 init_type (TYPE_CODE_INT
, 128 / 8,
3278 "uint128_t", (struct objfile
*) NULL
);
3280 builtin_type_ieee_single
=
3281 build_flt (-1, "builtin_type_ieee_single", floatformats_ieee_single
);
3282 builtin_type_ieee_double
=
3283 build_flt (-1, "builtin_type_ieee_double", floatformats_ieee_double
);
3284 builtin_type_i387_ext
=
3285 build_flt (-1, "builtin_type_i387_ext", floatformats_i387_ext
);
3286 builtin_type_m68881_ext
=
3287 build_flt (-1, "builtin_type_m68881_ext", floatformats_m68881_ext
);
3288 builtin_type_arm_ext
=
3289 build_flt (-1, "builtin_type_arm_ext", floatformats_arm_ext
);
3290 builtin_type_ia64_spill
=
3291 build_flt (-1, "builtin_type_ia64_spill", floatformats_ia64_spill
);
3292 builtin_type_ia64_quad
=
3293 build_flt (-1, "builtin_type_ia64_quad", floatformats_ia64_quad
);
3296 init_type (TYPE_CODE_VOID
, 1,
3298 "void", (struct objfile
*) NULL
);
3299 builtin_type_true_char
=
3300 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3302 "true character", (struct objfile
*) NULL
);
3303 builtin_type_true_unsigned_char
=
3304 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3306 "true character", (struct objfile
*) NULL
);
3308 add_setshow_zinteger_cmd ("overload", no_class
, &overload_debug
, _("\
3309 Set debugging of C++ overloading."), _("\
3310 Show debugging of C++ overloading."), _("\
3311 When enabled, ranking of the functions is displayed."),
3313 show_overload_debug
,
3314 &setdebuglist
, &showdebuglist
);
3316 /* Add user knob for controlling resolution of opaque types. */
3317 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
3318 &opaque_type_resolution
, _("\
3319 Set resolution of opaque struct/class/union types (if set before loading symbols)."), _("\
3320 Show resolution of opaque struct/class/union types (if set before loading symbols)."), NULL
,
3322 show_opaque_type_resolution
,
3323 &setlist
, &showlist
);