1 /* Support routines for manipulating internal types for GDB.
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
4 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
6 Contributed by Cygnus Support, using pieces from other GDB modules.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
30 #include "expression.h"
35 #include "complaints.h"
39 #include "gdb_assert.h"
42 /* These variables point to the objects
43 representing the predefined C data types. */
45 struct type *builtin_type_int0;
46 struct type *builtin_type_int8;
47 struct type *builtin_type_uint8;
48 struct type *builtin_type_int16;
49 struct type *builtin_type_uint16;
50 struct type *builtin_type_int32;
51 struct type *builtin_type_uint32;
52 struct type *builtin_type_int64;
53 struct type *builtin_type_uint64;
54 struct type *builtin_type_int128;
55 struct type *builtin_type_uint128;
57 /* Floatformat pairs. */
58 const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN] = {
59 &floatformat_ieee_single_big,
60 &floatformat_ieee_single_little
62 const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN] = {
63 &floatformat_ieee_double_big,
64 &floatformat_ieee_double_little
66 const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN] = {
67 &floatformat_ieee_double_big,
68 &floatformat_ieee_double_littlebyte_bigword
70 const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN] = {
71 &floatformat_i387_ext,
74 const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN] = {
75 &floatformat_m68881_ext,
76 &floatformat_m68881_ext
78 const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN] = {
79 &floatformat_arm_ext_big,
80 &floatformat_arm_ext_littlebyte_bigword
82 const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN] = {
83 &floatformat_ia64_spill_big,
84 &floatformat_ia64_spill_little
86 const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN] = {
87 &floatformat_ia64_quad_big,
88 &floatformat_ia64_quad_little
90 const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN] = {
94 const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN] = {
98 const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN] = {
99 &floatformat_ibm_long_double,
100 &floatformat_ibm_long_double
103 struct type *builtin_type_ieee_single;
104 struct type *builtin_type_ieee_double;
105 struct type *builtin_type_i387_ext;
106 struct type *builtin_type_m68881_ext;
107 struct type *builtin_type_arm_ext;
108 struct type *builtin_type_ia64_spill;
109 struct type *builtin_type_ia64_quad;
112 int opaque_type_resolution = 1;
114 show_opaque_type_resolution (struct ui_file *file, int from_tty,
115 struct cmd_list_element *c,
118 fprintf_filtered (file, _("\
119 Resolution of opaque struct/class/union types (if set before loading symbols) is %s.\n"),
123 int overload_debug = 0;
125 show_overload_debug (struct ui_file *file, int from_tty,
126 struct cmd_list_element *c, const char *value)
128 fprintf_filtered (file, _("Debugging of C++ overloading is %s.\n"),
136 }; /* Maximum extension is 128! FIXME */
138 static void print_bit_vector (B_TYPE *, int);
139 static void print_arg_types (struct field *, int, int);
140 static void dump_fn_fieldlists (struct type *, int);
141 static void print_cplus_stuff (struct type *, int);
144 /* Alloc a new type structure and fill it with some defaults. If
145 OBJFILE is non-NULL, then allocate the space for the type structure
146 in that objfile's objfile_obstack. Otherwise allocate the new type
147 structure by xmalloc () (for permanent types). */
150 alloc_type (struct objfile *objfile)
154 /* Alloc the structure and start off with all fields zeroed. */
158 type = xmalloc (sizeof (struct type));
159 memset (type, 0, sizeof (struct type));
160 TYPE_MAIN_TYPE (type) = xmalloc (sizeof (struct main_type));
164 type = obstack_alloc (&objfile->objfile_obstack,
165 sizeof (struct type));
166 memset (type, 0, sizeof (struct type));
167 TYPE_MAIN_TYPE (type) = obstack_alloc (&objfile->objfile_obstack,
168 sizeof (struct main_type));
169 OBJSTAT (objfile, n_types++);
171 memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
173 /* Initialize the fields that might not be zero. */
175 TYPE_CODE (type) = TYPE_CODE_UNDEF;
176 TYPE_OBJFILE (type) = objfile;
177 TYPE_VPTR_FIELDNO (type) = -1;
178 TYPE_CHAIN (type) = type; /* Chain back to itself. */
183 /* Alloc a new type instance structure, fill it with some defaults,
184 and point it at OLDTYPE. Allocate the new type instance from the
185 same place as OLDTYPE. */
188 alloc_type_instance (struct type *oldtype)
192 /* Allocate the structure. */
194 if (TYPE_OBJFILE (oldtype) == NULL)
196 type = xmalloc (sizeof (struct type));
197 memset (type, 0, sizeof (struct type));
201 type = obstack_alloc (&TYPE_OBJFILE (oldtype)->objfile_obstack,
202 sizeof (struct type));
203 memset (type, 0, sizeof (struct type));
205 TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype);
207 TYPE_CHAIN (type) = type; /* Chain back to itself for now. */
212 /* Clear all remnants of the previous type at TYPE, in preparation for
213 replacing it with something else. */
215 smash_type (struct type *type)
217 memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
219 /* For now, delete the rings. */
220 TYPE_CHAIN (type) = type;
222 /* For now, leave the pointer/reference types alone. */
225 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
226 to a pointer to memory where the pointer type should be stored.
227 If *TYPEPTR is zero, update it to point to the pointer type we return.
228 We allocate new memory if needed. */
231 make_pointer_type (struct type *type, struct type **typeptr)
233 struct type *ntype; /* New type */
234 struct objfile *objfile;
237 ntype = TYPE_POINTER_TYPE (type);
242 return ntype; /* Don't care about alloc,
243 and have new type. */
244 else if (*typeptr == 0)
246 *typeptr = ntype; /* Tracking alloc, and have new type. */
251 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
253 ntype = alloc_type (TYPE_OBJFILE (type));
257 else /* We have storage, but need to reset it. */
260 objfile = TYPE_OBJFILE (ntype);
261 chain = TYPE_CHAIN (ntype);
263 TYPE_CHAIN (ntype) = chain;
264 TYPE_OBJFILE (ntype) = objfile;
267 TYPE_TARGET_TYPE (ntype) = type;
268 TYPE_POINTER_TYPE (type) = ntype;
270 /* FIXME! Assume the machine has only one representation for
273 TYPE_LENGTH (ntype) =
274 gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT;
275 TYPE_CODE (ntype) = TYPE_CODE_PTR;
277 /* Mark pointers as unsigned. The target converts between pointers
278 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
279 gdbarch_address_to_pointer. */
280 TYPE_UNSIGNED (ntype) = 1;
282 if (!TYPE_POINTER_TYPE (type)) /* Remember it, if don't have one. */
283 TYPE_POINTER_TYPE (type) = ntype;
285 /* Update the length of all the other variants of this type. */
286 chain = TYPE_CHAIN (ntype);
287 while (chain != ntype)
289 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
290 chain = TYPE_CHAIN (chain);
296 /* Given a type TYPE, return a type of pointers to that type.
297 May need to construct such a type if this is the first use. */
300 lookup_pointer_type (struct type *type)
302 return make_pointer_type (type, (struct type **) 0);
305 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
306 points to a pointer to memory where the reference type should be
307 stored. If *TYPEPTR is zero, update it to point to the reference
308 type we return. We allocate new memory if needed. */
311 make_reference_type (struct type *type, struct type **typeptr)
313 struct type *ntype; /* New type */
314 struct objfile *objfile;
317 ntype = TYPE_REFERENCE_TYPE (type);
322 return ntype; /* Don't care about alloc,
323 and have new type. */
324 else if (*typeptr == 0)
326 *typeptr = ntype; /* Tracking alloc, and have new type. */
331 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
333 ntype = alloc_type (TYPE_OBJFILE (type));
337 else /* We have storage, but need to reset it. */
340 objfile = TYPE_OBJFILE (ntype);
341 chain = TYPE_CHAIN (ntype);
343 TYPE_CHAIN (ntype) = chain;
344 TYPE_OBJFILE (ntype) = objfile;
347 TYPE_TARGET_TYPE (ntype) = type;
348 TYPE_REFERENCE_TYPE (type) = ntype;
350 /* FIXME! Assume the machine has only one representation for
351 references, and that it matches the (only) representation for
354 TYPE_LENGTH (ntype) = gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT;
355 TYPE_CODE (ntype) = TYPE_CODE_REF;
357 if (!TYPE_REFERENCE_TYPE (type)) /* Remember it, if don't have one. */
358 TYPE_REFERENCE_TYPE (type) = ntype;
360 /* Update the length of all the other variants of this type. */
361 chain = TYPE_CHAIN (ntype);
362 while (chain != ntype)
364 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
365 chain = TYPE_CHAIN (chain);
371 /* Same as above, but caller doesn't care about memory allocation
375 lookup_reference_type (struct type *type)
377 return make_reference_type (type, (struct type **) 0);
380 /* Lookup a function type that returns type TYPE. TYPEPTR, if
381 nonzero, points to a pointer to memory where the function type
382 should be stored. If *TYPEPTR is zero, update it to point to the
383 function type we return. We allocate new memory if needed. */
386 make_function_type (struct type *type, struct type **typeptr)
388 struct type *ntype; /* New type */
389 struct objfile *objfile;
391 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
393 ntype = alloc_type (TYPE_OBJFILE (type));
397 else /* We have storage, but need to reset it. */
400 objfile = TYPE_OBJFILE (ntype);
402 TYPE_OBJFILE (ntype) = objfile;
405 TYPE_TARGET_TYPE (ntype) = type;
407 TYPE_LENGTH (ntype) = 1;
408 TYPE_CODE (ntype) = TYPE_CODE_FUNC;
414 /* Given a type TYPE, return a type of functions that return that type.
415 May need to construct such a type if this is the first use. */
418 lookup_function_type (struct type *type)
420 return make_function_type (type, (struct type **) 0);
423 /* Identify address space identifier by name --
424 return the integer flag defined in gdbtypes.h. */
426 address_space_name_to_int (char *space_identifier)
428 struct gdbarch *gdbarch = current_gdbarch;
430 /* Check for known address space delimiters. */
431 if (!strcmp (space_identifier, "code"))
432 return TYPE_INSTANCE_FLAG_CODE_SPACE;
433 else if (!strcmp (space_identifier, "data"))
434 return TYPE_INSTANCE_FLAG_DATA_SPACE;
435 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch)
436 && gdbarch_address_class_name_to_type_flags (gdbarch,
441 error (_("Unknown address space specifier: \"%s\""), space_identifier);
444 /* Identify address space identifier by integer flag as defined in
445 gdbtypes.h -- return the string version of the adress space name. */
448 address_space_int_to_name (int space_flag)
450 struct gdbarch *gdbarch = current_gdbarch;
451 if (space_flag & TYPE_INSTANCE_FLAG_CODE_SPACE)
453 else if (space_flag & TYPE_INSTANCE_FLAG_DATA_SPACE)
455 else if ((space_flag & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
456 && gdbarch_address_class_type_flags_to_name_p (gdbarch))
457 return gdbarch_address_class_type_flags_to_name (gdbarch, space_flag);
462 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
464 If STORAGE is non-NULL, create the new type instance there.
465 STORAGE must be in the same obstack as TYPE. */
468 make_qualified_type (struct type *type, int new_flags,
469 struct type *storage)
475 if (TYPE_INSTANCE_FLAGS (ntype) == new_flags)
477 ntype = TYPE_CHAIN (ntype);
478 } while (ntype != type);
480 /* Create a new type instance. */
482 ntype = alloc_type_instance (type);
485 /* If STORAGE was provided, it had better be in the same objfile
486 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
487 if one objfile is freed and the other kept, we'd have
488 dangling pointers. */
489 gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage));
492 TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type);
493 TYPE_CHAIN (ntype) = ntype;
496 /* Pointers or references to the original type are not relevant to
498 TYPE_POINTER_TYPE (ntype) = (struct type *) 0;
499 TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0;
501 /* Chain the new qualified type to the old type. */
502 TYPE_CHAIN (ntype) = TYPE_CHAIN (type);
503 TYPE_CHAIN (type) = ntype;
505 /* Now set the instance flags and return the new type. */
506 TYPE_INSTANCE_FLAGS (ntype) = new_flags;
508 /* Set length of new type to that of the original type. */
509 TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
514 /* Make an address-space-delimited variant of a type -- a type that
515 is identical to the one supplied except that it has an address
516 space attribute attached to it (such as "code" or "data").
518 The space attributes "code" and "data" are for Harvard
519 architectures. The address space attributes are for architectures
520 which have alternately sized pointers or pointers with alternate
524 make_type_with_address_space (struct type *type, int space_flag)
527 int new_flags = ((TYPE_INSTANCE_FLAGS (type)
528 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
529 | TYPE_INSTANCE_FLAG_DATA_SPACE
530 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL))
533 return make_qualified_type (type, new_flags, NULL);
536 /* Make a "c-v" variant of a type -- a type that is identical to the
537 one supplied except that it may have const or volatile attributes
538 CNST is a flag for setting the const attribute
539 VOLTL is a flag for setting the volatile attribute
540 TYPE is the base type whose variant we are creating.
542 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
543 storage to hold the new qualified type; *TYPEPTR and TYPE must be
544 in the same objfile. Otherwise, allocate fresh memory for the new
545 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
546 new type we construct. */
548 make_cv_type (int cnst, int voltl,
550 struct type **typeptr)
552 struct type *ntype; /* New type */
553 struct type *tmp_type = type; /* tmp type */
554 struct objfile *objfile;
556 int new_flags = (TYPE_INSTANCE_FLAGS (type)
557 & ~(TYPE_INSTANCE_FLAG_CONST | TYPE_INSTANCE_FLAG_VOLATILE));
560 new_flags |= TYPE_INSTANCE_FLAG_CONST;
563 new_flags |= TYPE_INSTANCE_FLAG_VOLATILE;
565 if (typeptr && *typeptr != NULL)
567 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
568 a C-V variant chain that threads across objfiles: if one
569 objfile gets freed, then the other has a broken C-V chain.
571 This code used to try to copy over the main type from TYPE to
572 *TYPEPTR if they were in different objfiles, but that's
573 wrong, too: TYPE may have a field list or member function
574 lists, which refer to types of their own, etc. etc. The
575 whole shebang would need to be copied over recursively; you
576 can't have inter-objfile pointers. The only thing to do is
577 to leave stub types as stub types, and look them up afresh by
578 name each time you encounter them. */
579 gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type));
582 ntype = make_qualified_type (type, new_flags,
583 typeptr ? *typeptr : NULL);
591 /* Replace the contents of ntype with the type *type. This changes the
592 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
593 the changes are propogated to all types in the TYPE_CHAIN.
595 In order to build recursive types, it's inevitable that we'll need
596 to update types in place --- but this sort of indiscriminate
597 smashing is ugly, and needs to be replaced with something more
598 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
599 clear if more steps are needed. */
601 replace_type (struct type *ntype, struct type *type)
605 /* These two types had better be in the same objfile. Otherwise,
606 the assignment of one type's main type structure to the other
607 will produce a type with references to objects (names; field
608 lists; etc.) allocated on an objfile other than its own. */
609 gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (ntype));
611 *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
613 /* The type length is not a part of the main type. Update it for
614 each type on the variant chain. */
617 /* Assert that this element of the chain has no address-class bits
618 set in its flags. Such type variants might have type lengths
619 which are supposed to be different from the non-address-class
620 variants. This assertion shouldn't ever be triggered because
621 symbol readers which do construct address-class variants don't
622 call replace_type(). */
623 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0);
625 TYPE_LENGTH (chain) = TYPE_LENGTH (type);
626 chain = TYPE_CHAIN (chain);
627 } while (ntype != chain);
629 /* Assert that the two types have equivalent instance qualifiers.
630 This should be true for at least all of our debug readers. */
631 gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type));
634 /* Implement direct support for MEMBER_TYPE in GNU C++.
635 May need to construct such a type if this is the first use.
636 The TYPE is the type of the member. The DOMAIN is the type
637 of the aggregate that the member belongs to. */
640 lookup_memberptr_type (struct type *type, struct type *domain)
644 mtype = alloc_type (TYPE_OBJFILE (type));
645 smash_to_memberptr_type (mtype, domain, type);
649 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
652 lookup_methodptr_type (struct type *to_type)
656 mtype = alloc_type (TYPE_OBJFILE (to_type));
657 TYPE_TARGET_TYPE (mtype) = to_type;
658 TYPE_DOMAIN_TYPE (mtype) = TYPE_DOMAIN_TYPE (to_type);
659 TYPE_LENGTH (mtype) = cplus_method_ptr_size ();
660 TYPE_CODE (mtype) = TYPE_CODE_METHODPTR;
664 /* Allocate a stub method whose return type is TYPE. This apparently
665 happens for speed of symbol reading, since parsing out the
666 arguments to the method is cpu-intensive, the way we are doing it.
667 So, we will fill in arguments later. This always returns a fresh
671 allocate_stub_method (struct type *type)
675 mtype = init_type (TYPE_CODE_METHOD, 1, TYPE_FLAG_STUB, NULL,
676 TYPE_OBJFILE (type));
677 TYPE_TARGET_TYPE (mtype) = type;
678 /* _DOMAIN_TYPE (mtype) = unknown yet */
682 /* Create a range type using either a blank type supplied in
683 RESULT_TYPE, or creating a new type, inheriting the objfile from
686 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
687 to HIGH_BOUND, inclusive.
689 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
690 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
693 create_range_type (struct type *result_type, struct type *index_type,
694 int low_bound, int high_bound)
696 if (result_type == NULL)
698 result_type = alloc_type (TYPE_OBJFILE (index_type));
700 TYPE_CODE (result_type) = TYPE_CODE_RANGE;
701 TYPE_TARGET_TYPE (result_type) = index_type;
702 if (TYPE_STUB (index_type))
703 TYPE_TARGET_STUB (result_type) = 1;
705 TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
706 TYPE_NFIELDS (result_type) = 2;
707 TYPE_FIELDS (result_type) = (struct field *)
708 TYPE_ALLOC (result_type, 2 * sizeof (struct field));
709 memset (TYPE_FIELDS (result_type), 0, 2 * sizeof (struct field));
710 TYPE_FIELD_BITPOS (result_type, 0) = low_bound;
711 TYPE_FIELD_BITPOS (result_type, 1) = high_bound;
714 TYPE_UNSIGNED (result_type) = 1;
716 return (result_type);
719 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
720 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
721 bounds will fit in LONGEST), or -1 otherwise. */
724 get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
726 CHECK_TYPEDEF (type);
727 switch (TYPE_CODE (type))
729 case TYPE_CODE_RANGE:
730 *lowp = TYPE_LOW_BOUND (type);
731 *highp = TYPE_HIGH_BOUND (type);
734 if (TYPE_NFIELDS (type) > 0)
736 /* The enums may not be sorted by value, so search all
740 *lowp = *highp = TYPE_FIELD_BITPOS (type, 0);
741 for (i = 0; i < TYPE_NFIELDS (type); i++)
743 if (TYPE_FIELD_BITPOS (type, i) < *lowp)
744 *lowp = TYPE_FIELD_BITPOS (type, i);
745 if (TYPE_FIELD_BITPOS (type, i) > *highp)
746 *highp = TYPE_FIELD_BITPOS (type, i);
749 /* Set unsigned indicator if warranted. */
752 TYPE_UNSIGNED (type) = 1;
766 if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */
768 if (!TYPE_UNSIGNED (type))
770 *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
774 /* ... fall through for unsigned ints ... */
777 /* This round-about calculation is to avoid shifting by
778 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
779 if TYPE_LENGTH (type) == sizeof (LONGEST). */
780 *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
781 *highp = (*highp - 1) | *highp;
788 /* Create an array type using either a blank type supplied in
789 RESULT_TYPE, or creating a new type, inheriting the objfile from
792 Elements will be of type ELEMENT_TYPE, the indices will be of type
795 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
796 sure it is TYPE_CODE_UNDEF before we bash it into an array
800 create_array_type (struct type *result_type,
801 struct type *element_type,
802 struct type *range_type)
804 LONGEST low_bound, high_bound;
806 if (result_type == NULL)
808 result_type = alloc_type (TYPE_OBJFILE (range_type));
810 TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
811 TYPE_TARGET_TYPE (result_type) = element_type;
812 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
813 low_bound = high_bound = 0;
814 CHECK_TYPEDEF (element_type);
815 /* Be careful when setting the array length. Ada arrays can be
816 empty arrays with the high_bound being smaller than the low_bound.
817 In such cases, the array length should be zero. */
818 if (high_bound < low_bound)
819 TYPE_LENGTH (result_type) = 0;
821 TYPE_LENGTH (result_type) =
822 TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
823 TYPE_NFIELDS (result_type) = 1;
824 TYPE_FIELDS (result_type) =
825 (struct field *) TYPE_ALLOC (result_type, sizeof (struct field));
826 memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
827 TYPE_FIELD_TYPE (result_type, 0) = range_type;
828 TYPE_VPTR_FIELDNO (result_type) = -1;
830 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
831 if (TYPE_LENGTH (result_type) == 0)
832 TYPE_TARGET_STUB (result_type) = 1;
834 return (result_type);
837 /* Create a string type using either a blank type supplied in
838 RESULT_TYPE, or creating a new type. String types are similar
839 enough to array of char types that we can use create_array_type to
840 build the basic type and then bash it into a string type.
842 For fixed length strings, the range type contains 0 as the lower
843 bound and the length of the string minus one as the upper bound.
845 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
846 sure it is TYPE_CODE_UNDEF before we bash it into a string
850 create_string_type (struct type *result_type,
851 struct type *range_type)
853 struct type *string_char_type;
855 string_char_type = language_string_char_type (current_language,
857 result_type = create_array_type (result_type,
860 TYPE_CODE (result_type) = TYPE_CODE_STRING;
861 return (result_type);
865 create_set_type (struct type *result_type, struct type *domain_type)
867 if (result_type == NULL)
869 result_type = alloc_type (TYPE_OBJFILE (domain_type));
871 TYPE_CODE (result_type) = TYPE_CODE_SET;
872 TYPE_NFIELDS (result_type) = 1;
873 TYPE_FIELDS (result_type) = (struct field *)
874 TYPE_ALLOC (result_type, 1 * sizeof (struct field));
875 memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
877 if (!TYPE_STUB (domain_type))
879 LONGEST low_bound, high_bound, bit_length;
880 if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
881 low_bound = high_bound = 0;
882 bit_length = high_bound - low_bound + 1;
883 TYPE_LENGTH (result_type)
884 = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
886 TYPE_UNSIGNED (result_type) = 1;
888 TYPE_FIELD_TYPE (result_type, 0) = domain_type;
890 return (result_type);
894 append_flags_type_flag (struct type *type, int bitpos, char *name)
896 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS);
897 gdb_assert (bitpos < TYPE_NFIELDS (type));
898 gdb_assert (bitpos >= 0);
902 TYPE_FIELD_NAME (type, bitpos) = xstrdup (name);
903 TYPE_FIELD_BITPOS (type, bitpos) = bitpos;
907 /* Don't show this field to the user. */
908 TYPE_FIELD_BITPOS (type, bitpos) = -1;
913 init_flags_type (char *name, int length)
915 int nfields = length * TARGET_CHAR_BIT;
918 type = init_type (TYPE_CODE_FLAGS, length,
919 TYPE_FLAG_UNSIGNED, name, NULL);
920 TYPE_NFIELDS (type) = nfields;
921 TYPE_FIELDS (type) = TYPE_ALLOC (type,
922 nfields * sizeof (struct field));
923 memset (TYPE_FIELDS (type), 0, nfields * sizeof (struct field));
928 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
929 and any array types nested inside it. */
932 make_vector_type (struct type *array_type)
934 struct type *inner_array, *elt_type;
937 /* Find the innermost array type, in case the array is
938 multi-dimensional. */
939 inner_array = array_type;
940 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
941 inner_array = TYPE_TARGET_TYPE (inner_array);
943 elt_type = TYPE_TARGET_TYPE (inner_array);
944 if (TYPE_CODE (elt_type) == TYPE_CODE_INT)
946 flags = TYPE_INSTANCE_FLAGS (elt_type) | TYPE_FLAG_NOTTEXT;
947 elt_type = make_qualified_type (elt_type, flags, NULL);
948 TYPE_TARGET_TYPE (inner_array) = elt_type;
951 TYPE_VECTOR (array_type) = 1;
955 init_vector_type (struct type *elt_type, int n)
957 struct type *array_type;
959 array_type = create_array_type (0, elt_type,
960 create_range_type (0,
963 make_vector_type (array_type);
967 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
968 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
969 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
970 TYPE doesn't include the offset (that's the value of the MEMBER
971 itself), but does include the structure type into which it points
974 When "smashing" the type, we preserve the objfile that the old type
975 pointed to, since we aren't changing where the type is actually
979 smash_to_memberptr_type (struct type *type, struct type *domain,
980 struct type *to_type)
982 struct objfile *objfile;
984 objfile = TYPE_OBJFILE (type);
987 TYPE_OBJFILE (type) = objfile;
988 TYPE_TARGET_TYPE (type) = to_type;
989 TYPE_DOMAIN_TYPE (type) = domain;
990 /* Assume that a data member pointer is the same size as a normal
992 TYPE_LENGTH (type) = gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT;
993 TYPE_CODE (type) = TYPE_CODE_MEMBERPTR;
996 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
997 METHOD just means `function that gets an extra "this" argument'.
999 When "smashing" the type, we preserve the objfile that the old type
1000 pointed to, since we aren't changing where the type is actually
1004 smash_to_method_type (struct type *type, struct type *domain,
1005 struct type *to_type, struct field *args,
1006 int nargs, int varargs)
1008 struct objfile *objfile;
1010 objfile = TYPE_OBJFILE (type);
1013 TYPE_OBJFILE (type) = objfile;
1014 TYPE_TARGET_TYPE (type) = to_type;
1015 TYPE_DOMAIN_TYPE (type) = domain;
1016 TYPE_FIELDS (type) = args;
1017 TYPE_NFIELDS (type) = nargs;
1019 TYPE_VARARGS (type) = 1;
1020 TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
1021 TYPE_CODE (type) = TYPE_CODE_METHOD;
1024 /* Return a typename for a struct/union/enum type without "struct ",
1025 "union ", or "enum ". If the type has a NULL name, return NULL. */
1028 type_name_no_tag (const struct type *type)
1030 if (TYPE_TAG_NAME (type) != NULL)
1031 return TYPE_TAG_NAME (type);
1033 /* Is there code which expects this to return the name if there is
1034 no tag name? My guess is that this is mainly used for C++ in
1035 cases where the two will always be the same. */
1036 return TYPE_NAME (type);
1039 /* Lookup a typedef or primitive type named NAME, visible in lexical
1040 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1041 suitably defined. */
1044 lookup_typename (char *name, struct block *block, int noerr)
1049 sym = lookup_symbol (name, block, VAR_DOMAIN, 0);
1050 if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
1052 tmp = language_lookup_primitive_type_by_name (current_language,
1059 else if (!tmp && noerr)
1065 error (_("No type named %s."), name);
1068 return (SYMBOL_TYPE (sym));
1072 lookup_unsigned_typename (char *name)
1074 char *uns = alloca (strlen (name) + 10);
1076 strcpy (uns, "unsigned ");
1077 strcpy (uns + 9, name);
1078 return (lookup_typename (uns, (struct block *) NULL, 0));
1082 lookup_signed_typename (char *name)
1085 char *uns = alloca (strlen (name) + 8);
1087 strcpy (uns, "signed ");
1088 strcpy (uns + 7, name);
1089 t = lookup_typename (uns, (struct block *) NULL, 1);
1090 /* If we don't find "signed FOO" just try again with plain "FOO". */
1093 return lookup_typename (name, (struct block *) NULL, 0);
1096 /* Lookup a structure type named "struct NAME",
1097 visible in lexical block BLOCK. */
1100 lookup_struct (char *name, struct block *block)
1104 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1108 error (_("No struct type named %s."), name);
1110 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1112 error (_("This context has class, union or enum %s, not a struct."),
1115 return (SYMBOL_TYPE (sym));
1118 /* Lookup a union type named "union NAME",
1119 visible in lexical block BLOCK. */
1122 lookup_union (char *name, struct block *block)
1127 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1130 error (_("No union type named %s."), name);
1132 t = SYMBOL_TYPE (sym);
1134 if (TYPE_CODE (t) == TYPE_CODE_UNION)
1137 /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
1138 * a further "declared_type" field to discover it is really a union.
1140 if (HAVE_CPLUS_STRUCT (t))
1141 if (TYPE_DECLARED_TYPE (t) == DECLARED_TYPE_UNION)
1144 /* If we get here, it's not a union. */
1145 error (_("This context has class, struct or enum %s, not a union."),
1150 /* Lookup an enum type named "enum NAME",
1151 visible in lexical block BLOCK. */
1154 lookup_enum (char *name, struct block *block)
1158 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1161 error (_("No enum type named %s."), name);
1163 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
1165 error (_("This context has class, struct or union %s, not an enum."),
1168 return (SYMBOL_TYPE (sym));
1171 /* Lookup a template type named "template NAME<TYPE>",
1172 visible in lexical block BLOCK. */
1175 lookup_template_type (char *name, struct type *type,
1176 struct block *block)
1179 char *nam = (char *)
1180 alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4);
1183 strcat (nam, TYPE_NAME (type));
1184 strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
1186 sym = lookup_symbol (nam, block, VAR_DOMAIN, 0);
1190 error (_("No template type named %s."), name);
1192 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1194 error (_("This context has class, union or enum %s, not a struct."),
1197 return (SYMBOL_TYPE (sym));
1200 /* Given a type TYPE, lookup the type of the component of type named
1203 TYPE can be either a struct or union, or a pointer or reference to
1204 a struct or union. If it is a pointer or reference, its target
1205 type is automatically used. Thus '.' and '->' are interchangable,
1206 as specified for the definitions of the expression element types
1207 STRUCTOP_STRUCT and STRUCTOP_PTR.
1209 If NOERR is nonzero, return zero if NAME is not suitably defined.
1210 If NAME is the name of a baseclass type, return that type. */
1213 lookup_struct_elt_type (struct type *type, char *name, int noerr)
1219 CHECK_TYPEDEF (type);
1220 if (TYPE_CODE (type) != TYPE_CODE_PTR
1221 && TYPE_CODE (type) != TYPE_CODE_REF)
1223 type = TYPE_TARGET_TYPE (type);
1226 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1227 && TYPE_CODE (type) != TYPE_CODE_UNION)
1229 target_terminal_ours ();
1230 gdb_flush (gdb_stdout);
1231 fprintf_unfiltered (gdb_stderr, "Type ");
1232 type_print (type, "", gdb_stderr, -1);
1233 error (_(" is not a structure or union type."));
1237 /* FIXME: This change put in by Michael seems incorrect for the case
1238 where the structure tag name is the same as the member name.
1239 I.E. when doing "ptype bell->bar" for "struct foo { int bar; int
1240 foo; } bell;" Disabled by fnf. */
1244 typename = type_name_no_tag (type);
1245 if (typename != NULL && strcmp (typename, name) == 0)
1250 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1252 char *t_field_name = TYPE_FIELD_NAME (type, i);
1254 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1256 return TYPE_FIELD_TYPE (type, i);
1260 /* OK, it's not in this class. Recursively check the baseclasses. */
1261 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1265 t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 1);
1277 target_terminal_ours ();
1278 gdb_flush (gdb_stdout);
1279 fprintf_unfiltered (gdb_stderr, "Type ");
1280 type_print (type, "", gdb_stderr, -1);
1281 fprintf_unfiltered (gdb_stderr, " has no component named ");
1282 fputs_filtered (name, gdb_stderr);
1284 return (struct type *) -1; /* For lint */
1287 /* Lookup the vptr basetype/fieldno values for TYPE.
1288 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1289 vptr_fieldno. Also, if found and basetype is from the same objfile,
1291 If not found, return -1 and ignore BASETYPEP.
1292 Callers should be aware that in some cases (for example,
1293 the type or one of its baseclasses is a stub type and we are
1294 debugging a .o file), this function will not be able to find the
1295 virtual function table pointer, and vptr_fieldno will remain -1 and
1296 vptr_basetype will remain NULL or incomplete. */
1299 get_vptr_fieldno (struct type *type, struct type **basetypep)
1301 CHECK_TYPEDEF (type);
1303 if (TYPE_VPTR_FIELDNO (type) < 0)
1307 /* We must start at zero in case the first (and only) baseclass
1308 is virtual (and hence we cannot share the table pointer). */
1309 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1311 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
1313 struct type *basetype;
1315 fieldno = get_vptr_fieldno (baseclass, &basetype);
1318 /* If the type comes from a different objfile we can't cache
1319 it, it may have a different lifetime. PR 2384 */
1320 if (TYPE_OBJFILE (type) == TYPE_OBJFILE (baseclass))
1322 TYPE_VPTR_FIELDNO (type) = fieldno;
1323 TYPE_VPTR_BASETYPE (type) = basetype;
1326 *basetypep = basetype;
1337 *basetypep = TYPE_VPTR_BASETYPE (type);
1338 return TYPE_VPTR_FIELDNO (type);
1342 /* Find the method and field indices for the destructor in class type T.
1343 Return 1 if the destructor was found, otherwise, return 0. */
1346 get_destructor_fn_field (struct type *t,
1352 for (i = 0; i < TYPE_NFN_FIELDS (t); i++)
1355 struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
1357 for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (t, i); j++)
1359 if (is_destructor_name (TYPE_FN_FIELD_PHYSNAME (f, j)) != 0)
1371 stub_noname_complaint (void)
1373 complaint (&symfile_complaints, _("stub type has NULL name"));
1376 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1378 If this is a stubbed struct (i.e. declared as struct foo *), see if
1379 we can find a full definition in some other file. If so, copy this
1380 definition, so we can use it in future. There used to be a comment
1381 (but not any code) that if we don't find a full definition, we'd
1382 set a flag so we don't spend time in the future checking the same
1383 type. That would be a mistake, though--we might load in more
1384 symbols which contain a full definition for the type.
1386 This used to be coded as a macro, but I don't think it is called
1387 often enough to merit such treatment. */
1389 /* Find the real type of TYPE. This function returns the real type,
1390 after removing all layers of typedefs and completing opaque or stub
1391 types. Completion changes the TYPE argument, but stripping of
1392 typedefs does not. */
1395 check_typedef (struct type *type)
1397 struct type *orig_type = type;
1398 int is_const, is_volatile;
1402 while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1404 if (!TYPE_TARGET_TYPE (type))
1409 /* It is dangerous to call lookup_symbol if we are currently
1410 reading a symtab. Infinite recursion is one danger. */
1411 if (currently_reading_symtab)
1414 name = type_name_no_tag (type);
1415 /* FIXME: shouldn't we separately check the TYPE_NAME and
1416 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1417 VAR_DOMAIN as appropriate? (this code was written before
1418 TYPE_NAME and TYPE_TAG_NAME were separate). */
1421 stub_noname_complaint ();
1424 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
1426 TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
1427 else /* TYPE_CODE_UNDEF */
1428 TYPE_TARGET_TYPE (type) = alloc_type (NULL);
1430 type = TYPE_TARGET_TYPE (type);
1433 is_const = TYPE_CONST (type);
1434 is_volatile = TYPE_VOLATILE (type);
1436 /* If this is a struct/class/union with no fields, then check
1437 whether a full definition exists somewhere else. This is for
1438 systems where a type definition with no fields is issued for such
1439 types, instead of identifying them as stub types in the first
1442 if (TYPE_IS_OPAQUE (type)
1443 && opaque_type_resolution
1444 && !currently_reading_symtab)
1446 char *name = type_name_no_tag (type);
1447 struct type *newtype;
1450 stub_noname_complaint ();
1453 newtype = lookup_transparent_type (name);
1457 /* If the resolved type and the stub are in the same
1458 objfile, then replace the stub type with the real deal.
1459 But if they're in separate objfiles, leave the stub
1460 alone; we'll just look up the transparent type every time
1461 we call check_typedef. We can't create pointers between
1462 types allocated to different objfiles, since they may
1463 have different lifetimes. Trying to copy NEWTYPE over to
1464 TYPE's objfile is pointless, too, since you'll have to
1465 move over any other types NEWTYPE refers to, which could
1466 be an unbounded amount of stuff. */
1467 if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type))
1468 make_cv_type (is_const, is_volatile, newtype, &type);
1473 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1475 else if (TYPE_STUB (type) && !currently_reading_symtab)
1477 char *name = type_name_no_tag (type);
1478 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1479 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1480 as appropriate? (this code was written before TYPE_NAME and
1481 TYPE_TAG_NAME were separate). */
1485 stub_noname_complaint ();
1488 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
1491 /* Same as above for opaque types, we can replace the stub
1492 with the complete type only if they are int the same
1494 if (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type))
1495 make_cv_type (is_const, is_volatile,
1496 SYMBOL_TYPE (sym), &type);
1498 type = SYMBOL_TYPE (sym);
1502 if (TYPE_TARGET_STUB (type))
1504 struct type *range_type;
1505 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1507 if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type))
1511 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
1512 && TYPE_NFIELDS (type) == 1
1513 && (TYPE_CODE (range_type = TYPE_FIELD_TYPE (type, 0))
1514 == TYPE_CODE_RANGE))
1516 /* Now recompute the length of the array type, based on its
1517 number of elements and the target type's length.
1518 Watch out for Ada null Ada arrays where the high bound
1519 is smaller than the low bound. */
1520 const int low_bound = TYPE_FIELD_BITPOS (range_type, 0);
1521 const int high_bound = TYPE_FIELD_BITPOS (range_type, 1);
1524 if (high_bound < low_bound)
1527 nb_elements = high_bound - low_bound + 1;
1529 TYPE_LENGTH (type) = nb_elements * TYPE_LENGTH (target_type);
1530 TYPE_TARGET_STUB (type) = 0;
1532 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
1534 TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
1535 TYPE_TARGET_STUB (type) = 0;
1538 /* Cache TYPE_LENGTH for future use. */
1539 TYPE_LENGTH (orig_type) = TYPE_LENGTH (type);
1543 /* Parse a type expression in the string [P..P+LENGTH). If an error
1544 occurs, silently return builtin_type_void. */
1546 static struct type *
1547 safe_parse_type (char *p, int length)
1549 struct ui_file *saved_gdb_stderr;
1552 /* Suppress error messages. */
1553 saved_gdb_stderr = gdb_stderr;
1554 gdb_stderr = ui_file_new ();
1556 /* Call parse_and_eval_type() without fear of longjmp()s. */
1557 if (!gdb_parse_and_eval_type (p, length, &type))
1558 type = builtin_type_void;
1560 /* Stop suppressing error messages. */
1561 ui_file_delete (gdb_stderr);
1562 gdb_stderr = saved_gdb_stderr;
1567 /* Ugly hack to convert method stubs into method types.
1569 He ain't kiddin'. This demangles the name of the method into a
1570 string including argument types, parses out each argument type,
1571 generates a string casting a zero to that type, evaluates the
1572 string, and stuffs the resulting type into an argtype vector!!!
1573 Then it knows the type of the whole function (including argument
1574 types for overloading), which info used to be in the stab's but was
1575 removed to hack back the space required for them. */
1578 check_stub_method (struct type *type, int method_id, int signature_id)
1581 char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
1582 char *demangled_name = cplus_demangle (mangled_name,
1583 DMGL_PARAMS | DMGL_ANSI);
1584 char *argtypetext, *p;
1585 int depth = 0, argcount = 1;
1586 struct field *argtypes;
1589 /* Make sure we got back a function string that we can use. */
1591 p = strchr (demangled_name, '(');
1595 if (demangled_name == NULL || p == NULL)
1596 error (_("Internal: Cannot demangle mangled name `%s'."),
1599 /* Now, read in the parameters that define this type. */
1604 if (*p == '(' || *p == '<')
1608 else if (*p == ')' || *p == '>')
1612 else if (*p == ',' && depth == 0)
1620 /* If we read one argument and it was ``void'', don't count it. */
1621 if (strncmp (argtypetext, "(void)", 6) == 0)
1624 /* We need one extra slot, for the THIS pointer. */
1626 argtypes = (struct field *)
1627 TYPE_ALLOC (type, (argcount + 1) * sizeof (struct field));
1630 /* Add THIS pointer for non-static methods. */
1631 f = TYPE_FN_FIELDLIST1 (type, method_id);
1632 if (TYPE_FN_FIELD_STATIC_P (f, signature_id))
1636 argtypes[0].type = lookup_pointer_type (type);
1640 if (*p != ')') /* () means no args, skip while */
1645 if (depth <= 0 && (*p == ',' || *p == ')'))
1647 /* Avoid parsing of ellipsis, they will be handled below.
1648 Also avoid ``void'' as above. */
1649 if (strncmp (argtypetext, "...", p - argtypetext) != 0
1650 && strncmp (argtypetext, "void", p - argtypetext) != 0)
1652 argtypes[argcount].type =
1653 safe_parse_type (argtypetext, p - argtypetext);
1656 argtypetext = p + 1;
1659 if (*p == '(' || *p == '<')
1663 else if (*p == ')' || *p == '>')
1672 TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name;
1674 /* Now update the old "stub" type into a real type. */
1675 mtype = TYPE_FN_FIELD_TYPE (f, signature_id);
1676 TYPE_DOMAIN_TYPE (mtype) = type;
1677 TYPE_FIELDS (mtype) = argtypes;
1678 TYPE_NFIELDS (mtype) = argcount;
1679 TYPE_STUB (mtype) = 0;
1680 TYPE_FN_FIELD_STUB (f, signature_id) = 0;
1682 TYPE_VARARGS (mtype) = 1;
1684 xfree (demangled_name);
1687 /* This is the external interface to check_stub_method, above. This
1688 function unstubs all of the signatures for TYPE's METHOD_ID method
1689 name. After calling this function TYPE_FN_FIELD_STUB will be
1690 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1693 This function unfortunately can not die until stabs do. */
1696 check_stub_method_group (struct type *type, int method_id)
1698 int len = TYPE_FN_FIELDLIST_LENGTH (type, method_id);
1699 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
1700 int j, found_stub = 0;
1702 for (j = 0; j < len; j++)
1703 if (TYPE_FN_FIELD_STUB (f, j))
1706 check_stub_method (type, method_id, j);
1709 /* GNU v3 methods with incorrect names were corrected when we read
1710 in type information, because it was cheaper to do it then. The
1711 only GNU v2 methods with incorrect method names are operators and
1712 destructors; destructors were also corrected when we read in type
1715 Therefore the only thing we need to handle here are v2 operator
1717 if (found_stub && strncmp (TYPE_FN_FIELD_PHYSNAME (f, 0), "_Z", 2) != 0)
1720 char dem_opname[256];
1722 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
1724 dem_opname, DMGL_ANSI);
1726 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
1730 TYPE_FN_FIELDLIST_NAME (type, method_id) = xstrdup (dem_opname);
1734 const struct cplus_struct_type cplus_struct_default;
1737 allocate_cplus_struct_type (struct type *type)
1739 if (!HAVE_CPLUS_STRUCT (type))
1741 TYPE_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
1742 TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
1743 *(TYPE_CPLUS_SPECIFIC (type)) = cplus_struct_default;
1747 /* Helper function to initialize the standard scalar types.
1749 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy of
1750 the string pointed to by name in the objfile_obstack for that
1751 objfile, and initialize the type name to that copy. There are
1752 places (mipsread.c in particular, where init_type is called with a
1753 NULL value for NAME). */
1756 init_type (enum type_code code, int length, int flags,
1757 char *name, struct objfile *objfile)
1761 type = alloc_type (objfile);
1762 TYPE_CODE (type) = code;
1763 TYPE_LENGTH (type) = length;
1765 gdb_assert (!(flags & (TYPE_FLAG_MIN - 1)));
1766 if (flags & TYPE_FLAG_UNSIGNED)
1767 TYPE_UNSIGNED (type) = 1;
1768 if (flags & TYPE_FLAG_NOSIGN)
1769 TYPE_NOSIGN (type) = 1;
1770 if (flags & TYPE_FLAG_STUB)
1771 TYPE_STUB (type) = 1;
1772 if (flags & TYPE_FLAG_TARGET_STUB)
1773 TYPE_TARGET_STUB (type) = 1;
1774 if (flags & TYPE_FLAG_STATIC)
1775 TYPE_STATIC (type) = 1;
1776 if (flags & TYPE_FLAG_PROTOTYPED)
1777 TYPE_PROTOTYPED (type) = 1;
1778 if (flags & TYPE_FLAG_INCOMPLETE)
1779 TYPE_INCOMPLETE (type) = 1;
1780 if (flags & TYPE_FLAG_VARARGS)
1781 TYPE_VARARGS (type) = 1;
1782 if (flags & TYPE_FLAG_VECTOR)
1783 TYPE_VECTOR (type) = 1;
1784 if (flags & TYPE_FLAG_STUB_SUPPORTED)
1785 TYPE_STUB_SUPPORTED (type) = 1;
1786 if (flags & TYPE_FLAG_NOTTEXT)
1787 TYPE_NOTTEXT (type) = 1;
1788 if (flags & TYPE_FLAG_FIXED_INSTANCE)
1789 TYPE_FIXED_INSTANCE (type) = 1;
1791 if ((name != NULL) && (objfile != NULL))
1793 TYPE_NAME (type) = obsavestring (name, strlen (name),
1794 &objfile->objfile_obstack);
1798 TYPE_NAME (type) = name;
1803 if (name && strcmp (name, "char") == 0)
1804 TYPE_NOSIGN (type) = 1;
1806 if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION
1807 || code == TYPE_CODE_NAMESPACE)
1809 INIT_CPLUS_SPECIFIC (type);
1814 /* Helper function. Create an empty composite type. */
1817 init_composite_type (char *name, enum type_code code)
1820 gdb_assert (code == TYPE_CODE_STRUCT
1821 || code == TYPE_CODE_UNION);
1822 t = init_type (code, 0, 0, NULL, NULL);
1823 TYPE_TAG_NAME (t) = name;
1827 /* Helper function. Append a field to a composite type. */
1830 append_composite_type_field (struct type *t, char *name,
1834 TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
1835 TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t),
1836 sizeof (struct field) * TYPE_NFIELDS (t));
1837 f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
1838 memset (f, 0, sizeof f[0]);
1839 FIELD_TYPE (f[0]) = field;
1840 FIELD_NAME (f[0]) = name;
1841 if (TYPE_CODE (t) == TYPE_CODE_UNION)
1843 if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
1844 TYPE_LENGTH (t) = TYPE_LENGTH (field);
1846 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
1848 TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
1849 if (TYPE_NFIELDS (t) > 1)
1851 FIELD_BITPOS (f[0]) = (FIELD_BITPOS (f[-1])
1852 + TYPE_LENGTH (field) * TARGET_CHAR_BIT);
1858 can_dereference (struct type *t)
1860 /* FIXME: Should we return true for references as well as
1865 && TYPE_CODE (t) == TYPE_CODE_PTR
1866 && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
1870 is_integral_type (struct type *t)
1875 && ((TYPE_CODE (t) == TYPE_CODE_INT)
1876 || (TYPE_CODE (t) == TYPE_CODE_ENUM)
1877 || (TYPE_CODE (t) == TYPE_CODE_FLAGS)
1878 || (TYPE_CODE (t) == TYPE_CODE_CHAR)
1879 || (TYPE_CODE (t) == TYPE_CODE_RANGE)
1880 || (TYPE_CODE (t) == TYPE_CODE_BOOL)));
1883 /* Check whether BASE is an ancestor or base class or DCLASS
1884 Return 1 if so, and 0 if not.
1885 Note: callers may want to check for identity of the types before
1886 calling this function -- identical types are considered to satisfy
1887 the ancestor relationship even if they're identical. */
1890 is_ancestor (struct type *base, struct type *dclass)
1894 CHECK_TYPEDEF (base);
1895 CHECK_TYPEDEF (dclass);
1899 if (TYPE_NAME (base) && TYPE_NAME (dclass)
1900 && !strcmp (TYPE_NAME (base), TYPE_NAME (dclass)))
1903 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
1904 if (is_ancestor (base, TYPE_BASECLASS (dclass, i)))
1912 /* Functions for overload resolution begin here */
1914 /* Compare two badness vectors A and B and return the result.
1915 0 => A and B are identical
1916 1 => A and B are incomparable
1917 2 => A is better than B
1918 3 => A is worse than B */
1921 compare_badness (struct badness_vector *a, struct badness_vector *b)
1925 short found_pos = 0; /* any positives in c? */
1926 short found_neg = 0; /* any negatives in c? */
1928 /* differing lengths => incomparable */
1929 if (a->length != b->length)
1932 /* Subtract b from a */
1933 for (i = 0; i < a->length; i++)
1935 tmp = a->rank[i] - b->rank[i];
1945 return 1; /* incomparable */
1947 return 3; /* A > B */
1953 return 2; /* A < B */
1955 return 0; /* A == B */
1959 /* Rank a function by comparing its parameter types (PARMS, length
1960 NPARMS), to the types of an argument list (ARGS, length NARGS).
1961 Return a pointer to a badness vector. This has NARGS + 1
1964 struct badness_vector *
1965 rank_function (struct type **parms, int nparms,
1966 struct type **args, int nargs)
1969 struct badness_vector *bv;
1970 int min_len = nparms < nargs ? nparms : nargs;
1972 bv = xmalloc (sizeof (struct badness_vector));
1973 bv->length = nargs + 1; /* add 1 for the length-match rank */
1974 bv->rank = xmalloc ((nargs + 1) * sizeof (int));
1976 /* First compare the lengths of the supplied lists.
1977 If there is a mismatch, set it to a high value. */
1979 /* pai/1997-06-03 FIXME: when we have debug info about default
1980 arguments and ellipsis parameter lists, we should consider those
1981 and rank the length-match more finely. */
1983 LENGTH_MATCH (bv) = (nargs != nparms) ? LENGTH_MISMATCH_BADNESS : 0;
1985 /* Now rank all the parameters of the candidate function */
1986 for (i = 1; i <= min_len; i++)
1987 bv->rank[i] = rank_one_type (parms[i-1], args[i-1]);
1989 /* If more arguments than parameters, add dummy entries */
1990 for (i = min_len + 1; i <= nargs; i++)
1991 bv->rank[i] = TOO_FEW_PARAMS_BADNESS;
1996 /* Compare the names of two integer types, assuming that any sign
1997 qualifiers have been checked already. We do it this way because
1998 there may be an "int" in the name of one of the types. */
2001 integer_types_same_name_p (const char *first, const char *second)
2003 int first_p, second_p;
2005 /* If both are shorts, return 1; if neither is a short, keep
2007 first_p = (strstr (first, "short") != NULL);
2008 second_p = (strstr (second, "short") != NULL);
2009 if (first_p && second_p)
2011 if (first_p || second_p)
2014 /* Likewise for long. */
2015 first_p = (strstr (first, "long") != NULL);
2016 second_p = (strstr (second, "long") != NULL);
2017 if (first_p && second_p)
2019 if (first_p || second_p)
2022 /* Likewise for char. */
2023 first_p = (strstr (first, "char") != NULL);
2024 second_p = (strstr (second, "char") != NULL);
2025 if (first_p && second_p)
2027 if (first_p || second_p)
2030 /* They must both be ints. */
2034 /* Compare one type (PARM) for compatibility with another (ARG).
2035 * PARM is intended to be the parameter type of a function; and
2036 * ARG is the supplied argument's type. This function tests if
2037 * the latter can be converted to the former.
2039 * Return 0 if they are identical types;
2040 * Otherwise, return an integer which corresponds to how compatible
2041 * PARM is to ARG. The higher the return value, the worse the match.
2042 * Generally the "bad" conversions are all uniformly assigned a 100. */
2045 rank_one_type (struct type *parm, struct type *arg)
2047 /* Identical type pointers. */
2048 /* However, this still doesn't catch all cases of same type for arg
2049 and param. The reason is that builtin types are different from
2050 the same ones constructed from the object. */
2054 /* Resolve typedefs */
2055 if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF)
2056 parm = check_typedef (parm);
2057 if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
2058 arg = check_typedef (arg);
2061 Well, damnit, if the names are exactly the same, I'll say they
2062 are exactly the same. This happens when we generate method
2063 stubs. The types won't point to the same address, but they
2064 really are the same.
2067 if (TYPE_NAME (parm) && TYPE_NAME (arg)
2068 && !strcmp (TYPE_NAME (parm), TYPE_NAME (arg)))
2071 /* Check if identical after resolving typedefs. */
2075 /* See through references, since we can almost make non-references
2077 if (TYPE_CODE (arg) == TYPE_CODE_REF)
2078 return (rank_one_type (parm, TYPE_TARGET_TYPE (arg))
2079 + REFERENCE_CONVERSION_BADNESS);
2080 if (TYPE_CODE (parm) == TYPE_CODE_REF)
2081 return (rank_one_type (TYPE_TARGET_TYPE (parm), arg)
2082 + REFERENCE_CONVERSION_BADNESS);
2084 /* Debugging only. */
2085 fprintf_filtered (gdb_stderr,
2086 "------ Arg is %s [%d], parm is %s [%d]\n",
2087 TYPE_NAME (arg), TYPE_CODE (arg),
2088 TYPE_NAME (parm), TYPE_CODE (parm));
2090 /* x -> y means arg of type x being supplied for parameter of type y */
2092 switch (TYPE_CODE (parm))
2095 switch (TYPE_CODE (arg))
2098 if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID)
2099 return VOID_PTR_CONVERSION_BADNESS;
2101 return rank_one_type (TYPE_TARGET_TYPE (parm),
2102 TYPE_TARGET_TYPE (arg));
2103 case TYPE_CODE_ARRAY:
2104 return rank_one_type (TYPE_TARGET_TYPE (parm),
2105 TYPE_TARGET_TYPE (arg));
2106 case TYPE_CODE_FUNC:
2107 return rank_one_type (TYPE_TARGET_TYPE (parm), arg);
2109 case TYPE_CODE_ENUM:
2110 case TYPE_CODE_FLAGS:
2111 case TYPE_CODE_CHAR:
2112 case TYPE_CODE_RANGE:
2113 case TYPE_CODE_BOOL:
2114 return POINTER_CONVERSION_BADNESS;
2116 return INCOMPATIBLE_TYPE_BADNESS;
2118 case TYPE_CODE_ARRAY:
2119 switch (TYPE_CODE (arg))
2122 case TYPE_CODE_ARRAY:
2123 return rank_one_type (TYPE_TARGET_TYPE (parm),
2124 TYPE_TARGET_TYPE (arg));
2126 return INCOMPATIBLE_TYPE_BADNESS;
2128 case TYPE_CODE_FUNC:
2129 switch (TYPE_CODE (arg))
2131 case TYPE_CODE_PTR: /* funcptr -> func */
2132 return rank_one_type (parm, TYPE_TARGET_TYPE (arg));
2134 return INCOMPATIBLE_TYPE_BADNESS;
2137 switch (TYPE_CODE (arg))
2140 if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2142 /* Deal with signed, unsigned, and plain chars and
2143 signed and unsigned ints. */
2144 if (TYPE_NOSIGN (parm))
2146 /* This case only for character types */
2147 if (TYPE_NOSIGN (arg))
2148 return 0; /* plain char -> plain char */
2149 else /* signed/unsigned char -> plain char */
2150 return INTEGER_CONVERSION_BADNESS;
2152 else if (TYPE_UNSIGNED (parm))
2154 if (TYPE_UNSIGNED (arg))
2156 /* unsigned int -> unsigned int, or
2157 unsigned long -> unsigned long */
2158 if (integer_types_same_name_p (TYPE_NAME (parm),
2161 else if (integer_types_same_name_p (TYPE_NAME (arg),
2163 && integer_types_same_name_p (TYPE_NAME (parm),
2165 return INTEGER_PROMOTION_BADNESS; /* unsigned int -> unsigned long */
2167 return INTEGER_CONVERSION_BADNESS; /* unsigned long -> unsigned int */
2171 if (integer_types_same_name_p (TYPE_NAME (arg),
2173 && integer_types_same_name_p (TYPE_NAME (parm),
2175 return INTEGER_CONVERSION_BADNESS; /* signed long -> unsigned int */
2177 return INTEGER_CONVERSION_BADNESS; /* signed int/long -> unsigned int/long */
2180 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2182 if (integer_types_same_name_p (TYPE_NAME (parm),
2185 else if (integer_types_same_name_p (TYPE_NAME (arg),
2187 && integer_types_same_name_p (TYPE_NAME (parm),
2189 return INTEGER_PROMOTION_BADNESS;
2191 return INTEGER_CONVERSION_BADNESS;
2194 return INTEGER_CONVERSION_BADNESS;
2196 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2197 return INTEGER_PROMOTION_BADNESS;
2199 return INTEGER_CONVERSION_BADNESS;
2200 case TYPE_CODE_ENUM:
2201 case TYPE_CODE_FLAGS:
2202 case TYPE_CODE_CHAR:
2203 case TYPE_CODE_RANGE:
2204 case TYPE_CODE_BOOL:
2205 return INTEGER_PROMOTION_BADNESS;
2207 return INT_FLOAT_CONVERSION_BADNESS;
2209 return NS_POINTER_CONVERSION_BADNESS;
2211 return INCOMPATIBLE_TYPE_BADNESS;
2214 case TYPE_CODE_ENUM:
2215 switch (TYPE_CODE (arg))
2218 case TYPE_CODE_CHAR:
2219 case TYPE_CODE_RANGE:
2220 case TYPE_CODE_BOOL:
2221 case TYPE_CODE_ENUM:
2222 return INTEGER_CONVERSION_BADNESS;
2224 return INT_FLOAT_CONVERSION_BADNESS;
2226 return INCOMPATIBLE_TYPE_BADNESS;
2229 case TYPE_CODE_CHAR:
2230 switch (TYPE_CODE (arg))
2232 case TYPE_CODE_RANGE:
2233 case TYPE_CODE_BOOL:
2234 case TYPE_CODE_ENUM:
2235 return INTEGER_CONVERSION_BADNESS;
2237 return INT_FLOAT_CONVERSION_BADNESS;
2239 if (TYPE_LENGTH (arg) > TYPE_LENGTH (parm))
2240 return INTEGER_CONVERSION_BADNESS;
2241 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2242 return INTEGER_PROMOTION_BADNESS;
2243 /* >>> !! else fall through !! <<< */
2244 case TYPE_CODE_CHAR:
2245 /* Deal with signed, unsigned, and plain chars for C++ and
2246 with int cases falling through from previous case. */
2247 if (TYPE_NOSIGN (parm))
2249 if (TYPE_NOSIGN (arg))
2252 return INTEGER_CONVERSION_BADNESS;
2254 else if (TYPE_UNSIGNED (parm))
2256 if (TYPE_UNSIGNED (arg))
2259 return INTEGER_PROMOTION_BADNESS;
2261 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2264 return INTEGER_CONVERSION_BADNESS;
2266 return INCOMPATIBLE_TYPE_BADNESS;
2269 case TYPE_CODE_RANGE:
2270 switch (TYPE_CODE (arg))
2273 case TYPE_CODE_CHAR:
2274 case TYPE_CODE_RANGE:
2275 case TYPE_CODE_BOOL:
2276 case TYPE_CODE_ENUM:
2277 return INTEGER_CONVERSION_BADNESS;
2279 return INT_FLOAT_CONVERSION_BADNESS;
2281 return INCOMPATIBLE_TYPE_BADNESS;
2284 case TYPE_CODE_BOOL:
2285 switch (TYPE_CODE (arg))
2288 case TYPE_CODE_CHAR:
2289 case TYPE_CODE_RANGE:
2290 case TYPE_CODE_ENUM:
2293 return BOOLEAN_CONVERSION_BADNESS;
2294 case TYPE_CODE_BOOL:
2297 return INCOMPATIBLE_TYPE_BADNESS;
2301 switch (TYPE_CODE (arg))
2304 if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2305 return FLOAT_PROMOTION_BADNESS;
2306 else if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2309 return FLOAT_CONVERSION_BADNESS;
2311 case TYPE_CODE_BOOL:
2312 case TYPE_CODE_ENUM:
2313 case TYPE_CODE_RANGE:
2314 case TYPE_CODE_CHAR:
2315 return INT_FLOAT_CONVERSION_BADNESS;
2317 return INCOMPATIBLE_TYPE_BADNESS;
2320 case TYPE_CODE_COMPLEX:
2321 switch (TYPE_CODE (arg))
2322 { /* Strictly not needed for C++, but... */
2324 return FLOAT_PROMOTION_BADNESS;
2325 case TYPE_CODE_COMPLEX:
2328 return INCOMPATIBLE_TYPE_BADNESS;
2331 case TYPE_CODE_STRUCT:
2332 /* currently same as TYPE_CODE_CLASS */
2333 switch (TYPE_CODE (arg))
2335 case TYPE_CODE_STRUCT:
2336 /* Check for derivation */
2337 if (is_ancestor (parm, arg))
2338 return BASE_CONVERSION_BADNESS;
2339 /* else fall through */
2341 return INCOMPATIBLE_TYPE_BADNESS;
2344 case TYPE_CODE_UNION:
2345 switch (TYPE_CODE (arg))
2347 case TYPE_CODE_UNION:
2349 return INCOMPATIBLE_TYPE_BADNESS;
2352 case TYPE_CODE_MEMBERPTR:
2353 switch (TYPE_CODE (arg))
2356 return INCOMPATIBLE_TYPE_BADNESS;
2359 case TYPE_CODE_METHOD:
2360 switch (TYPE_CODE (arg))
2364 return INCOMPATIBLE_TYPE_BADNESS;
2368 switch (TYPE_CODE (arg))
2372 return INCOMPATIBLE_TYPE_BADNESS;
2377 switch (TYPE_CODE (arg))
2381 return rank_one_type (TYPE_FIELD_TYPE (parm, 0),
2382 TYPE_FIELD_TYPE (arg, 0));
2384 return INCOMPATIBLE_TYPE_BADNESS;
2387 case TYPE_CODE_VOID:
2389 return INCOMPATIBLE_TYPE_BADNESS;
2390 } /* switch (TYPE_CODE (arg)) */
2394 /* End of functions for overload resolution */
2397 print_bit_vector (B_TYPE *bits, int nbits)
2401 for (bitno = 0; bitno < nbits; bitno++)
2403 if ((bitno % 8) == 0)
2405 puts_filtered (" ");
2407 if (B_TST (bits, bitno))
2408 printf_filtered (("1"));
2410 printf_filtered (("0"));
2414 /* Note the first arg should be the "this" pointer, we may not want to
2415 include it since we may get into a infinitely recursive
2419 print_arg_types (struct field *args, int nargs, int spaces)
2425 for (i = 0; i < nargs; i++)
2426 recursive_dump_type (args[i].type, spaces + 2);
2431 dump_fn_fieldlists (struct type *type, int spaces)
2437 printfi_filtered (spaces, "fn_fieldlists ");
2438 gdb_print_host_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
2439 printf_filtered ("\n");
2440 for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
2442 f = TYPE_FN_FIELDLIST1 (type, method_idx);
2443 printfi_filtered (spaces + 2, "[%d] name '%s' (",
2445 TYPE_FN_FIELDLIST_NAME (type, method_idx));
2446 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
2448 printf_filtered (_(") length %d\n"),
2449 TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
2450 for (overload_idx = 0;
2451 overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
2454 printfi_filtered (spaces + 4, "[%d] physname '%s' (",
2456 TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
2457 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
2459 printf_filtered (")\n");
2460 printfi_filtered (spaces + 8, "type ");
2461 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx),
2463 printf_filtered ("\n");
2465 recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
2468 printfi_filtered (spaces + 8, "args ");
2469 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx),
2471 printf_filtered ("\n");
2473 print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx),
2474 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f,
2477 printfi_filtered (spaces + 8, "fcontext ");
2478 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
2480 printf_filtered ("\n");
2482 printfi_filtered (spaces + 8, "is_const %d\n",
2483 TYPE_FN_FIELD_CONST (f, overload_idx));
2484 printfi_filtered (spaces + 8, "is_volatile %d\n",
2485 TYPE_FN_FIELD_VOLATILE (f, overload_idx));
2486 printfi_filtered (spaces + 8, "is_private %d\n",
2487 TYPE_FN_FIELD_PRIVATE (f, overload_idx));
2488 printfi_filtered (spaces + 8, "is_protected %d\n",
2489 TYPE_FN_FIELD_PROTECTED (f, overload_idx));
2490 printfi_filtered (spaces + 8, "is_stub %d\n",
2491 TYPE_FN_FIELD_STUB (f, overload_idx));
2492 printfi_filtered (spaces + 8, "voffset %u\n",
2493 TYPE_FN_FIELD_VOFFSET (f, overload_idx));
2499 print_cplus_stuff (struct type *type, int spaces)
2501 printfi_filtered (spaces, "n_baseclasses %d\n",
2502 TYPE_N_BASECLASSES (type));
2503 printfi_filtered (spaces, "nfn_fields %d\n",
2504 TYPE_NFN_FIELDS (type));
2505 printfi_filtered (spaces, "nfn_fields_total %d\n",
2506 TYPE_NFN_FIELDS_TOTAL (type));
2507 if (TYPE_N_BASECLASSES (type) > 0)
2509 printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
2510 TYPE_N_BASECLASSES (type));
2511 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type),
2513 printf_filtered (")");
2515 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
2516 TYPE_N_BASECLASSES (type));
2517 puts_filtered ("\n");
2519 if (TYPE_NFIELDS (type) > 0)
2521 if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
2523 printfi_filtered (spaces,
2524 "private_field_bits (%d bits at *",
2525 TYPE_NFIELDS (type));
2526 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type),
2528 printf_filtered (")");
2529 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
2530 TYPE_NFIELDS (type));
2531 puts_filtered ("\n");
2533 if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
2535 printfi_filtered (spaces,
2536 "protected_field_bits (%d bits at *",
2537 TYPE_NFIELDS (type));
2538 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type),
2540 printf_filtered (")");
2541 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
2542 TYPE_NFIELDS (type));
2543 puts_filtered ("\n");
2546 if (TYPE_NFN_FIELDS (type) > 0)
2548 dump_fn_fieldlists (type, spaces);
2553 print_bound_type (int bt)
2557 case BOUND_CANNOT_BE_DETERMINED:
2558 printf_filtered ("(BOUND_CANNOT_BE_DETERMINED)");
2560 case BOUND_BY_REF_ON_STACK:
2561 printf_filtered ("(BOUND_BY_REF_ON_STACK)");
2563 case BOUND_BY_VALUE_ON_STACK:
2564 printf_filtered ("(BOUND_BY_VALUE_ON_STACK)");
2566 case BOUND_BY_REF_IN_REG:
2567 printf_filtered ("(BOUND_BY_REF_IN_REG)");
2569 case BOUND_BY_VALUE_IN_REG:
2570 printf_filtered ("(BOUND_BY_VALUE_IN_REG)");
2573 printf_filtered ("(BOUND_SIMPLE)");
2576 printf_filtered (_("(unknown bound type)"));
2581 static struct obstack dont_print_type_obstack;
2584 recursive_dump_type (struct type *type, int spaces)
2589 obstack_begin (&dont_print_type_obstack, 0);
2591 if (TYPE_NFIELDS (type) > 0
2592 || (TYPE_CPLUS_SPECIFIC (type) && TYPE_NFN_FIELDS (type) > 0))
2594 struct type **first_dont_print
2595 = (struct type **) obstack_base (&dont_print_type_obstack);
2597 int i = (struct type **)
2598 obstack_next_free (&dont_print_type_obstack) - first_dont_print;
2602 if (type == first_dont_print[i])
2604 printfi_filtered (spaces, "type node ");
2605 gdb_print_host_address (type, gdb_stdout);
2606 printf_filtered (_(" <same as already seen type>\n"));
2611 obstack_ptr_grow (&dont_print_type_obstack, type);
2614 printfi_filtered (spaces, "type node ");
2615 gdb_print_host_address (type, gdb_stdout);
2616 printf_filtered ("\n");
2617 printfi_filtered (spaces, "name '%s' (",
2618 TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
2619 gdb_print_host_address (TYPE_NAME (type), gdb_stdout);
2620 printf_filtered (")\n");
2621 printfi_filtered (spaces, "tagname '%s' (",
2622 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : "<NULL>");
2623 gdb_print_host_address (TYPE_TAG_NAME (type), gdb_stdout);
2624 printf_filtered (")\n");
2625 printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
2626 switch (TYPE_CODE (type))
2628 case TYPE_CODE_UNDEF:
2629 printf_filtered ("(TYPE_CODE_UNDEF)");
2632 printf_filtered ("(TYPE_CODE_PTR)");
2634 case TYPE_CODE_ARRAY:
2635 printf_filtered ("(TYPE_CODE_ARRAY)");
2637 case TYPE_CODE_STRUCT:
2638 printf_filtered ("(TYPE_CODE_STRUCT)");
2640 case TYPE_CODE_UNION:
2641 printf_filtered ("(TYPE_CODE_UNION)");
2643 case TYPE_CODE_ENUM:
2644 printf_filtered ("(TYPE_CODE_ENUM)");
2646 case TYPE_CODE_FLAGS:
2647 printf_filtered ("(TYPE_CODE_FLAGS)");
2649 case TYPE_CODE_FUNC:
2650 printf_filtered ("(TYPE_CODE_FUNC)");
2653 printf_filtered ("(TYPE_CODE_INT)");
2656 printf_filtered ("(TYPE_CODE_FLT)");
2658 case TYPE_CODE_VOID:
2659 printf_filtered ("(TYPE_CODE_VOID)");
2662 printf_filtered ("(TYPE_CODE_SET)");
2664 case TYPE_CODE_RANGE:
2665 printf_filtered ("(TYPE_CODE_RANGE)");
2667 case TYPE_CODE_STRING:
2668 printf_filtered ("(TYPE_CODE_STRING)");
2670 case TYPE_CODE_BITSTRING:
2671 printf_filtered ("(TYPE_CODE_BITSTRING)");
2673 case TYPE_CODE_ERROR:
2674 printf_filtered ("(TYPE_CODE_ERROR)");
2676 case TYPE_CODE_MEMBERPTR:
2677 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
2679 case TYPE_CODE_METHODPTR:
2680 printf_filtered ("(TYPE_CODE_METHODPTR)");
2682 case TYPE_CODE_METHOD:
2683 printf_filtered ("(TYPE_CODE_METHOD)");
2686 printf_filtered ("(TYPE_CODE_REF)");
2688 case TYPE_CODE_CHAR:
2689 printf_filtered ("(TYPE_CODE_CHAR)");
2691 case TYPE_CODE_BOOL:
2692 printf_filtered ("(TYPE_CODE_BOOL)");
2694 case TYPE_CODE_COMPLEX:
2695 printf_filtered ("(TYPE_CODE_COMPLEX)");
2697 case TYPE_CODE_TYPEDEF:
2698 printf_filtered ("(TYPE_CODE_TYPEDEF)");
2700 case TYPE_CODE_TEMPLATE:
2701 printf_filtered ("(TYPE_CODE_TEMPLATE)");
2703 case TYPE_CODE_TEMPLATE_ARG:
2704 printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)");
2706 case TYPE_CODE_NAMESPACE:
2707 printf_filtered ("(TYPE_CODE_NAMESPACE)");
2710 printf_filtered ("(UNKNOWN TYPE CODE)");
2713 puts_filtered ("\n");
2714 printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
2715 printfi_filtered (spaces, "upper_bound_type 0x%x ",
2716 TYPE_ARRAY_UPPER_BOUND_TYPE (type));
2717 print_bound_type (TYPE_ARRAY_UPPER_BOUND_TYPE (type));
2718 puts_filtered ("\n");
2719 printfi_filtered (spaces, "lower_bound_type 0x%x ",
2720 TYPE_ARRAY_LOWER_BOUND_TYPE (type));
2721 print_bound_type (TYPE_ARRAY_LOWER_BOUND_TYPE (type));
2722 puts_filtered ("\n");
2723 printfi_filtered (spaces, "objfile ");
2724 gdb_print_host_address (TYPE_OBJFILE (type), gdb_stdout);
2725 printf_filtered ("\n");
2726 printfi_filtered (spaces, "target_type ");
2727 gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout);
2728 printf_filtered ("\n");
2729 if (TYPE_TARGET_TYPE (type) != NULL)
2731 recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
2733 printfi_filtered (spaces, "pointer_type ");
2734 gdb_print_host_address (TYPE_POINTER_TYPE (type), gdb_stdout);
2735 printf_filtered ("\n");
2736 printfi_filtered (spaces, "reference_type ");
2737 gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
2738 printf_filtered ("\n");
2739 printfi_filtered (spaces, "type_chain ");
2740 gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);
2741 printf_filtered ("\n");
2742 printfi_filtered (spaces, "instance_flags 0x%x",
2743 TYPE_INSTANCE_FLAGS (type));
2744 if (TYPE_CONST (type))
2746 puts_filtered (" TYPE_FLAG_CONST");
2748 if (TYPE_VOLATILE (type))
2750 puts_filtered (" TYPE_FLAG_VOLATILE");
2752 if (TYPE_CODE_SPACE (type))
2754 puts_filtered (" TYPE_FLAG_CODE_SPACE");
2756 if (TYPE_DATA_SPACE (type))
2758 puts_filtered (" TYPE_FLAG_DATA_SPACE");
2760 if (TYPE_ADDRESS_CLASS_1 (type))
2762 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
2764 if (TYPE_ADDRESS_CLASS_2 (type))
2766 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
2768 puts_filtered ("\n");
2770 printfi_filtered (spaces, "flags");
2771 if (TYPE_UNSIGNED (type))
2773 puts_filtered (" TYPE_FLAG_UNSIGNED");
2775 if (TYPE_NOSIGN (type))
2777 puts_filtered (" TYPE_FLAG_NOSIGN");
2779 if (TYPE_STUB (type))
2781 puts_filtered (" TYPE_FLAG_STUB");
2783 if (TYPE_TARGET_STUB (type))
2785 puts_filtered (" TYPE_FLAG_TARGET_STUB");
2787 if (TYPE_STATIC (type))
2789 puts_filtered (" TYPE_FLAG_STATIC");
2791 if (TYPE_PROTOTYPED (type))
2793 puts_filtered (" TYPE_FLAG_PROTOTYPED");
2795 if (TYPE_INCOMPLETE (type))
2797 puts_filtered (" TYPE_FLAG_INCOMPLETE");
2799 if (TYPE_VARARGS (type))
2801 puts_filtered (" TYPE_FLAG_VARARGS");
2803 /* This is used for things like AltiVec registers on ppc. Gcc emits
2804 an attribute for the array type, which tells whether or not we
2805 have a vector, instead of a regular array. */
2806 if (TYPE_VECTOR (type))
2808 puts_filtered (" TYPE_FLAG_VECTOR");
2810 if (TYPE_FIXED_INSTANCE (type))
2812 puts_filtered (" TYPE_FIXED_INSTANCE");
2814 if (TYPE_STUB_SUPPORTED (type))
2816 puts_filtered (" TYPE_STUB_SUPPORTED");
2818 if (TYPE_NOTTEXT (type))
2820 puts_filtered (" TYPE_NOTTEXT");
2822 puts_filtered ("\n");
2823 printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
2824 gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
2825 puts_filtered ("\n");
2826 for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
2828 printfi_filtered (spaces + 2,
2829 "[%d] bitpos %d bitsize %d type ",
2830 idx, TYPE_FIELD_BITPOS (type, idx),
2831 TYPE_FIELD_BITSIZE (type, idx));
2832 gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
2833 printf_filtered (" name '%s' (",
2834 TYPE_FIELD_NAME (type, idx) != NULL
2835 ? TYPE_FIELD_NAME (type, idx)
2837 gdb_print_host_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
2838 printf_filtered (")\n");
2839 if (TYPE_FIELD_TYPE (type, idx) != NULL)
2841 recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
2844 printfi_filtered (spaces, "vptr_basetype ");
2845 gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
2846 puts_filtered ("\n");
2847 if (TYPE_VPTR_BASETYPE (type) != NULL)
2849 recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
2851 printfi_filtered (spaces, "vptr_fieldno %d\n",
2852 TYPE_VPTR_FIELDNO (type));
2853 switch (TYPE_CODE (type))
2855 case TYPE_CODE_STRUCT:
2856 printfi_filtered (spaces, "cplus_stuff ");
2857 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type),
2859 puts_filtered ("\n");
2860 print_cplus_stuff (type, spaces);
2864 printfi_filtered (spaces, "floatformat ");
2865 if (TYPE_FLOATFORMAT (type) == NULL)
2866 puts_filtered ("(null)");
2869 puts_filtered ("{ ");
2870 if (TYPE_FLOATFORMAT (type)[0] == NULL
2871 || TYPE_FLOATFORMAT (type)[0]->name == NULL)
2872 puts_filtered ("(null)");
2874 puts_filtered (TYPE_FLOATFORMAT (type)[0]->name);
2876 puts_filtered (", ");
2877 if (TYPE_FLOATFORMAT (type)[1] == NULL
2878 || TYPE_FLOATFORMAT (type)[1]->name == NULL)
2879 puts_filtered ("(null)");
2881 puts_filtered (TYPE_FLOATFORMAT (type)[1]->name);
2883 puts_filtered (" }");
2885 puts_filtered ("\n");
2889 /* We have to pick one of the union types to be able print and
2890 test the value. Pick cplus_struct_type, even though we know
2891 it isn't any particular one. */
2892 printfi_filtered (spaces, "type_specific ");
2893 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
2894 if (TYPE_CPLUS_SPECIFIC (type) != NULL)
2896 printf_filtered (_(" (unknown data form)"));
2898 printf_filtered ("\n");
2903 obstack_free (&dont_print_type_obstack, NULL);
2906 /* Trivial helpers for the libiberty hash table, for mapping one
2911 struct type *old, *new;
2915 type_pair_hash (const void *item)
2917 const struct type_pair *pair = item;
2918 return htab_hash_pointer (pair->old);
2922 type_pair_eq (const void *item_lhs, const void *item_rhs)
2924 const struct type_pair *lhs = item_lhs, *rhs = item_rhs;
2925 return lhs->old == rhs->old;
2928 /* Allocate the hash table used by copy_type_recursive to walk
2929 types without duplicates. We use OBJFILE's obstack, because
2930 OBJFILE is about to be deleted. */
2933 create_copied_types_hash (struct objfile *objfile)
2935 return htab_create_alloc_ex (1, type_pair_hash, type_pair_eq,
2936 NULL, &objfile->objfile_obstack,
2937 hashtab_obstack_allocate,
2938 dummy_obstack_deallocate);
2941 /* Recursively copy (deep copy) TYPE, if it is associated with
2942 OBJFILE. Return a new type allocated using malloc, a saved type if
2943 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
2944 not associated with OBJFILE. */
2947 copy_type_recursive (struct objfile *objfile,
2949 htab_t copied_types)
2951 struct type_pair *stored, pair;
2953 struct type *new_type;
2955 if (TYPE_OBJFILE (type) == NULL)
2958 /* This type shouldn't be pointing to any types in other objfiles;
2959 if it did, the type might disappear unexpectedly. */
2960 gdb_assert (TYPE_OBJFILE (type) == objfile);
2963 slot = htab_find_slot (copied_types, &pair, INSERT);
2965 return ((struct type_pair *) *slot)->new;
2967 new_type = alloc_type (NULL);
2969 /* We must add the new type to the hash table immediately, in case
2970 we encounter this type again during a recursive call below. */
2971 stored = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair));
2973 stored->new = new_type;
2976 /* Copy the common fields of types. For the main type, we simply
2977 copy the entire thing and then update specific fields as needed. */
2978 *TYPE_MAIN_TYPE (new_type) = *TYPE_MAIN_TYPE (type);
2979 TYPE_OBJFILE (new_type) = NULL;
2981 if (TYPE_NAME (type))
2982 TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type));
2983 if (TYPE_TAG_NAME (type))
2984 TYPE_TAG_NAME (new_type) = xstrdup (TYPE_TAG_NAME (type));
2986 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
2987 TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
2989 /* Copy the fields. */
2990 if (TYPE_NFIELDS (type))
2994 nfields = TYPE_NFIELDS (type);
2995 TYPE_FIELDS (new_type) = xmalloc (sizeof (struct field) * nfields);
2996 for (i = 0; i < nfields; i++)
2998 TYPE_FIELD_ARTIFICIAL (new_type, i) =
2999 TYPE_FIELD_ARTIFICIAL (type, i);
3000 TYPE_FIELD_BITSIZE (new_type, i) = TYPE_FIELD_BITSIZE (type, i);
3001 if (TYPE_FIELD_TYPE (type, i))
3002 TYPE_FIELD_TYPE (new_type, i)
3003 = copy_type_recursive (objfile, TYPE_FIELD_TYPE (type, i),
3005 if (TYPE_FIELD_NAME (type, i))
3006 TYPE_FIELD_NAME (new_type, i) =
3007 xstrdup (TYPE_FIELD_NAME (type, i));
3008 if (TYPE_FIELD_STATIC_HAS_ADDR (type, i))
3009 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i),
3010 TYPE_FIELD_STATIC_PHYSADDR (type, i));
3011 else if (TYPE_FIELD_STATIC (type, i))
3012 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i),
3013 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type,
3017 TYPE_FIELD_BITPOS (new_type, i) =
3018 TYPE_FIELD_BITPOS (type, i);
3019 TYPE_FIELD_STATIC_KIND (new_type, i) = 0;
3024 /* Copy pointers to other types. */
3025 if (TYPE_TARGET_TYPE (type))
3026 TYPE_TARGET_TYPE (new_type) =
3027 copy_type_recursive (objfile,
3028 TYPE_TARGET_TYPE (type),
3030 if (TYPE_VPTR_BASETYPE (type))
3031 TYPE_VPTR_BASETYPE (new_type) =
3032 copy_type_recursive (objfile,
3033 TYPE_VPTR_BASETYPE (type),
3035 /* Maybe copy the type_specific bits.
3037 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3038 base classes and methods. There's no fundamental reason why we
3039 can't, but at the moment it is not needed. */
3041 if (TYPE_CODE (type) == TYPE_CODE_FLT)
3042 TYPE_FLOATFORMAT (new_type) = TYPE_FLOATFORMAT (type);
3043 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
3044 || TYPE_CODE (type) == TYPE_CODE_UNION
3045 || TYPE_CODE (type) == TYPE_CODE_TEMPLATE
3046 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
3047 INIT_CPLUS_SPECIFIC (new_type);
3052 static struct type *
3053 build_flt (int bit, char *name, const struct floatformat **floatformats)
3059 gdb_assert (floatformats != NULL);
3060 gdb_assert (floatformats[0] != NULL && floatformats[1] != NULL);
3061 bit = floatformats[0]->totalsize;
3063 gdb_assert (bit >= 0);
3065 t = init_type (TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, 0, name, NULL);
3066 TYPE_FLOATFORMAT (t) = floatformats;
3070 static struct gdbarch_data *gdbtypes_data;
3072 const struct builtin_type *
3073 builtin_type (struct gdbarch *gdbarch)
3075 return gdbarch_data (gdbarch, gdbtypes_data);
3079 static struct type *
3080 build_complex (int bit, char *name, struct type *target_type)
3083 if (bit <= 0 || target_type == builtin_type_error)
3085 gdb_assert (builtin_type_error != NULL);
3086 return builtin_type_error;
3088 t = init_type (TYPE_CODE_COMPLEX, 2 * bit / TARGET_CHAR_BIT,
3089 0, name, (struct objfile *) NULL);
3090 TYPE_TARGET_TYPE (t) = target_type;
3095 gdbtypes_post_init (struct gdbarch *gdbarch)
3097 struct builtin_type *builtin_type
3098 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type);
3100 builtin_type->builtin_void =
3101 init_type (TYPE_CODE_VOID, 1,
3103 "void", (struct objfile *) NULL);
3104 builtin_type->builtin_char =
3105 init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3107 | (gdbarch_char_signed (gdbarch) ? 0 : TYPE_FLAG_UNSIGNED)),
3108 "char", (struct objfile *) NULL);
3109 builtin_type->builtin_true_char =
3110 init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3112 "true character", (struct objfile *) NULL);
3113 builtin_type->builtin_true_unsigned_char =
3114 init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3116 "true character", (struct objfile *) NULL);
3117 builtin_type->builtin_signed_char =
3118 init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3120 "signed char", (struct objfile *) NULL);
3121 builtin_type->builtin_unsigned_char =
3122 init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3124 "unsigned char", (struct objfile *) NULL);
3125 builtin_type->builtin_short =
3126 init_type (TYPE_CODE_INT,
3127 gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
3128 0, "short", (struct objfile *) NULL);
3129 builtin_type->builtin_unsigned_short =
3130 init_type (TYPE_CODE_INT,
3131 gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
3132 TYPE_FLAG_UNSIGNED, "unsigned short",
3133 (struct objfile *) NULL);
3134 builtin_type->builtin_int =
3135 init_type (TYPE_CODE_INT,
3136 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
3137 0, "int", (struct objfile *) NULL);
3138 builtin_type->builtin_unsigned_int =
3139 init_type (TYPE_CODE_INT,
3140 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
3141 TYPE_FLAG_UNSIGNED, "unsigned int",
3142 (struct objfile *) NULL);
3143 builtin_type->builtin_long =
3144 init_type (TYPE_CODE_INT,
3145 gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
3146 0, "long", (struct objfile *) NULL);
3147 builtin_type->builtin_unsigned_long =
3148 init_type (TYPE_CODE_INT,
3149 gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
3150 TYPE_FLAG_UNSIGNED, "unsigned long",
3151 (struct objfile *) NULL);
3152 builtin_type->builtin_long_long =
3153 init_type (TYPE_CODE_INT,
3154 gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
3155 0, "long long", (struct objfile *) NULL);
3156 builtin_type->builtin_unsigned_long_long =
3157 init_type (TYPE_CODE_INT,
3158 gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
3159 TYPE_FLAG_UNSIGNED, "unsigned long long",
3160 (struct objfile *) NULL);
3161 builtin_type->builtin_float
3162 = build_flt (gdbarch_float_bit (gdbarch), "float",
3163 gdbarch_float_format (gdbarch));
3164 builtin_type->builtin_double
3165 = build_flt (gdbarch_double_bit (gdbarch), "double",
3166 gdbarch_double_format (gdbarch));
3167 builtin_type->builtin_long_double
3168 = build_flt (gdbarch_long_double_bit (gdbarch), "long double",
3169 gdbarch_long_double_format (gdbarch));
3170 builtin_type->builtin_complex
3171 = build_complex (gdbarch_float_bit (gdbarch), "complex",
3172 builtin_type->builtin_float);
3173 builtin_type->builtin_double_complex
3174 = build_complex (gdbarch_double_bit (gdbarch), "double complex",
3175 builtin_type->builtin_double);
3176 builtin_type->builtin_string =
3177 init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3179 "string", (struct objfile *) NULL);
3180 builtin_type->builtin_bool =
3181 init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3183 "bool", (struct objfile *) NULL);
3185 /* The following three are about decimal floating point types, which
3186 are 32-bits, 64-bits and 128-bits respectively. */
3187 builtin_type->builtin_decfloat
3188 = init_type (TYPE_CODE_DECFLOAT, 32 / 8,
3190 "_Decimal32", (struct objfile *) NULL);
3191 builtin_type->builtin_decdouble
3192 = init_type (TYPE_CODE_DECFLOAT, 64 / 8,
3194 "_Decimal64", (struct objfile *) NULL);
3195 builtin_type->builtin_declong
3196 = init_type (TYPE_CODE_DECFLOAT, 128 / 8,
3198 "_Decimal128", (struct objfile *) NULL);
3200 /* Pointer/Address types. */
3202 /* NOTE: on some targets, addresses and pointers are not necessarily
3203 the same --- for example, on the D10V, pointers are 16 bits long,
3204 but addresses are 32 bits long. See doc/gdbint.texinfo,
3205 ``Pointers Are Not Always Addresses''.
3208 - gdb's `struct type' always describes the target's
3210 - gdb's `struct value' objects should always hold values in
3212 - gdb's CORE_ADDR values are addresses in the unified virtual
3213 address space that the assembler and linker work with. Thus,
3214 since target_read_memory takes a CORE_ADDR as an argument, it
3215 can access any memory on the target, even if the processor has
3216 separate code and data address spaces.
3219 - If v is a value holding a D10V code pointer, its contents are
3220 in target form: a big-endian address left-shifted two bits.
3221 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3222 sizeof (void *) == 2 on the target.
3224 In this context, builtin_type->CORE_ADDR is a bit odd: it's a
3225 target type for a value the target will never see. It's only
3226 used to hold the values of (typeless) linker symbols, which are
3227 indeed in the unified virtual address space. */
3229 builtin_type->builtin_data_ptr =
3230 make_pointer_type (builtin_type->builtin_void, NULL);
3231 builtin_type->builtin_func_ptr =
3232 lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
3233 builtin_type->builtin_core_addr =
3234 init_type (TYPE_CODE_INT,
3235 gdbarch_addr_bit (gdbarch) / 8,
3237 "__CORE_ADDR", (struct objfile *) NULL);
3240 /* The following set of types is used for symbols with no
3241 debug information. */
3242 builtin_type->nodebug_text_symbol =
3243 init_type (TYPE_CODE_FUNC, 1, 0,
3244 "<text variable, no debug info>", NULL);
3245 TYPE_TARGET_TYPE (builtin_type->nodebug_text_symbol) =
3246 builtin_type->builtin_int;
3247 builtin_type->nodebug_data_symbol =
3248 init_type (TYPE_CODE_INT,
3249 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
3250 "<data variable, no debug info>", NULL);
3251 builtin_type->nodebug_unknown_symbol =
3252 init_type (TYPE_CODE_INT, 1, 0,
3253 "<variable (not text or data), no debug info>", NULL);
3254 builtin_type->nodebug_tls_symbol =
3255 init_type (TYPE_CODE_INT,
3256 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
3257 "<thread local variable, no debug info>", NULL);
3259 return builtin_type;
3262 extern void _initialize_gdbtypes (void);
3264 _initialize_gdbtypes (void)
3266 gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
3268 /* FIXME: The following types are architecture-neutral. However,
3269 they contain pointer_type and reference_type fields potentially
3270 caching pointer or reference types that *are* architecture
3274 init_type (TYPE_CODE_INT, 0 / 8,
3276 "int0_t", (struct objfile *) NULL);
3278 init_type (TYPE_CODE_INT, 8 / 8,
3280 "int8_t", (struct objfile *) NULL);
3281 builtin_type_uint8 =
3282 init_type (TYPE_CODE_INT, 8 / 8,
3283 TYPE_FLAG_UNSIGNED | TYPE_FLAG_NOTTEXT,
3284 "uint8_t", (struct objfile *) NULL);
3285 builtin_type_int16 =
3286 init_type (TYPE_CODE_INT, 16 / 8,
3288 "int16_t", (struct objfile *) NULL);
3289 builtin_type_uint16 =
3290 init_type (TYPE_CODE_INT, 16 / 8,
3292 "uint16_t", (struct objfile *) NULL);
3293 builtin_type_int32 =
3294 init_type (TYPE_CODE_INT, 32 / 8,
3296 "int32_t", (struct objfile *) NULL);
3297 builtin_type_uint32 =
3298 init_type (TYPE_CODE_INT, 32 / 8,
3300 "uint32_t", (struct objfile *) NULL);
3301 builtin_type_int64 =
3302 init_type (TYPE_CODE_INT, 64 / 8,
3304 "int64_t", (struct objfile *) NULL);
3305 builtin_type_uint64 =
3306 init_type (TYPE_CODE_INT, 64 / 8,
3308 "uint64_t", (struct objfile *) NULL);
3309 builtin_type_int128 =
3310 init_type (TYPE_CODE_INT, 128 / 8,
3312 "int128_t", (struct objfile *) NULL);
3313 builtin_type_uint128 =
3314 init_type (TYPE_CODE_INT, 128 / 8,
3316 "uint128_t", (struct objfile *) NULL);
3318 builtin_type_ieee_single =
3319 build_flt (-1, "builtin_type_ieee_single", floatformats_ieee_single);
3320 builtin_type_ieee_double =
3321 build_flt (-1, "builtin_type_ieee_double", floatformats_ieee_double);
3322 builtin_type_i387_ext =
3323 build_flt (-1, "builtin_type_i387_ext", floatformats_i387_ext);
3324 builtin_type_m68881_ext =
3325 build_flt (-1, "builtin_type_m68881_ext", floatformats_m68881_ext);
3326 builtin_type_arm_ext =
3327 build_flt (-1, "builtin_type_arm_ext", floatformats_arm_ext);
3328 builtin_type_ia64_spill =
3329 build_flt (-1, "builtin_type_ia64_spill", floatformats_ia64_spill);
3330 builtin_type_ia64_quad =
3331 build_flt (-1, "builtin_type_ia64_quad", floatformats_ia64_quad);
3333 add_setshow_zinteger_cmd ("overload", no_class, &overload_debug, _("\
3334 Set debugging of C++ overloading."), _("\
3335 Show debugging of C++ overloading."), _("\
3336 When enabled, ranking of the functions is displayed."),
3338 show_overload_debug,
3339 &setdebuglist, &showdebuglist);
3341 /* Add user knob for controlling resolution of opaque types. */
3342 add_setshow_boolean_cmd ("opaque-type-resolution", class_support,
3343 &opaque_type_resolution, _("\
3344 Set resolution of opaque struct/class/union types (if set before loading symbols)."), _("\
3345 Show resolution of opaque struct/class/union types (if set before loading symbols)."), NULL,
3347 show_opaque_type_resolution,
3348 &setlist, &showlist);