1 /* Support routines for manipulating internal types for GDB.
2 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
4 Contributed by Cygnus Support, using pieces from other GDB modules.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 #include "gdb_string.h"
30 #include "expression.h"
35 #include "complaints.h"
39 #include "gdb_assert.h"
41 /* These variables point to the objects
42 representing the predefined C data types. */
44 struct type *builtin_type_void;
45 struct type *builtin_type_char;
46 struct type *builtin_type_true_char;
47 struct type *builtin_type_short;
48 struct type *builtin_type_int;
49 struct type *builtin_type_long;
50 struct type *builtin_type_long_long;
51 struct type *builtin_type_signed_char;
52 struct type *builtin_type_unsigned_char;
53 struct type *builtin_type_unsigned_short;
54 struct type *builtin_type_unsigned_int;
55 struct type *builtin_type_unsigned_long;
56 struct type *builtin_type_unsigned_long_long;
57 struct type *builtin_type_float;
58 struct type *builtin_type_double;
59 struct type *builtin_type_long_double;
60 struct type *builtin_type_complex;
61 struct type *builtin_type_double_complex;
62 struct type *builtin_type_string;
63 struct type *builtin_type_int8;
64 struct type *builtin_type_uint8;
65 struct type *builtin_type_int16;
66 struct type *builtin_type_uint16;
67 struct type *builtin_type_int32;
68 struct type *builtin_type_uint32;
69 struct type *builtin_type_int64;
70 struct type *builtin_type_uint64;
71 struct type *builtin_type_int128;
72 struct type *builtin_type_uint128;
73 struct type *builtin_type_bool;
75 /* 128 bit long vector types */
76 struct type *builtin_type_v2_double;
77 struct type *builtin_type_v4_float;
78 struct type *builtin_type_v2_int64;
79 struct type *builtin_type_v4_int32;
80 struct type *builtin_type_v8_int16;
81 struct type *builtin_type_v16_int8;
82 /* 64 bit long vector types */
83 struct type *builtin_type_v2_float;
84 struct type *builtin_type_v2_int32;
85 struct type *builtin_type_v4_int16;
86 struct type *builtin_type_v8_int8;
88 struct type *builtin_type_v4sf;
89 struct type *builtin_type_v4si;
90 struct type *builtin_type_v16qi;
91 struct type *builtin_type_v8qi;
92 struct type *builtin_type_v8hi;
93 struct type *builtin_type_v4hi;
94 struct type *builtin_type_v2si;
95 struct type *builtin_type_vec64;
96 struct type *builtin_type_vec64i;
97 struct type *builtin_type_vec128;
98 struct type *builtin_type_vec128i;
99 struct type *builtin_type_ieee_single_big;
100 struct type *builtin_type_ieee_single_little;
101 struct type *builtin_type_ieee_double_big;
102 struct type *builtin_type_ieee_double_little;
103 struct type *builtin_type_ieee_double_littlebyte_bigword;
104 struct type *builtin_type_i387_ext;
105 struct type *builtin_type_m68881_ext;
106 struct type *builtin_type_i960_ext;
107 struct type *builtin_type_m88110_ext;
108 struct type *builtin_type_m88110_harris_ext;
109 struct type *builtin_type_arm_ext_big;
110 struct type *builtin_type_arm_ext_littlebyte_bigword;
111 struct type *builtin_type_ia64_spill_big;
112 struct type *builtin_type_ia64_spill_little;
113 struct type *builtin_type_ia64_quad_big;
114 struct type *builtin_type_ia64_quad_little;
115 struct type *builtin_type_void_data_ptr;
116 struct type *builtin_type_void_func_ptr;
117 struct type *builtin_type_CORE_ADDR;
118 struct type *builtin_type_bfd_vma;
120 int opaque_type_resolution = 1;
121 int overload_debug = 0;
127 }; /* maximum extension is 128! FIXME */
129 static void add_name (struct extra *, char *);
130 static void add_mangled_type (struct extra *, struct type *);
132 static void cfront_mangle_name (struct type *, int, int);
134 static void print_bit_vector (B_TYPE *, int);
135 static void print_arg_types (struct field *, int, int);
136 static void dump_fn_fieldlists (struct type *, int);
137 static void print_cplus_stuff (struct type *, int);
138 static void virtual_base_list_aux (struct type *dclass);
141 /* Alloc a new type structure and fill it with some defaults. If
142 OBJFILE is non-NULL, then allocate the space for the type structure
143 in that objfile's type_obstack. Otherwise allocate the new type structure
144 by xmalloc () (for permanent types). */
147 alloc_type (struct objfile *objfile)
149 register struct type *type;
151 /* Alloc the structure and start off with all fields zeroed. */
155 type = xmalloc (sizeof (struct type));
156 memset (type, 0, sizeof (struct type));
157 TYPE_MAIN_TYPE (type) = xmalloc (sizeof (struct main_type));
161 type = obstack_alloc (&objfile->type_obstack,
162 sizeof (struct type));
163 memset (type, 0, sizeof (struct type));
164 TYPE_MAIN_TYPE (type) = obstack_alloc (&objfile->type_obstack,
165 sizeof (struct main_type));
166 OBJSTAT (objfile, n_types++);
168 memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
170 /* Initialize the fields that might not be zero. */
172 TYPE_CODE (type) = TYPE_CODE_UNDEF;
173 TYPE_OBJFILE (type) = objfile;
174 TYPE_VPTR_FIELDNO (type) = -1;
175 TYPE_CHAIN (type) = type; /* Chain back to itself. */
180 /* Alloc a new type instance structure, fill it with some defaults,
181 and point it at OLDTYPE. Allocate the new type instance from the
182 same place as OLDTYPE. */
185 alloc_type_instance (struct type *oldtype)
189 /* Allocate the structure. */
191 if (TYPE_OBJFILE (oldtype) == NULL)
193 type = xmalloc (sizeof (struct type));
194 memset (type, 0, sizeof (struct type));
198 type = obstack_alloc (&TYPE_OBJFILE (oldtype)->type_obstack,
199 sizeof (struct type));
200 memset (type, 0, sizeof (struct type));
202 TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype);
204 TYPE_CHAIN (type) = type; /* Chain back to itself for now. */
209 /* Clear all remnants of the previous type at TYPE, in preparation for
210 replacing it with something else. */
212 smash_type (struct type *type)
214 memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
216 /* For now, delete the rings. */
217 TYPE_CHAIN (type) = type;
219 /* For now, leave the pointer/reference types alone. */
222 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
223 to a pointer to memory where the pointer type should be stored.
224 If *TYPEPTR is zero, update it to point to the pointer type we return.
225 We allocate new memory if needed. */
228 make_pointer_type (struct type *type, struct type **typeptr)
230 register struct type *ntype; /* New type */
231 struct objfile *objfile;
233 ntype = TYPE_POINTER_TYPE (type);
238 return ntype; /* Don't care about alloc, and have new type. */
239 else if (*typeptr == 0)
241 *typeptr = ntype; /* Tracking alloc, and we have new type. */
246 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
248 ntype = alloc_type (TYPE_OBJFILE (type));
253 /* We have storage, but need to reset it. */
256 objfile = TYPE_OBJFILE (ntype);
258 TYPE_OBJFILE (ntype) = objfile;
261 TYPE_TARGET_TYPE (ntype) = type;
262 TYPE_POINTER_TYPE (type) = ntype;
264 /* FIXME! Assume the machine has only one representation for pointers! */
266 TYPE_LENGTH (ntype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
267 TYPE_CODE (ntype) = TYPE_CODE_PTR;
269 /* Mark pointers as unsigned. The target converts between pointers
270 and addresses (CORE_ADDRs) using POINTER_TO_ADDRESS() and
271 ADDRESS_TO_POINTER(). */
272 TYPE_FLAGS (ntype) |= TYPE_FLAG_UNSIGNED;
274 if (!TYPE_POINTER_TYPE (type)) /* Remember it, if don't have one. */
275 TYPE_POINTER_TYPE (type) = ntype;
280 /* Given a type TYPE, return a type of pointers to that type.
281 May need to construct such a type if this is the first use. */
284 lookup_pointer_type (struct type *type)
286 return make_pointer_type (type, (struct type **) 0);
289 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero, points
290 to a pointer to memory where the reference type should be stored.
291 If *TYPEPTR is zero, update it to point to the reference type we return.
292 We allocate new memory if needed. */
295 make_reference_type (struct type *type, struct type **typeptr)
297 register struct type *ntype; /* New type */
298 struct objfile *objfile;
300 ntype = TYPE_REFERENCE_TYPE (type);
305 return ntype; /* Don't care about alloc, and have new type. */
306 else if (*typeptr == 0)
308 *typeptr = ntype; /* Tracking alloc, and we have new type. */
313 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
315 ntype = alloc_type (TYPE_OBJFILE (type));
320 /* We have storage, but need to reset it. */
323 objfile = TYPE_OBJFILE (ntype);
325 TYPE_OBJFILE (ntype) = objfile;
328 TYPE_TARGET_TYPE (ntype) = type;
329 TYPE_REFERENCE_TYPE (type) = ntype;
331 /* FIXME! Assume the machine has only one representation for references,
332 and that it matches the (only) representation for pointers! */
334 TYPE_LENGTH (ntype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
335 TYPE_CODE (ntype) = TYPE_CODE_REF;
337 if (!TYPE_REFERENCE_TYPE (type)) /* Remember it, if don't have one. */
338 TYPE_REFERENCE_TYPE (type) = ntype;
343 /* Same as above, but caller doesn't care about memory allocation details. */
346 lookup_reference_type (struct type *type)
348 return make_reference_type (type, (struct type **) 0);
351 /* Lookup a function type that returns type TYPE. TYPEPTR, if nonzero, points
352 to a pointer to memory where the function type should be stored.
353 If *TYPEPTR is zero, update it to point to the function type we return.
354 We allocate new memory if needed. */
357 make_function_type (struct type *type, struct type **typeptr)
359 register struct type *ntype; /* New type */
360 struct objfile *objfile;
362 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
364 ntype = alloc_type (TYPE_OBJFILE (type));
369 /* We have storage, but need to reset it. */
372 objfile = TYPE_OBJFILE (ntype);
374 TYPE_OBJFILE (ntype) = objfile;
377 TYPE_TARGET_TYPE (ntype) = type;
379 TYPE_LENGTH (ntype) = 1;
380 TYPE_CODE (ntype) = TYPE_CODE_FUNC;
386 /* Given a type TYPE, return a type of functions that return that type.
387 May need to construct such a type if this is the first use. */
390 lookup_function_type (struct type *type)
392 return make_function_type (type, (struct type **) 0);
395 /* Identify address space identifier by name --
396 return the integer flag defined in gdbtypes.h. */
398 address_space_name_to_int (char *space_identifier)
401 /* Check for known address space delimiters. */
402 if (!strcmp (space_identifier, "code"))
403 return TYPE_FLAG_CODE_SPACE;
404 else if (!strcmp (space_identifier, "data"))
405 return TYPE_FLAG_DATA_SPACE;
406 else if (ADDRESS_CLASS_NAME_TO_TYPE_FLAGS_P ()
407 && ADDRESS_CLASS_NAME_TO_TYPE_FLAGS (space_identifier, &type_flags))
410 error ("Unknown address space specifier: \"%s\"", space_identifier);
413 /* Identify address space identifier by integer flag as defined in
414 gdbtypes.h -- return the string version of the adress space name. */
417 address_space_int_to_name (int space_flag)
419 if (space_flag & TYPE_FLAG_CODE_SPACE)
421 else if (space_flag & TYPE_FLAG_DATA_SPACE)
423 else if ((space_flag & TYPE_FLAG_ADDRESS_CLASS_ALL)
424 && ADDRESS_CLASS_TYPE_FLAGS_TO_NAME_P ())
425 return ADDRESS_CLASS_TYPE_FLAGS_TO_NAME (space_flag);
430 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
431 If STORAGE is non-NULL, create the new type instance there. */
434 make_qualified_type (struct type *type, int new_flags,
435 struct type *storage)
441 if (TYPE_INSTANCE_FLAGS (ntype) == new_flags)
443 ntype = TYPE_CHAIN (ntype);
444 } while (ntype != type);
446 /* Create a new type instance. */
448 ntype = alloc_type_instance (type);
452 TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type);
453 TYPE_CHAIN (ntype) = ntype;
456 /* Pointers or references to the original type are not relevant to
458 TYPE_POINTER_TYPE (ntype) = (struct type *) 0;
459 TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0;
461 /* Chain the new qualified type to the old type. */
462 TYPE_CHAIN (ntype) = TYPE_CHAIN (type);
463 TYPE_CHAIN (type) = ntype;
465 /* Now set the instance flags and return the new type. */
466 TYPE_INSTANCE_FLAGS (ntype) = new_flags;
471 /* Make an address-space-delimited variant of a type -- a type that
472 is identical to the one supplied except that it has an address
473 space attribute attached to it (such as "code" or "data").
475 The space attributes "code" and "data" are for Harvard architectures.
476 The address space attributes are for architectures which have
477 alternately sized pointers or pointers with alternate representations. */
480 make_type_with_address_space (struct type *type, int space_flag)
483 int new_flags = ((TYPE_INSTANCE_FLAGS (type)
484 & ~(TYPE_FLAG_CODE_SPACE | TYPE_FLAG_DATA_SPACE
485 | TYPE_FLAG_ADDRESS_CLASS_ALL))
488 return make_qualified_type (type, new_flags, NULL);
491 /* Make a "c-v" variant of a type -- a type that is identical to the
492 one supplied except that it may have const or volatile attributes
493 CNST is a flag for setting the const attribute
494 VOLTL is a flag for setting the volatile attribute
495 TYPE is the base type whose variant we are creating.
496 TYPEPTR, if nonzero, points
497 to a pointer to memory where the reference type should be stored.
498 If *TYPEPTR is zero, update it to point to the reference type we return.
499 We allocate new memory if needed. */
502 make_cv_type (int cnst, int voltl, struct type *type, struct type **typeptr)
504 register struct type *ntype; /* New type */
505 register struct type *tmp_type = type; /* tmp type */
506 struct objfile *objfile;
508 int new_flags = (TYPE_INSTANCE_FLAGS (type)
509 & ~(TYPE_FLAG_CONST | TYPE_FLAG_VOLATILE));
512 new_flags |= TYPE_FLAG_CONST;
515 new_flags |= TYPE_FLAG_VOLATILE;
517 if (typeptr && *typeptr != NULL)
519 /* Objfile is per-core-type. This const-qualified type had best
520 belong to the same objfile as the type it is qualifying, unless
521 we are overwriting a stub type, in which case the safest thing
522 to do is to copy the core type into the new objfile. */
524 gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type)
525 || TYPE_STUB (*typeptr));
526 if (TYPE_OBJFILE (*typeptr) != TYPE_OBJFILE (type))
528 TYPE_MAIN_TYPE (*typeptr)
529 = TYPE_ALLOC (*typeptr, sizeof (struct main_type));
530 *TYPE_MAIN_TYPE (*typeptr)
531 = *TYPE_MAIN_TYPE (type);
535 ntype = make_qualified_type (type, new_flags, typeptr ? *typeptr : NULL);
543 /* Replace the contents of ntype with the type *type. This changes the
544 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
545 the changes are propogated to all types in the TYPE_CHAIN.
547 In order to build recursive types, it's inevitable that we'll need
548 to update types in place --- but this sort of indiscriminate
549 smashing is ugly, and needs to be replaced with something more
550 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
551 clear if more steps are needed. */
553 replace_type (struct type *ntype, struct type *type)
555 struct type *cv_chain, *as_chain, *ptr, *ref;
557 *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
559 /* Assert that the two types have equivalent instance qualifiers.
560 This should be true for at least all of our debug readers. */
561 gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type));
564 /* Implement direct support for MEMBER_TYPE in GNU C++.
565 May need to construct such a type if this is the first use.
566 The TYPE is the type of the member. The DOMAIN is the type
567 of the aggregate that the member belongs to. */
570 lookup_member_type (struct type *type, struct type *domain)
572 register struct type *mtype;
574 mtype = alloc_type (TYPE_OBJFILE (type));
575 smash_to_member_type (mtype, domain, type);
579 /* Allocate a stub method whose return type is TYPE.
580 This apparently happens for speed of symbol reading, since parsing
581 out the arguments to the method is cpu-intensive, the way we are doing
582 it. So, we will fill in arguments later.
583 This always returns a fresh type. */
586 allocate_stub_method (struct type *type)
590 mtype = init_type (TYPE_CODE_METHOD, 1, TYPE_FLAG_STUB, NULL,
591 TYPE_OBJFILE (type));
592 TYPE_TARGET_TYPE (mtype) = type;
593 /* _DOMAIN_TYPE (mtype) = unknown yet */
597 /* Create a range type using either a blank type supplied in RESULT_TYPE,
598 or creating a new type, inheriting the objfile from INDEX_TYPE.
600 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
601 HIGH_BOUND, inclusive.
603 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
604 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
607 create_range_type (struct type *result_type, struct type *index_type,
608 int low_bound, int high_bound)
610 if (result_type == NULL)
612 result_type = alloc_type (TYPE_OBJFILE (index_type));
614 TYPE_CODE (result_type) = TYPE_CODE_RANGE;
615 TYPE_TARGET_TYPE (result_type) = index_type;
616 if (TYPE_STUB (index_type))
617 TYPE_FLAGS (result_type) |= TYPE_FLAG_TARGET_STUB;
619 TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
620 TYPE_NFIELDS (result_type) = 2;
621 TYPE_FIELDS (result_type) = (struct field *)
622 TYPE_ALLOC (result_type, 2 * sizeof (struct field));
623 memset (TYPE_FIELDS (result_type), 0, 2 * sizeof (struct field));
624 TYPE_FIELD_BITPOS (result_type, 0) = low_bound;
625 TYPE_FIELD_BITPOS (result_type, 1) = high_bound;
626 TYPE_FIELD_TYPE (result_type, 0) = builtin_type_int; /* FIXME */
627 TYPE_FIELD_TYPE (result_type, 1) = builtin_type_int; /* FIXME */
630 TYPE_FLAGS (result_type) |= TYPE_FLAG_UNSIGNED;
632 return (result_type);
635 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE.
636 Return 1 of type is a range type, 0 if it is discrete (and bounds
637 will fit in LONGEST), or -1 otherwise. */
640 get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
642 CHECK_TYPEDEF (type);
643 switch (TYPE_CODE (type))
645 case TYPE_CODE_RANGE:
646 *lowp = TYPE_LOW_BOUND (type);
647 *highp = TYPE_HIGH_BOUND (type);
650 if (TYPE_NFIELDS (type) > 0)
652 /* The enums may not be sorted by value, so search all
656 *lowp = *highp = TYPE_FIELD_BITPOS (type, 0);
657 for (i = 0; i < TYPE_NFIELDS (type); i++)
659 if (TYPE_FIELD_BITPOS (type, i) < *lowp)
660 *lowp = TYPE_FIELD_BITPOS (type, i);
661 if (TYPE_FIELD_BITPOS (type, i) > *highp)
662 *highp = TYPE_FIELD_BITPOS (type, i);
665 /* Set unsigned indicator if warranted. */
668 TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
682 if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */
684 if (!TYPE_UNSIGNED (type))
686 *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
690 /* ... fall through for unsigned ints ... */
693 /* This round-about calculation is to avoid shifting by
694 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
695 if TYPE_LENGTH (type) == sizeof (LONGEST). */
696 *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
697 *highp = (*highp - 1) | *highp;
704 /* Create an array type using either a blank type supplied in RESULT_TYPE,
705 or creating a new type, inheriting the objfile from RANGE_TYPE.
707 Elements will be of type ELEMENT_TYPE, the indices will be of type
710 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
711 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
714 create_array_type (struct type *result_type, struct type *element_type,
715 struct type *range_type)
717 LONGEST low_bound, high_bound;
719 if (result_type == NULL)
721 result_type = alloc_type (TYPE_OBJFILE (range_type));
723 TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
724 TYPE_TARGET_TYPE (result_type) = element_type;
725 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
726 low_bound = high_bound = 0;
727 CHECK_TYPEDEF (element_type);
728 TYPE_LENGTH (result_type) =
729 TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
730 TYPE_NFIELDS (result_type) = 1;
731 TYPE_FIELDS (result_type) =
732 (struct field *) TYPE_ALLOC (result_type, sizeof (struct field));
733 memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
734 TYPE_FIELD_TYPE (result_type, 0) = range_type;
735 TYPE_VPTR_FIELDNO (result_type) = -1;
737 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
738 if (TYPE_LENGTH (result_type) == 0)
739 TYPE_FLAGS (result_type) |= TYPE_FLAG_TARGET_STUB;
741 return (result_type);
744 /* Create a string type using either a blank type supplied in RESULT_TYPE,
745 or creating a new type. String types are similar enough to array of
746 char types that we can use create_array_type to build the basic type
747 and then bash it into a string type.
749 For fixed length strings, the range type contains 0 as the lower
750 bound and the length of the string minus one as the upper bound.
752 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
753 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
756 create_string_type (struct type *result_type, struct type *range_type)
758 result_type = create_array_type (result_type,
759 *current_language->string_char_type,
761 TYPE_CODE (result_type) = TYPE_CODE_STRING;
762 return (result_type);
766 create_set_type (struct type *result_type, struct type *domain_type)
768 LONGEST low_bound, high_bound, bit_length;
769 if (result_type == NULL)
771 result_type = alloc_type (TYPE_OBJFILE (domain_type));
773 TYPE_CODE (result_type) = TYPE_CODE_SET;
774 TYPE_NFIELDS (result_type) = 1;
775 TYPE_FIELDS (result_type) = (struct field *)
776 TYPE_ALLOC (result_type, 1 * sizeof (struct field));
777 memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
779 if (!TYPE_STUB (domain_type))
781 if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
782 low_bound = high_bound = 0;
783 bit_length = high_bound - low_bound + 1;
784 TYPE_LENGTH (result_type)
785 = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
787 TYPE_FIELD_TYPE (result_type, 0) = domain_type;
790 TYPE_FLAGS (result_type) |= TYPE_FLAG_UNSIGNED;
792 return (result_type);
795 /* Construct and return a type of the form:
796 struct NAME { ELT_TYPE ELT_NAME[N]; }
797 We use these types for SIMD registers. For example, the type of
798 the SSE registers on the late x86-family processors is:
799 struct __builtin_v4sf { float f[4]; }
800 built by the function call:
801 init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4)
802 The type returned is a permanent type, allocated using malloc; it
803 doesn't live in any objfile's obstack. */
805 init_simd_type (char *name,
806 struct type *elt_type,
810 struct type *simd_type;
811 struct type *array_type;
813 simd_type = init_composite_type (name, TYPE_CODE_STRUCT);
814 array_type = create_array_type (0, elt_type,
815 create_range_type (0, builtin_type_int,
817 append_composite_type_field (simd_type, elt_name, array_type);
822 init_vector_type (struct type *elt_type, int n)
824 struct type *array_type;
826 array_type = create_array_type (0, elt_type,
827 create_range_type (0, builtin_type_int,
829 TYPE_FLAGS (array_type) |= TYPE_FLAG_VECTOR;
834 build_builtin_type_vec64 (void)
836 /* Construct a type for the 64 bit registers. The type we're
839 union __gdb_builtin_type_vec64
851 t = init_composite_type ("__gdb_builtin_type_vec64", TYPE_CODE_UNION);
852 append_composite_type_field (t, "uint64", builtin_type_int64);
853 append_composite_type_field (t, "v2_float", builtin_type_v2_float);
854 append_composite_type_field (t, "v2_int32", builtin_type_v2_int32);
855 append_composite_type_field (t, "v4_int16", builtin_type_v4_int16);
856 append_composite_type_field (t, "v8_int8", builtin_type_v8_int8);
858 TYPE_FLAGS (t) |= TYPE_FLAG_VECTOR;
859 TYPE_NAME (t) = "builtin_type_vec64";
864 build_builtin_type_vec64i (void)
866 /* Construct a type for the 64 bit registers. The type we're
869 union __gdb_builtin_type_vec64i
880 t = init_composite_type ("__gdb_builtin_type_vec64i", TYPE_CODE_UNION);
881 append_composite_type_field (t, "uint64", builtin_type_int64);
882 append_composite_type_field (t, "v2_int32", builtin_type_v2_int32);
883 append_composite_type_field (t, "v4_int16", builtin_type_v4_int16);
884 append_composite_type_field (t, "v8_int8", builtin_type_v8_int8);
886 TYPE_FLAGS (t) |= TYPE_FLAG_VECTOR;
887 TYPE_NAME (t) = "builtin_type_vec64i";
892 build_builtin_type_vec128 (void)
894 /* Construct a type for the 128 bit registers. The type we're
897 union __gdb_builtin_type_vec128
909 t = init_composite_type ("__gdb_builtin_type_vec128", TYPE_CODE_UNION);
910 append_composite_type_field (t, "uint128", builtin_type_int128);
911 append_composite_type_field (t, "v4_float", builtin_type_v4_float);
912 append_composite_type_field (t, "v4_int32", builtin_type_v4_int32);
913 append_composite_type_field (t, "v8_int16", builtin_type_v8_int16);
914 append_composite_type_field (t, "v16_int8", builtin_type_v16_int8);
916 TYPE_FLAGS (t) |= TYPE_FLAG_VECTOR;
917 TYPE_NAME (t) = "builtin_type_vec128";
922 build_builtin_type_vec128i (void)
924 /* 128-bit Intel SIMD registers */
927 t = init_composite_type ("__gdb_builtin_type_vec128i", TYPE_CODE_UNION);
928 append_composite_type_field (t, "v4_float", builtin_type_v4_float);
929 append_composite_type_field (t, "v2_double", builtin_type_v2_double);
930 append_composite_type_field (t, "v16_int8", builtin_type_v16_int8);
931 append_composite_type_field (t, "v8_int16", builtin_type_v8_int16);
932 append_composite_type_field (t, "v4_int32", builtin_type_v4_int32);
933 append_composite_type_field (t, "v2_int64", builtin_type_v2_int64);
934 append_composite_type_field (t, "uint128", builtin_type_int128);
936 TYPE_FLAGS (t) |= TYPE_FLAG_VECTOR;
937 TYPE_NAME (t) = "builtin_type_vec128i";
941 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
942 A MEMBER is a wierd thing -- it amounts to a typed offset into
943 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
944 include the offset (that's the value of the MEMBER itself), but does
945 include the structure type into which it points (for some reason).
947 When "smashing" the type, we preserve the objfile that the
948 old type pointed to, since we aren't changing where the type is actually
952 smash_to_member_type (struct type *type, struct type *domain,
953 struct type *to_type)
955 struct objfile *objfile;
957 objfile = TYPE_OBJFILE (type);
960 TYPE_OBJFILE (type) = objfile;
961 TYPE_TARGET_TYPE (type) = to_type;
962 TYPE_DOMAIN_TYPE (type) = domain;
963 TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
964 TYPE_CODE (type) = TYPE_CODE_MEMBER;
967 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
968 METHOD just means `function that gets an extra "this" argument'.
970 When "smashing" the type, we preserve the objfile that the
971 old type pointed to, since we aren't changing where the type is actually
975 smash_to_method_type (struct type *type, struct type *domain,
976 struct type *to_type, struct field *args,
977 int nargs, int varargs)
979 struct objfile *objfile;
981 objfile = TYPE_OBJFILE (type);
984 TYPE_OBJFILE (type) = objfile;
985 TYPE_TARGET_TYPE (type) = to_type;
986 TYPE_DOMAIN_TYPE (type) = domain;
987 TYPE_FIELDS (type) = args;
988 TYPE_NFIELDS (type) = nargs;
990 TYPE_FLAGS (type) |= TYPE_FLAG_VARARGS;
991 TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
992 TYPE_CODE (type) = TYPE_CODE_METHOD;
995 /* Return a typename for a struct/union/enum type without "struct ",
996 "union ", or "enum ". If the type has a NULL name, return NULL. */
999 type_name_no_tag (register const struct type *type)
1001 if (TYPE_TAG_NAME (type) != NULL)
1002 return TYPE_TAG_NAME (type);
1004 /* Is there code which expects this to return the name if there is no
1005 tag name? My guess is that this is mainly used for C++ in cases where
1006 the two will always be the same. */
1007 return TYPE_NAME (type);
1010 /* Lookup a primitive type named NAME.
1011 Return zero if NAME is not a primitive type. */
1014 lookup_primitive_typename (char *name)
1016 struct type **const *p;
1018 for (p = current_language->la_builtin_type_vector; *p != NULL; p++)
1020 if (STREQ (TYPE_NAME (**p), name))
1028 /* Lookup a typedef or primitive type named NAME,
1029 visible in lexical block BLOCK.
1030 If NOERR is nonzero, return zero if NAME is not suitably defined. */
1033 lookup_typename (char *name, struct block *block, int noerr)
1035 register struct symbol *sym;
1036 register struct type *tmp;
1038 sym = lookup_symbol (name, block, VAR_NAMESPACE, 0, (struct symtab **) NULL);
1039 if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
1041 tmp = lookup_primitive_typename (name);
1046 else if (!tmp && noerr)
1052 error ("No type named %s.", name);
1055 return (SYMBOL_TYPE (sym));
1059 lookup_unsigned_typename (char *name)
1061 char *uns = alloca (strlen (name) + 10);
1063 strcpy (uns, "unsigned ");
1064 strcpy (uns + 9, name);
1065 return (lookup_typename (uns, (struct block *) NULL, 0));
1069 lookup_signed_typename (char *name)
1072 char *uns = alloca (strlen (name) + 8);
1074 strcpy (uns, "signed ");
1075 strcpy (uns + 7, name);
1076 t = lookup_typename (uns, (struct block *) NULL, 1);
1077 /* If we don't find "signed FOO" just try again with plain "FOO". */
1080 return lookup_typename (name, (struct block *) NULL, 0);
1083 /* Lookup a structure type named "struct NAME",
1084 visible in lexical block BLOCK. */
1087 lookup_struct (char *name, struct block *block)
1089 register struct symbol *sym;
1091 sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
1092 (struct symtab **) NULL);
1096 error ("No struct type named %s.", name);
1098 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1100 error ("This context has class, union or enum %s, not a struct.", name);
1102 return (SYMBOL_TYPE (sym));
1105 /* Lookup a union type named "union NAME",
1106 visible in lexical block BLOCK. */
1109 lookup_union (char *name, struct block *block)
1111 register struct symbol *sym;
1114 sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
1115 (struct symtab **) NULL);
1118 error ("No union type named %s.", name);
1120 t = SYMBOL_TYPE (sym);
1122 if (TYPE_CODE (t) == TYPE_CODE_UNION)
1125 /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
1126 * a further "declared_type" field to discover it is really a union.
1128 if (HAVE_CPLUS_STRUCT (t))
1129 if (TYPE_DECLARED_TYPE (t) == DECLARED_TYPE_UNION)
1132 /* If we get here, it's not a union */
1133 error ("This context has class, struct or enum %s, not a union.", name);
1137 /* Lookup an enum type named "enum NAME",
1138 visible in lexical block BLOCK. */
1141 lookup_enum (char *name, struct block *block)
1143 register struct symbol *sym;
1145 sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
1146 (struct symtab **) NULL);
1149 error ("No enum type named %s.", name);
1151 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
1153 error ("This context has class, struct or union %s, not an enum.", name);
1155 return (SYMBOL_TYPE (sym));
1158 /* Lookup a template type named "template NAME<TYPE>",
1159 visible in lexical block BLOCK. */
1162 lookup_template_type (char *name, struct type *type, struct block *block)
1165 char *nam = (char *) alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4);
1168 strcat (nam, TYPE_NAME (type));
1169 strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
1171 sym = lookup_symbol (nam, block, VAR_NAMESPACE, 0, (struct symtab **) NULL);
1175 error ("No template type named %s.", name);
1177 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1179 error ("This context has class, union or enum %s, not a struct.", name);
1181 return (SYMBOL_TYPE (sym));
1184 /* Given a type TYPE, lookup the type of the component of type named NAME.
1186 TYPE can be either a struct or union, or a pointer or reference to a struct or
1187 union. If it is a pointer or reference, its target type is automatically used.
1188 Thus '.' and '->' are interchangable, as specified for the definitions of the
1189 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
1191 If NOERR is nonzero, return zero if NAME is not suitably defined.
1192 If NAME is the name of a baseclass type, return that type. */
1195 lookup_struct_elt_type (struct type *type, char *name, int noerr)
1201 CHECK_TYPEDEF (type);
1202 if (TYPE_CODE (type) != TYPE_CODE_PTR
1203 && TYPE_CODE (type) != TYPE_CODE_REF)
1205 type = TYPE_TARGET_TYPE (type);
1208 if (TYPE_CODE (type) != TYPE_CODE_STRUCT &&
1209 TYPE_CODE (type) != TYPE_CODE_UNION)
1211 target_terminal_ours ();
1212 gdb_flush (gdb_stdout);
1213 fprintf_unfiltered (gdb_stderr, "Type ");
1214 type_print (type, "", gdb_stderr, -1);
1215 error (" is not a structure or union type.");
1219 /* FIXME: This change put in by Michael seems incorrect for the case where
1220 the structure tag name is the same as the member name. I.E. when doing
1221 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
1226 typename = type_name_no_tag (type);
1227 if (typename != NULL && STREQ (typename, name))
1232 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1234 char *t_field_name = TYPE_FIELD_NAME (type, i);
1236 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1238 return TYPE_FIELD_TYPE (type, i);
1242 /* OK, it's not in this class. Recursively check the baseclasses. */
1243 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1247 t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, noerr);
1259 target_terminal_ours ();
1260 gdb_flush (gdb_stdout);
1261 fprintf_unfiltered (gdb_stderr, "Type ");
1262 type_print (type, "", gdb_stderr, -1);
1263 fprintf_unfiltered (gdb_stderr, " has no component named ");
1264 fputs_filtered (name, gdb_stderr);
1266 return (struct type *) -1; /* For lint */
1269 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
1270 valid. Callers should be aware that in some cases (for example,
1271 the type or one of its baseclasses is a stub type and we are
1272 debugging a .o file), this function will not be able to find the virtual
1273 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
1274 will remain NULL. */
1277 fill_in_vptr_fieldno (struct type *type)
1279 CHECK_TYPEDEF (type);
1281 if (TYPE_VPTR_FIELDNO (type) < 0)
1285 /* We must start at zero in case the first (and only) baseclass is
1286 virtual (and hence we cannot share the table pointer). */
1287 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1289 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
1290 fill_in_vptr_fieldno (baseclass);
1291 if (TYPE_VPTR_FIELDNO (baseclass) >= 0)
1293 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (baseclass);
1294 TYPE_VPTR_BASETYPE (type) = TYPE_VPTR_BASETYPE (baseclass);
1301 /* Find the method and field indices for the destructor in class type T.
1302 Return 1 if the destructor was found, otherwise, return 0. */
1305 get_destructor_fn_field (struct type *t, int *method_indexp, int *field_indexp)
1309 for (i = 0; i < TYPE_NFN_FIELDS (t); i++)
1312 struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
1314 for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (t, i); j++)
1316 if (is_destructor_name (TYPE_FN_FIELD_PHYSNAME (f, j)) != 0)
1327 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1329 If this is a stubbed struct (i.e. declared as struct foo *), see if
1330 we can find a full definition in some other file. If so, copy this
1331 definition, so we can use it in future. There used to be a comment (but
1332 not any code) that if we don't find a full definition, we'd set a flag
1333 so we don't spend time in the future checking the same type. That would
1334 be a mistake, though--we might load in more symbols which contain a
1335 full definition for the type.
1337 This used to be coded as a macro, but I don't think it is called
1338 often enough to merit such treatment. */
1340 struct complaint stub_noname_complaint =
1341 {"stub type has NULL name", 0, 0};
1344 check_typedef (struct type *type)
1346 struct type *orig_type = type;
1347 int is_const, is_volatile;
1349 while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1351 if (!TYPE_TARGET_TYPE (type))
1356 /* It is dangerous to call lookup_symbol if we are currently
1357 reading a symtab. Infinite recursion is one danger. */
1358 if (currently_reading_symtab)
1361 name = type_name_no_tag (type);
1362 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1363 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
1364 as appropriate? (this code was written before TYPE_NAME and
1365 TYPE_TAG_NAME were separate). */
1368 complain (&stub_noname_complaint);
1371 sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0,
1372 (struct symtab **) NULL);
1374 TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
1376 TYPE_TARGET_TYPE (type) = alloc_type (NULL); /* TYPE_CODE_UNDEF */
1378 type = TYPE_TARGET_TYPE (type);
1381 is_const = TYPE_CONST (type);
1382 is_volatile = TYPE_VOLATILE (type);
1384 /* If this is a struct/class/union with no fields, then check whether a
1385 full definition exists somewhere else. This is for systems where a
1386 type definition with no fields is issued for such types, instead of
1387 identifying them as stub types in the first place */
1389 if (TYPE_IS_OPAQUE (type) && opaque_type_resolution && !currently_reading_symtab)
1391 char *name = type_name_no_tag (type);
1392 struct type *newtype;
1395 complain (&stub_noname_complaint);
1398 newtype = lookup_transparent_type (name);
1400 make_cv_type (is_const, is_volatile, newtype, &type);
1402 /* Otherwise, rely on the stub flag being set for opaque/stubbed types */
1403 else if (TYPE_STUB (type) && !currently_reading_symtab)
1405 char *name = type_name_no_tag (type);
1406 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1407 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
1408 as appropriate? (this code was written before TYPE_NAME and
1409 TYPE_TAG_NAME were separate). */
1413 complain (&stub_noname_complaint);
1416 sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0, (struct symtab **) NULL);
1418 make_cv_type (is_const, is_volatile, SYMBOL_TYPE (sym), &type);
1421 if (TYPE_TARGET_STUB (type))
1423 struct type *range_type;
1424 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1426 if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type))
1429 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
1430 && TYPE_NFIELDS (type) == 1
1431 && (TYPE_CODE (range_type = TYPE_FIELD_TYPE (type, 0))
1432 == TYPE_CODE_RANGE))
1434 /* Now recompute the length of the array type, based on its
1435 number of elements and the target type's length. */
1436 TYPE_LENGTH (type) =
1437 ((TYPE_FIELD_BITPOS (range_type, 1)
1438 - TYPE_FIELD_BITPOS (range_type, 0)
1440 * TYPE_LENGTH (target_type));
1441 TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB;
1443 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
1445 TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
1446 TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB;
1449 /* Cache TYPE_LENGTH for future use. */
1450 TYPE_LENGTH (orig_type) = TYPE_LENGTH (type);
1454 /* New code added to support parsing of Cfront stabs strings */
1455 #define INIT_EXTRA { pextras->len=0; pextras->str[0]='\0'; }
1456 #define ADD_EXTRA(c) { pextras->str[pextras->len++]=c; }
1459 add_name (struct extra *pextras, char *n)
1463 if ((nlen = (n ? strlen (n) : 0)) == 0)
1465 sprintf (pextras->str + pextras->len, "%d%s", nlen, n);
1466 pextras->len = strlen (pextras->str);
1470 add_mangled_type (struct extra *pextras, struct type *t)
1472 enum type_code tcode;
1476 tcode = TYPE_CODE (t);
1477 tlen = TYPE_LENGTH (t);
1478 tflags = TYPE_FLAGS (t);
1479 tname = TYPE_NAME (t);
1480 /* args of "..." seem to get mangled as "e" */
1498 if ((pname = strrchr (tname, 'l'), pname) && !strcmp (pname, "long"))
1511 static struct complaint msg =
1512 {"Bad int type code length x%x\n", 0, 0};
1514 complain (&msg, tlen);
1533 static struct complaint msg =
1534 {"Bad float type code length x%x\n", 0, 0};
1535 complain (&msg, tlen);
1541 /* followed by what it's a ref to */
1545 /* followed by what it's a ptr to */
1547 case TYPE_CODE_TYPEDEF:
1549 static struct complaint msg =
1550 {"Typedefs in overloaded functions not yet supported\n", 0, 0};
1553 /* followed by type bytes & name */
1555 case TYPE_CODE_FUNC:
1557 /* followed by func's arg '_' & ret types */
1559 case TYPE_CODE_VOID:
1562 case TYPE_CODE_METHOD:
1564 /* followed by name of class and func's arg '_' & ret types */
1565 add_name (pextras, tname);
1566 ADD_EXTRA ('F'); /* then mangle function */
1568 case TYPE_CODE_STRUCT: /* C struct */
1569 case TYPE_CODE_UNION: /* C union */
1570 case TYPE_CODE_ENUM: /* Enumeration type */
1571 /* followed by name of type */
1572 add_name (pextras, tname);
1575 /* errors possible types/not supported */
1576 case TYPE_CODE_CHAR:
1577 case TYPE_CODE_ARRAY: /* Array type */
1578 case TYPE_CODE_MEMBER: /* Member type */
1579 case TYPE_CODE_BOOL:
1580 case TYPE_CODE_COMPLEX: /* Complex float */
1581 case TYPE_CODE_UNDEF:
1582 case TYPE_CODE_SET: /* Pascal sets */
1583 case TYPE_CODE_RANGE:
1584 case TYPE_CODE_STRING:
1585 case TYPE_CODE_BITSTRING:
1586 case TYPE_CODE_ERROR:
1589 static struct complaint msg =
1590 {"Unknown type code x%x\n", 0, 0};
1591 complain (&msg, tcode);
1594 if (TYPE_TARGET_TYPE (t))
1595 add_mangled_type (pextras, TYPE_TARGET_TYPE (t));
1600 cfront_mangle_name (struct type *type, int i, int j)
1603 char *mangled_name = gdb_mangle_name (type, i, j);
1605 f = TYPE_FN_FIELDLIST1 (type, i); /* moved from below */
1607 /* kludge to support cfront methods - gdb expects to find "F" for
1608 ARM_mangled names, so when we mangle, we have to add it here */
1612 char *arm_mangled_name;
1613 struct fn_field *method = &f[j];
1614 char *field_name = TYPE_FN_FIELDLIST_NAME (type, i);
1615 char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
1616 char *newname = type_name_no_tag (type);
1618 struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
1619 int nargs = TYPE_NFIELDS (ftype); /* number of args */
1620 struct extra extras, *pextras = &extras;
1623 if (TYPE_FN_FIELD_STATIC_P (f, j)) /* j for sublist within this list */
1626 /* add args here! */
1627 if (nargs <= 1) /* no args besides this */
1631 for (k = 1; k < nargs; k++)
1634 t = TYPE_FIELD_TYPE (ftype, k);
1635 add_mangled_type (pextras, t);
1639 printf ("add_mangled_type: %s\n", extras.str); /* FIXME */
1640 xasprintf (&arm_mangled_name, "%s%s", mangled_name, extras.str);
1641 xfree (mangled_name);
1642 mangled_name = arm_mangled_name;
1648 /* End of new code added to support parsing of Cfront stabs strings */
1650 /* Parse a type expression in the string [P..P+LENGTH). If an error occurs,
1651 silently return builtin_type_void. */
1654 safe_parse_type (char *p, int length)
1656 struct ui_file *saved_gdb_stderr;
1659 /* Suppress error messages. */
1660 saved_gdb_stderr = gdb_stderr;
1661 gdb_stderr = ui_file_new ();
1663 /* Call parse_and_eval_type() without fear of longjmp()s. */
1664 if (!gdb_parse_and_eval_type (p, length, &type))
1665 type = builtin_type_void;
1667 /* Stop suppressing error messages. */
1668 ui_file_delete (gdb_stderr);
1669 gdb_stderr = saved_gdb_stderr;
1674 /* Ugly hack to convert method stubs into method types.
1676 He ain't kiddin'. This demangles the name of the method into a string
1677 including argument types, parses out each argument type, generates
1678 a string casting a zero to that type, evaluates the string, and stuffs
1679 the resulting type into an argtype vector!!! Then it knows the type
1680 of the whole function (including argument types for overloading),
1681 which info used to be in the stab's but was removed to hack back
1682 the space required for them. */
1685 check_stub_method (struct type *type, int method_id, int signature_id)
1688 char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
1689 char *demangled_name = cplus_demangle (mangled_name,
1690 DMGL_PARAMS | DMGL_ANSI);
1691 char *argtypetext, *p;
1692 int depth = 0, argcount = 1;
1693 struct field *argtypes;
1696 /* Make sure we got back a function string that we can use. */
1698 p = strchr (demangled_name, '(');
1702 if (demangled_name == NULL || p == NULL)
1703 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name);
1705 /* Now, read in the parameters that define this type. */
1710 if (*p == '(' || *p == '<')
1714 else if (*p == ')' || *p == '>')
1718 else if (*p == ',' && depth == 0)
1726 /* If we read one argument and it was ``void'', don't count it. */
1727 if (strncmp (argtypetext, "(void)", 6) == 0)
1730 /* We need one extra slot, for the THIS pointer. */
1732 argtypes = (struct field *)
1733 TYPE_ALLOC (type, (argcount + 1) * sizeof (struct field));
1736 /* Add THIS pointer for non-static methods. */
1737 f = TYPE_FN_FIELDLIST1 (type, method_id);
1738 if (TYPE_FN_FIELD_STATIC_P (f, signature_id))
1742 argtypes[0].type = lookup_pointer_type (type);
1746 if (*p != ')') /* () means no args, skip while */
1751 if (depth <= 0 && (*p == ',' || *p == ')'))
1753 /* Avoid parsing of ellipsis, they will be handled below.
1754 Also avoid ``void'' as above. */
1755 if (strncmp (argtypetext, "...", p - argtypetext) != 0
1756 && strncmp (argtypetext, "void", p - argtypetext) != 0)
1758 argtypes[argcount].type =
1759 safe_parse_type (argtypetext, p - argtypetext);
1762 argtypetext = p + 1;
1765 if (*p == '(' || *p == '<')
1769 else if (*p == ')' || *p == '>')
1778 TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name;
1780 /* Now update the old "stub" type into a real type. */
1781 mtype = TYPE_FN_FIELD_TYPE (f, signature_id);
1782 TYPE_DOMAIN_TYPE (mtype) = type;
1783 TYPE_FIELDS (mtype) = argtypes;
1784 TYPE_NFIELDS (mtype) = argcount;
1785 TYPE_FLAGS (mtype) &= ~TYPE_FLAG_STUB;
1786 TYPE_FN_FIELD_STUB (f, signature_id) = 0;
1788 TYPE_FLAGS (mtype) |= TYPE_FLAG_VARARGS;
1790 xfree (demangled_name);
1793 /* This is the external interface to check_stub_method, above. This function
1794 unstubs all of the signatures for TYPE's METHOD_ID method name. After
1795 calling this function TYPE_FN_FIELD_STUB will be cleared for each signature
1796 and TYPE_FN_FIELDLIST_NAME will be correct.
1798 This function unfortunately can not die until stabs do. */
1801 check_stub_method_group (struct type *type, int method_id)
1803 int len = TYPE_FN_FIELDLIST_LENGTH (type, method_id);
1804 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
1805 int j, found_stub = 0;
1807 for (j = 0; j < len; j++)
1808 if (TYPE_FN_FIELD_STUB (f, j))
1811 check_stub_method (type, method_id, j);
1814 /* GNU v3 methods with incorrect names were corrected when we read in
1815 type information, because it was cheaper to do it then. The only GNU v2
1816 methods with incorrect method names are operators and destructors;
1817 destructors were also corrected when we read in type information.
1819 Therefore the only thing we need to handle here are v2 operator
1821 if (found_stub && strncmp (TYPE_FN_FIELD_PHYSNAME (f, 0), "_Z", 2) != 0)
1824 char dem_opname[256];
1826 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type, method_id),
1827 dem_opname, DMGL_ANSI);
1829 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type, method_id),
1832 TYPE_FN_FIELDLIST_NAME (type, method_id) = xstrdup (dem_opname);
1836 const struct cplus_struct_type cplus_struct_default;
1839 allocate_cplus_struct_type (struct type *type)
1841 if (!HAVE_CPLUS_STRUCT (type))
1843 TYPE_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
1844 TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
1845 *(TYPE_CPLUS_SPECIFIC (type)) = cplus_struct_default;
1849 /* Helper function to initialize the standard scalar types.
1851 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1852 of the string pointed to by name in the type_obstack for that objfile,
1853 and initialize the type name to that copy. There are places (mipsread.c
1854 in particular, where init_type is called with a NULL value for NAME). */
1857 init_type (enum type_code code, int length, int flags, char *name,
1858 struct objfile *objfile)
1860 register struct type *type;
1862 type = alloc_type (objfile);
1863 TYPE_CODE (type) = code;
1864 TYPE_LENGTH (type) = length;
1865 TYPE_FLAGS (type) |= flags;
1866 if ((name != NULL) && (objfile != NULL))
1869 obsavestring (name, strlen (name), &objfile->type_obstack);
1873 TYPE_NAME (type) = name;
1878 if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION)
1880 INIT_CPLUS_SPECIFIC (type);
1885 /* Helper function. Create an empty composite type. */
1888 init_composite_type (char *name, enum type_code code)
1891 gdb_assert (code == TYPE_CODE_STRUCT
1892 || code == TYPE_CODE_UNION);
1893 t = init_type (code, 0, 0, NULL, NULL);
1894 TYPE_TAG_NAME (t) = name;
1898 /* Helper function. Append a field to a composite type. */
1901 append_composite_type_field (struct type *t, char *name, struct type *field)
1904 TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
1905 TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t),
1906 sizeof (struct field) * TYPE_NFIELDS (t));
1907 f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
1908 memset (f, 0, sizeof f[0]);
1909 FIELD_TYPE (f[0]) = field;
1910 FIELD_NAME (f[0]) = name;
1911 if (TYPE_CODE (t) == TYPE_CODE_UNION)
1913 if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
1914 TYPE_LENGTH (t) = TYPE_LENGTH (field);
1916 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
1918 TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
1919 if (TYPE_NFIELDS (t) > 1)
1921 FIELD_BITPOS (f[0]) = (FIELD_BITPOS (f[-1])
1922 + TYPE_LENGTH (field) * TARGET_CHAR_BIT);
1927 /* Look up a fundamental type for the specified objfile.
1928 May need to construct such a type if this is the first use.
1930 Some object file formats (ELF, COFF, etc) do not define fundamental
1931 types such as "int" or "double". Others (stabs for example), do
1932 define fundamental types.
1934 For the formats which don't provide fundamental types, gdb can create
1935 such types, using defaults reasonable for the current language and
1936 the current target machine.
1938 NOTE: This routine is obsolescent. Each debugging format reader
1939 should manage it's own fundamental types, either creating them from
1940 suitable defaults or reading them from the debugging information,
1941 whichever is appropriate. The DWARF reader has already been
1942 fixed to do this. Once the other readers are fixed, this routine
1943 will go away. Also note that fundamental types should be managed
1944 on a compilation unit basis in a multi-language environment, not
1945 on a linkage unit basis as is done here. */
1949 lookup_fundamental_type (struct objfile *objfile, int typeid)
1951 register struct type **typep;
1952 register int nbytes;
1954 if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
1956 error ("internal error - invalid fundamental type id %d", typeid);
1959 /* If this is the first time we need a fundamental type for this objfile
1960 then we need to initialize the vector of type pointers. */
1962 if (objfile->fundamental_types == NULL)
1964 nbytes = FT_NUM_MEMBERS * sizeof (struct type *);
1965 objfile->fundamental_types = (struct type **)
1966 obstack_alloc (&objfile->type_obstack, nbytes);
1967 memset ((char *) objfile->fundamental_types, 0, nbytes);
1968 OBJSTAT (objfile, n_types += FT_NUM_MEMBERS);
1971 /* Look for this particular type in the fundamental type vector. If one is
1972 not found, create and install one appropriate for the current language. */
1974 typep = objfile->fundamental_types + typeid;
1977 *typep = create_fundamental_type (objfile, typeid);
1984 can_dereference (struct type *t)
1986 /* FIXME: Should we return true for references as well as pointers? */
1990 && TYPE_CODE (t) == TYPE_CODE_PTR
1991 && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
1995 is_integral_type (struct type *t)
2000 && ((TYPE_CODE (t) == TYPE_CODE_INT)
2001 || (TYPE_CODE (t) == TYPE_CODE_ENUM)
2002 || (TYPE_CODE (t) == TYPE_CODE_CHAR)
2003 || (TYPE_CODE (t) == TYPE_CODE_RANGE)
2004 || (TYPE_CODE (t) == TYPE_CODE_BOOL)));
2007 /* (OBSOLETE) Chill (OBSOLETE) varying string and arrays are
2008 represented as follows:
2010 struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
2012 Return true if TYPE is such a (OBSOLETE) Chill (OBSOLETE) varying
2016 /* OBSOLETE chill_varying_type (struct type *type) */
2018 /* OBSOLETE if (TYPE_CODE (type) != TYPE_CODE_STRUCT */
2019 /* OBSOLETE || TYPE_NFIELDS (type) != 2 */
2020 /* OBSOLETE || strcmp (TYPE_FIELD_NAME (type, 0), "__var_length") != 0) */
2021 /* OBSOLETE return 0; */
2022 /* OBSOLETE return 1; */
2025 /* Check whether BASE is an ancestor or base class or DCLASS
2026 Return 1 if so, and 0 if not.
2027 Note: callers may want to check for identity of the types before
2028 calling this function -- identical types are considered to satisfy
2029 the ancestor relationship even if they're identical */
2032 is_ancestor (struct type *base, struct type *dclass)
2036 CHECK_TYPEDEF (base);
2037 CHECK_TYPEDEF (dclass);
2041 if (TYPE_NAME (base) && TYPE_NAME (dclass) &&
2042 !strcmp (TYPE_NAME (base), TYPE_NAME (dclass)))
2045 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
2046 if (is_ancestor (base, TYPE_BASECLASS (dclass, i)))
2054 /* See whether DCLASS has a virtual table. This routine is aimed at
2055 the HP/Taligent ANSI C++ runtime model, and may not work with other
2056 runtime models. Return 1 => Yes, 0 => No. */
2059 has_vtable (struct type *dclass)
2061 /* In the HP ANSI C++ runtime model, a class has a vtable only if it
2062 has virtual functions or virtual bases. */
2066 if (TYPE_CODE (dclass) != TYPE_CODE_CLASS)
2069 /* First check for the presence of virtual bases */
2070 if (TYPE_FIELD_VIRTUAL_BITS (dclass))
2071 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
2072 if (B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass), i))
2075 /* Next check for virtual functions */
2076 if (TYPE_FN_FIELDLISTS (dclass))
2077 for (i = 0; i < TYPE_NFN_FIELDS (dclass); i++)
2078 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass, i), 0))
2081 /* Recurse on non-virtual bases to see if any of them needs a vtable */
2082 if (TYPE_FIELD_VIRTUAL_BITS (dclass))
2083 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
2084 if ((!B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass), i)) &&
2085 (has_vtable (TYPE_FIELD_TYPE (dclass, i))))
2088 /* Well, maybe we don't need a virtual table */
2092 /* Return a pointer to the "primary base class" of DCLASS.
2094 A NULL return indicates that DCLASS has no primary base, or that it
2095 couldn't be found (insufficient information).
2097 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
2098 and may not work with other runtime models. */
2101 primary_base_class (struct type *dclass)
2103 /* In HP ANSI C++'s runtime model, a "primary base class" of a class
2104 is the first directly inherited, non-virtual base class that
2105 requires a virtual table */
2109 if (TYPE_CODE (dclass) != TYPE_CODE_CLASS)
2112 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
2113 if (!TYPE_FIELD_VIRTUAL (dclass, i) &&
2114 has_vtable (TYPE_FIELD_TYPE (dclass, i)))
2115 return TYPE_FIELD_TYPE (dclass, i);
2120 /* Global manipulated by virtual_base_list[_aux]() */
2122 static struct vbase *current_vbase_list = NULL;
2124 /* Return a pointer to a null-terminated list of struct vbase
2125 items. The vbasetype pointer of each item in the list points to the
2126 type information for a virtual base of the argument DCLASS.
2128 Helper function for virtual_base_list().
2129 Note: the list goes backward, right-to-left. virtual_base_list()
2130 copies the items out in reverse order. */
2133 virtual_base_list_aux (struct type *dclass)
2135 struct vbase *tmp_vbase;
2138 if (TYPE_CODE (dclass) != TYPE_CODE_CLASS)
2141 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
2143 /* Recurse on this ancestor, first */
2144 virtual_base_list_aux (TYPE_FIELD_TYPE (dclass, i));
2146 /* If this current base is itself virtual, add it to the list */
2147 if (BASETYPE_VIA_VIRTUAL (dclass, i))
2149 struct type *basetype = TYPE_FIELD_TYPE (dclass, i);
2151 /* Check if base already recorded */
2152 tmp_vbase = current_vbase_list;
2155 if (tmp_vbase->vbasetype == basetype)
2156 break; /* found it */
2157 tmp_vbase = tmp_vbase->next;
2160 if (!tmp_vbase) /* normal exit from loop */
2162 /* Allocate new item for this virtual base */
2163 tmp_vbase = (struct vbase *) xmalloc (sizeof (struct vbase));
2165 /* Stick it on at the end of the list */
2166 tmp_vbase->vbasetype = basetype;
2167 tmp_vbase->next = current_vbase_list;
2168 current_vbase_list = tmp_vbase;
2171 } /* for loop over bases */
2175 /* Compute the list of virtual bases in the right order. Virtual
2176 bases are laid out in the object's memory area in order of their
2177 occurrence in a depth-first, left-to-right search through the
2180 Argument DCLASS is the type whose virtual bases are required.
2181 Return value is the address of a null-terminated array of pointers
2182 to struct type items.
2184 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
2185 and may not work with other runtime models.
2187 This routine merely hands off the argument to virtual_base_list_aux()
2188 and then copies the result into an array to save space. */
2191 virtual_base_list (struct type *dclass)
2193 register struct vbase *tmp_vbase;
2194 register struct vbase *tmp_vbase_2;
2197 struct type **vbase_array;
2199 current_vbase_list = NULL;
2200 virtual_base_list_aux (dclass);
2202 for (i = 0, tmp_vbase = current_vbase_list; tmp_vbase != NULL; i++, tmp_vbase = tmp_vbase->next)
2207 vbase_array = (struct type **) xmalloc ((count + 1) * sizeof (struct type *));
2209 for (i = count - 1, tmp_vbase = current_vbase_list; i >= 0; i--, tmp_vbase = tmp_vbase->next)
2210 vbase_array[i] = tmp_vbase->vbasetype;
2212 /* Get rid of constructed chain */
2213 tmp_vbase_2 = tmp_vbase = current_vbase_list;
2216 tmp_vbase = tmp_vbase->next;
2217 xfree (tmp_vbase_2);
2218 tmp_vbase_2 = tmp_vbase;
2221 vbase_array[count] = NULL;
2225 /* Return the length of the virtual base list of the type DCLASS. */
2228 virtual_base_list_length (struct type *dclass)
2231 register struct vbase *tmp_vbase;
2233 current_vbase_list = NULL;
2234 virtual_base_list_aux (dclass);
2236 for (i = 0, tmp_vbase = current_vbase_list; tmp_vbase != NULL; i++, tmp_vbase = tmp_vbase->next)
2241 /* Return the number of elements of the virtual base list of the type
2242 DCLASS, ignoring those appearing in the primary base (and its
2243 primary base, recursively). */
2246 virtual_base_list_length_skip_primaries (struct type *dclass)
2249 register struct vbase *tmp_vbase;
2250 struct type *primary;
2252 primary = TYPE_RUNTIME_PTR (dclass) ? TYPE_PRIMARY_BASE (dclass) : NULL;
2255 return virtual_base_list_length (dclass);
2257 current_vbase_list = NULL;
2258 virtual_base_list_aux (dclass);
2260 for (i = 0, tmp_vbase = current_vbase_list; tmp_vbase != NULL; tmp_vbase = tmp_vbase->next)
2262 if (virtual_base_index (tmp_vbase->vbasetype, primary) >= 0)
2270 /* Return the index (position) of type BASE, which is a virtual base
2271 class of DCLASS, in the latter's virtual base list. A return of -1
2272 indicates "not found" or a problem. */
2275 virtual_base_index (struct type *base, struct type *dclass)
2277 register struct type *vbase;
2280 if ((TYPE_CODE (dclass) != TYPE_CODE_CLASS) ||
2281 (TYPE_CODE (base) != TYPE_CODE_CLASS))
2285 vbase = virtual_base_list (dclass)[0];
2290 vbase = virtual_base_list (dclass)[++i];
2293 return vbase ? i : -1;
2298 /* Return the index (position) of type BASE, which is a virtual base
2299 class of DCLASS, in the latter's virtual base list. Skip over all
2300 bases that may appear in the virtual base list of the primary base
2301 class of DCLASS (recursively). A return of -1 indicates "not
2302 found" or a problem. */
2305 virtual_base_index_skip_primaries (struct type *base, struct type *dclass)
2307 register struct type *vbase;
2309 struct type *primary;
2311 if ((TYPE_CODE (dclass) != TYPE_CODE_CLASS) ||
2312 (TYPE_CODE (base) != TYPE_CODE_CLASS))
2315 primary = TYPE_RUNTIME_PTR (dclass) ? TYPE_PRIMARY_BASE (dclass) : NULL;
2319 vbase = virtual_base_list (dclass)[0];
2322 if (!primary || (virtual_base_index_skip_primaries (vbase, primary) < 0))
2326 vbase = virtual_base_list (dclass)[++i];
2329 return vbase ? j : -1;
2332 /* Return position of a derived class DCLASS in the list of
2333 * primary bases starting with the remotest ancestor.
2334 * Position returned is 0-based. */
2337 class_index_in_primary_list (struct type *dclass)
2339 struct type *pbc; /* primary base class */
2341 /* Simply recurse on primary base */
2342 pbc = TYPE_PRIMARY_BASE (dclass);
2344 return 1 + class_index_in_primary_list (pbc);
2349 /* Return a count of the number of virtual functions a type has.
2350 * This includes all the virtual functions it inherits from its
2354 /* pai: FIXME This doesn't do the right thing: count redefined virtual
2355 * functions only once (latest redefinition)
2359 count_virtual_fns (struct type *dclass)
2361 int fn, oi; /* function and overloaded instance indices */
2362 int vfuncs; /* count to return */
2364 /* recurse on bases that can share virtual table */
2365 struct type *pbc = primary_base_class (dclass);
2367 vfuncs = count_virtual_fns (pbc);
2371 for (fn = 0; fn < TYPE_NFN_FIELDS (dclass); fn++)
2372 for (oi = 0; oi < TYPE_FN_FIELDLIST_LENGTH (dclass, fn); oi++)
2373 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass, fn), oi))
2381 /* Functions for overload resolution begin here */
2383 /* Compare two badness vectors A and B and return the result.
2384 * 0 => A and B are identical
2385 * 1 => A and B are incomparable
2386 * 2 => A is better than B
2387 * 3 => A is worse than B */
2390 compare_badness (struct badness_vector *a, struct badness_vector *b)
2394 short found_pos = 0; /* any positives in c? */
2395 short found_neg = 0; /* any negatives in c? */
2397 /* differing lengths => incomparable */
2398 if (a->length != b->length)
2401 /* Subtract b from a */
2402 for (i = 0; i < a->length; i++)
2404 tmp = a->rank[i] - b->rank[i];
2414 return 1; /* incomparable */
2416 return 3; /* A > B */
2422 return 2; /* A < B */
2424 return 0; /* A == B */
2428 /* Rank a function by comparing its parameter types (PARMS, length NPARMS),
2429 * to the types of an argument list (ARGS, length NARGS).
2430 * Return a pointer to a badness vector. This has NARGS + 1 entries. */
2432 struct badness_vector *
2433 rank_function (struct type **parms, int nparms, struct type **args, int nargs)
2436 struct badness_vector *bv;
2437 int min_len = nparms < nargs ? nparms : nargs;
2439 bv = xmalloc (sizeof (struct badness_vector));
2440 bv->length = nargs + 1; /* add 1 for the length-match rank */
2441 bv->rank = xmalloc ((nargs + 1) * sizeof (int));
2443 /* First compare the lengths of the supplied lists.
2444 * If there is a mismatch, set it to a high value. */
2446 /* pai/1997-06-03 FIXME: when we have debug info about default
2447 * arguments and ellipsis parameter lists, we should consider those
2448 * and rank the length-match more finely. */
2450 LENGTH_MATCH (bv) = (nargs != nparms) ? LENGTH_MISMATCH_BADNESS : 0;
2452 /* Now rank all the parameters of the candidate function */
2453 for (i = 1; i <= min_len; i++)
2454 bv->rank[i] = rank_one_type (parms[i-1], args[i-1]);
2456 /* If more arguments than parameters, add dummy entries */
2457 for (i = min_len + 1; i <= nargs; i++)
2458 bv->rank[i] = TOO_FEW_PARAMS_BADNESS;
2463 /* Compare one type (PARM) for compatibility with another (ARG).
2464 * PARM is intended to be the parameter type of a function; and
2465 * ARG is the supplied argument's type. This function tests if
2466 * the latter can be converted to the former.
2468 * Return 0 if they are identical types;
2469 * Otherwise, return an integer which corresponds to how compatible
2470 * PARM is to ARG. The higher the return value, the worse the match.
2471 * Generally the "bad" conversions are all uniformly assigned a 100 */
2474 rank_one_type (struct type *parm, struct type *arg)
2476 /* Identical type pointers */
2477 /* However, this still doesn't catch all cases of same type for arg
2478 * and param. The reason is that builtin types are different from
2479 * the same ones constructed from the object. */
2483 /* Resolve typedefs */
2484 if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF)
2485 parm = check_typedef (parm);
2486 if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
2487 arg = check_typedef (arg);
2490 Well, damnit, if the names are exactly the same,
2491 i'll say they are exactly the same. This happens when we generate
2492 method stubs. The types won't point to the same address, but they
2493 really are the same.
2496 if (TYPE_NAME (parm) && TYPE_NAME (arg) &&
2497 !strcmp (TYPE_NAME (parm), TYPE_NAME (arg)))
2500 /* Check if identical after resolving typedefs */
2504 /* See through references, since we can almost make non-references
2506 if (TYPE_CODE (arg) == TYPE_CODE_REF)
2507 return (rank_one_type (parm, TYPE_TARGET_TYPE (arg))
2508 + REFERENCE_CONVERSION_BADNESS);
2509 if (TYPE_CODE (parm) == TYPE_CODE_REF)
2510 return (rank_one_type (TYPE_TARGET_TYPE (parm), arg)
2511 + REFERENCE_CONVERSION_BADNESS);
2513 /* Debugging only. */
2514 fprintf_filtered (gdb_stderr,"------ Arg is %s [%d], parm is %s [%d]\n",
2515 TYPE_NAME (arg), TYPE_CODE (arg), TYPE_NAME (parm), TYPE_CODE (parm));
2517 /* x -> y means arg of type x being supplied for parameter of type y */
2519 switch (TYPE_CODE (parm))
2522 switch (TYPE_CODE (arg))
2525 if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID)
2526 return VOID_PTR_CONVERSION_BADNESS;
2528 return rank_one_type (TYPE_TARGET_TYPE (parm), TYPE_TARGET_TYPE (arg));
2529 case TYPE_CODE_ARRAY:
2530 return rank_one_type (TYPE_TARGET_TYPE (parm), TYPE_TARGET_TYPE (arg));
2531 case TYPE_CODE_FUNC:
2532 return rank_one_type (TYPE_TARGET_TYPE (parm), arg);
2534 case TYPE_CODE_ENUM:
2535 case TYPE_CODE_CHAR:
2536 case TYPE_CODE_RANGE:
2537 case TYPE_CODE_BOOL:
2538 return POINTER_CONVERSION_BADNESS;
2540 return INCOMPATIBLE_TYPE_BADNESS;
2542 case TYPE_CODE_ARRAY:
2543 switch (TYPE_CODE (arg))
2546 case TYPE_CODE_ARRAY:
2547 return rank_one_type (TYPE_TARGET_TYPE (parm), TYPE_TARGET_TYPE (arg));
2549 return INCOMPATIBLE_TYPE_BADNESS;
2551 case TYPE_CODE_FUNC:
2552 switch (TYPE_CODE (arg))
2554 case TYPE_CODE_PTR: /* funcptr -> func */
2555 return rank_one_type (parm, TYPE_TARGET_TYPE (arg));
2557 return INCOMPATIBLE_TYPE_BADNESS;
2560 switch (TYPE_CODE (arg))
2563 if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2565 /* Deal with signed, unsigned, and plain chars and
2566 signed and unsigned ints */
2567 if (TYPE_NOSIGN (parm))
2569 /* This case only for character types */
2570 if (TYPE_NOSIGN (arg)) /* plain char -> plain char */
2573 return INTEGER_COERCION_BADNESS; /* signed/unsigned char -> plain char */
2575 else if (TYPE_UNSIGNED (parm))
2577 if (TYPE_UNSIGNED (arg))
2579 if (!strcmp_iw (TYPE_NAME (parm), TYPE_NAME (arg)))
2580 return 0; /* unsigned int -> unsigned int, or unsigned long -> unsigned long */
2581 else if (!strcmp_iw (TYPE_NAME (arg), "int") && !strcmp_iw (TYPE_NAME (parm), "long"))
2582 return INTEGER_PROMOTION_BADNESS; /* unsigned int -> unsigned long */
2584 return INTEGER_COERCION_BADNESS; /* unsigned long -> unsigned int */
2588 if (!strcmp_iw (TYPE_NAME (arg), "long") && !strcmp_iw (TYPE_NAME (parm), "int"))
2589 return INTEGER_COERCION_BADNESS; /* signed long -> unsigned int */
2591 return INTEGER_CONVERSION_BADNESS; /* signed int/long -> unsigned int/long */
2594 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2596 if (!strcmp_iw (TYPE_NAME (parm), TYPE_NAME (arg)))
2598 else if (!strcmp_iw (TYPE_NAME (arg), "int") && !strcmp_iw (TYPE_NAME (parm), "long"))
2599 return INTEGER_PROMOTION_BADNESS;
2601 return INTEGER_COERCION_BADNESS;
2604 return INTEGER_COERCION_BADNESS;
2606 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2607 return INTEGER_PROMOTION_BADNESS;
2609 return INTEGER_COERCION_BADNESS;
2610 case TYPE_CODE_ENUM:
2611 case TYPE_CODE_CHAR:
2612 case TYPE_CODE_RANGE:
2613 case TYPE_CODE_BOOL:
2614 return INTEGER_PROMOTION_BADNESS;
2616 return INT_FLOAT_CONVERSION_BADNESS;
2618 return NS_POINTER_CONVERSION_BADNESS;
2620 return INCOMPATIBLE_TYPE_BADNESS;
2623 case TYPE_CODE_ENUM:
2624 switch (TYPE_CODE (arg))
2627 case TYPE_CODE_CHAR:
2628 case TYPE_CODE_RANGE:
2629 case TYPE_CODE_BOOL:
2630 case TYPE_CODE_ENUM:
2631 return INTEGER_COERCION_BADNESS;
2633 return INT_FLOAT_CONVERSION_BADNESS;
2635 return INCOMPATIBLE_TYPE_BADNESS;
2638 case TYPE_CODE_CHAR:
2639 switch (TYPE_CODE (arg))
2641 case TYPE_CODE_RANGE:
2642 case TYPE_CODE_BOOL:
2643 case TYPE_CODE_ENUM:
2644 return INTEGER_COERCION_BADNESS;
2646 return INT_FLOAT_CONVERSION_BADNESS;
2648 if (TYPE_LENGTH (arg) > TYPE_LENGTH (parm))
2649 return INTEGER_COERCION_BADNESS;
2650 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2651 return INTEGER_PROMOTION_BADNESS;
2652 /* >>> !! else fall through !! <<< */
2653 case TYPE_CODE_CHAR:
2654 /* Deal with signed, unsigned, and plain chars for C++
2655 and with int cases falling through from previous case */
2656 if (TYPE_NOSIGN (parm))
2658 if (TYPE_NOSIGN (arg))
2661 return INTEGER_COERCION_BADNESS;
2663 else if (TYPE_UNSIGNED (parm))
2665 if (TYPE_UNSIGNED (arg))
2668 return INTEGER_PROMOTION_BADNESS;
2670 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2673 return INTEGER_COERCION_BADNESS;
2675 return INCOMPATIBLE_TYPE_BADNESS;
2678 case TYPE_CODE_RANGE:
2679 switch (TYPE_CODE (arg))
2682 case TYPE_CODE_CHAR:
2683 case TYPE_CODE_RANGE:
2684 case TYPE_CODE_BOOL:
2685 case TYPE_CODE_ENUM:
2686 return INTEGER_COERCION_BADNESS;
2688 return INT_FLOAT_CONVERSION_BADNESS;
2690 return INCOMPATIBLE_TYPE_BADNESS;
2693 case TYPE_CODE_BOOL:
2694 switch (TYPE_CODE (arg))
2697 case TYPE_CODE_CHAR:
2698 case TYPE_CODE_RANGE:
2699 case TYPE_CODE_ENUM:
2702 return BOOLEAN_CONVERSION_BADNESS;
2703 case TYPE_CODE_BOOL:
2706 return INCOMPATIBLE_TYPE_BADNESS;
2710 switch (TYPE_CODE (arg))
2713 if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2714 return FLOAT_PROMOTION_BADNESS;
2715 else if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2718 return FLOAT_CONVERSION_BADNESS;
2720 case TYPE_CODE_BOOL:
2721 case TYPE_CODE_ENUM:
2722 case TYPE_CODE_RANGE:
2723 case TYPE_CODE_CHAR:
2724 return INT_FLOAT_CONVERSION_BADNESS;
2726 return INCOMPATIBLE_TYPE_BADNESS;
2729 case TYPE_CODE_COMPLEX:
2730 switch (TYPE_CODE (arg))
2731 { /* Strictly not needed for C++, but... */
2733 return FLOAT_PROMOTION_BADNESS;
2734 case TYPE_CODE_COMPLEX:
2737 return INCOMPATIBLE_TYPE_BADNESS;
2740 case TYPE_CODE_STRUCT:
2741 /* currently same as TYPE_CODE_CLASS */
2742 switch (TYPE_CODE (arg))
2744 case TYPE_CODE_STRUCT:
2745 /* Check for derivation */
2746 if (is_ancestor (parm, arg))
2747 return BASE_CONVERSION_BADNESS;
2748 /* else fall through */
2750 return INCOMPATIBLE_TYPE_BADNESS;
2753 case TYPE_CODE_UNION:
2754 switch (TYPE_CODE (arg))
2756 case TYPE_CODE_UNION:
2758 return INCOMPATIBLE_TYPE_BADNESS;
2761 case TYPE_CODE_MEMBER:
2762 switch (TYPE_CODE (arg))
2765 return INCOMPATIBLE_TYPE_BADNESS;
2768 case TYPE_CODE_METHOD:
2769 switch (TYPE_CODE (arg))
2773 return INCOMPATIBLE_TYPE_BADNESS;
2777 switch (TYPE_CODE (arg))
2781 return INCOMPATIBLE_TYPE_BADNESS;
2786 switch (TYPE_CODE (arg))
2790 return rank_one_type (TYPE_FIELD_TYPE (parm, 0), TYPE_FIELD_TYPE (arg, 0));
2792 return INCOMPATIBLE_TYPE_BADNESS;
2795 case TYPE_CODE_VOID:
2797 return INCOMPATIBLE_TYPE_BADNESS;
2798 } /* switch (TYPE_CODE (arg)) */
2802 /* End of functions for overload resolution */
2805 print_bit_vector (B_TYPE *bits, int nbits)
2809 for (bitno = 0; bitno < nbits; bitno++)
2811 if ((bitno % 8) == 0)
2813 puts_filtered (" ");
2815 if (B_TST (bits, bitno))
2817 printf_filtered ("1");
2821 printf_filtered ("0");
2826 /* Note the first arg should be the "this" pointer, we may not want to
2827 include it since we may get into a infinitely recursive situation. */
2830 print_arg_types (struct field *args, int nargs, int spaces)
2836 for (i = 0; i < nargs; i++)
2837 recursive_dump_type (args[i].type, spaces + 2);
2842 dump_fn_fieldlists (struct type *type, int spaces)
2848 printfi_filtered (spaces, "fn_fieldlists ");
2849 gdb_print_host_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
2850 printf_filtered ("\n");
2851 for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
2853 f = TYPE_FN_FIELDLIST1 (type, method_idx);
2854 printfi_filtered (spaces + 2, "[%d] name '%s' (",
2856 TYPE_FN_FIELDLIST_NAME (type, method_idx));
2857 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
2859 printf_filtered (") length %d\n",
2860 TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
2861 for (overload_idx = 0;
2862 overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
2865 printfi_filtered (spaces + 4, "[%d] physname '%s' (",
2867 TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
2868 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
2870 printf_filtered (")\n");
2871 printfi_filtered (spaces + 8, "type ");
2872 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx), gdb_stdout);
2873 printf_filtered ("\n");
2875 recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
2878 printfi_filtered (spaces + 8, "args ");
2879 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx), gdb_stdout);
2880 printf_filtered ("\n");
2882 print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx),
2883 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, overload_idx)),
2885 printfi_filtered (spaces + 8, "fcontext ");
2886 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
2888 printf_filtered ("\n");
2890 printfi_filtered (spaces + 8, "is_const %d\n",
2891 TYPE_FN_FIELD_CONST (f, overload_idx));
2892 printfi_filtered (spaces + 8, "is_volatile %d\n",
2893 TYPE_FN_FIELD_VOLATILE (f, overload_idx));
2894 printfi_filtered (spaces + 8, "is_private %d\n",
2895 TYPE_FN_FIELD_PRIVATE (f, overload_idx));
2896 printfi_filtered (spaces + 8, "is_protected %d\n",
2897 TYPE_FN_FIELD_PROTECTED (f, overload_idx));
2898 printfi_filtered (spaces + 8, "is_stub %d\n",
2899 TYPE_FN_FIELD_STUB (f, overload_idx));
2900 printfi_filtered (spaces + 8, "voffset %u\n",
2901 TYPE_FN_FIELD_VOFFSET (f, overload_idx));
2907 print_cplus_stuff (struct type *type, int spaces)
2909 printfi_filtered (spaces, "n_baseclasses %d\n",
2910 TYPE_N_BASECLASSES (type));
2911 printfi_filtered (spaces, "nfn_fields %d\n",
2912 TYPE_NFN_FIELDS (type));
2913 printfi_filtered (spaces, "nfn_fields_total %d\n",
2914 TYPE_NFN_FIELDS_TOTAL (type));
2915 if (TYPE_N_BASECLASSES (type) > 0)
2917 printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
2918 TYPE_N_BASECLASSES (type));
2919 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type), gdb_stdout);
2920 printf_filtered (")");
2922 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
2923 TYPE_N_BASECLASSES (type));
2924 puts_filtered ("\n");
2926 if (TYPE_NFIELDS (type) > 0)
2928 if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
2930 printfi_filtered (spaces, "private_field_bits (%d bits at *",
2931 TYPE_NFIELDS (type));
2932 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type), gdb_stdout);
2933 printf_filtered (")");
2934 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
2935 TYPE_NFIELDS (type));
2936 puts_filtered ("\n");
2938 if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
2940 printfi_filtered (spaces, "protected_field_bits (%d bits at *",
2941 TYPE_NFIELDS (type));
2942 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type), gdb_stdout);
2943 printf_filtered (")");
2944 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
2945 TYPE_NFIELDS (type));
2946 puts_filtered ("\n");
2949 if (TYPE_NFN_FIELDS (type) > 0)
2951 dump_fn_fieldlists (type, spaces);
2956 print_bound_type (int bt)
2960 case BOUND_CANNOT_BE_DETERMINED:
2961 printf_filtered ("(BOUND_CANNOT_BE_DETERMINED)");
2963 case BOUND_BY_REF_ON_STACK:
2964 printf_filtered ("(BOUND_BY_REF_ON_STACK)");
2966 case BOUND_BY_VALUE_ON_STACK:
2967 printf_filtered ("(BOUND_BY_VALUE_ON_STACK)");
2969 case BOUND_BY_REF_IN_REG:
2970 printf_filtered ("(BOUND_BY_REF_IN_REG)");
2972 case BOUND_BY_VALUE_IN_REG:
2973 printf_filtered ("(BOUND_BY_VALUE_IN_REG)");
2976 printf_filtered ("(BOUND_SIMPLE)");
2979 printf_filtered ("(unknown bound type)");
2984 static struct obstack dont_print_type_obstack;
2987 recursive_dump_type (struct type *type, int spaces)
2992 obstack_begin (&dont_print_type_obstack, 0);
2994 if (TYPE_NFIELDS (type) > 0
2995 || (TYPE_CPLUS_SPECIFIC (type) && TYPE_NFN_FIELDS (type) > 0))
2997 struct type **first_dont_print
2998 = (struct type **) obstack_base (&dont_print_type_obstack);
3000 int i = (struct type **) obstack_next_free (&dont_print_type_obstack)
3005 if (type == first_dont_print[i])
3007 printfi_filtered (spaces, "type node ");
3008 gdb_print_host_address (type, gdb_stdout);
3009 printf_filtered (" <same as already seen type>\n");
3014 obstack_ptr_grow (&dont_print_type_obstack, type);
3017 printfi_filtered (spaces, "type node ");
3018 gdb_print_host_address (type, gdb_stdout);
3019 printf_filtered ("\n");
3020 printfi_filtered (spaces, "name '%s' (",
3021 TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
3022 gdb_print_host_address (TYPE_NAME (type), gdb_stdout);
3023 printf_filtered (")\n");
3024 printfi_filtered (spaces, "tagname '%s' (",
3025 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : "<NULL>");
3026 gdb_print_host_address (TYPE_TAG_NAME (type), gdb_stdout);
3027 printf_filtered (")\n");
3028 printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
3029 switch (TYPE_CODE (type))
3031 case TYPE_CODE_UNDEF:
3032 printf_filtered ("(TYPE_CODE_UNDEF)");
3035 printf_filtered ("(TYPE_CODE_PTR)");
3037 case TYPE_CODE_ARRAY:
3038 printf_filtered ("(TYPE_CODE_ARRAY)");
3040 case TYPE_CODE_STRUCT:
3041 printf_filtered ("(TYPE_CODE_STRUCT)");
3043 case TYPE_CODE_UNION:
3044 printf_filtered ("(TYPE_CODE_UNION)");
3046 case TYPE_CODE_ENUM:
3047 printf_filtered ("(TYPE_CODE_ENUM)");
3049 case TYPE_CODE_FUNC:
3050 printf_filtered ("(TYPE_CODE_FUNC)");
3053 printf_filtered ("(TYPE_CODE_INT)");
3056 printf_filtered ("(TYPE_CODE_FLT)");
3058 case TYPE_CODE_VOID:
3059 printf_filtered ("(TYPE_CODE_VOID)");
3062 printf_filtered ("(TYPE_CODE_SET)");
3064 case TYPE_CODE_RANGE:
3065 printf_filtered ("(TYPE_CODE_RANGE)");
3067 case TYPE_CODE_STRING:
3068 printf_filtered ("(TYPE_CODE_STRING)");
3070 case TYPE_CODE_BITSTRING:
3071 printf_filtered ("(TYPE_CODE_BITSTRING)");
3073 case TYPE_CODE_ERROR:
3074 printf_filtered ("(TYPE_CODE_ERROR)");
3076 case TYPE_CODE_MEMBER:
3077 printf_filtered ("(TYPE_CODE_MEMBER)");
3079 case TYPE_CODE_METHOD:
3080 printf_filtered ("(TYPE_CODE_METHOD)");
3083 printf_filtered ("(TYPE_CODE_REF)");
3085 case TYPE_CODE_CHAR:
3086 printf_filtered ("(TYPE_CODE_CHAR)");
3088 case TYPE_CODE_BOOL:
3089 printf_filtered ("(TYPE_CODE_BOOL)");
3091 case TYPE_CODE_COMPLEX:
3092 printf_filtered ("(TYPE_CODE_COMPLEX)");
3094 case TYPE_CODE_TYPEDEF:
3095 printf_filtered ("(TYPE_CODE_TYPEDEF)");
3097 case TYPE_CODE_TEMPLATE:
3098 printf_filtered ("(TYPE_CODE_TEMPLATE)");
3100 case TYPE_CODE_TEMPLATE_ARG:
3101 printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)");
3104 printf_filtered ("(UNKNOWN TYPE CODE)");
3107 puts_filtered ("\n");
3108 printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
3109 printfi_filtered (spaces, "upper_bound_type 0x%x ",
3110 TYPE_ARRAY_UPPER_BOUND_TYPE (type));
3111 print_bound_type (TYPE_ARRAY_UPPER_BOUND_TYPE (type));
3112 puts_filtered ("\n");
3113 printfi_filtered (spaces, "lower_bound_type 0x%x ",
3114 TYPE_ARRAY_LOWER_BOUND_TYPE (type));
3115 print_bound_type (TYPE_ARRAY_LOWER_BOUND_TYPE (type));
3116 puts_filtered ("\n");
3117 printfi_filtered (spaces, "objfile ");
3118 gdb_print_host_address (TYPE_OBJFILE (type), gdb_stdout);
3119 printf_filtered ("\n");
3120 printfi_filtered (spaces, "target_type ");
3121 gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout);
3122 printf_filtered ("\n");
3123 if (TYPE_TARGET_TYPE (type) != NULL)
3125 recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
3127 printfi_filtered (spaces, "pointer_type ");
3128 gdb_print_host_address (TYPE_POINTER_TYPE (type), gdb_stdout);
3129 printf_filtered ("\n");
3130 printfi_filtered (spaces, "reference_type ");
3131 gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
3132 printf_filtered ("\n");
3133 printfi_filtered (spaces, "type_chain ");
3134 gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);
3135 printf_filtered ("\n");
3136 printfi_filtered (spaces, "instance_flags 0x%x", TYPE_INSTANCE_FLAGS (type));
3137 if (TYPE_CONST (type))
3139 puts_filtered (" TYPE_FLAG_CONST");
3141 if (TYPE_VOLATILE (type))
3143 puts_filtered (" TYPE_FLAG_VOLATILE");
3145 if (TYPE_CODE_SPACE (type))
3147 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3149 if (TYPE_DATA_SPACE (type))
3151 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3153 if (TYPE_ADDRESS_CLASS_1 (type))
3155 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3157 if (TYPE_ADDRESS_CLASS_2 (type))
3159 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3161 puts_filtered ("\n");
3162 printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
3163 if (TYPE_UNSIGNED (type))
3165 puts_filtered (" TYPE_FLAG_UNSIGNED");
3167 if (TYPE_NOSIGN (type))
3169 puts_filtered (" TYPE_FLAG_NOSIGN");
3171 if (TYPE_STUB (type))
3173 puts_filtered (" TYPE_FLAG_STUB");
3175 if (TYPE_TARGET_STUB (type))
3177 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3179 if (TYPE_STATIC (type))
3181 puts_filtered (" TYPE_FLAG_STATIC");
3183 if (TYPE_PROTOTYPED (type))
3185 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3187 if (TYPE_INCOMPLETE (type))
3189 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3191 if (TYPE_VARARGS (type))
3193 puts_filtered (" TYPE_FLAG_VARARGS");
3195 /* This is used for things like AltiVec registers on ppc. Gcc emits
3196 an attribute for the array type, which tells whether or not we
3197 have a vector, instead of a regular array. */
3198 if (TYPE_VECTOR (type))
3200 puts_filtered (" TYPE_FLAG_VECTOR");
3202 puts_filtered ("\n");
3203 printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
3204 gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
3205 puts_filtered ("\n");
3206 for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
3208 printfi_filtered (spaces + 2,
3209 "[%d] bitpos %d bitsize %d type ",
3210 idx, TYPE_FIELD_BITPOS (type, idx),
3211 TYPE_FIELD_BITSIZE (type, idx));
3212 gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
3213 printf_filtered (" name '%s' (",
3214 TYPE_FIELD_NAME (type, idx) != NULL
3215 ? TYPE_FIELD_NAME (type, idx)
3217 gdb_print_host_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
3218 printf_filtered (")\n");
3219 if (TYPE_FIELD_TYPE (type, idx) != NULL)
3221 recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
3224 printfi_filtered (spaces, "vptr_basetype ");
3225 gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
3226 puts_filtered ("\n");
3227 if (TYPE_VPTR_BASETYPE (type) != NULL)
3229 recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
3231 printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type));
3232 switch (TYPE_CODE (type))
3234 case TYPE_CODE_STRUCT:
3235 printfi_filtered (spaces, "cplus_stuff ");
3236 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
3237 puts_filtered ("\n");
3238 print_cplus_stuff (type, spaces);
3242 printfi_filtered (spaces, "floatformat ");
3243 if (TYPE_FLOATFORMAT (type) == NULL
3244 || TYPE_FLOATFORMAT (type)->name == NULL)
3245 puts_filtered ("(null)");
3247 puts_filtered (TYPE_FLOATFORMAT (type)->name);
3248 puts_filtered ("\n");
3252 /* We have to pick one of the union types to be able print and test
3253 the value. Pick cplus_struct_type, even though we know it isn't
3254 any particular one. */
3255 printfi_filtered (spaces, "type_specific ");
3256 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
3257 if (TYPE_CPLUS_SPECIFIC (type) != NULL)
3259 printf_filtered (" (unknown data form)");
3261 printf_filtered ("\n");
3266 obstack_free (&dont_print_type_obstack, NULL);
3269 static void build_gdbtypes (void);
3271 build_gdbtypes (void)
3274 init_type (TYPE_CODE_VOID, 1,
3276 "void", (struct objfile *) NULL);
3278 init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3280 | (TARGET_CHAR_SIGNED ? 0 : TYPE_FLAG_UNSIGNED)),
3281 "char", (struct objfile *) NULL);
3282 builtin_type_true_char =
3283 init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3285 "true character", (struct objfile *) NULL);
3286 builtin_type_signed_char =
3287 init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3289 "signed char", (struct objfile *) NULL);
3290 builtin_type_unsigned_char =
3291 init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3293 "unsigned char", (struct objfile *) NULL);
3294 builtin_type_short =
3295 init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
3297 "short", (struct objfile *) NULL);
3298 builtin_type_unsigned_short =
3299 init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
3301 "unsigned short", (struct objfile *) NULL);
3303 init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
3305 "int", (struct objfile *) NULL);
3306 builtin_type_unsigned_int =
3307 init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
3309 "unsigned int", (struct objfile *) NULL);
3311 init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
3313 "long", (struct objfile *) NULL);
3314 builtin_type_unsigned_long =
3315 init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
3317 "unsigned long", (struct objfile *) NULL);
3318 builtin_type_long_long =
3319 init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
3321 "long long", (struct objfile *) NULL);
3322 builtin_type_unsigned_long_long =
3323 init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
3325 "unsigned long long", (struct objfile *) NULL);
3326 builtin_type_float =
3327 init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
3329 "float", (struct objfile *) NULL);
3330 /* vinschen@redhat.com 2002-02-08:
3331 The below lines are disabled since they are doing the wrong
3332 thing for non-multiarch targets. They are setting the correct
3333 type of floats for the target but while on multiarch targets
3334 this is done everytime the architecture changes, it's done on
3335 non-multiarch targets only on startup, leaving the wrong values
3336 in even if the architecture changes (eg. from big-endian to
3339 TYPE_FLOATFORMAT (builtin_type_float) = TARGET_FLOAT_FORMAT;
3341 builtin_type_double =
3342 init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
3344 "double", (struct objfile *) NULL);
3346 TYPE_FLOATFORMAT (builtin_type_double) = TARGET_DOUBLE_FORMAT;
3348 builtin_type_long_double =
3349 init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
3351 "long double", (struct objfile *) NULL);
3353 TYPE_FLOATFORMAT (builtin_type_long_double) = TARGET_LONG_DOUBLE_FORMAT;
3355 builtin_type_complex =
3356 init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
3358 "complex", (struct objfile *) NULL);
3359 TYPE_TARGET_TYPE (builtin_type_complex) = builtin_type_float;
3360 builtin_type_double_complex =
3361 init_type (TYPE_CODE_COMPLEX, 2 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
3363 "double complex", (struct objfile *) NULL);
3364 TYPE_TARGET_TYPE (builtin_type_double_complex) = builtin_type_double;
3365 builtin_type_string =
3366 init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3368 "string", (struct objfile *) NULL);
3370 init_type (TYPE_CODE_INT, 8 / 8,
3372 "int8_t", (struct objfile *) NULL);
3373 builtin_type_uint8 =
3374 init_type (TYPE_CODE_INT, 8 / 8,
3376 "uint8_t", (struct objfile *) NULL);
3377 builtin_type_int16 =
3378 init_type (TYPE_CODE_INT, 16 / 8,
3380 "int16_t", (struct objfile *) NULL);
3381 builtin_type_uint16 =
3382 init_type (TYPE_CODE_INT, 16 / 8,
3384 "uint16_t", (struct objfile *) NULL);
3385 builtin_type_int32 =
3386 init_type (TYPE_CODE_INT, 32 / 8,
3388 "int32_t", (struct objfile *) NULL);
3389 builtin_type_uint32 =
3390 init_type (TYPE_CODE_INT, 32 / 8,
3392 "uint32_t", (struct objfile *) NULL);
3393 builtin_type_int64 =
3394 init_type (TYPE_CODE_INT, 64 / 8,
3396 "int64_t", (struct objfile *) NULL);
3397 builtin_type_uint64 =
3398 init_type (TYPE_CODE_INT, 64 / 8,
3400 "uint64_t", (struct objfile *) NULL);
3401 builtin_type_int128 =
3402 init_type (TYPE_CODE_INT, 128 / 8,
3404 "int128_t", (struct objfile *) NULL);
3405 builtin_type_uint128 =
3406 init_type (TYPE_CODE_INT, 128 / 8,
3408 "uint128_t", (struct objfile *) NULL);
3410 init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3412 "bool", (struct objfile *) NULL);
3414 /* Add user knob for controlling resolution of opaque types */
3416 (add_set_cmd ("opaque-type-resolution", class_support, var_boolean, (char *) &opaque_type_resolution,
3417 "Set resolution of opaque struct/class/union types (if set before loading symbols).",
3420 opaque_type_resolution = 1;
3422 /* Build SIMD types. */
3424 = init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4);
3426 = init_simd_type ("__builtin_v4si", builtin_type_int32, "f", 4);
3428 = init_simd_type ("__builtin_v16qi", builtin_type_int8, "f", 16);
3430 = init_simd_type ("__builtin_v8qi", builtin_type_int8, "f", 8);
3432 = init_simd_type ("__builtin_v8hi", builtin_type_int16, "f", 8);
3434 = init_simd_type ("__builtin_v4hi", builtin_type_int16, "f", 4);
3436 = init_simd_type ("__builtin_v2si", builtin_type_int32, "f", 2);
3438 /* 128 bit vectors. */
3439 builtin_type_v2_double = init_vector_type (builtin_type_double, 2);
3440 builtin_type_v4_float = init_vector_type (builtin_type_float, 4);
3441 builtin_type_v2_int64 = init_vector_type (builtin_type_int64, 2);
3442 builtin_type_v4_int32 = init_vector_type (builtin_type_int32, 4);
3443 builtin_type_v8_int16 = init_vector_type (builtin_type_int16, 8);
3444 builtin_type_v16_int8 = init_vector_type (builtin_type_int8, 16);
3445 /* 64 bit vectors. */
3446 builtin_type_v2_float = init_vector_type (builtin_type_float, 2);
3447 builtin_type_v2_int32 = init_vector_type (builtin_type_int32, 2);
3448 builtin_type_v4_int16 = init_vector_type (builtin_type_int16, 4);
3449 builtin_type_v8_int8 = init_vector_type (builtin_type_int8, 8);
3452 builtin_type_vec64 = build_builtin_type_vec64 ();
3453 builtin_type_vec64i = build_builtin_type_vec64i ();
3454 builtin_type_vec128 = build_builtin_type_vec128 ();
3455 builtin_type_vec128i = build_builtin_type_vec128i ();
3457 /* Pointer/Address types. */
3459 /* NOTE: on some targets, addresses and pointers are not necessarily
3460 the same --- for example, on the D10V, pointers are 16 bits long,
3461 but addresses are 32 bits long. See doc/gdbint.texinfo,
3462 ``Pointers Are Not Always Addresses''.
3465 - gdb's `struct type' always describes the target's
3467 - gdb's `struct value' objects should always hold values in
3469 - gdb's CORE_ADDR values are addresses in the unified virtual
3470 address space that the assembler and linker work with. Thus,
3471 since target_read_memory takes a CORE_ADDR as an argument, it
3472 can access any memory on the target, even if the processor has
3473 separate code and data address spaces.
3476 - If v is a value holding a D10V code pointer, its contents are
3477 in target form: a big-endian address left-shifted two bits.
3478 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3479 sizeof (void *) == 2 on the target.
3481 In this context, builtin_type_CORE_ADDR is a bit odd: it's a
3482 target type for a value the target will never see. It's only
3483 used to hold the values of (typeless) linker symbols, which are
3484 indeed in the unified virtual address space. */
3485 builtin_type_void_data_ptr = make_pointer_type (builtin_type_void, NULL);
3486 builtin_type_void_func_ptr
3487 = lookup_pointer_type (lookup_function_type (builtin_type_void));
3488 builtin_type_CORE_ADDR =
3489 init_type (TYPE_CODE_INT, TARGET_ADDR_BIT / 8,
3491 "__CORE_ADDR", (struct objfile *) NULL);
3492 builtin_type_bfd_vma =
3493 init_type (TYPE_CODE_INT, TARGET_BFD_VMA_BIT / 8,
3495 "__bfd_vma", (struct objfile *) NULL);
3498 extern void _initialize_gdbtypes (void);
3500 _initialize_gdbtypes (void)
3502 struct cmd_list_element *c;
3505 /* FIXME - For the moment, handle types by swapping them in and out.
3506 Should be using the per-architecture data-pointer and a large
3508 register_gdbarch_swap (&builtin_type_void, sizeof (struct type *), NULL);
3509 register_gdbarch_swap (&builtin_type_char, sizeof (struct type *), NULL);
3510 register_gdbarch_swap (&builtin_type_short, sizeof (struct type *), NULL);
3511 register_gdbarch_swap (&builtin_type_int, sizeof (struct type *), NULL);
3512 register_gdbarch_swap (&builtin_type_long, sizeof (struct type *), NULL);
3513 register_gdbarch_swap (&builtin_type_long_long, sizeof (struct type *), NULL);
3514 register_gdbarch_swap (&builtin_type_signed_char, sizeof (struct type *), NULL);
3515 register_gdbarch_swap (&builtin_type_unsigned_char, sizeof (struct type *), NULL);
3516 register_gdbarch_swap (&builtin_type_unsigned_short, sizeof (struct type *), NULL);
3517 register_gdbarch_swap (&builtin_type_unsigned_int, sizeof (struct type *), NULL);
3518 register_gdbarch_swap (&builtin_type_unsigned_long, sizeof (struct type *), NULL);
3519 register_gdbarch_swap (&builtin_type_unsigned_long_long, sizeof (struct type *), NULL);
3520 register_gdbarch_swap (&builtin_type_float, sizeof (struct type *), NULL);
3521 register_gdbarch_swap (&builtin_type_double, sizeof (struct type *), NULL);
3522 register_gdbarch_swap (&builtin_type_long_double, sizeof (struct type *), NULL);
3523 register_gdbarch_swap (&builtin_type_complex, sizeof (struct type *), NULL);
3524 register_gdbarch_swap (&builtin_type_double_complex, sizeof (struct type *), NULL);
3525 register_gdbarch_swap (&builtin_type_string, sizeof (struct type *), NULL);
3526 register_gdbarch_swap (&builtin_type_int8, sizeof (struct type *), NULL);
3527 register_gdbarch_swap (&builtin_type_uint8, sizeof (struct type *), NULL);
3528 register_gdbarch_swap (&builtin_type_int16, sizeof (struct type *), NULL);
3529 register_gdbarch_swap (&builtin_type_uint16, sizeof (struct type *), NULL);
3530 register_gdbarch_swap (&builtin_type_int32, sizeof (struct type *), NULL);
3531 register_gdbarch_swap (&builtin_type_uint32, sizeof (struct type *), NULL);
3532 register_gdbarch_swap (&builtin_type_int64, sizeof (struct type *), NULL);
3533 register_gdbarch_swap (&builtin_type_uint64, sizeof (struct type *), NULL);
3534 register_gdbarch_swap (&builtin_type_int128, sizeof (struct type *), NULL);
3535 register_gdbarch_swap (&builtin_type_uint128, sizeof (struct type *), NULL);
3536 register_gdbarch_swap (&builtin_type_v4sf, sizeof (struct type *), NULL);
3537 register_gdbarch_swap (&builtin_type_v4si, sizeof (struct type *), NULL);
3538 register_gdbarch_swap (&builtin_type_v16qi, sizeof (struct type *), NULL);
3539 register_gdbarch_swap (&builtin_type_v8qi, sizeof (struct type *), NULL);
3540 register_gdbarch_swap (&builtin_type_v8hi, sizeof (struct type *), NULL);
3541 register_gdbarch_swap (&builtin_type_v4hi, sizeof (struct type *), NULL);
3542 register_gdbarch_swap (&builtin_type_v2si, sizeof (struct type *), NULL);
3543 register_gdbarch_swap (&builtin_type_v2_double, sizeof (struct type *), NULL);
3544 register_gdbarch_swap (&builtin_type_v4_float, sizeof (struct type *), NULL);
3545 register_gdbarch_swap (&builtin_type_v2_int64, sizeof (struct type *), NULL);
3546 register_gdbarch_swap (&builtin_type_v4_int32, sizeof (struct type *), NULL);
3547 register_gdbarch_swap (&builtin_type_v8_int16, sizeof (struct type *), NULL);
3548 register_gdbarch_swap (&builtin_type_v16_int8, sizeof (struct type *), NULL);
3549 register_gdbarch_swap (&builtin_type_v2_float, sizeof (struct type *), NULL);
3550 register_gdbarch_swap (&builtin_type_v2_int32, sizeof (struct type *), NULL);
3551 register_gdbarch_swap (&builtin_type_v8_int8, sizeof (struct type *), NULL);
3552 register_gdbarch_swap (&builtin_type_v4_int16, sizeof (struct type *), NULL);
3553 register_gdbarch_swap (&builtin_type_vec128, sizeof (struct type *), NULL);
3554 register_gdbarch_swap (&builtin_type_vec128i, sizeof (struct type *), NULL);
3555 REGISTER_GDBARCH_SWAP (builtin_type_void_data_ptr);
3556 REGISTER_GDBARCH_SWAP (builtin_type_void_func_ptr);
3557 REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR);
3558 REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma);
3559 register_gdbarch_swap (NULL, 0, build_gdbtypes);
3561 /* Note: These types do not need to be swapped - they are target
3563 builtin_type_ieee_single_big =
3564 init_type (TYPE_CODE_FLT, floatformat_ieee_single_big.totalsize / 8,
3565 0, "builtin_type_ieee_single_big", NULL);
3566 TYPE_FLOATFORMAT (builtin_type_ieee_single_big) = &floatformat_ieee_single_big;
3567 builtin_type_ieee_single_little =
3568 init_type (TYPE_CODE_FLT, floatformat_ieee_single_little.totalsize / 8,
3569 0, "builtin_type_ieee_single_little", NULL);
3570 TYPE_FLOATFORMAT (builtin_type_ieee_single_little) = &floatformat_ieee_single_little;
3571 builtin_type_ieee_double_big =
3572 init_type (TYPE_CODE_FLT, floatformat_ieee_double_big.totalsize / 8,
3573 0, "builtin_type_ieee_double_big", NULL);
3574 TYPE_FLOATFORMAT (builtin_type_ieee_double_big) = &floatformat_ieee_double_big;
3575 builtin_type_ieee_double_little =
3576 init_type (TYPE_CODE_FLT, floatformat_ieee_double_little.totalsize / 8,
3577 0, "builtin_type_ieee_double_little", NULL);
3578 TYPE_FLOATFORMAT (builtin_type_ieee_double_little) = &floatformat_ieee_double_little;
3579 builtin_type_ieee_double_littlebyte_bigword =
3580 init_type (TYPE_CODE_FLT, floatformat_ieee_double_littlebyte_bigword.totalsize / 8,
3581 0, "builtin_type_ieee_double_littlebyte_bigword", NULL);
3582 TYPE_FLOATFORMAT (builtin_type_ieee_double_littlebyte_bigword) = &floatformat_ieee_double_littlebyte_bigword;
3583 builtin_type_i387_ext =
3584 init_type (TYPE_CODE_FLT, floatformat_i387_ext.totalsize / 8,
3585 0, "builtin_type_i387_ext", NULL);
3586 TYPE_FLOATFORMAT (builtin_type_i387_ext) = &floatformat_i387_ext;
3587 builtin_type_m68881_ext =
3588 init_type (TYPE_CODE_FLT, floatformat_m68881_ext.totalsize / 8,
3589 0, "builtin_type_m68881_ext", NULL);
3590 TYPE_FLOATFORMAT (builtin_type_m68881_ext) = &floatformat_m68881_ext;
3591 builtin_type_i960_ext =
3592 init_type (TYPE_CODE_FLT, floatformat_i960_ext.totalsize / 8,
3593 0, "builtin_type_i960_ext", NULL);
3594 TYPE_FLOATFORMAT (builtin_type_i960_ext) = &floatformat_i960_ext;
3595 builtin_type_m88110_ext =
3596 init_type (TYPE_CODE_FLT, floatformat_m88110_ext.totalsize / 8,
3597 0, "builtin_type_m88110_ext", NULL);
3598 TYPE_FLOATFORMAT (builtin_type_m88110_ext) = &floatformat_m88110_ext;
3599 builtin_type_m88110_harris_ext =
3600 init_type (TYPE_CODE_FLT, floatformat_m88110_harris_ext.totalsize / 8,
3601 0, "builtin_type_m88110_harris_ext", NULL);
3602 TYPE_FLOATFORMAT (builtin_type_m88110_harris_ext) = &floatformat_m88110_harris_ext;
3603 builtin_type_arm_ext_big =
3604 init_type (TYPE_CODE_FLT, floatformat_arm_ext_big.totalsize / 8,
3605 0, "builtin_type_arm_ext_big", NULL);
3606 TYPE_FLOATFORMAT (builtin_type_arm_ext_big) = &floatformat_arm_ext_big;
3607 builtin_type_arm_ext_littlebyte_bigword =
3608 init_type (TYPE_CODE_FLT, floatformat_arm_ext_littlebyte_bigword.totalsize / 8,
3609 0, "builtin_type_arm_ext_littlebyte_bigword", NULL);
3610 TYPE_FLOATFORMAT (builtin_type_arm_ext_littlebyte_bigword) = &floatformat_arm_ext_littlebyte_bigword;
3611 builtin_type_ia64_spill_big =
3612 init_type (TYPE_CODE_FLT, floatformat_ia64_spill_big.totalsize / 8,
3613 0, "builtin_type_ia64_spill_big", NULL);
3614 TYPE_FLOATFORMAT (builtin_type_ia64_spill_big) = &floatformat_ia64_spill_big;
3615 builtin_type_ia64_spill_little =
3616 init_type (TYPE_CODE_FLT, floatformat_ia64_spill_little.totalsize / 8,
3617 0, "builtin_type_ia64_spill_little", NULL);
3618 TYPE_FLOATFORMAT (builtin_type_ia64_spill_little) = &floatformat_ia64_spill_little;
3619 builtin_type_ia64_quad_big =
3620 init_type (TYPE_CODE_FLT, floatformat_ia64_quad_big.totalsize / 8,
3621 0, "builtin_type_ia64_quad_big", NULL);
3622 TYPE_FLOATFORMAT (builtin_type_ia64_quad_big) = &floatformat_ia64_quad_big;
3623 builtin_type_ia64_quad_little =
3624 init_type (TYPE_CODE_FLT, floatformat_ia64_quad_little.totalsize / 8,
3625 0, "builtin_type_ia64_quad_little", NULL);
3626 TYPE_FLOATFORMAT (builtin_type_ia64_quad_little) = &floatformat_ia64_quad_little;
3629 add_set_cmd ("overload", no_class, var_zinteger, (char *) &overload_debug,
3630 "Set debugging of C++ overloading.\n\
3631 When enabled, ranking of the functions\n\
3632 is displayed.", &setdebuglist),