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, 2009, 2010
5 Free Software Foundation, Inc.
7 Contributed by Cygnus Support, using pieces from other GDB modules.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "gdb_string.h"
31 #include "expression.h"
36 #include "complaints.h"
40 #include "gdb_assert.h"
44 /* Floatformat pairs. */
45 const struct floatformat
*floatformats_ieee_single
[BFD_ENDIAN_UNKNOWN
] = {
46 &floatformat_ieee_single_big
,
47 &floatformat_ieee_single_little
49 const struct floatformat
*floatformats_ieee_double
[BFD_ENDIAN_UNKNOWN
] = {
50 &floatformat_ieee_double_big
,
51 &floatformat_ieee_double_little
53 const struct floatformat
*floatformats_ieee_double_littlebyte_bigword
[BFD_ENDIAN_UNKNOWN
] = {
54 &floatformat_ieee_double_big
,
55 &floatformat_ieee_double_littlebyte_bigword
57 const struct floatformat
*floatformats_i387_ext
[BFD_ENDIAN_UNKNOWN
] = {
58 &floatformat_i387_ext
,
61 const struct floatformat
*floatformats_m68881_ext
[BFD_ENDIAN_UNKNOWN
] = {
62 &floatformat_m68881_ext
,
63 &floatformat_m68881_ext
65 const struct floatformat
*floatformats_arm_ext
[BFD_ENDIAN_UNKNOWN
] = {
66 &floatformat_arm_ext_big
,
67 &floatformat_arm_ext_littlebyte_bigword
69 const struct floatformat
*floatformats_ia64_spill
[BFD_ENDIAN_UNKNOWN
] = {
70 &floatformat_ia64_spill_big
,
71 &floatformat_ia64_spill_little
73 const struct floatformat
*floatformats_ia64_quad
[BFD_ENDIAN_UNKNOWN
] = {
74 &floatformat_ia64_quad_big
,
75 &floatformat_ia64_quad_little
77 const struct floatformat
*floatformats_vax_f
[BFD_ENDIAN_UNKNOWN
] = {
81 const struct floatformat
*floatformats_vax_d
[BFD_ENDIAN_UNKNOWN
] = {
85 const struct floatformat
*floatformats_ibm_long_double
[BFD_ENDIAN_UNKNOWN
] = {
86 &floatformat_ibm_long_double
,
87 &floatformat_ibm_long_double
91 int opaque_type_resolution
= 1;
93 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
94 struct cmd_list_element
*c
,
97 fprintf_filtered (file
, _("\
98 Resolution of opaque struct/class/union types (if set before loading symbols) is %s.\n"),
102 int overload_debug
= 0;
104 show_overload_debug (struct ui_file
*file
, int from_tty
,
105 struct cmd_list_element
*c
, const char *value
)
107 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"),
115 }; /* Maximum extension is 128! FIXME */
117 static void print_bit_vector (B_TYPE
*, int);
118 static void print_arg_types (struct field
*, int, int);
119 static void dump_fn_fieldlists (struct type
*, int);
120 static void print_cplus_stuff (struct type
*, int);
123 /* Allocate a new OBJFILE-associated type structure and fill it
124 with some defaults. Space for the type structure is allocated
125 on the objfile's objfile_obstack. */
128 alloc_type (struct objfile
*objfile
)
132 gdb_assert (objfile
!= NULL
);
134 /* Alloc the structure and start off with all fields zeroed. */
135 type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct type
);
136 TYPE_MAIN_TYPE (type
) = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
138 OBJSTAT (objfile
, n_types
++);
140 TYPE_OBJFILE_OWNED (type
) = 1;
141 TYPE_OWNER (type
).objfile
= objfile
;
143 /* Initialize the fields that might not be zero. */
145 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
146 TYPE_VPTR_FIELDNO (type
) = -1;
147 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
152 /* Allocate a new GDBARCH-associated type structure and fill it
153 with some defaults. Space for the type structure is allocated
157 alloc_type_arch (struct gdbarch
*gdbarch
)
161 gdb_assert (gdbarch
!= NULL
);
163 /* Alloc the structure and start off with all fields zeroed. */
165 type
= XZALLOC (struct type
);
166 TYPE_MAIN_TYPE (type
) = XZALLOC (struct main_type
);
168 TYPE_OBJFILE_OWNED (type
) = 0;
169 TYPE_OWNER (type
).gdbarch
= gdbarch
;
171 /* Initialize the fields that might not be zero. */
173 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
174 TYPE_VPTR_FIELDNO (type
) = -1;
175 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
180 /* If TYPE is objfile-associated, allocate a new type structure
181 associated with the same objfile. If TYPE is gdbarch-associated,
182 allocate a new type structure associated with the same gdbarch. */
185 alloc_type_copy (const struct type
*type
)
187 if (TYPE_OBJFILE_OWNED (type
))
188 return alloc_type (TYPE_OWNER (type
).objfile
);
190 return alloc_type_arch (TYPE_OWNER (type
).gdbarch
);
193 /* If TYPE is gdbarch-associated, return that architecture.
194 If TYPE is objfile-associated, return that objfile's architecture. */
197 get_type_arch (const struct type
*type
)
199 if (TYPE_OBJFILE_OWNED (type
))
200 return get_objfile_arch (TYPE_OWNER (type
).objfile
);
202 return TYPE_OWNER (type
).gdbarch
;
206 /* Alloc a new type instance structure, fill it with some defaults,
207 and point it at OLDTYPE. Allocate the new type instance from the
208 same place as OLDTYPE. */
211 alloc_type_instance (struct type
*oldtype
)
215 /* Allocate the structure. */
217 if (! TYPE_OBJFILE_OWNED (oldtype
))
218 type
= XZALLOC (struct type
);
220 type
= OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype
)->objfile_obstack
,
223 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
225 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
230 /* Clear all remnants of the previous type at TYPE, in preparation for
231 replacing it with something else. Preserve owner information. */
233 smash_type (struct type
*type
)
235 int objfile_owned
= TYPE_OBJFILE_OWNED (type
);
236 union type_owner owner
= TYPE_OWNER (type
);
238 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
240 /* Restore owner information. */
241 TYPE_OBJFILE_OWNED (type
) = objfile_owned
;
242 TYPE_OWNER (type
) = owner
;
244 /* For now, delete the rings. */
245 TYPE_CHAIN (type
) = type
;
247 /* For now, leave the pointer/reference types alone. */
250 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
251 to a pointer to memory where the pointer type should be stored.
252 If *TYPEPTR is zero, update it to point to the pointer type we return.
253 We allocate new memory if needed. */
256 make_pointer_type (struct type
*type
, struct type
**typeptr
)
258 struct type
*ntype
; /* New type */
261 ntype
= TYPE_POINTER_TYPE (type
);
266 return ntype
; /* Don't care about alloc,
267 and have new type. */
268 else if (*typeptr
== 0)
270 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
275 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
277 ntype
= alloc_type_copy (type
);
281 else /* We have storage, but need to reset it. */
284 chain
= TYPE_CHAIN (ntype
);
286 TYPE_CHAIN (ntype
) = chain
;
289 TYPE_TARGET_TYPE (ntype
) = type
;
290 TYPE_POINTER_TYPE (type
) = ntype
;
292 /* FIXME! Assume the machine has only one representation for
296 = gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
297 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
299 /* Mark pointers as unsigned. The target converts between pointers
300 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
301 gdbarch_address_to_pointer. */
302 TYPE_UNSIGNED (ntype
) = 1;
304 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
305 TYPE_POINTER_TYPE (type
) = ntype
;
307 /* Update the length of all the other variants of this type. */
308 chain
= TYPE_CHAIN (ntype
);
309 while (chain
!= ntype
)
311 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
312 chain
= TYPE_CHAIN (chain
);
318 /* Given a type TYPE, return a type of pointers to that type.
319 May need to construct such a type if this is the first use. */
322 lookup_pointer_type (struct type
*type
)
324 return make_pointer_type (type
, (struct type
**) 0);
327 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
328 points to a pointer to memory where the reference type should be
329 stored. If *TYPEPTR is zero, update it to point to the reference
330 type we return. We allocate new memory if needed. */
333 make_reference_type (struct type
*type
, struct type
**typeptr
)
335 struct type
*ntype
; /* New type */
338 ntype
= TYPE_REFERENCE_TYPE (type
);
343 return ntype
; /* Don't care about alloc,
344 and have new type. */
345 else if (*typeptr
== 0)
347 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
352 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
354 ntype
= alloc_type_copy (type
);
358 else /* We have storage, but need to reset it. */
361 chain
= TYPE_CHAIN (ntype
);
363 TYPE_CHAIN (ntype
) = chain
;
366 TYPE_TARGET_TYPE (ntype
) = type
;
367 TYPE_REFERENCE_TYPE (type
) = ntype
;
369 /* FIXME! Assume the machine has only one representation for
370 references, and that it matches the (only) representation for
373 TYPE_LENGTH (ntype
) =
374 gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
375 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
377 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
378 TYPE_REFERENCE_TYPE (type
) = ntype
;
380 /* Update the length of all the other variants of this type. */
381 chain
= TYPE_CHAIN (ntype
);
382 while (chain
!= ntype
)
384 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
385 chain
= TYPE_CHAIN (chain
);
391 /* Same as above, but caller doesn't care about memory allocation
395 lookup_reference_type (struct type
*type
)
397 return make_reference_type (type
, (struct type
**) 0);
400 /* Lookup a function type that returns type TYPE. TYPEPTR, if
401 nonzero, points to a pointer to memory where the function type
402 should be stored. If *TYPEPTR is zero, update it to point to the
403 function type we return. We allocate new memory if needed. */
406 make_function_type (struct type
*type
, struct type
**typeptr
)
408 struct type
*ntype
; /* New type */
410 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
412 ntype
= alloc_type_copy (type
);
416 else /* We have storage, but need to reset it. */
422 TYPE_TARGET_TYPE (ntype
) = type
;
424 TYPE_LENGTH (ntype
) = 1;
425 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
431 /* Given a type TYPE, return a type of functions that return that type.
432 May need to construct such a type if this is the first use. */
435 lookup_function_type (struct type
*type
)
437 return make_function_type (type
, (struct type
**) 0);
440 /* Identify address space identifier by name --
441 return the integer flag defined in gdbtypes.h. */
443 address_space_name_to_int (struct gdbarch
*gdbarch
, char *space_identifier
)
447 /* Check for known address space delimiters. */
448 if (!strcmp (space_identifier
, "code"))
449 return TYPE_INSTANCE_FLAG_CODE_SPACE
;
450 else if (!strcmp (space_identifier
, "data"))
451 return TYPE_INSTANCE_FLAG_DATA_SPACE
;
452 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
453 && gdbarch_address_class_name_to_type_flags (gdbarch
,
458 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
461 /* Identify address space identifier by integer flag as defined in
462 gdbtypes.h -- return the string version of the adress space name. */
465 address_space_int_to_name (struct gdbarch
*gdbarch
, int space_flag
)
467 if (space_flag
& TYPE_INSTANCE_FLAG_CODE_SPACE
)
469 else if (space_flag
& TYPE_INSTANCE_FLAG_DATA_SPACE
)
471 else if ((space_flag
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
472 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
473 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
478 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
480 If STORAGE is non-NULL, create the new type instance there.
481 STORAGE must be in the same obstack as TYPE. */
484 make_qualified_type (struct type
*type
, int new_flags
,
485 struct type
*storage
)
492 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
494 ntype
= TYPE_CHAIN (ntype
);
496 while (ntype
!= type
);
498 /* Create a new type instance. */
500 ntype
= alloc_type_instance (type
);
503 /* If STORAGE was provided, it had better be in the same objfile
504 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
505 if one objfile is freed and the other kept, we'd have
506 dangling pointers. */
507 gdb_assert (TYPE_OBJFILE (type
) == TYPE_OBJFILE (storage
));
510 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
511 TYPE_CHAIN (ntype
) = ntype
;
514 /* Pointers or references to the original type are not relevant to
516 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
517 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
519 /* Chain the new qualified type to the old type. */
520 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
521 TYPE_CHAIN (type
) = ntype
;
523 /* Now set the instance flags and return the new type. */
524 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
526 /* Set length of new type to that of the original type. */
527 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
532 /* Make an address-space-delimited variant of a type -- a type that
533 is identical to the one supplied except that it has an address
534 space attribute attached to it (such as "code" or "data").
536 The space attributes "code" and "data" are for Harvard
537 architectures. The address space attributes are for architectures
538 which have alternately sized pointers or pointers with alternate
542 make_type_with_address_space (struct type
*type
, int space_flag
)
544 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
545 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
546 | TYPE_INSTANCE_FLAG_DATA_SPACE
547 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
))
550 return make_qualified_type (type
, new_flags
, NULL
);
553 /* Make a "c-v" variant of a type -- a type that is identical to the
554 one supplied except that it may have const or volatile attributes
555 CNST is a flag for setting the const attribute
556 VOLTL is a flag for setting the volatile attribute
557 TYPE is the base type whose variant we are creating.
559 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
560 storage to hold the new qualified type; *TYPEPTR and TYPE must be
561 in the same objfile. Otherwise, allocate fresh memory for the new
562 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
563 new type we construct. */
565 make_cv_type (int cnst
, int voltl
,
567 struct type
**typeptr
)
569 struct type
*ntype
; /* New type */
571 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
572 & ~(TYPE_INSTANCE_FLAG_CONST
573 | TYPE_INSTANCE_FLAG_VOLATILE
));
576 new_flags
|= TYPE_INSTANCE_FLAG_CONST
;
579 new_flags
|= TYPE_INSTANCE_FLAG_VOLATILE
;
581 if (typeptr
&& *typeptr
!= NULL
)
583 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
584 a C-V variant chain that threads across objfiles: if one
585 objfile gets freed, then the other has a broken C-V chain.
587 This code used to try to copy over the main type from TYPE to
588 *TYPEPTR if they were in different objfiles, but that's
589 wrong, too: TYPE may have a field list or member function
590 lists, which refer to types of their own, etc. etc. The
591 whole shebang would need to be copied over recursively; you
592 can't have inter-objfile pointers. The only thing to do is
593 to leave stub types as stub types, and look them up afresh by
594 name each time you encounter them. */
595 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
));
598 ntype
= make_qualified_type (type
, new_flags
,
599 typeptr
? *typeptr
: NULL
);
607 /* Replace the contents of ntype with the type *type. This changes the
608 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
609 the changes are propogated to all types in the TYPE_CHAIN.
611 In order to build recursive types, it's inevitable that we'll need
612 to update types in place --- but this sort of indiscriminate
613 smashing is ugly, and needs to be replaced with something more
614 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
615 clear if more steps are needed. */
617 replace_type (struct type
*ntype
, struct type
*type
)
621 /* These two types had better be in the same objfile. Otherwise,
622 the assignment of one type's main type structure to the other
623 will produce a type with references to objects (names; field
624 lists; etc.) allocated on an objfile other than its own. */
625 gdb_assert (TYPE_OBJFILE (ntype
) == TYPE_OBJFILE (ntype
));
627 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
629 /* The type length is not a part of the main type. Update it for
630 each type on the variant chain. */
634 /* Assert that this element of the chain has no address-class bits
635 set in its flags. Such type variants might have type lengths
636 which are supposed to be different from the non-address-class
637 variants. This assertion shouldn't ever be triggered because
638 symbol readers which do construct address-class variants don't
639 call replace_type(). */
640 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
642 TYPE_LENGTH (chain
) = TYPE_LENGTH (type
);
643 chain
= TYPE_CHAIN (chain
);
645 while (ntype
!= chain
);
647 /* Assert that the two types have equivalent instance qualifiers.
648 This should be true for at least all of our debug readers. */
649 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
652 /* Implement direct support for MEMBER_TYPE in GNU C++.
653 May need to construct such a type if this is the first use.
654 The TYPE is the type of the member. The DOMAIN is the type
655 of the aggregate that the member belongs to. */
658 lookup_memberptr_type (struct type
*type
, struct type
*domain
)
662 mtype
= alloc_type_copy (type
);
663 smash_to_memberptr_type (mtype
, domain
, type
);
667 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
670 lookup_methodptr_type (struct type
*to_type
)
674 mtype
= alloc_type_copy (to_type
);
675 smash_to_methodptr_type (mtype
, to_type
);
679 /* Allocate a stub method whose return type is TYPE. This apparently
680 happens for speed of symbol reading, since parsing out the
681 arguments to the method is cpu-intensive, the way we are doing it.
682 So, we will fill in arguments later. This always returns a fresh
686 allocate_stub_method (struct type
*type
)
690 mtype
= alloc_type_copy (type
);
691 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
692 TYPE_LENGTH (mtype
) = 1;
693 TYPE_STUB (mtype
) = 1;
694 TYPE_TARGET_TYPE (mtype
) = type
;
695 /* _DOMAIN_TYPE (mtype) = unknown yet */
699 /* Create a range type using either a blank type supplied in
700 RESULT_TYPE, or creating a new type, inheriting the objfile from
703 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
704 to HIGH_BOUND, inclusive.
706 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
707 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
710 create_range_type (struct type
*result_type
, struct type
*index_type
,
711 LONGEST low_bound
, LONGEST high_bound
)
713 if (result_type
== NULL
)
714 result_type
= alloc_type_copy (index_type
);
715 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
716 TYPE_TARGET_TYPE (result_type
) = index_type
;
717 if (TYPE_STUB (index_type
))
718 TYPE_TARGET_STUB (result_type
) = 1;
720 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
721 TYPE_RANGE_DATA (result_type
) = (struct range_bounds
*)
722 TYPE_ZALLOC (result_type
, sizeof (struct range_bounds
));
723 TYPE_LOW_BOUND (result_type
) = low_bound
;
724 TYPE_HIGH_BOUND (result_type
) = high_bound
;
727 TYPE_UNSIGNED (result_type
) = 1;
732 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
733 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
734 bounds will fit in LONGEST), or -1 otherwise. */
737 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
739 CHECK_TYPEDEF (type
);
740 switch (TYPE_CODE (type
))
742 case TYPE_CODE_RANGE
:
743 *lowp
= TYPE_LOW_BOUND (type
);
744 *highp
= TYPE_HIGH_BOUND (type
);
747 if (TYPE_NFIELDS (type
) > 0)
749 /* The enums may not be sorted by value, so search all
753 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
754 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
756 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
757 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
758 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
759 *highp
= TYPE_FIELD_BITPOS (type
, i
);
762 /* Set unsigned indicator if warranted. */
765 TYPE_UNSIGNED (type
) = 1;
779 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
781 if (!TYPE_UNSIGNED (type
))
783 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
787 /* ... fall through for unsigned ints ... */
790 /* This round-about calculation is to avoid shifting by
791 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
792 if TYPE_LENGTH (type) == sizeof (LONGEST). */
793 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
794 *highp
= (*highp
- 1) | *highp
;
801 /* Create an array type using either a blank type supplied in
802 RESULT_TYPE, or creating a new type, inheriting the objfile from
805 Elements will be of type ELEMENT_TYPE, the indices will be of type
808 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
809 sure it is TYPE_CODE_UNDEF before we bash it into an array
813 create_array_type (struct type
*result_type
,
814 struct type
*element_type
,
815 struct type
*range_type
)
817 LONGEST low_bound
, high_bound
;
819 if (result_type
== NULL
)
820 result_type
= alloc_type_copy (range_type
);
822 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
823 TYPE_TARGET_TYPE (result_type
) = element_type
;
824 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
825 low_bound
= high_bound
= 0;
826 CHECK_TYPEDEF (element_type
);
827 /* Be careful when setting the array length. Ada arrays can be
828 empty arrays with the high_bound being smaller than the low_bound.
829 In such cases, the array length should be zero. */
830 if (high_bound
< low_bound
)
831 TYPE_LENGTH (result_type
) = 0;
833 TYPE_LENGTH (result_type
) =
834 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
835 TYPE_NFIELDS (result_type
) = 1;
836 TYPE_FIELDS (result_type
) =
837 (struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
));
838 TYPE_INDEX_TYPE (result_type
) = range_type
;
839 TYPE_VPTR_FIELDNO (result_type
) = -1;
841 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
842 if (TYPE_LENGTH (result_type
) == 0)
843 TYPE_TARGET_STUB (result_type
) = 1;
849 lookup_array_range_type (struct type
*element_type
,
850 int low_bound
, int high_bound
)
852 struct gdbarch
*gdbarch
= get_type_arch (element_type
);
853 struct type
*index_type
= builtin_type (gdbarch
)->builtin_int
;
854 struct type
*range_type
855 = create_range_type (NULL
, index_type
, low_bound
, high_bound
);
857 return create_array_type (NULL
, element_type
, range_type
);
860 /* Create a string type using either a blank type supplied in
861 RESULT_TYPE, or creating a new type. String types are similar
862 enough to array of char types that we can use create_array_type to
863 build the basic type and then bash it into a string type.
865 For fixed length strings, the range type contains 0 as the lower
866 bound and the length of the string minus one as the upper bound.
868 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
869 sure it is TYPE_CODE_UNDEF before we bash it into a string
873 create_string_type (struct type
*result_type
,
874 struct type
*string_char_type
,
875 struct type
*range_type
)
877 result_type
= create_array_type (result_type
,
880 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
885 lookup_string_range_type (struct type
*string_char_type
,
886 int low_bound
, int high_bound
)
888 struct type
*result_type
;
890 result_type
= lookup_array_range_type (string_char_type
,
891 low_bound
, high_bound
);
892 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
897 create_set_type (struct type
*result_type
, struct type
*domain_type
)
899 if (result_type
== NULL
)
900 result_type
= alloc_type_copy (domain_type
);
902 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
903 TYPE_NFIELDS (result_type
) = 1;
904 TYPE_FIELDS (result_type
) = TYPE_ZALLOC (result_type
, sizeof (struct field
));
906 if (!TYPE_STUB (domain_type
))
908 LONGEST low_bound
, high_bound
, bit_length
;
910 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
911 low_bound
= high_bound
= 0;
912 bit_length
= high_bound
- low_bound
+ 1;
913 TYPE_LENGTH (result_type
)
914 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
916 TYPE_UNSIGNED (result_type
) = 1;
918 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
923 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
924 and any array types nested inside it. */
927 make_vector_type (struct type
*array_type
)
929 struct type
*inner_array
, *elt_type
;
932 /* Find the innermost array type, in case the array is
933 multi-dimensional. */
934 inner_array
= array_type
;
935 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
936 inner_array
= TYPE_TARGET_TYPE (inner_array
);
938 elt_type
= TYPE_TARGET_TYPE (inner_array
);
939 if (TYPE_CODE (elt_type
) == TYPE_CODE_INT
)
941 flags
= TYPE_INSTANCE_FLAGS (elt_type
) | TYPE_FLAG_NOTTEXT
;
942 elt_type
= make_qualified_type (elt_type
, flags
, NULL
);
943 TYPE_TARGET_TYPE (inner_array
) = elt_type
;
946 TYPE_VECTOR (array_type
) = 1;
950 init_vector_type (struct type
*elt_type
, int n
)
952 struct type
*array_type
;
954 array_type
= lookup_array_range_type (elt_type
, 0, n
- 1);
955 make_vector_type (array_type
);
959 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
960 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
961 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
962 TYPE doesn't include the offset (that's the value of the MEMBER
963 itself), but does include the structure type into which it points
966 When "smashing" the type, we preserve the objfile that the old type
967 pointed to, since we aren't changing where the type is actually
971 smash_to_memberptr_type (struct type
*type
, struct type
*domain
,
972 struct type
*to_type
)
975 TYPE_TARGET_TYPE (type
) = to_type
;
976 TYPE_DOMAIN_TYPE (type
) = domain
;
977 /* Assume that a data member pointer is the same size as a normal
980 = gdbarch_ptr_bit (get_type_arch (to_type
)) / TARGET_CHAR_BIT
;
981 TYPE_CODE (type
) = TYPE_CODE_MEMBERPTR
;
984 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
986 When "smashing" the type, we preserve the objfile that the old type
987 pointed to, since we aren't changing where the type is actually
991 smash_to_methodptr_type (struct type
*type
, struct type
*to_type
)
994 TYPE_TARGET_TYPE (type
) = to_type
;
995 TYPE_DOMAIN_TYPE (type
) = TYPE_DOMAIN_TYPE (to_type
);
996 TYPE_LENGTH (type
) = cplus_method_ptr_size (to_type
);
997 TYPE_CODE (type
) = TYPE_CODE_METHODPTR
;
1000 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
1001 METHOD just means `function that gets an extra "this" argument'.
1003 When "smashing" the type, we preserve the objfile that the old type
1004 pointed to, since we aren't changing where the type is actually
1008 smash_to_method_type (struct type
*type
, struct type
*domain
,
1009 struct type
*to_type
, struct field
*args
,
1010 int nargs
, int varargs
)
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_VARARGS (type
) = 1;
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 (const struct language_defn
*language
,
1044 struct gdbarch
*gdbarch
, char *name
,
1045 struct block
*block
, int noerr
)
1050 sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, 0);
1051 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1053 tmp
= language_lookup_primitive_type_by_name (language
, gdbarch
, name
);
1058 else if (!tmp
&& noerr
)
1064 error (_("No type named %s."), name
);
1067 return (SYMBOL_TYPE (sym
));
1071 lookup_unsigned_typename (const struct language_defn
*language
,
1072 struct gdbarch
*gdbarch
, char *name
)
1074 char *uns
= alloca (strlen (name
) + 10);
1076 strcpy (uns
, "unsigned ");
1077 strcpy (uns
+ 9, name
);
1078 return lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 0);
1082 lookup_signed_typename (const struct language_defn
*language
,
1083 struct gdbarch
*gdbarch
, char *name
)
1086 char *uns
= alloca (strlen (name
) + 8);
1088 strcpy (uns
, "signed ");
1089 strcpy (uns
+ 7, name
);
1090 t
= lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 1);
1091 /* If we don't find "signed FOO" just try again with plain "FOO". */
1094 return lookup_typename (language
, gdbarch
, name
, (struct block
*) NULL
, 0);
1097 /* Lookup a structure type named "struct NAME",
1098 visible in lexical block BLOCK. */
1101 lookup_struct (char *name
, struct block
*block
)
1105 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1109 error (_("No struct type named %s."), name
);
1111 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1113 error (_("This context has class, union or enum %s, not a struct."),
1116 return (SYMBOL_TYPE (sym
));
1119 /* Lookup a union type named "union NAME",
1120 visible in lexical block BLOCK. */
1123 lookup_union (char *name
, struct block
*block
)
1128 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1131 error (_("No union type named %s."), name
);
1133 t
= SYMBOL_TYPE (sym
);
1135 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1138 /* If we get here, it's not a union. */
1139 error (_("This context has class, struct or enum %s, not a union."),
1144 /* Lookup an enum type named "enum NAME",
1145 visible in lexical block BLOCK. */
1148 lookup_enum (char *name
, struct block
*block
)
1152 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1155 error (_("No enum type named %s."), name
);
1157 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1159 error (_("This context has class, struct or union %s, not an enum."),
1162 return (SYMBOL_TYPE (sym
));
1165 /* Lookup a template type named "template NAME<TYPE>",
1166 visible in lexical block BLOCK. */
1169 lookup_template_type (char *name
, struct type
*type
,
1170 struct block
*block
)
1173 char *nam
= (char *)
1174 alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1178 strcat (nam
, TYPE_NAME (type
));
1179 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1181 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0);
1185 error (_("No template type named %s."), name
);
1187 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1189 error (_("This context has class, union or enum %s, not a struct."),
1192 return (SYMBOL_TYPE (sym
));
1195 /* Given a type TYPE, lookup the type of the component of type named
1198 TYPE can be either a struct or union, or a pointer or reference to
1199 a struct or union. If it is a pointer or reference, its target
1200 type is automatically used. Thus '.' and '->' are interchangable,
1201 as specified for the definitions of the expression element types
1202 STRUCTOP_STRUCT and STRUCTOP_PTR.
1204 If NOERR is nonzero, return zero if NAME is not suitably defined.
1205 If NAME is the name of a baseclass type, return that type. */
1208 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
1214 CHECK_TYPEDEF (type
);
1215 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1216 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1218 type
= TYPE_TARGET_TYPE (type
);
1221 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1222 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1224 target_terminal_ours ();
1225 gdb_flush (gdb_stdout
);
1226 fprintf_unfiltered (gdb_stderr
, "Type ");
1227 type_print (type
, "", gdb_stderr
, -1);
1228 error (_(" is not a structure or union type."));
1232 /* FIXME: This change put in by Michael seems incorrect for the case
1233 where the structure tag name is the same as the member name.
1234 I.E. when doing "ptype bell->bar" for "struct foo { int bar; int
1235 foo; } bell;" Disabled by fnf. */
1239 typename
= type_name_no_tag (type
);
1240 if (typename
!= NULL
&& strcmp (typename
, name
) == 0)
1245 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1247 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1249 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1251 return TYPE_FIELD_TYPE (type
, i
);
1253 else if (!t_field_name
|| *t_field_name
== '\0')
1255 struct type
*subtype
1256 = lookup_struct_elt_type (TYPE_FIELD_TYPE (type
, i
), name
, 1);
1258 if (subtype
!= NULL
)
1263 /* OK, it's not in this class. Recursively check the baseclasses. */
1264 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1268 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, 1);
1280 target_terminal_ours ();
1281 gdb_flush (gdb_stdout
);
1282 fprintf_unfiltered (gdb_stderr
, "Type ");
1283 type_print (type
, "", gdb_stderr
, -1);
1284 fprintf_unfiltered (gdb_stderr
, " has no component named ");
1285 fputs_filtered (name
, gdb_stderr
);
1287 return (struct type
*) -1; /* For lint */
1290 /* Lookup the vptr basetype/fieldno values for TYPE.
1291 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1292 vptr_fieldno. Also, if found and basetype is from the same objfile,
1294 If not found, return -1 and ignore BASETYPEP.
1295 Callers should be aware that in some cases (for example,
1296 the type or one of its baseclasses is a stub type and we are
1297 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1298 this function will not be able to find the
1299 virtual function table pointer, and vptr_fieldno will remain -1 and
1300 vptr_basetype will remain NULL or incomplete. */
1303 get_vptr_fieldno (struct type
*type
, struct type
**basetypep
)
1305 CHECK_TYPEDEF (type
);
1307 if (TYPE_VPTR_FIELDNO (type
) < 0)
1311 /* We must start at zero in case the first (and only) baseclass
1312 is virtual (and hence we cannot share the table pointer). */
1313 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1315 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1317 struct type
*basetype
;
1319 fieldno
= get_vptr_fieldno (baseclass
, &basetype
);
1322 /* If the type comes from a different objfile we can't cache
1323 it, it may have a different lifetime. PR 2384 */
1324 if (TYPE_OBJFILE (type
) == TYPE_OBJFILE (basetype
))
1326 TYPE_VPTR_FIELDNO (type
) = fieldno
;
1327 TYPE_VPTR_BASETYPE (type
) = basetype
;
1330 *basetypep
= basetype
;
1341 *basetypep
= TYPE_VPTR_BASETYPE (type
);
1342 return TYPE_VPTR_FIELDNO (type
);
1347 stub_noname_complaint (void)
1349 complaint (&symfile_complaints
, _("stub type has NULL name"));
1352 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1354 If this is a stubbed struct (i.e. declared as struct foo *), see if
1355 we can find a full definition in some other file. If so, copy this
1356 definition, so we can use it in future. There used to be a comment
1357 (but not any code) that if we don't find a full definition, we'd
1358 set a flag so we don't spend time in the future checking the same
1359 type. That would be a mistake, though--we might load in more
1360 symbols which contain a full definition for the type.
1362 This used to be coded as a macro, but I don't think it is called
1363 often enough to merit such treatment.
1365 Find the real type of TYPE. This function returns the real type,
1366 after removing all layers of typedefs and completing opaque or stub
1367 types. Completion changes the TYPE argument, but stripping of
1370 If TYPE is a TYPE_CODE_TYPEDEF, its length is (also) set to the length of
1371 the target type instead of zero. However, in the case of TYPE_CODE_TYPEDEF
1372 check_typedef can still return different type than the original TYPE
1376 check_typedef (struct type
*type
)
1378 struct type
*orig_type
= type
;
1379 int is_const
, is_volatile
;
1383 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1385 if (!TYPE_TARGET_TYPE (type
))
1390 /* It is dangerous to call lookup_symbol if we are currently
1391 reading a symtab. Infinite recursion is one danger. */
1392 if (currently_reading_symtab
)
1395 name
= type_name_no_tag (type
);
1396 /* FIXME: shouldn't we separately check the TYPE_NAME and
1397 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1398 VAR_DOMAIN as appropriate? (this code was written before
1399 TYPE_NAME and TYPE_TAG_NAME were separate). */
1402 stub_noname_complaint ();
1405 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1407 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1408 else /* TYPE_CODE_UNDEF */
1409 TYPE_TARGET_TYPE (type
) = alloc_type_arch (get_type_arch (type
));
1411 type
= TYPE_TARGET_TYPE (type
);
1414 is_const
= TYPE_CONST (type
);
1415 is_volatile
= TYPE_VOLATILE (type
);
1417 /* If this is a struct/class/union with no fields, then check
1418 whether a full definition exists somewhere else. This is for
1419 systems where a type definition with no fields is issued for such
1420 types, instead of identifying them as stub types in the first
1423 if (TYPE_IS_OPAQUE (type
)
1424 && opaque_type_resolution
1425 && !currently_reading_symtab
)
1427 char *name
= type_name_no_tag (type
);
1428 struct type
*newtype
;
1432 stub_noname_complaint ();
1435 newtype
= lookup_transparent_type (name
);
1439 /* If the resolved type and the stub are in the same
1440 objfile, then replace the stub type with the real deal.
1441 But if they're in separate objfiles, leave the stub
1442 alone; we'll just look up the transparent type every time
1443 we call check_typedef. We can't create pointers between
1444 types allocated to different objfiles, since they may
1445 have different lifetimes. Trying to copy NEWTYPE over to
1446 TYPE's objfile is pointless, too, since you'll have to
1447 move over any other types NEWTYPE refers to, which could
1448 be an unbounded amount of stuff. */
1449 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
1450 make_cv_type (is_const
, is_volatile
, newtype
, &type
);
1455 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1457 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1459 char *name
= type_name_no_tag (type
);
1460 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1461 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1462 as appropriate? (this code was written before TYPE_NAME and
1463 TYPE_TAG_NAME were separate). */
1468 stub_noname_complaint ();
1471 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1474 /* Same as above for opaque types, we can replace the stub
1475 with the complete type only if they are int the same
1477 if (TYPE_OBJFILE (SYMBOL_TYPE(sym
)) == TYPE_OBJFILE (type
))
1478 make_cv_type (is_const
, is_volatile
,
1479 SYMBOL_TYPE (sym
), &type
);
1481 type
= SYMBOL_TYPE (sym
);
1485 if (TYPE_TARGET_STUB (type
))
1487 struct type
*range_type
;
1488 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1490 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1494 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1495 && TYPE_NFIELDS (type
) == 1
1496 && (TYPE_CODE (range_type
= TYPE_INDEX_TYPE (type
))
1497 == TYPE_CODE_RANGE
))
1499 /* Now recompute the length of the array type, based on its
1500 number of elements and the target type's length.
1501 Watch out for Ada null Ada arrays where the high bound
1502 is smaller than the low bound. */
1503 const LONGEST low_bound
= TYPE_LOW_BOUND (range_type
);
1504 const LONGEST high_bound
= TYPE_HIGH_BOUND (range_type
);
1507 if (high_bound
< low_bound
)
1511 /* For now, we conservatively take the array length to be 0
1512 if its length exceeds UINT_MAX. The code below assumes
1513 that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
1514 which is technically not guaranteed by C, but is usually true
1515 (because it would be true if x were unsigned with its
1516 high-order bit on). It uses the fact that
1517 high_bound-low_bound is always representable in
1518 ULONGEST and that if high_bound-low_bound+1 overflows,
1519 it overflows to 0. We must change these tests if we
1520 decide to increase the representation of TYPE_LENGTH
1521 from unsigned int to ULONGEST. */
1522 ULONGEST ulow
= low_bound
, uhigh
= high_bound
;
1523 ULONGEST tlen
= TYPE_LENGTH (target_type
);
1525 len
= tlen
* (uhigh
- ulow
+ 1);
1526 if (tlen
== 0 || (len
/ tlen
- 1 + ulow
) != uhigh
1530 TYPE_LENGTH (type
) = len
;
1531 TYPE_TARGET_STUB (type
) = 0;
1533 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1535 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1536 TYPE_TARGET_STUB (type
) = 0;
1539 /* Cache TYPE_LENGTH for future use. */
1540 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1544 /* Parse a type expression in the string [P..P+LENGTH). If an error
1545 occurs, silently return a void type. */
1547 static struct type
*
1548 safe_parse_type (struct gdbarch
*gdbarch
, char *p
, int length
)
1550 struct ui_file
*saved_gdb_stderr
;
1553 /* Suppress error messages. */
1554 saved_gdb_stderr
= gdb_stderr
;
1555 gdb_stderr
= ui_file_new ();
1557 /* Call parse_and_eval_type() without fear of longjmp()s. */
1558 if (!gdb_parse_and_eval_type (p
, length
, &type
))
1559 type
= builtin_type (gdbarch
)->builtin_void
;
1561 /* Stop suppressing error messages. */
1562 ui_file_delete (gdb_stderr
);
1563 gdb_stderr
= saved_gdb_stderr
;
1568 /* Ugly hack to convert method stubs into method types.
1570 He ain't kiddin'. This demangles the name of the method into a
1571 string including argument types, parses out each argument type,
1572 generates a string casting a zero to that type, evaluates the
1573 string, and stuffs the resulting type into an argtype vector!!!
1574 Then it knows the type of the whole function (including argument
1575 types for overloading), which info used to be in the stab's but was
1576 removed to hack back the space required for them. */
1579 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1581 struct gdbarch
*gdbarch
= get_type_arch (type
);
1583 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1584 char *demangled_name
= cplus_demangle (mangled_name
,
1585 DMGL_PARAMS
| DMGL_ANSI
);
1586 char *argtypetext
, *p
;
1587 int depth
= 0, argcount
= 1;
1588 struct field
*argtypes
;
1591 /* Make sure we got back a function string that we can use. */
1593 p
= strchr (demangled_name
, '(');
1597 if (demangled_name
== NULL
|| p
== NULL
)
1598 error (_("Internal: Cannot demangle mangled name `%s'."),
1601 /* Now, read in the parameters that define this type. */
1606 if (*p
== '(' || *p
== '<')
1610 else if (*p
== ')' || *p
== '>')
1614 else if (*p
== ',' && depth
== 0)
1622 /* If we read one argument and it was ``void'', don't count it. */
1623 if (strncmp (argtypetext
, "(void)", 6) == 0)
1626 /* We need one extra slot, for the THIS pointer. */
1628 argtypes
= (struct field
*)
1629 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
1632 /* Add THIS pointer for non-static methods. */
1633 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1634 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
1638 argtypes
[0].type
= lookup_pointer_type (type
);
1642 if (*p
!= ')') /* () means no args, skip while */
1647 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1649 /* Avoid parsing of ellipsis, they will be handled below.
1650 Also avoid ``void'' as above. */
1651 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
1652 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
1654 argtypes
[argcount
].type
=
1655 safe_parse_type (gdbarch
, argtypetext
, p
- argtypetext
);
1658 argtypetext
= p
+ 1;
1661 if (*p
== '(' || *p
== '<')
1665 else if (*p
== ')' || *p
== '>')
1674 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1676 /* Now update the old "stub" type into a real type. */
1677 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1678 TYPE_DOMAIN_TYPE (mtype
) = type
;
1679 TYPE_FIELDS (mtype
) = argtypes
;
1680 TYPE_NFIELDS (mtype
) = argcount
;
1681 TYPE_STUB (mtype
) = 0;
1682 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1684 TYPE_VARARGS (mtype
) = 1;
1686 xfree (demangled_name
);
1689 /* This is the external interface to check_stub_method, above. This
1690 function unstubs all of the signatures for TYPE's METHOD_ID method
1691 name. After calling this function TYPE_FN_FIELD_STUB will be
1692 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1695 This function unfortunately can not die until stabs do. */
1698 check_stub_method_group (struct type
*type
, int method_id
)
1700 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
1701 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1702 int j
, found_stub
= 0;
1704 for (j
= 0; j
< len
; j
++)
1705 if (TYPE_FN_FIELD_STUB (f
, j
))
1708 check_stub_method (type
, method_id
, j
);
1711 /* GNU v3 methods with incorrect names were corrected when we read
1712 in type information, because it was cheaper to do it then. The
1713 only GNU v2 methods with incorrect method names are operators and
1714 destructors; destructors were also corrected when we read in type
1717 Therefore the only thing we need to handle here are v2 operator
1719 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
1722 char dem_opname
[256];
1724 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1726 dem_opname
, DMGL_ANSI
);
1728 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1732 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
1736 const struct cplus_struct_type cplus_struct_default
;
1739 allocate_cplus_struct_type (struct type
*type
)
1741 if (HAVE_CPLUS_STRUCT (type
))
1742 /* Structure was already allocated. Nothing more to do. */
1745 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_CPLUS_STUFF
;
1746 TYPE_RAW_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1747 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1748 *(TYPE_RAW_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1751 const struct gnat_aux_type gnat_aux_default
=
1754 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
1755 and allocate the associated gnat-specific data. The gnat-specific
1756 data is also initialized to gnat_aux_default. */
1758 allocate_gnat_aux_type (struct type
*type
)
1760 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_GNAT_STUFF
;
1761 TYPE_GNAT_SPECIFIC (type
) = (struct gnat_aux_type
*)
1762 TYPE_ALLOC (type
, sizeof (struct gnat_aux_type
));
1763 *(TYPE_GNAT_SPECIFIC (type
)) = gnat_aux_default
;
1767 /* Helper function to initialize the standard scalar types.
1769 If NAME is non-NULL, then we make a copy of the string pointed
1770 to by name in the objfile_obstack for that objfile, and initialize
1771 the type name to that copy. There are places (mipsread.c in particular),
1772 where init_type is called with a NULL value for NAME). */
1775 init_type (enum type_code code
, int length
, int flags
,
1776 char *name
, struct objfile
*objfile
)
1780 type
= alloc_type (objfile
);
1781 TYPE_CODE (type
) = code
;
1782 TYPE_LENGTH (type
) = length
;
1784 gdb_assert (!(flags
& (TYPE_FLAG_MIN
- 1)));
1785 if (flags
& TYPE_FLAG_UNSIGNED
)
1786 TYPE_UNSIGNED (type
) = 1;
1787 if (flags
& TYPE_FLAG_NOSIGN
)
1788 TYPE_NOSIGN (type
) = 1;
1789 if (flags
& TYPE_FLAG_STUB
)
1790 TYPE_STUB (type
) = 1;
1791 if (flags
& TYPE_FLAG_TARGET_STUB
)
1792 TYPE_TARGET_STUB (type
) = 1;
1793 if (flags
& TYPE_FLAG_STATIC
)
1794 TYPE_STATIC (type
) = 1;
1795 if (flags
& TYPE_FLAG_PROTOTYPED
)
1796 TYPE_PROTOTYPED (type
) = 1;
1797 if (flags
& TYPE_FLAG_INCOMPLETE
)
1798 TYPE_INCOMPLETE (type
) = 1;
1799 if (flags
& TYPE_FLAG_VARARGS
)
1800 TYPE_VARARGS (type
) = 1;
1801 if (flags
& TYPE_FLAG_VECTOR
)
1802 TYPE_VECTOR (type
) = 1;
1803 if (flags
& TYPE_FLAG_STUB_SUPPORTED
)
1804 TYPE_STUB_SUPPORTED (type
) = 1;
1805 if (flags
& TYPE_FLAG_NOTTEXT
)
1806 TYPE_NOTTEXT (type
) = 1;
1807 if (flags
& TYPE_FLAG_FIXED_INSTANCE
)
1808 TYPE_FIXED_INSTANCE (type
) = 1;
1811 TYPE_NAME (type
) = obsavestring (name
, strlen (name
),
1812 &objfile
->objfile_obstack
);
1816 if (name
&& strcmp (name
, "char") == 0)
1817 TYPE_NOSIGN (type
) = 1;
1821 case TYPE_CODE_STRUCT
:
1822 case TYPE_CODE_UNION
:
1823 case TYPE_CODE_NAMESPACE
:
1824 INIT_CPLUS_SPECIFIC (type
);
1827 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_FLOATFORMAT
;
1829 case TYPE_CODE_FUNC
:
1830 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_CALLING_CONVENTION
;
1837 can_dereference (struct type
*t
)
1839 /* FIXME: Should we return true for references as well as
1844 && TYPE_CODE (t
) == TYPE_CODE_PTR
1845 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1849 is_integral_type (struct type
*t
)
1854 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
1855 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
1856 || (TYPE_CODE (t
) == TYPE_CODE_FLAGS
)
1857 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
1858 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
1859 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
1862 /* A helper function which returns true if types A and B represent the
1863 "same" class type. This is true if the types have the same main
1864 type, or the same name. */
1867 class_types_same_p (const struct type
*a
, const struct type
*b
)
1869 return (TYPE_MAIN_TYPE (a
) == TYPE_MAIN_TYPE (b
)
1870 || (TYPE_NAME (a
) && TYPE_NAME (b
)
1871 && !strcmp (TYPE_NAME (a
), TYPE_NAME (b
))));
1874 /* Check whether BASE is an ancestor or base class or DCLASS
1875 Return 1 if so, and 0 if not.
1876 Note: callers may want to check for identity of the types before
1877 calling this function -- identical types are considered to satisfy
1878 the ancestor relationship even if they're identical. */
1881 is_ancestor (struct type
*base
, struct type
*dclass
)
1885 CHECK_TYPEDEF (base
);
1886 CHECK_TYPEDEF (dclass
);
1888 if (class_types_same_p (base
, dclass
))
1891 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1893 if (is_ancestor (base
, TYPE_BASECLASS (dclass
, i
)))
1900 /* Like is_ancestor, but only returns true when BASE is a public
1901 ancestor of DCLASS. */
1904 is_public_ancestor (struct type
*base
, struct type
*dclass
)
1908 CHECK_TYPEDEF (base
);
1909 CHECK_TYPEDEF (dclass
);
1911 if (class_types_same_p (base
, dclass
))
1914 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); ++i
)
1916 if (! BASETYPE_VIA_PUBLIC (dclass
, i
))
1918 if (is_public_ancestor (base
, TYPE_BASECLASS (dclass
, i
)))
1925 /* A helper function for is_unique_ancestor. */
1928 is_unique_ancestor_worker (struct type
*base
, struct type
*dclass
,
1930 const bfd_byte
*contents
, CORE_ADDR address
)
1934 CHECK_TYPEDEF (base
);
1935 CHECK_TYPEDEF (dclass
);
1937 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
) && count
< 2; ++i
)
1939 struct type
*iter
= check_typedef (TYPE_BASECLASS (dclass
, i
));
1940 int this_offset
= baseclass_offset (dclass
, i
, contents
, address
);
1942 if (this_offset
== -1)
1943 error (_("virtual baseclass botch"));
1945 if (class_types_same_p (base
, iter
))
1947 /* If this is the first subclass, set *OFFSET and set count
1948 to 1. Otherwise, if this is at the same offset as
1949 previous instances, do nothing. Otherwise, increment
1953 *offset
= this_offset
;
1956 else if (this_offset
== *offset
)
1964 count
+= is_unique_ancestor_worker (base
, iter
, offset
,
1965 contents
+ this_offset
,
1966 address
+ this_offset
);
1972 /* Like is_ancestor, but only returns true if BASE is a unique base
1973 class of the type of VAL. */
1976 is_unique_ancestor (struct type
*base
, struct value
*val
)
1980 return is_unique_ancestor_worker (base
, value_type (val
), &offset
,
1981 value_contents (val
),
1982 value_address (val
)) == 1;
1988 /* Functions for overload resolution begin here */
1990 /* Compare two badness vectors A and B and return the result.
1991 0 => A and B are identical
1992 1 => A and B are incomparable
1993 2 => A is better than B
1994 3 => A is worse than B */
1997 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
2001 short found_pos
= 0; /* any positives in c? */
2002 short found_neg
= 0; /* any negatives in c? */
2004 /* differing lengths => incomparable */
2005 if (a
->length
!= b
->length
)
2008 /* Subtract b from a */
2009 for (i
= 0; i
< a
->length
; i
++)
2011 tmp
= a
->rank
[i
] - b
->rank
[i
];
2021 return 1; /* incomparable */
2023 return 3; /* A > B */
2029 return 2; /* A < B */
2031 return 0; /* A == B */
2035 /* Rank a function by comparing its parameter types (PARMS, length
2036 NPARMS), to the types of an argument list (ARGS, length NARGS).
2037 Return a pointer to a badness vector. This has NARGS + 1
2040 struct badness_vector
*
2041 rank_function (struct type
**parms
, int nparms
,
2042 struct type
**args
, int nargs
)
2045 struct badness_vector
*bv
;
2046 int min_len
= nparms
< nargs
? nparms
: nargs
;
2048 bv
= xmalloc (sizeof (struct badness_vector
));
2049 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank */
2050 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
2052 /* First compare the lengths of the supplied lists.
2053 If there is a mismatch, set it to a high value. */
2055 /* pai/1997-06-03 FIXME: when we have debug info about default
2056 arguments and ellipsis parameter lists, we should consider those
2057 and rank the length-match more finely. */
2059 LENGTH_MATCH (bv
) = (nargs
!= nparms
) ? LENGTH_MISMATCH_BADNESS
: 0;
2061 /* Now rank all the parameters of the candidate function */
2062 for (i
= 1; i
<= min_len
; i
++)
2063 bv
->rank
[i
] = rank_one_type (parms
[i
-1], args
[i
-1]);
2065 /* If more arguments than parameters, add dummy entries */
2066 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2067 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2072 /* Compare the names of two integer types, assuming that any sign
2073 qualifiers have been checked already. We do it this way because
2074 there may be an "int" in the name of one of the types. */
2077 integer_types_same_name_p (const char *first
, const char *second
)
2079 int first_p
, second_p
;
2081 /* If both are shorts, return 1; if neither is a short, keep
2083 first_p
= (strstr (first
, "short") != NULL
);
2084 second_p
= (strstr (second
, "short") != NULL
);
2085 if (first_p
&& second_p
)
2087 if (first_p
|| second_p
)
2090 /* Likewise for long. */
2091 first_p
= (strstr (first
, "long") != NULL
);
2092 second_p
= (strstr (second
, "long") != NULL
);
2093 if (first_p
&& second_p
)
2095 if (first_p
|| second_p
)
2098 /* Likewise for char. */
2099 first_p
= (strstr (first
, "char") != NULL
);
2100 second_p
= (strstr (second
, "char") != NULL
);
2101 if (first_p
&& second_p
)
2103 if (first_p
|| second_p
)
2106 /* They must both be ints. */
2110 /* Compare one type (PARM) for compatibility with another (ARG).
2111 * PARM is intended to be the parameter type of a function; and
2112 * ARG is the supplied argument's type. This function tests if
2113 * the latter can be converted to the former.
2115 * Return 0 if they are identical types;
2116 * Otherwise, return an integer which corresponds to how compatible
2117 * PARM is to ARG. The higher the return value, the worse the match.
2118 * Generally the "bad" conversions are all uniformly assigned a 100. */
2121 rank_one_type (struct type
*parm
, struct type
*arg
)
2123 /* Identical type pointers. */
2124 /* However, this still doesn't catch all cases of same type for arg
2125 and param. The reason is that builtin types are different from
2126 the same ones constructed from the object. */
2130 /* Resolve typedefs */
2131 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2132 parm
= check_typedef (parm
);
2133 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2134 arg
= check_typedef (arg
);
2137 Well, damnit, if the names are exactly the same, I'll say they
2138 are exactly the same. This happens when we generate method
2139 stubs. The types won't point to the same address, but they
2140 really are the same.
2143 if (TYPE_NAME (parm
) && TYPE_NAME (arg
)
2144 && !strcmp (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2147 /* Check if identical after resolving typedefs. */
2151 /* See through references, since we can almost make non-references
2153 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2154 return (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
))
2155 + REFERENCE_CONVERSION_BADNESS
);
2156 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2157 return (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
)
2158 + REFERENCE_CONVERSION_BADNESS
);
2160 /* Debugging only. */
2161 fprintf_filtered (gdb_stderr
,
2162 "------ Arg is %s [%d], parm is %s [%d]\n",
2163 TYPE_NAME (arg
), TYPE_CODE (arg
),
2164 TYPE_NAME (parm
), TYPE_CODE (parm
));
2166 /* x -> y means arg of type x being supplied for parameter of type y */
2168 switch (TYPE_CODE (parm
))
2171 switch (TYPE_CODE (arg
))
2174 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
2175 && TYPE_CODE (TYPE_TARGET_TYPE (arg
)) != TYPE_CODE_VOID
)
2176 return VOID_PTR_CONVERSION_BADNESS
;
2178 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2179 TYPE_TARGET_TYPE (arg
));
2180 case TYPE_CODE_ARRAY
:
2181 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2182 TYPE_TARGET_TYPE (arg
));
2183 case TYPE_CODE_FUNC
:
2184 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
);
2186 case TYPE_CODE_ENUM
:
2187 case TYPE_CODE_FLAGS
:
2188 case TYPE_CODE_CHAR
:
2189 case TYPE_CODE_RANGE
:
2190 case TYPE_CODE_BOOL
:
2191 return POINTER_CONVERSION_BADNESS
;
2193 return INCOMPATIBLE_TYPE_BADNESS
;
2195 case TYPE_CODE_ARRAY
:
2196 switch (TYPE_CODE (arg
))
2199 case TYPE_CODE_ARRAY
:
2200 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2201 TYPE_TARGET_TYPE (arg
));
2203 return INCOMPATIBLE_TYPE_BADNESS
;
2205 case TYPE_CODE_FUNC
:
2206 switch (TYPE_CODE (arg
))
2208 case TYPE_CODE_PTR
: /* funcptr -> func */
2209 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
));
2211 return INCOMPATIBLE_TYPE_BADNESS
;
2214 switch (TYPE_CODE (arg
))
2217 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2219 /* Deal with signed, unsigned, and plain chars and
2220 signed and unsigned ints. */
2221 if (TYPE_NOSIGN (parm
))
2223 /* This case only for character types */
2224 if (TYPE_NOSIGN (arg
))
2225 return 0; /* plain char -> plain char */
2226 else /* signed/unsigned char -> plain char */
2227 return INTEGER_CONVERSION_BADNESS
;
2229 else if (TYPE_UNSIGNED (parm
))
2231 if (TYPE_UNSIGNED (arg
))
2233 /* unsigned int -> unsigned int, or
2234 unsigned long -> unsigned long */
2235 if (integer_types_same_name_p (TYPE_NAME (parm
),
2238 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2240 && integer_types_same_name_p (TYPE_NAME (parm
),
2242 return INTEGER_PROMOTION_BADNESS
; /* unsigned int -> unsigned long */
2244 return INTEGER_CONVERSION_BADNESS
; /* unsigned long -> unsigned int */
2248 if (integer_types_same_name_p (TYPE_NAME (arg
),
2250 && integer_types_same_name_p (TYPE_NAME (parm
),
2252 return INTEGER_CONVERSION_BADNESS
; /* signed long -> unsigned int */
2254 return INTEGER_CONVERSION_BADNESS
; /* signed int/long -> unsigned int/long */
2257 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2259 if (integer_types_same_name_p (TYPE_NAME (parm
),
2262 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2264 && integer_types_same_name_p (TYPE_NAME (parm
),
2266 return INTEGER_PROMOTION_BADNESS
;
2268 return INTEGER_CONVERSION_BADNESS
;
2271 return INTEGER_CONVERSION_BADNESS
;
2273 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2274 return INTEGER_PROMOTION_BADNESS
;
2276 return INTEGER_CONVERSION_BADNESS
;
2277 case TYPE_CODE_ENUM
:
2278 case TYPE_CODE_FLAGS
:
2279 case TYPE_CODE_CHAR
:
2280 case TYPE_CODE_RANGE
:
2281 case TYPE_CODE_BOOL
:
2282 return INTEGER_PROMOTION_BADNESS
;
2284 return INT_FLOAT_CONVERSION_BADNESS
;
2286 return NS_POINTER_CONVERSION_BADNESS
;
2288 return INCOMPATIBLE_TYPE_BADNESS
;
2291 case TYPE_CODE_ENUM
:
2292 switch (TYPE_CODE (arg
))
2295 case TYPE_CODE_CHAR
:
2296 case TYPE_CODE_RANGE
:
2297 case TYPE_CODE_BOOL
:
2298 case TYPE_CODE_ENUM
:
2299 return INTEGER_CONVERSION_BADNESS
;
2301 return INT_FLOAT_CONVERSION_BADNESS
;
2303 return INCOMPATIBLE_TYPE_BADNESS
;
2306 case TYPE_CODE_CHAR
:
2307 switch (TYPE_CODE (arg
))
2309 case TYPE_CODE_RANGE
:
2310 case TYPE_CODE_BOOL
:
2311 case TYPE_CODE_ENUM
:
2312 return INTEGER_CONVERSION_BADNESS
;
2314 return INT_FLOAT_CONVERSION_BADNESS
;
2316 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2317 return INTEGER_CONVERSION_BADNESS
;
2318 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2319 return INTEGER_PROMOTION_BADNESS
;
2320 /* >>> !! else fall through !! <<< */
2321 case TYPE_CODE_CHAR
:
2322 /* Deal with signed, unsigned, and plain chars for C++ and
2323 with int cases falling through from previous case. */
2324 if (TYPE_NOSIGN (parm
))
2326 if (TYPE_NOSIGN (arg
))
2329 return INTEGER_CONVERSION_BADNESS
;
2331 else if (TYPE_UNSIGNED (parm
))
2333 if (TYPE_UNSIGNED (arg
))
2336 return INTEGER_PROMOTION_BADNESS
;
2338 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2341 return INTEGER_CONVERSION_BADNESS
;
2343 return INCOMPATIBLE_TYPE_BADNESS
;
2346 case TYPE_CODE_RANGE
:
2347 switch (TYPE_CODE (arg
))
2350 case TYPE_CODE_CHAR
:
2351 case TYPE_CODE_RANGE
:
2352 case TYPE_CODE_BOOL
:
2353 case TYPE_CODE_ENUM
:
2354 return INTEGER_CONVERSION_BADNESS
;
2356 return INT_FLOAT_CONVERSION_BADNESS
;
2358 return INCOMPATIBLE_TYPE_BADNESS
;
2361 case TYPE_CODE_BOOL
:
2362 switch (TYPE_CODE (arg
))
2365 case TYPE_CODE_CHAR
:
2366 case TYPE_CODE_RANGE
:
2367 case TYPE_CODE_ENUM
:
2370 return BOOLEAN_CONVERSION_BADNESS
;
2371 case TYPE_CODE_BOOL
:
2374 return INCOMPATIBLE_TYPE_BADNESS
;
2378 switch (TYPE_CODE (arg
))
2381 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2382 return FLOAT_PROMOTION_BADNESS
;
2383 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2386 return FLOAT_CONVERSION_BADNESS
;
2388 case TYPE_CODE_BOOL
:
2389 case TYPE_CODE_ENUM
:
2390 case TYPE_CODE_RANGE
:
2391 case TYPE_CODE_CHAR
:
2392 return INT_FLOAT_CONVERSION_BADNESS
;
2394 return INCOMPATIBLE_TYPE_BADNESS
;
2397 case TYPE_CODE_COMPLEX
:
2398 switch (TYPE_CODE (arg
))
2399 { /* Strictly not needed for C++, but... */
2401 return FLOAT_PROMOTION_BADNESS
;
2402 case TYPE_CODE_COMPLEX
:
2405 return INCOMPATIBLE_TYPE_BADNESS
;
2408 case TYPE_CODE_STRUCT
:
2409 /* currently same as TYPE_CODE_CLASS */
2410 switch (TYPE_CODE (arg
))
2412 case TYPE_CODE_STRUCT
:
2413 /* Check for derivation */
2414 if (is_ancestor (parm
, arg
))
2415 return BASE_CONVERSION_BADNESS
;
2416 /* else fall through */
2418 return INCOMPATIBLE_TYPE_BADNESS
;
2421 case TYPE_CODE_UNION
:
2422 switch (TYPE_CODE (arg
))
2424 case TYPE_CODE_UNION
:
2426 return INCOMPATIBLE_TYPE_BADNESS
;
2429 case TYPE_CODE_MEMBERPTR
:
2430 switch (TYPE_CODE (arg
))
2433 return INCOMPATIBLE_TYPE_BADNESS
;
2436 case TYPE_CODE_METHOD
:
2437 switch (TYPE_CODE (arg
))
2441 return INCOMPATIBLE_TYPE_BADNESS
;
2445 switch (TYPE_CODE (arg
))
2449 return INCOMPATIBLE_TYPE_BADNESS
;
2454 switch (TYPE_CODE (arg
))
2458 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0),
2459 TYPE_FIELD_TYPE (arg
, 0));
2461 return INCOMPATIBLE_TYPE_BADNESS
;
2464 case TYPE_CODE_VOID
:
2466 return INCOMPATIBLE_TYPE_BADNESS
;
2467 } /* switch (TYPE_CODE (arg)) */
2471 /* End of functions for overload resolution */
2474 print_bit_vector (B_TYPE
*bits
, int nbits
)
2478 for (bitno
= 0; bitno
< nbits
; bitno
++)
2480 if ((bitno
% 8) == 0)
2482 puts_filtered (" ");
2484 if (B_TST (bits
, bitno
))
2485 printf_filtered (("1"));
2487 printf_filtered (("0"));
2491 /* Note the first arg should be the "this" pointer, we may not want to
2492 include it since we may get into a infinitely recursive
2496 print_arg_types (struct field
*args
, int nargs
, int spaces
)
2502 for (i
= 0; i
< nargs
; i
++)
2503 recursive_dump_type (args
[i
].type
, spaces
+ 2);
2508 field_is_static (struct field
*f
)
2510 /* "static" fields are the fields whose location is not relative
2511 to the address of the enclosing struct. It would be nice to
2512 have a dedicated flag that would be set for static fields when
2513 the type is being created. But in practice, checking the field
2514 loc_kind should give us an accurate answer (at least as long as
2515 we assume that DWARF block locations are not going to be used
2516 for static fields). FIXME? */
2517 return (FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSNAME
2518 || FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSADDR
);
2522 dump_fn_fieldlists (struct type
*type
, int spaces
)
2528 printfi_filtered (spaces
, "fn_fieldlists ");
2529 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2530 printf_filtered ("\n");
2531 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2533 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2534 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2536 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2537 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2539 printf_filtered (_(") length %d\n"),
2540 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2541 for (overload_idx
= 0;
2542 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2545 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2547 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2548 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2550 printf_filtered (")\n");
2551 printfi_filtered (spaces
+ 8, "type ");
2552 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2554 printf_filtered ("\n");
2556 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2559 printfi_filtered (spaces
+ 8, "args ");
2560 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2562 printf_filtered ("\n");
2564 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2565 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
,
2568 printfi_filtered (spaces
+ 8, "fcontext ");
2569 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2571 printf_filtered ("\n");
2573 printfi_filtered (spaces
+ 8, "is_const %d\n",
2574 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2575 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2576 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2577 printfi_filtered (spaces
+ 8, "is_private %d\n",
2578 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2579 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2580 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2581 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2582 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2583 printfi_filtered (spaces
+ 8, "voffset %u\n",
2584 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2590 print_cplus_stuff (struct type
*type
, int spaces
)
2592 printfi_filtered (spaces
, "n_baseclasses %d\n",
2593 TYPE_N_BASECLASSES (type
));
2594 printfi_filtered (spaces
, "nfn_fields %d\n",
2595 TYPE_NFN_FIELDS (type
));
2596 printfi_filtered (spaces
, "nfn_fields_total %d\n",
2597 TYPE_NFN_FIELDS_TOTAL (type
));
2598 if (TYPE_N_BASECLASSES (type
) > 0)
2600 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2601 TYPE_N_BASECLASSES (type
));
2602 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
2604 printf_filtered (")");
2606 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2607 TYPE_N_BASECLASSES (type
));
2608 puts_filtered ("\n");
2610 if (TYPE_NFIELDS (type
) > 0)
2612 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2614 printfi_filtered (spaces
,
2615 "private_field_bits (%d bits at *",
2616 TYPE_NFIELDS (type
));
2617 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
2619 printf_filtered (")");
2620 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2621 TYPE_NFIELDS (type
));
2622 puts_filtered ("\n");
2624 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2626 printfi_filtered (spaces
,
2627 "protected_field_bits (%d bits at *",
2628 TYPE_NFIELDS (type
));
2629 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
2631 printf_filtered (")");
2632 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2633 TYPE_NFIELDS (type
));
2634 puts_filtered ("\n");
2637 if (TYPE_NFN_FIELDS (type
) > 0)
2639 dump_fn_fieldlists (type
, spaces
);
2643 /* Print the contents of the TYPE's type_specific union, assuming that
2644 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
2647 print_gnat_stuff (struct type
*type
, int spaces
)
2649 struct type
*descriptive_type
= TYPE_DESCRIPTIVE_TYPE (type
);
2651 recursive_dump_type (descriptive_type
, spaces
+ 2);
2654 static struct obstack dont_print_type_obstack
;
2657 recursive_dump_type (struct type
*type
, int spaces
)
2662 obstack_begin (&dont_print_type_obstack
, 0);
2664 if (TYPE_NFIELDS (type
) > 0
2665 || (HAVE_CPLUS_STRUCT (type
) && TYPE_NFN_FIELDS (type
) > 0))
2667 struct type
**first_dont_print
2668 = (struct type
**) obstack_base (&dont_print_type_obstack
);
2670 int i
= (struct type
**)
2671 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
2675 if (type
== first_dont_print
[i
])
2677 printfi_filtered (spaces
, "type node ");
2678 gdb_print_host_address (type
, gdb_stdout
);
2679 printf_filtered (_(" <same as already seen type>\n"));
2684 obstack_ptr_grow (&dont_print_type_obstack
, type
);
2687 printfi_filtered (spaces
, "type node ");
2688 gdb_print_host_address (type
, gdb_stdout
);
2689 printf_filtered ("\n");
2690 printfi_filtered (spaces
, "name '%s' (",
2691 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
2692 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
2693 printf_filtered (")\n");
2694 printfi_filtered (spaces
, "tagname '%s' (",
2695 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
2696 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
2697 printf_filtered (")\n");
2698 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
2699 switch (TYPE_CODE (type
))
2701 case TYPE_CODE_UNDEF
:
2702 printf_filtered ("(TYPE_CODE_UNDEF)");
2705 printf_filtered ("(TYPE_CODE_PTR)");
2707 case TYPE_CODE_ARRAY
:
2708 printf_filtered ("(TYPE_CODE_ARRAY)");
2710 case TYPE_CODE_STRUCT
:
2711 printf_filtered ("(TYPE_CODE_STRUCT)");
2713 case TYPE_CODE_UNION
:
2714 printf_filtered ("(TYPE_CODE_UNION)");
2716 case TYPE_CODE_ENUM
:
2717 printf_filtered ("(TYPE_CODE_ENUM)");
2719 case TYPE_CODE_FLAGS
:
2720 printf_filtered ("(TYPE_CODE_FLAGS)");
2722 case TYPE_CODE_FUNC
:
2723 printf_filtered ("(TYPE_CODE_FUNC)");
2726 printf_filtered ("(TYPE_CODE_INT)");
2729 printf_filtered ("(TYPE_CODE_FLT)");
2731 case TYPE_CODE_VOID
:
2732 printf_filtered ("(TYPE_CODE_VOID)");
2735 printf_filtered ("(TYPE_CODE_SET)");
2737 case TYPE_CODE_RANGE
:
2738 printf_filtered ("(TYPE_CODE_RANGE)");
2740 case TYPE_CODE_STRING
:
2741 printf_filtered ("(TYPE_CODE_STRING)");
2743 case TYPE_CODE_BITSTRING
:
2744 printf_filtered ("(TYPE_CODE_BITSTRING)");
2746 case TYPE_CODE_ERROR
:
2747 printf_filtered ("(TYPE_CODE_ERROR)");
2749 case TYPE_CODE_MEMBERPTR
:
2750 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
2752 case TYPE_CODE_METHODPTR
:
2753 printf_filtered ("(TYPE_CODE_METHODPTR)");
2755 case TYPE_CODE_METHOD
:
2756 printf_filtered ("(TYPE_CODE_METHOD)");
2759 printf_filtered ("(TYPE_CODE_REF)");
2761 case TYPE_CODE_CHAR
:
2762 printf_filtered ("(TYPE_CODE_CHAR)");
2764 case TYPE_CODE_BOOL
:
2765 printf_filtered ("(TYPE_CODE_BOOL)");
2767 case TYPE_CODE_COMPLEX
:
2768 printf_filtered ("(TYPE_CODE_COMPLEX)");
2770 case TYPE_CODE_TYPEDEF
:
2771 printf_filtered ("(TYPE_CODE_TYPEDEF)");
2773 case TYPE_CODE_NAMESPACE
:
2774 printf_filtered ("(TYPE_CODE_NAMESPACE)");
2777 printf_filtered ("(UNKNOWN TYPE CODE)");
2780 puts_filtered ("\n");
2781 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
2782 if (TYPE_OBJFILE_OWNED (type
))
2784 printfi_filtered (spaces
, "objfile ");
2785 gdb_print_host_address (TYPE_OWNER (type
).objfile
, gdb_stdout
);
2789 printfi_filtered (spaces
, "gdbarch ");
2790 gdb_print_host_address (TYPE_OWNER (type
).gdbarch
, gdb_stdout
);
2792 printf_filtered ("\n");
2793 printfi_filtered (spaces
, "target_type ");
2794 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
2795 printf_filtered ("\n");
2796 if (TYPE_TARGET_TYPE (type
) != NULL
)
2798 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
2800 printfi_filtered (spaces
, "pointer_type ");
2801 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
2802 printf_filtered ("\n");
2803 printfi_filtered (spaces
, "reference_type ");
2804 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
2805 printf_filtered ("\n");
2806 printfi_filtered (spaces
, "type_chain ");
2807 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
2808 printf_filtered ("\n");
2809 printfi_filtered (spaces
, "instance_flags 0x%x",
2810 TYPE_INSTANCE_FLAGS (type
));
2811 if (TYPE_CONST (type
))
2813 puts_filtered (" TYPE_FLAG_CONST");
2815 if (TYPE_VOLATILE (type
))
2817 puts_filtered (" TYPE_FLAG_VOLATILE");
2819 if (TYPE_CODE_SPACE (type
))
2821 puts_filtered (" TYPE_FLAG_CODE_SPACE");
2823 if (TYPE_DATA_SPACE (type
))
2825 puts_filtered (" TYPE_FLAG_DATA_SPACE");
2827 if (TYPE_ADDRESS_CLASS_1 (type
))
2829 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
2831 if (TYPE_ADDRESS_CLASS_2 (type
))
2833 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
2835 puts_filtered ("\n");
2837 printfi_filtered (spaces
, "flags");
2838 if (TYPE_UNSIGNED (type
))
2840 puts_filtered (" TYPE_FLAG_UNSIGNED");
2842 if (TYPE_NOSIGN (type
))
2844 puts_filtered (" TYPE_FLAG_NOSIGN");
2846 if (TYPE_STUB (type
))
2848 puts_filtered (" TYPE_FLAG_STUB");
2850 if (TYPE_TARGET_STUB (type
))
2852 puts_filtered (" TYPE_FLAG_TARGET_STUB");
2854 if (TYPE_STATIC (type
))
2856 puts_filtered (" TYPE_FLAG_STATIC");
2858 if (TYPE_PROTOTYPED (type
))
2860 puts_filtered (" TYPE_FLAG_PROTOTYPED");
2862 if (TYPE_INCOMPLETE (type
))
2864 puts_filtered (" TYPE_FLAG_INCOMPLETE");
2866 if (TYPE_VARARGS (type
))
2868 puts_filtered (" TYPE_FLAG_VARARGS");
2870 /* This is used for things like AltiVec registers on ppc. Gcc emits
2871 an attribute for the array type, which tells whether or not we
2872 have a vector, instead of a regular array. */
2873 if (TYPE_VECTOR (type
))
2875 puts_filtered (" TYPE_FLAG_VECTOR");
2877 if (TYPE_FIXED_INSTANCE (type
))
2879 puts_filtered (" TYPE_FIXED_INSTANCE");
2881 if (TYPE_STUB_SUPPORTED (type
))
2883 puts_filtered (" TYPE_STUB_SUPPORTED");
2885 if (TYPE_NOTTEXT (type
))
2887 puts_filtered (" TYPE_NOTTEXT");
2889 puts_filtered ("\n");
2890 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
2891 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
2892 puts_filtered ("\n");
2893 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
2895 printfi_filtered (spaces
+ 2,
2896 "[%d] bitpos %d bitsize %d type ",
2897 idx
, TYPE_FIELD_BITPOS (type
, idx
),
2898 TYPE_FIELD_BITSIZE (type
, idx
));
2899 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
2900 printf_filtered (" name '%s' (",
2901 TYPE_FIELD_NAME (type
, idx
) != NULL
2902 ? TYPE_FIELD_NAME (type
, idx
)
2904 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
2905 printf_filtered (")\n");
2906 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
2908 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
2911 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
2913 printfi_filtered (spaces
, "low %s%s high %s%s\n",
2914 plongest (TYPE_LOW_BOUND (type
)),
2915 TYPE_LOW_BOUND_UNDEFINED (type
) ? " (undefined)" : "",
2916 plongest (TYPE_HIGH_BOUND (type
)),
2917 TYPE_HIGH_BOUND_UNDEFINED (type
) ? " (undefined)" : "");
2919 printfi_filtered (spaces
, "vptr_basetype ");
2920 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
2921 puts_filtered ("\n");
2922 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
2924 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
2926 printfi_filtered (spaces
, "vptr_fieldno %d\n",
2927 TYPE_VPTR_FIELDNO (type
));
2929 switch (TYPE_SPECIFIC_FIELD (type
))
2931 case TYPE_SPECIFIC_CPLUS_STUFF
:
2932 printfi_filtered (spaces
, "cplus_stuff ");
2933 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
),
2935 puts_filtered ("\n");
2936 print_cplus_stuff (type
, spaces
);
2939 case TYPE_SPECIFIC_GNAT_STUFF
:
2940 printfi_filtered (spaces
, "gnat_stuff ");
2941 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type
), gdb_stdout
);
2942 puts_filtered ("\n");
2943 print_gnat_stuff (type
, spaces
);
2946 case TYPE_SPECIFIC_FLOATFORMAT
:
2947 printfi_filtered (spaces
, "floatformat ");
2948 if (TYPE_FLOATFORMAT (type
) == NULL
)
2949 puts_filtered ("(null)");
2952 puts_filtered ("{ ");
2953 if (TYPE_FLOATFORMAT (type
)[0] == NULL
2954 || TYPE_FLOATFORMAT (type
)[0]->name
== NULL
)
2955 puts_filtered ("(null)");
2957 puts_filtered (TYPE_FLOATFORMAT (type
)[0]->name
);
2959 puts_filtered (", ");
2960 if (TYPE_FLOATFORMAT (type
)[1] == NULL
2961 || TYPE_FLOATFORMAT (type
)[1]->name
== NULL
)
2962 puts_filtered ("(null)");
2964 puts_filtered (TYPE_FLOATFORMAT (type
)[1]->name
);
2966 puts_filtered (" }");
2968 puts_filtered ("\n");
2971 case TYPE_SPECIFIC_CALLING_CONVENTION
:
2972 printfi_filtered (spaces
, "calling_convention %d\n",
2973 TYPE_CALLING_CONVENTION (type
));
2978 obstack_free (&dont_print_type_obstack
, NULL
);
2981 /* Trivial helpers for the libiberty hash table, for mapping one
2986 struct type
*old
, *new;
2990 type_pair_hash (const void *item
)
2992 const struct type_pair
*pair
= item
;
2994 return htab_hash_pointer (pair
->old
);
2998 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
3000 const struct type_pair
*lhs
= item_lhs
, *rhs
= item_rhs
;
3002 return lhs
->old
== rhs
->old
;
3005 /* Allocate the hash table used by copy_type_recursive to walk
3006 types without duplicates. We use OBJFILE's obstack, because
3007 OBJFILE is about to be deleted. */
3010 create_copied_types_hash (struct objfile
*objfile
)
3012 return htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
3013 NULL
, &objfile
->objfile_obstack
,
3014 hashtab_obstack_allocate
,
3015 dummy_obstack_deallocate
);
3018 /* Recursively copy (deep copy) TYPE, if it is associated with
3019 OBJFILE. Return a new type allocated using malloc, a saved type if
3020 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
3021 not associated with OBJFILE. */
3024 copy_type_recursive (struct objfile
*objfile
,
3026 htab_t copied_types
)
3028 struct type_pair
*stored
, pair
;
3030 struct type
*new_type
;
3032 if (! TYPE_OBJFILE_OWNED (type
))
3035 /* This type shouldn't be pointing to any types in other objfiles;
3036 if it did, the type might disappear unexpectedly. */
3037 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
3040 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
3042 return ((struct type_pair
*) *slot
)->new;
3044 new_type
= alloc_type_arch (get_type_arch (type
));
3046 /* We must add the new type to the hash table immediately, in case
3047 we encounter this type again during a recursive call below. */
3048 stored
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct type_pair
));
3050 stored
->new = new_type
;
3053 /* Copy the common fields of types. For the main type, we simply
3054 copy the entire thing and then update specific fields as needed. */
3055 *TYPE_MAIN_TYPE (new_type
) = *TYPE_MAIN_TYPE (type
);
3056 TYPE_OBJFILE_OWNED (new_type
) = 0;
3057 TYPE_OWNER (new_type
).gdbarch
= get_type_arch (type
);
3059 if (TYPE_NAME (type
))
3060 TYPE_NAME (new_type
) = xstrdup (TYPE_NAME (type
));
3061 if (TYPE_TAG_NAME (type
))
3062 TYPE_TAG_NAME (new_type
) = xstrdup (TYPE_TAG_NAME (type
));
3064 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
3065 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
3067 /* Copy the fields. */
3068 if (TYPE_NFIELDS (type
))
3072 nfields
= TYPE_NFIELDS (type
);
3073 TYPE_FIELDS (new_type
) = XCALLOC (nfields
, struct field
);
3074 for (i
= 0; i
< nfields
; i
++)
3076 TYPE_FIELD_ARTIFICIAL (new_type
, i
) =
3077 TYPE_FIELD_ARTIFICIAL (type
, i
);
3078 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
3079 if (TYPE_FIELD_TYPE (type
, i
))
3080 TYPE_FIELD_TYPE (new_type
, i
)
3081 = copy_type_recursive (objfile
, TYPE_FIELD_TYPE (type
, i
),
3083 if (TYPE_FIELD_NAME (type
, i
))
3084 TYPE_FIELD_NAME (new_type
, i
) =
3085 xstrdup (TYPE_FIELD_NAME (type
, i
));
3086 switch (TYPE_FIELD_LOC_KIND (type
, i
))
3088 case FIELD_LOC_KIND_BITPOS
:
3089 SET_FIELD_BITPOS (TYPE_FIELD (new_type
, i
),
3090 TYPE_FIELD_BITPOS (type
, i
));
3092 case FIELD_LOC_KIND_PHYSADDR
:
3093 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type
, i
),
3094 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
3096 case FIELD_LOC_KIND_PHYSNAME
:
3097 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type
, i
),
3098 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
,
3102 internal_error (__FILE__
, __LINE__
,
3103 _("Unexpected type field location kind: %d"),
3104 TYPE_FIELD_LOC_KIND (type
, i
));
3109 /* For range types, copy the bounds information. */
3110 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
3112 TYPE_RANGE_DATA (new_type
) = xmalloc (sizeof (struct range_bounds
));
3113 *TYPE_RANGE_DATA (new_type
) = *TYPE_RANGE_DATA (type
);
3116 /* Copy pointers to other types. */
3117 if (TYPE_TARGET_TYPE (type
))
3118 TYPE_TARGET_TYPE (new_type
) =
3119 copy_type_recursive (objfile
,
3120 TYPE_TARGET_TYPE (type
),
3122 if (TYPE_VPTR_BASETYPE (type
))
3123 TYPE_VPTR_BASETYPE (new_type
) =
3124 copy_type_recursive (objfile
,
3125 TYPE_VPTR_BASETYPE (type
),
3127 /* Maybe copy the type_specific bits.
3129 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3130 base classes and methods. There's no fundamental reason why we
3131 can't, but at the moment it is not needed. */
3133 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
3134 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
3135 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3136 || TYPE_CODE (type
) == TYPE_CODE_UNION
3137 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
3138 INIT_CPLUS_SPECIFIC (new_type
);
3143 /* Make a copy of the given TYPE, except that the pointer & reference
3144 types are not preserved.
3146 This function assumes that the given type has an associated objfile.
3147 This objfile is used to allocate the new type. */
3150 copy_type (const struct type
*type
)
3152 struct type
*new_type
;
3154 gdb_assert (TYPE_OBJFILE_OWNED (type
));
3156 new_type
= alloc_type_copy (type
);
3157 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
3158 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
3159 memcpy (TYPE_MAIN_TYPE (new_type
), TYPE_MAIN_TYPE (type
),
3160 sizeof (struct main_type
));
3166 /* Helper functions to initialize architecture-specific types. */
3168 /* Allocate a type structure associated with GDBARCH and set its
3169 CODE, LENGTH, and NAME fields. */
3171 arch_type (struct gdbarch
*gdbarch
,
3172 enum type_code code
, int length
, char *name
)
3176 type
= alloc_type_arch (gdbarch
);
3177 TYPE_CODE (type
) = code
;
3178 TYPE_LENGTH (type
) = length
;
3181 TYPE_NAME (type
) = xstrdup (name
);
3186 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
3187 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3188 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3190 arch_integer_type (struct gdbarch
*gdbarch
,
3191 int bit
, int unsigned_p
, char *name
)
3195 t
= arch_type (gdbarch
, TYPE_CODE_INT
, bit
/ TARGET_CHAR_BIT
, name
);
3197 TYPE_UNSIGNED (t
) = 1;
3198 if (name
&& strcmp (name
, "char") == 0)
3199 TYPE_NOSIGN (t
) = 1;
3204 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
3205 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3206 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3208 arch_character_type (struct gdbarch
*gdbarch
,
3209 int bit
, int unsigned_p
, char *name
)
3213 t
= arch_type (gdbarch
, TYPE_CODE_CHAR
, bit
/ TARGET_CHAR_BIT
, name
);
3215 TYPE_UNSIGNED (t
) = 1;
3220 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
3221 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3222 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3224 arch_boolean_type (struct gdbarch
*gdbarch
,
3225 int bit
, int unsigned_p
, char *name
)
3229 t
= arch_type (gdbarch
, TYPE_CODE_BOOL
, bit
/ TARGET_CHAR_BIT
, name
);
3231 TYPE_UNSIGNED (t
) = 1;
3236 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
3237 BIT is the type size in bits; if BIT equals -1, the size is
3238 determined by the floatformat. NAME is the type name. Set the
3239 TYPE_FLOATFORMAT from FLOATFORMATS. */
3241 arch_float_type (struct gdbarch
*gdbarch
,
3242 int bit
, char *name
, const struct floatformat
**floatformats
)
3248 gdb_assert (floatformats
!= NULL
);
3249 gdb_assert (floatformats
[0] != NULL
&& floatformats
[1] != NULL
);
3250 bit
= floatformats
[0]->totalsize
;
3252 gdb_assert (bit
>= 0);
3254 t
= arch_type (gdbarch
, TYPE_CODE_FLT
, bit
/ TARGET_CHAR_BIT
, name
);
3255 TYPE_FLOATFORMAT (t
) = floatformats
;
3259 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
3260 NAME is the type name. TARGET_TYPE is the component float type. */
3262 arch_complex_type (struct gdbarch
*gdbarch
,
3263 char *name
, struct type
*target_type
)
3267 t
= arch_type (gdbarch
, TYPE_CODE_COMPLEX
,
3268 2 * TYPE_LENGTH (target_type
), name
);
3269 TYPE_TARGET_TYPE (t
) = target_type
;
3273 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
3274 NAME is the type name. LENGTH is the size of the flag word in bytes. */
3276 arch_flags_type (struct gdbarch
*gdbarch
, char *name
, int length
)
3278 int nfields
= length
* TARGET_CHAR_BIT
;
3281 type
= arch_type (gdbarch
, TYPE_CODE_FLAGS
, length
, name
);
3282 TYPE_UNSIGNED (type
) = 1;
3283 TYPE_NFIELDS (type
) = nfields
;
3284 TYPE_FIELDS (type
) = TYPE_ZALLOC (type
, nfields
* sizeof (struct field
));
3289 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
3290 position BITPOS is called NAME. */
3292 append_flags_type_flag (struct type
*type
, int bitpos
, char *name
)
3294 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLAGS
);
3295 gdb_assert (bitpos
< TYPE_NFIELDS (type
));
3296 gdb_assert (bitpos
>= 0);
3300 TYPE_FIELD_NAME (type
, bitpos
) = xstrdup (name
);
3301 TYPE_FIELD_BITPOS (type
, bitpos
) = bitpos
;
3305 /* Don't show this field to the user. */
3306 TYPE_FIELD_BITPOS (type
, bitpos
) = -1;
3310 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
3311 specified by CODE) associated with GDBARCH. NAME is the type name. */
3313 arch_composite_type (struct gdbarch
*gdbarch
, char *name
, enum type_code code
)
3317 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
3318 t
= arch_type (gdbarch
, code
, 0, NULL
);
3319 TYPE_TAG_NAME (t
) = name
;
3320 INIT_CPLUS_SPECIFIC (t
);
3324 /* Add new field with name NAME and type FIELD to composite type T.
3325 Do not set the field's position or adjust the type's length;
3326 the caller should do so. Return the new field. */
3328 append_composite_type_field_raw (struct type
*t
, char *name
,
3333 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
3334 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
3335 sizeof (struct field
) * TYPE_NFIELDS (t
));
3336 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
3337 memset (f
, 0, sizeof f
[0]);
3338 FIELD_TYPE (f
[0]) = field
;
3339 FIELD_NAME (f
[0]) = name
;
3343 /* Add new field with name NAME and type FIELD to composite type T.
3344 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
3346 append_composite_type_field_aligned (struct type
*t
, char *name
,
3347 struct type
*field
, int alignment
)
3349 struct field
*f
= append_composite_type_field_raw (t
, name
, field
);
3351 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
3353 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
3354 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
3356 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
3358 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
3359 if (TYPE_NFIELDS (t
) > 1)
3361 FIELD_BITPOS (f
[0]) = (FIELD_BITPOS (f
[-1])
3362 + (TYPE_LENGTH (FIELD_TYPE (f
[-1]))
3363 * TARGET_CHAR_BIT
));
3367 int left
= FIELD_BITPOS (f
[0]) % (alignment
* TARGET_CHAR_BIT
);
3371 FIELD_BITPOS (f
[0]) += left
;
3372 TYPE_LENGTH (t
) += left
/ TARGET_CHAR_BIT
;
3379 /* Add new field with name NAME and type FIELD to composite type T. */
3381 append_composite_type_field (struct type
*t
, char *name
,
3384 append_composite_type_field_aligned (t
, name
, field
, 0);
3388 static struct gdbarch_data
*gdbtypes_data
;
3390 const struct builtin_type
*
3391 builtin_type (struct gdbarch
*gdbarch
)
3393 return gdbarch_data (gdbarch
, gdbtypes_data
);
3397 gdbtypes_post_init (struct gdbarch
*gdbarch
)
3399 struct builtin_type
*builtin_type
3400 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
3403 builtin_type
->builtin_void
3404 = arch_type (gdbarch
, TYPE_CODE_VOID
, 1, "void");
3405 builtin_type
->builtin_char
3406 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3407 !gdbarch_char_signed (gdbarch
), "char");
3408 builtin_type
->builtin_signed_char
3409 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3411 builtin_type
->builtin_unsigned_char
3412 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3413 1, "unsigned char");
3414 builtin_type
->builtin_short
3415 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
3417 builtin_type
->builtin_unsigned_short
3418 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
3419 1, "unsigned short");
3420 builtin_type
->builtin_int
3421 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
3423 builtin_type
->builtin_unsigned_int
3424 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
3426 builtin_type
->builtin_long
3427 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
3429 builtin_type
->builtin_unsigned_long
3430 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
3431 1, "unsigned long");
3432 builtin_type
->builtin_long_long
3433 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
3435 builtin_type
->builtin_unsigned_long_long
3436 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
3437 1, "unsigned long long");
3438 builtin_type
->builtin_float
3439 = arch_float_type (gdbarch
, gdbarch_float_bit (gdbarch
),
3440 "float", gdbarch_float_format (gdbarch
));
3441 builtin_type
->builtin_double
3442 = arch_float_type (gdbarch
, gdbarch_double_bit (gdbarch
),
3443 "double", gdbarch_double_format (gdbarch
));
3444 builtin_type
->builtin_long_double
3445 = arch_float_type (gdbarch
, gdbarch_long_double_bit (gdbarch
),
3446 "long double", gdbarch_long_double_format (gdbarch
));
3447 builtin_type
->builtin_complex
3448 = arch_complex_type (gdbarch
, "complex",
3449 builtin_type
->builtin_float
);
3450 builtin_type
->builtin_double_complex
3451 = arch_complex_type (gdbarch
, "double complex",
3452 builtin_type
->builtin_double
);
3453 builtin_type
->builtin_string
3454 = arch_type (gdbarch
, TYPE_CODE_STRING
, 1, "string");
3455 builtin_type
->builtin_bool
3456 = arch_type (gdbarch
, TYPE_CODE_BOOL
, 1, "bool");
3458 /* The following three are about decimal floating point types, which
3459 are 32-bits, 64-bits and 128-bits respectively. */
3460 builtin_type
->builtin_decfloat
3461 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 32 / 8, "_Decimal32");
3462 builtin_type
->builtin_decdouble
3463 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 64 / 8, "_Decimal64");
3464 builtin_type
->builtin_declong
3465 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 128 / 8, "_Decimal128");
3467 /* "True" character types. */
3468 builtin_type
->builtin_true_char
3469 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 0, "true character");
3470 builtin_type
->builtin_true_unsigned_char
3471 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 1, "true character");
3473 /* Fixed-size integer types. */
3474 builtin_type
->builtin_int0
3475 = arch_integer_type (gdbarch
, 0, 0, "int0_t");
3476 builtin_type
->builtin_int8
3477 = arch_integer_type (gdbarch
, 8, 0, "int8_t");
3478 builtin_type
->builtin_uint8
3479 = arch_integer_type (gdbarch
, 8, 1, "uint8_t");
3480 builtin_type
->builtin_int16
3481 = arch_integer_type (gdbarch
, 16, 0, "int16_t");
3482 builtin_type
->builtin_uint16
3483 = arch_integer_type (gdbarch
, 16, 1, "uint16_t");
3484 builtin_type
->builtin_int32
3485 = arch_integer_type (gdbarch
, 32, 0, "int32_t");
3486 builtin_type
->builtin_uint32
3487 = arch_integer_type (gdbarch
, 32, 1, "uint32_t");
3488 builtin_type
->builtin_int64
3489 = arch_integer_type (gdbarch
, 64, 0, "int64_t");
3490 builtin_type
->builtin_uint64
3491 = arch_integer_type (gdbarch
, 64, 1, "uint64_t");
3492 builtin_type
->builtin_int128
3493 = arch_integer_type (gdbarch
, 128, 0, "int128_t");
3494 builtin_type
->builtin_uint128
3495 = arch_integer_type (gdbarch
, 128, 1, "uint128_t");
3496 TYPE_NOTTEXT (builtin_type
->builtin_int8
) = 1;
3497 TYPE_NOTTEXT (builtin_type
->builtin_uint8
) = 1;
3499 /* Wide character types. */
3500 builtin_type
->builtin_char16
3501 = arch_integer_type (gdbarch
, 16, 0, "char16_t");
3502 builtin_type
->builtin_char32
3503 = arch_integer_type (gdbarch
, 32, 0, "char32_t");
3506 /* Default data/code pointer types. */
3507 builtin_type
->builtin_data_ptr
3508 = lookup_pointer_type (builtin_type
->builtin_void
);
3509 builtin_type
->builtin_func_ptr
3510 = lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
3512 /* This type represents a GDB internal function. */
3513 builtin_type
->internal_fn
3514 = arch_type (gdbarch
, TYPE_CODE_INTERNAL_FUNCTION
, 0,
3515 "<internal function>");
3517 return builtin_type
;
3521 /* This set of objfile-based types is intended to be used by symbol
3522 readers as basic types. */
3524 static const struct objfile_data
*objfile_type_data
;
3526 const struct objfile_type
*
3527 objfile_type (struct objfile
*objfile
)
3529 struct gdbarch
*gdbarch
;
3530 struct objfile_type
*objfile_type
3531 = objfile_data (objfile
, objfile_type_data
);
3534 return objfile_type
;
3536 objfile_type
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
3537 1, struct objfile_type
);
3539 /* Use the objfile architecture to determine basic type properties. */
3540 gdbarch
= get_objfile_arch (objfile
);
3543 objfile_type
->builtin_void
3544 = init_type (TYPE_CODE_VOID
, 1,
3548 objfile_type
->builtin_char
3549 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3551 | (gdbarch_char_signed (gdbarch
) ? 0 : TYPE_FLAG_UNSIGNED
)),
3553 objfile_type
->builtin_signed_char
3554 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3556 "signed char", objfile
);
3557 objfile_type
->builtin_unsigned_char
3558 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3560 "unsigned char", objfile
);
3561 objfile_type
->builtin_short
3562 = init_type (TYPE_CODE_INT
,
3563 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3564 0, "short", objfile
);
3565 objfile_type
->builtin_unsigned_short
3566 = init_type (TYPE_CODE_INT
,
3567 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3568 TYPE_FLAG_UNSIGNED
, "unsigned short", objfile
);
3569 objfile_type
->builtin_int
3570 = init_type (TYPE_CODE_INT
,
3571 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3573 objfile_type
->builtin_unsigned_int
3574 = init_type (TYPE_CODE_INT
,
3575 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3576 TYPE_FLAG_UNSIGNED
, "unsigned int", objfile
);
3577 objfile_type
->builtin_long
3578 = init_type (TYPE_CODE_INT
,
3579 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3580 0, "long", objfile
);
3581 objfile_type
->builtin_unsigned_long
3582 = init_type (TYPE_CODE_INT
,
3583 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3584 TYPE_FLAG_UNSIGNED
, "unsigned long", objfile
);
3585 objfile_type
->builtin_long_long
3586 = init_type (TYPE_CODE_INT
,
3587 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3588 0, "long long", objfile
);
3589 objfile_type
->builtin_unsigned_long_long
3590 = init_type (TYPE_CODE_INT
,
3591 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3592 TYPE_FLAG_UNSIGNED
, "unsigned long long", objfile
);
3594 objfile_type
->builtin_float
3595 = init_type (TYPE_CODE_FLT
,
3596 gdbarch_float_bit (gdbarch
) / TARGET_CHAR_BIT
,
3597 0, "float", objfile
);
3598 TYPE_FLOATFORMAT (objfile_type
->builtin_float
)
3599 = gdbarch_float_format (gdbarch
);
3600 objfile_type
->builtin_double
3601 = init_type (TYPE_CODE_FLT
,
3602 gdbarch_double_bit (gdbarch
) / TARGET_CHAR_BIT
,
3603 0, "double", objfile
);
3604 TYPE_FLOATFORMAT (objfile_type
->builtin_double
)
3605 = gdbarch_double_format (gdbarch
);
3606 objfile_type
->builtin_long_double
3607 = init_type (TYPE_CODE_FLT
,
3608 gdbarch_long_double_bit (gdbarch
) / TARGET_CHAR_BIT
,
3609 0, "long double", objfile
);
3610 TYPE_FLOATFORMAT (objfile_type
->builtin_long_double
)
3611 = gdbarch_long_double_format (gdbarch
);
3613 /* This type represents a type that was unrecognized in symbol read-in. */
3614 objfile_type
->builtin_error
3615 = init_type (TYPE_CODE_ERROR
, 0, 0, "<unknown type>", objfile
);
3617 /* The following set of types is used for symbols with no
3618 debug information. */
3619 objfile_type
->nodebug_text_symbol
3620 = init_type (TYPE_CODE_FUNC
, 1, 0,
3621 "<text variable, no debug info>", objfile
);
3622 TYPE_TARGET_TYPE (objfile_type
->nodebug_text_symbol
)
3623 = objfile_type
->builtin_int
;
3624 objfile_type
->nodebug_data_symbol
3625 = init_type (TYPE_CODE_INT
,
3626 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3627 "<data variable, no debug info>", objfile
);
3628 objfile_type
->nodebug_unknown_symbol
3629 = init_type (TYPE_CODE_INT
, 1, 0,
3630 "<variable (not text or data), no debug info>", objfile
);
3631 objfile_type
->nodebug_tls_symbol
3632 = init_type (TYPE_CODE_INT
,
3633 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3634 "<thread local variable, no debug info>", objfile
);
3636 /* NOTE: on some targets, addresses and pointers are not necessarily
3637 the same --- for example, on the D10V, pointers are 16 bits long,
3638 but addresses are 32 bits long. See doc/gdbint.texinfo,
3639 ``Pointers Are Not Always Addresses''.
3642 - gdb's `struct type' always describes the target's
3644 - gdb's `struct value' objects should always hold values in
3646 - gdb's CORE_ADDR values are addresses in the unified virtual
3647 address space that the assembler and linker work with. Thus,
3648 since target_read_memory takes a CORE_ADDR as an argument, it
3649 can access any memory on the target, even if the processor has
3650 separate code and data address spaces.
3653 - If v is a value holding a D10V code pointer, its contents are
3654 in target form: a big-endian address left-shifted two bits.
3655 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3656 sizeof (void *) == 2 on the target.
3658 In this context, objfile_type->builtin_core_addr is a bit odd:
3659 it's a target type for a value the target will never see. It's
3660 only used to hold the values of (typeless) linker symbols, which
3661 are indeed in the unified virtual address space. */
3663 objfile_type
->builtin_core_addr
3664 = init_type (TYPE_CODE_INT
,
3665 gdbarch_addr_bit (gdbarch
) / 8,
3666 TYPE_FLAG_UNSIGNED
, "__CORE_ADDR", objfile
);
3668 set_objfile_data (objfile
, objfile_type_data
, objfile_type
);
3669 return objfile_type
;
3673 extern void _initialize_gdbtypes (void);
3675 _initialize_gdbtypes (void)
3677 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
3678 objfile_type_data
= register_objfile_data ();
3680 add_setshow_zinteger_cmd ("overload", no_class
, &overload_debug
, _("\
3681 Set debugging of C++ overloading."), _("\
3682 Show debugging of C++ overloading."), _("\
3683 When enabled, ranking of the functions is displayed."),
3685 show_overload_debug
,
3686 &setdebuglist
, &showdebuglist
);
3688 /* Add user knob for controlling resolution of opaque types. */
3689 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
3690 &opaque_type_resolution
, _("\
3691 Set resolution of opaque struct/class/union types (if set before loading symbols)."), _("\
3692 Show resolution of opaque struct/class/union types (if set before loading symbols)."), NULL
,
3694 show_opaque_type_resolution
,
3695 &setlist
, &showlist
);