1 /* Support routines for manipulating internal types for GDB.
2 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003
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
*);
131 #if 0 /* OBSOLETE CFront */
132 // OBSOLETE static void cfront_mangle_name (struct type *, int, int);
133 #endif /* OBSOLETE CFront */
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
)
400 struct gdbarch
*gdbarch
= current_gdbarch
;
402 /* Check for known address space delimiters. */
403 if (!strcmp (space_identifier
, "code"))
404 return TYPE_FLAG_CODE_SPACE
;
405 else if (!strcmp (space_identifier
, "data"))
406 return TYPE_FLAG_DATA_SPACE
;
407 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
408 && gdbarch_address_class_name_to_type_flags (gdbarch
,
413 error ("Unknown address space specifier: \"%s\"", space_identifier
);
416 /* Identify address space identifier by integer flag as defined in
417 gdbtypes.h -- return the string version of the adress space name. */
420 address_space_int_to_name (int space_flag
)
422 struct gdbarch
*gdbarch
= current_gdbarch
;
423 if (space_flag
& TYPE_FLAG_CODE_SPACE
)
425 else if (space_flag
& TYPE_FLAG_DATA_SPACE
)
427 else if ((space_flag
& TYPE_FLAG_ADDRESS_CLASS_ALL
)
428 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
429 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
434 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
435 If STORAGE is non-NULL, create the new type instance there. */
438 make_qualified_type (struct type
*type
, int new_flags
,
439 struct type
*storage
)
445 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
447 ntype
= TYPE_CHAIN (ntype
);
448 } while (ntype
!= type
);
450 /* Create a new type instance. */
452 ntype
= alloc_type_instance (type
);
456 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
457 TYPE_CHAIN (ntype
) = ntype
;
460 /* Pointers or references to the original type are not relevant to
462 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
463 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
465 /* Chain the new qualified type to the old type. */
466 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
467 TYPE_CHAIN (type
) = ntype
;
469 /* Now set the instance flags and return the new type. */
470 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
475 /* Make an address-space-delimited variant of a type -- a type that
476 is identical to the one supplied except that it has an address
477 space attribute attached to it (such as "code" or "data").
479 The space attributes "code" and "data" are for Harvard architectures.
480 The address space attributes are for architectures which have
481 alternately sized pointers or pointers with alternate representations. */
484 make_type_with_address_space (struct type
*type
, int space_flag
)
487 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
488 & ~(TYPE_FLAG_CODE_SPACE
| TYPE_FLAG_DATA_SPACE
489 | TYPE_FLAG_ADDRESS_CLASS_ALL
))
492 return make_qualified_type (type
, new_flags
, NULL
);
495 /* Make a "c-v" variant of a type -- a type that is identical to the
496 one supplied except that it may have const or volatile attributes
497 CNST is a flag for setting the const attribute
498 VOLTL is a flag for setting the volatile attribute
499 TYPE is the base type whose variant we are creating.
500 TYPEPTR, if nonzero, points
501 to a pointer to memory where the reference type should be stored.
502 If *TYPEPTR is zero, update it to point to the reference type we return.
503 We allocate new memory if needed. */
506 make_cv_type (int cnst
, int voltl
, struct type
*type
, struct type
**typeptr
)
508 register struct type
*ntype
; /* New type */
509 register struct type
*tmp_type
= type
; /* tmp type */
510 struct objfile
*objfile
;
512 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
513 & ~(TYPE_FLAG_CONST
| TYPE_FLAG_VOLATILE
));
516 new_flags
|= TYPE_FLAG_CONST
;
519 new_flags
|= TYPE_FLAG_VOLATILE
;
521 if (typeptr
&& *typeptr
!= NULL
)
523 /* Objfile is per-core-type. This const-qualified type had best
524 belong to the same objfile as the type it is qualifying, unless
525 we are overwriting a stub type, in which case the safest thing
526 to do is to copy the core type into the new objfile. */
528 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
)
529 || TYPE_STUB (*typeptr
));
530 if (TYPE_OBJFILE (*typeptr
) != TYPE_OBJFILE (type
))
532 TYPE_MAIN_TYPE (*typeptr
)
533 = TYPE_ALLOC (*typeptr
, sizeof (struct main_type
));
534 *TYPE_MAIN_TYPE (*typeptr
)
535 = *TYPE_MAIN_TYPE (type
);
539 ntype
= make_qualified_type (type
, new_flags
, typeptr
? *typeptr
: NULL
);
547 /* Replace the contents of ntype with the type *type. This changes the
548 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
549 the changes are propogated to all types in the TYPE_CHAIN.
551 In order to build recursive types, it's inevitable that we'll need
552 to update types in place --- but this sort of indiscriminate
553 smashing is ugly, and needs to be replaced with something more
554 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
555 clear if more steps are needed. */
557 replace_type (struct type
*ntype
, struct type
*type
)
559 struct type
*cv_chain
, *as_chain
, *ptr
, *ref
;
561 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
563 /* Assert that the two types have equivalent instance qualifiers.
564 This should be true for at least all of our debug readers. */
565 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
568 /* Implement direct support for MEMBER_TYPE in GNU C++.
569 May need to construct such a type if this is the first use.
570 The TYPE is the type of the member. The DOMAIN is the type
571 of the aggregate that the member belongs to. */
574 lookup_member_type (struct type
*type
, struct type
*domain
)
576 register struct type
*mtype
;
578 mtype
= alloc_type (TYPE_OBJFILE (type
));
579 smash_to_member_type (mtype
, domain
, type
);
583 /* Allocate a stub method whose return type is TYPE.
584 This apparently happens for speed of symbol reading, since parsing
585 out the arguments to the method is cpu-intensive, the way we are doing
586 it. So, we will fill in arguments later.
587 This always returns a fresh type. */
590 allocate_stub_method (struct type
*type
)
594 mtype
= init_type (TYPE_CODE_METHOD
, 1, TYPE_FLAG_STUB
, NULL
,
595 TYPE_OBJFILE (type
));
596 TYPE_TARGET_TYPE (mtype
) = type
;
597 /* _DOMAIN_TYPE (mtype) = unknown yet */
601 /* Create a range type using either a blank type supplied in RESULT_TYPE,
602 or creating a new type, inheriting the objfile from INDEX_TYPE.
604 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
605 HIGH_BOUND, inclusive.
607 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
608 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
611 create_range_type (struct type
*result_type
, struct type
*index_type
,
612 int low_bound
, int high_bound
)
614 if (result_type
== NULL
)
616 result_type
= alloc_type (TYPE_OBJFILE (index_type
));
618 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
619 TYPE_TARGET_TYPE (result_type
) = index_type
;
620 if (TYPE_STUB (index_type
))
621 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
623 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
624 TYPE_NFIELDS (result_type
) = 2;
625 TYPE_FIELDS (result_type
) = (struct field
*)
626 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
627 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
628 TYPE_FIELD_BITPOS (result_type
, 0) = low_bound
;
629 TYPE_FIELD_BITPOS (result_type
, 1) = high_bound
;
630 TYPE_FIELD_TYPE (result_type
, 0) = builtin_type_int
; /* FIXME */
631 TYPE_FIELD_TYPE (result_type
, 1) = builtin_type_int
; /* FIXME */
634 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
636 return (result_type
);
639 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE.
640 Return 1 of type is a range type, 0 if it is discrete (and bounds
641 will fit in LONGEST), or -1 otherwise. */
644 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
646 CHECK_TYPEDEF (type
);
647 switch (TYPE_CODE (type
))
649 case TYPE_CODE_RANGE
:
650 *lowp
= TYPE_LOW_BOUND (type
);
651 *highp
= TYPE_HIGH_BOUND (type
);
654 if (TYPE_NFIELDS (type
) > 0)
656 /* The enums may not be sorted by value, so search all
660 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
661 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
663 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
664 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
665 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
666 *highp
= TYPE_FIELD_BITPOS (type
, i
);
669 /* Set unsigned indicator if warranted. */
672 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
686 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
688 if (!TYPE_UNSIGNED (type
))
690 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
694 /* ... fall through for unsigned ints ... */
697 /* This round-about calculation is to avoid shifting by
698 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
699 if TYPE_LENGTH (type) == sizeof (LONGEST). */
700 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
701 *highp
= (*highp
- 1) | *highp
;
708 /* Create an array type using either a blank type supplied in RESULT_TYPE,
709 or creating a new type, inheriting the objfile from RANGE_TYPE.
711 Elements will be of type ELEMENT_TYPE, the indices will be of type
714 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
715 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
718 create_array_type (struct type
*result_type
, struct type
*element_type
,
719 struct type
*range_type
)
721 LONGEST low_bound
, high_bound
;
723 if (result_type
== NULL
)
725 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
727 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
728 TYPE_TARGET_TYPE (result_type
) = element_type
;
729 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
730 low_bound
= high_bound
= 0;
731 CHECK_TYPEDEF (element_type
);
732 TYPE_LENGTH (result_type
) =
733 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
734 TYPE_NFIELDS (result_type
) = 1;
735 TYPE_FIELDS (result_type
) =
736 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
737 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
738 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
739 TYPE_VPTR_FIELDNO (result_type
) = -1;
741 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
742 if (TYPE_LENGTH (result_type
) == 0)
743 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
745 return (result_type
);
748 /* Create a string type using either a blank type supplied in RESULT_TYPE,
749 or creating a new type. String types are similar enough to array of
750 char types that we can use create_array_type to build the basic type
751 and then bash it into a string type.
753 For fixed length strings, the range type contains 0 as the lower
754 bound and the length of the string minus one as the upper bound.
756 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
757 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
760 create_string_type (struct type
*result_type
, struct type
*range_type
)
762 result_type
= create_array_type (result_type
,
763 *current_language
->string_char_type
,
765 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
766 return (result_type
);
770 create_set_type (struct type
*result_type
, struct type
*domain_type
)
772 LONGEST low_bound
, high_bound
, bit_length
;
773 if (result_type
== NULL
)
775 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
777 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
778 TYPE_NFIELDS (result_type
) = 1;
779 TYPE_FIELDS (result_type
) = (struct field
*)
780 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
781 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
783 if (!TYPE_STUB (domain_type
))
785 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
786 low_bound
= high_bound
= 0;
787 bit_length
= high_bound
- low_bound
+ 1;
788 TYPE_LENGTH (result_type
)
789 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
791 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
794 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
796 return (result_type
);
799 /* Construct and return a type of the form:
800 struct NAME { ELT_TYPE ELT_NAME[N]; }
801 We use these types for SIMD registers. For example, the type of
802 the SSE registers on the late x86-family processors is:
803 struct __builtin_v4sf { float f[4]; }
804 built by the function call:
805 init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4)
806 The type returned is a permanent type, allocated using malloc; it
807 doesn't live in any objfile's obstack. */
809 init_simd_type (char *name
,
810 struct type
*elt_type
,
814 struct type
*simd_type
;
815 struct type
*array_type
;
817 simd_type
= init_composite_type (name
, TYPE_CODE_STRUCT
);
818 array_type
= create_array_type (0, elt_type
,
819 create_range_type (0, builtin_type_int
,
821 append_composite_type_field (simd_type
, elt_name
, array_type
);
826 init_vector_type (struct type
*elt_type
, int n
)
828 struct type
*array_type
;
830 array_type
= create_array_type (0, elt_type
,
831 create_range_type (0, builtin_type_int
,
833 TYPE_FLAGS (array_type
) |= TYPE_FLAG_VECTOR
;
838 build_builtin_type_vec64 (void)
840 /* Construct a type for the 64 bit registers. The type we're
843 union __gdb_builtin_type_vec64
855 t
= init_composite_type ("__gdb_builtin_type_vec64", TYPE_CODE_UNION
);
856 append_composite_type_field (t
, "uint64", builtin_type_int64
);
857 append_composite_type_field (t
, "v2_float", builtin_type_v2_float
);
858 append_composite_type_field (t
, "v2_int32", builtin_type_v2_int32
);
859 append_composite_type_field (t
, "v4_int16", builtin_type_v4_int16
);
860 append_composite_type_field (t
, "v8_int8", builtin_type_v8_int8
);
862 TYPE_FLAGS (t
) |= TYPE_FLAG_VECTOR
;
863 TYPE_NAME (t
) = "builtin_type_vec64";
868 build_builtin_type_vec64i (void)
870 /* Construct a type for the 64 bit registers. The type we're
873 union __gdb_builtin_type_vec64i
884 t
= init_composite_type ("__gdb_builtin_type_vec64i", TYPE_CODE_UNION
);
885 append_composite_type_field (t
, "uint64", builtin_type_int64
);
886 append_composite_type_field (t
, "v2_int32", builtin_type_v2_int32
);
887 append_composite_type_field (t
, "v4_int16", builtin_type_v4_int16
);
888 append_composite_type_field (t
, "v8_int8", builtin_type_v8_int8
);
890 TYPE_FLAGS (t
) |= TYPE_FLAG_VECTOR
;
891 TYPE_NAME (t
) = "builtin_type_vec64i";
896 build_builtin_type_vec128 (void)
898 /* Construct a type for the 128 bit registers. The type we're
901 union __gdb_builtin_type_vec128
913 t
= init_composite_type ("__gdb_builtin_type_vec128", TYPE_CODE_UNION
);
914 append_composite_type_field (t
, "uint128", builtin_type_int128
);
915 append_composite_type_field (t
, "v4_float", builtin_type_v4_float
);
916 append_composite_type_field (t
, "v4_int32", builtin_type_v4_int32
);
917 append_composite_type_field (t
, "v8_int16", builtin_type_v8_int16
);
918 append_composite_type_field (t
, "v16_int8", builtin_type_v16_int8
);
920 TYPE_FLAGS (t
) |= TYPE_FLAG_VECTOR
;
921 TYPE_NAME (t
) = "builtin_type_vec128";
926 build_builtin_type_vec128i (void)
928 /* 128-bit Intel SIMD registers */
931 t
= init_composite_type ("__gdb_builtin_type_vec128i", TYPE_CODE_UNION
);
932 append_composite_type_field (t
, "v4_float", builtin_type_v4_float
);
933 append_composite_type_field (t
, "v2_double", builtin_type_v2_double
);
934 append_composite_type_field (t
, "v16_int8", builtin_type_v16_int8
);
935 append_composite_type_field (t
, "v8_int16", builtin_type_v8_int16
);
936 append_composite_type_field (t
, "v4_int32", builtin_type_v4_int32
);
937 append_composite_type_field (t
, "v2_int64", builtin_type_v2_int64
);
938 append_composite_type_field (t
, "uint128", builtin_type_int128
);
940 TYPE_FLAGS (t
) |= TYPE_FLAG_VECTOR
;
941 TYPE_NAME (t
) = "builtin_type_vec128i";
945 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
946 A MEMBER is a wierd thing -- it amounts to a typed offset into
947 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
948 include the offset (that's the value of the MEMBER itself), but does
949 include the structure type into which it points (for some reason).
951 When "smashing" the type, we preserve the objfile that the
952 old type pointed to, since we aren't changing where the type is actually
956 smash_to_member_type (struct type
*type
, struct type
*domain
,
957 struct type
*to_type
)
959 struct objfile
*objfile
;
961 objfile
= TYPE_OBJFILE (type
);
964 TYPE_OBJFILE (type
) = objfile
;
965 TYPE_TARGET_TYPE (type
) = to_type
;
966 TYPE_DOMAIN_TYPE (type
) = domain
;
967 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
968 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
971 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
972 METHOD just means `function that gets an extra "this" argument'.
974 When "smashing" the type, we preserve the objfile that the
975 old type pointed to, since we aren't changing where the type is actually
979 smash_to_method_type (struct type
*type
, struct type
*domain
,
980 struct type
*to_type
, struct field
*args
,
981 int nargs
, int varargs
)
983 struct objfile
*objfile
;
985 objfile
= TYPE_OBJFILE (type
);
988 TYPE_OBJFILE (type
) = objfile
;
989 TYPE_TARGET_TYPE (type
) = to_type
;
990 TYPE_DOMAIN_TYPE (type
) = domain
;
991 TYPE_FIELDS (type
) = args
;
992 TYPE_NFIELDS (type
) = nargs
;
994 TYPE_FLAGS (type
) |= TYPE_FLAG_VARARGS
;
995 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
996 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
999 /* Return a typename for a struct/union/enum type without "struct ",
1000 "union ", or "enum ". If the type has a NULL name, return NULL. */
1003 type_name_no_tag (register const struct type
*type
)
1005 if (TYPE_TAG_NAME (type
) != NULL
)
1006 return TYPE_TAG_NAME (type
);
1008 /* Is there code which expects this to return the name if there is no
1009 tag name? My guess is that this is mainly used for C++ in cases where
1010 the two will always be the same. */
1011 return TYPE_NAME (type
);
1014 /* Lookup a primitive type named NAME.
1015 Return zero if NAME is not a primitive type. */
1018 lookup_primitive_typename (char *name
)
1020 struct type
**const *p
;
1022 for (p
= current_language
->la_builtin_type_vector
; *p
!= NULL
; p
++)
1024 if (strcmp (TYPE_NAME (**p
), name
) == 0)
1032 /* Lookup a typedef or primitive type named NAME,
1033 visible in lexical block BLOCK.
1034 If NOERR is nonzero, return zero if NAME is not suitably defined. */
1037 lookup_typename (char *name
, struct block
*block
, int noerr
)
1039 register struct symbol
*sym
;
1040 register struct type
*tmp
;
1042 sym
= lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
1043 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1045 tmp
= lookup_primitive_typename (name
);
1050 else if (!tmp
&& noerr
)
1056 error ("No type named %s.", name
);
1059 return (SYMBOL_TYPE (sym
));
1063 lookup_unsigned_typename (char *name
)
1065 char *uns
= alloca (strlen (name
) + 10);
1067 strcpy (uns
, "unsigned ");
1068 strcpy (uns
+ 9, name
);
1069 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
1073 lookup_signed_typename (char *name
)
1076 char *uns
= alloca (strlen (name
) + 8);
1078 strcpy (uns
, "signed ");
1079 strcpy (uns
+ 7, name
);
1080 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
1081 /* If we don't find "signed FOO" just try again with plain "FOO". */
1084 return lookup_typename (name
, (struct block
*) NULL
, 0);
1087 /* Lookup a structure type named "struct NAME",
1088 visible in lexical block BLOCK. */
1091 lookup_struct (char *name
, struct block
*block
)
1093 register struct symbol
*sym
;
1095 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
1096 (struct symtab
**) NULL
);
1100 error ("No struct type named %s.", name
);
1102 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1104 error ("This context has class, union or enum %s, not a struct.", name
);
1106 return (SYMBOL_TYPE (sym
));
1109 /* Lookup a union type named "union NAME",
1110 visible in lexical block BLOCK. */
1113 lookup_union (char *name
, struct block
*block
)
1115 register struct symbol
*sym
;
1118 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
1119 (struct symtab
**) NULL
);
1122 error ("No union type named %s.", name
);
1124 t
= SYMBOL_TYPE (sym
);
1126 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1129 /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
1130 * a further "declared_type" field to discover it is really a union.
1132 if (HAVE_CPLUS_STRUCT (t
))
1133 if (TYPE_DECLARED_TYPE (t
) == DECLARED_TYPE_UNION
)
1136 /* If we get here, it's not a union */
1137 error ("This context has class, struct or enum %s, not a union.", name
);
1141 /* Lookup an enum type named "enum NAME",
1142 visible in lexical block BLOCK. */
1145 lookup_enum (char *name
, struct block
*block
)
1147 register struct symbol
*sym
;
1149 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
1150 (struct symtab
**) NULL
);
1153 error ("No enum type named %s.", name
);
1155 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1157 error ("This context has class, struct or union %s, not an enum.", name
);
1159 return (SYMBOL_TYPE (sym
));
1162 /* Lookup a template type named "template NAME<TYPE>",
1163 visible in lexical block BLOCK. */
1166 lookup_template_type (char *name
, struct type
*type
, struct block
*block
)
1169 char *nam
= (char *) alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1172 strcat (nam
, TYPE_NAME (type
));
1173 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1175 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
1179 error ("No template type named %s.", name
);
1181 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1183 error ("This context has class, union or enum %s, not a struct.", name
);
1185 return (SYMBOL_TYPE (sym
));
1188 /* Given a type TYPE, lookup the type of the component of type named NAME.
1190 TYPE can be either a struct or union, or a pointer or reference to a struct or
1191 union. If it is a pointer or reference, its target type is automatically used.
1192 Thus '.' and '->' are interchangable, as specified for the definitions of the
1193 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
1195 If NOERR is nonzero, return zero if NAME is not suitably defined.
1196 If NAME is the name of a baseclass type, return that type. */
1199 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
1205 CHECK_TYPEDEF (type
);
1206 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1207 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1209 type
= TYPE_TARGET_TYPE (type
);
1212 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
1213 TYPE_CODE (type
) != TYPE_CODE_UNION
)
1215 target_terminal_ours ();
1216 gdb_flush (gdb_stdout
);
1217 fprintf_unfiltered (gdb_stderr
, "Type ");
1218 type_print (type
, "", gdb_stderr
, -1);
1219 error (" is not a structure or union type.");
1223 /* FIXME: This change put in by Michael seems incorrect for the case where
1224 the structure tag name is the same as the member name. I.E. when doing
1225 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
1230 typename
= type_name_no_tag (type
);
1231 if (typename
!= NULL
&& strcmp (typename
, name
) == 0)
1236 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1238 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1240 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1242 return TYPE_FIELD_TYPE (type
, i
);
1246 /* OK, it's not in this class. Recursively check the baseclasses. */
1247 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1251 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, noerr
);
1263 target_terminal_ours ();
1264 gdb_flush (gdb_stdout
);
1265 fprintf_unfiltered (gdb_stderr
, "Type ");
1266 type_print (type
, "", gdb_stderr
, -1);
1267 fprintf_unfiltered (gdb_stderr
, " has no component named ");
1268 fputs_filtered (name
, gdb_stderr
);
1270 return (struct type
*) -1; /* For lint */
1273 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
1274 valid. Callers should be aware that in some cases (for example,
1275 the type or one of its baseclasses is a stub type and we are
1276 debugging a .o file), this function will not be able to find the virtual
1277 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
1278 will remain NULL. */
1281 fill_in_vptr_fieldno (struct type
*type
)
1283 CHECK_TYPEDEF (type
);
1285 if (TYPE_VPTR_FIELDNO (type
) < 0)
1289 /* We must start at zero in case the first (and only) baseclass is
1290 virtual (and hence we cannot share the table pointer). */
1291 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1293 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1294 fill_in_vptr_fieldno (baseclass
);
1295 if (TYPE_VPTR_FIELDNO (baseclass
) >= 0)
1297 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (baseclass
);
1298 TYPE_VPTR_BASETYPE (type
) = TYPE_VPTR_BASETYPE (baseclass
);
1305 /* Find the method and field indices for the destructor in class type T.
1306 Return 1 if the destructor was found, otherwise, return 0. */
1309 get_destructor_fn_field (struct type
*t
, int *method_indexp
, int *field_indexp
)
1313 for (i
= 0; i
< TYPE_NFN_FIELDS (t
); i
++)
1316 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1318 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (t
, i
); j
++)
1320 if (is_destructor_name (TYPE_FN_FIELD_PHYSNAME (f
, j
)) != 0)
1331 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1333 If this is a stubbed struct (i.e. declared as struct foo *), see if
1334 we can find a full definition in some other file. If so, copy this
1335 definition, so we can use it in future. There used to be a comment (but
1336 not any code) that if we don't find a full definition, we'd set a flag
1337 so we don't spend time in the future checking the same type. That would
1338 be a mistake, though--we might load in more symbols which contain a
1339 full definition for the type.
1341 This used to be coded as a macro, but I don't think it is called
1342 often enough to merit such treatment. */
1345 stub_noname_complaint (void)
1347 complaint (&symfile_complaints
, "stub type has NULL name");
1351 check_typedef (struct type
*type
)
1353 struct type
*orig_type
= type
;
1354 int is_const
, is_volatile
;
1356 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1358 if (!TYPE_TARGET_TYPE (type
))
1363 /* It is dangerous to call lookup_symbol if we are currently
1364 reading a symtab. Infinite recursion is one danger. */
1365 if (currently_reading_symtab
)
1368 name
= type_name_no_tag (type
);
1369 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1370 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
1371 as appropriate? (this code was written before TYPE_NAME and
1372 TYPE_TAG_NAME were separate). */
1375 stub_noname_complaint ();
1378 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
1379 (struct symtab
**) NULL
);
1381 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1383 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
); /* TYPE_CODE_UNDEF */
1385 type
= TYPE_TARGET_TYPE (type
);
1388 is_const
= TYPE_CONST (type
);
1389 is_volatile
= TYPE_VOLATILE (type
);
1391 /* If this is a struct/class/union with no fields, then check whether a
1392 full definition exists somewhere else. This is for systems where a
1393 type definition with no fields is issued for such types, instead of
1394 identifying them as stub types in the first place */
1396 if (TYPE_IS_OPAQUE (type
) && opaque_type_resolution
&& !currently_reading_symtab
)
1398 char *name
= type_name_no_tag (type
);
1399 struct type
*newtype
;
1402 stub_noname_complaint ();
1405 newtype
= lookup_transparent_type (name
);
1407 make_cv_type (is_const
, is_volatile
, newtype
, &type
);
1409 /* Otherwise, rely on the stub flag being set for opaque/stubbed types */
1410 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1412 char *name
= type_name_no_tag (type
);
1413 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1414 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
1415 as appropriate? (this code was written before TYPE_NAME and
1416 TYPE_TAG_NAME were separate). */
1420 stub_noname_complaint ();
1423 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0, (struct symtab
**) NULL
);
1425 make_cv_type (is_const
, is_volatile
, SYMBOL_TYPE (sym
), &type
);
1428 if (TYPE_TARGET_STUB (type
))
1430 struct type
*range_type
;
1431 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1433 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1436 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1437 && TYPE_NFIELDS (type
) == 1
1438 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
1439 == TYPE_CODE_RANGE
))
1441 /* Now recompute the length of the array type, based on its
1442 number of elements and the target type's length. */
1443 TYPE_LENGTH (type
) =
1444 ((TYPE_FIELD_BITPOS (range_type
, 1)
1445 - TYPE_FIELD_BITPOS (range_type
, 0)
1447 * TYPE_LENGTH (target_type
));
1448 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1450 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1452 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1453 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1456 /* Cache TYPE_LENGTH for future use. */
1457 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1461 #if 0 /* OBSOLETE CFront */
1462 // OBSOLETE /* New code added to support parsing of Cfront stabs strings */
1463 // OBSOLETE #define INIT_EXTRA { pextras->len=0; pextras->str[0]='\0'; }
1464 // OBSOLETE #define ADD_EXTRA(c) { pextras->str[pextras->len++]=c; }
1466 // OBSOLETE static void
1467 // OBSOLETE add_name (struct extra *pextras, char *n)
1469 // OBSOLETE int nlen;
1471 // OBSOLETE if ((nlen = (n ? strlen (n) : 0)) == 0)
1473 // OBSOLETE sprintf (pextras->str + pextras->len, "%d%s", nlen, n);
1474 // OBSOLETE pextras->len = strlen (pextras->str);
1477 // OBSOLETE static void
1478 // OBSOLETE add_mangled_type (struct extra *pextras, struct type *t)
1480 // OBSOLETE enum type_code tcode;
1481 // OBSOLETE int tlen, tflags;
1482 // OBSOLETE char *tname;
1484 // OBSOLETE tcode = TYPE_CODE (t);
1485 // OBSOLETE tlen = TYPE_LENGTH (t);
1486 // OBSOLETE tflags = TYPE_FLAGS (t);
1487 // OBSOLETE tname = TYPE_NAME (t);
1488 // OBSOLETE /* args of "..." seem to get mangled as "e" */
1490 // OBSOLETE switch (tcode)
1492 // OBSOLETE case TYPE_CODE_INT:
1493 // OBSOLETE if (tflags == 1)
1494 // OBSOLETE ADD_EXTRA ('U');
1495 // OBSOLETE switch (tlen)
1498 // OBSOLETE ADD_EXTRA ('c');
1501 // OBSOLETE ADD_EXTRA ('s');
1505 // OBSOLETE char *pname;
1506 // OBSOLETE if ((pname = strrchr (tname, 'l'), pname) && !strcmp (pname, "long"))
1508 // OBSOLETE ADD_EXTRA ('l');
1512 // OBSOLETE ADD_EXTRA ('i');
1516 // OBSOLETE default:
1518 // OBSOLETE complaint (&symfile_complaints, "Bad int type code length x%x",
1523 // OBSOLETE case TYPE_CODE_FLT:
1524 // OBSOLETE switch (tlen)
1527 // OBSOLETE ADD_EXTRA ('f');
1530 // OBSOLETE ADD_EXTRA ('d');
1532 // OBSOLETE case 16:
1533 // OBSOLETE ADD_EXTRA ('r');
1535 // OBSOLETE default:
1537 // OBSOLETE complaint (&symfile_complaints, "Bad float type code length x%x",
1542 // OBSOLETE case TYPE_CODE_REF:
1543 // OBSOLETE ADD_EXTRA ('R');
1544 // OBSOLETE /* followed by what it's a ref to */
1546 // OBSOLETE case TYPE_CODE_PTR:
1547 // OBSOLETE ADD_EXTRA ('P');
1548 // OBSOLETE /* followed by what it's a ptr to */
1550 // OBSOLETE case TYPE_CODE_TYPEDEF:
1552 // OBSOLETE complaint (&symfile_complaints,
1553 // OBSOLETE "Typedefs in overloaded functions not yet supported");
1555 // OBSOLETE /* followed by type bytes & name */
1557 // OBSOLETE case TYPE_CODE_FUNC:
1558 // OBSOLETE ADD_EXTRA ('F');
1559 // OBSOLETE /* followed by func's arg '_' & ret types */
1561 // OBSOLETE case TYPE_CODE_VOID:
1562 // OBSOLETE ADD_EXTRA ('v');
1564 // OBSOLETE case TYPE_CODE_METHOD:
1565 // OBSOLETE ADD_EXTRA ('M');
1566 // OBSOLETE /* followed by name of class and func's arg '_' & ret types */
1567 // OBSOLETE add_name (pextras, tname);
1568 // OBSOLETE ADD_EXTRA ('F'); /* then mangle function */
1570 // OBSOLETE case TYPE_CODE_STRUCT: /* C struct */
1571 // OBSOLETE case TYPE_CODE_UNION: /* C union */
1572 // OBSOLETE case TYPE_CODE_ENUM: /* Enumeration type */
1573 // OBSOLETE /* followed by name of type */
1574 // OBSOLETE add_name (pextras, tname);
1577 // OBSOLETE /* errors possible types/not supported */
1578 // OBSOLETE case TYPE_CODE_CHAR:
1579 // OBSOLETE case TYPE_CODE_ARRAY: /* Array type */
1580 // OBSOLETE case TYPE_CODE_MEMBER: /* Member type */
1581 // OBSOLETE case TYPE_CODE_BOOL:
1582 // OBSOLETE case TYPE_CODE_COMPLEX: /* Complex float */
1583 // OBSOLETE case TYPE_CODE_UNDEF:
1584 // OBSOLETE case TYPE_CODE_SET: /* Pascal sets */
1585 // OBSOLETE case TYPE_CODE_RANGE:
1586 // OBSOLETE case TYPE_CODE_STRING:
1587 // OBSOLETE case TYPE_CODE_BITSTRING:
1588 // OBSOLETE case TYPE_CODE_ERROR:
1589 // OBSOLETE default:
1591 // OBSOLETE complaint (&symfile_complaints, "Unknown type code x%x", tcode);
1594 // OBSOLETE if (TYPE_TARGET_TYPE (t))
1595 // OBSOLETE add_mangled_type (pextras, TYPE_TARGET_TYPE (t));
1599 // OBSOLETE cfront_mangle_name (struct type *type, int i, int j)
1601 // OBSOLETE struct fn_field *f;
1602 // OBSOLETE char *mangled_name = gdb_mangle_name (type, i, j);
1604 // OBSOLETE f = TYPE_FN_FIELDLIST1 (type, i); /* moved from below */
1606 // OBSOLETE /* kludge to support cfront methods - gdb expects to find "F" for
1607 // OBSOLETE ARM_mangled names, so when we mangle, we have to add it here */
1608 // OBSOLETE if (ARM_DEMANGLING)
1611 // OBSOLETE char *arm_mangled_name;
1612 // OBSOLETE struct fn_field *method = &f[j];
1613 // OBSOLETE char *field_name = TYPE_FN_FIELDLIST_NAME (type, i);
1614 // OBSOLETE char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
1615 // OBSOLETE char *newname = type_name_no_tag (type);
1617 // OBSOLETE struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
1618 // OBSOLETE int nargs = TYPE_NFIELDS (ftype); /* number of args */
1619 // OBSOLETE struct extra extras, *pextras = &extras;
1620 // OBSOLETE INIT_EXTRA
1622 // OBSOLETE if (TYPE_FN_FIELD_STATIC_P (f, j)) /* j for sublist within this list */
1623 // OBSOLETE ADD_EXTRA ('S')
1624 // OBSOLETE ADD_EXTRA ('F')
1625 // OBSOLETE /* add args here! */
1626 // OBSOLETE if (nargs <= 1) /* no args besides this */
1627 // OBSOLETE ADD_EXTRA ('v')
1630 // OBSOLETE for (k = 1; k < nargs; k++)
1632 // OBSOLETE struct type *t;
1633 // OBSOLETE t = TYPE_FIELD_TYPE (ftype, k);
1634 // OBSOLETE add_mangled_type (pextras, t);
1637 // OBSOLETE ADD_EXTRA ('\0')
1638 // OBSOLETE printf ("add_mangled_type: %s\n", extras.str); /* FIXME */
1639 // OBSOLETE xasprintf (&arm_mangled_name, "%s%s", mangled_name, extras.str);
1640 // OBSOLETE xfree (mangled_name);
1641 // OBSOLETE mangled_name = arm_mangled_name;
1645 // OBSOLETE #undef ADD_EXTRA
1646 // OBSOLETE /* End of new code added to support parsing of Cfront stabs strings */
1647 #endif /* OBSOLETE CFront */
1649 /* Parse a type expression in the string [P..P+LENGTH). If an error occurs,
1650 silently return builtin_type_void. */
1653 safe_parse_type (char *p
, int length
)
1655 struct ui_file
*saved_gdb_stderr
;
1658 /* Suppress error messages. */
1659 saved_gdb_stderr
= gdb_stderr
;
1660 gdb_stderr
= ui_file_new ();
1662 /* Call parse_and_eval_type() without fear of longjmp()s. */
1663 if (!gdb_parse_and_eval_type (p
, length
, &type
))
1664 type
= builtin_type_void
;
1666 /* Stop suppressing error messages. */
1667 ui_file_delete (gdb_stderr
);
1668 gdb_stderr
= saved_gdb_stderr
;
1673 /* Ugly hack to convert method stubs into method types.
1675 He ain't kiddin'. This demangles the name of the method into a string
1676 including argument types, parses out each argument type, generates
1677 a string casting a zero to that type, evaluates the string, and stuffs
1678 the resulting type into an argtype vector!!! Then it knows the type
1679 of the whole function (including argument types for overloading),
1680 which info used to be in the stab's but was removed to hack back
1681 the space required for them. */
1684 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1687 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1688 char *demangled_name
= cplus_demangle (mangled_name
,
1689 DMGL_PARAMS
| DMGL_ANSI
);
1690 char *argtypetext
, *p
;
1691 int depth
= 0, argcount
= 1;
1692 struct field
*argtypes
;
1695 /* Make sure we got back a function string that we can use. */
1697 p
= strchr (demangled_name
, '(');
1701 if (demangled_name
== NULL
|| p
== NULL
)
1702 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
1704 /* Now, read in the parameters that define this type. */
1709 if (*p
== '(' || *p
== '<')
1713 else if (*p
== ')' || *p
== '>')
1717 else if (*p
== ',' && depth
== 0)
1725 /* If we read one argument and it was ``void'', don't count it. */
1726 if (strncmp (argtypetext
, "(void)", 6) == 0)
1729 /* We need one extra slot, for the THIS pointer. */
1731 argtypes
= (struct field
*)
1732 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
1735 /* Add THIS pointer for non-static methods. */
1736 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1737 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
1741 argtypes
[0].type
= lookup_pointer_type (type
);
1745 if (*p
!= ')') /* () means no args, skip while */
1750 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1752 /* Avoid parsing of ellipsis, they will be handled below.
1753 Also avoid ``void'' as above. */
1754 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
1755 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
1757 argtypes
[argcount
].type
=
1758 safe_parse_type (argtypetext
, p
- argtypetext
);
1761 argtypetext
= p
+ 1;
1764 if (*p
== '(' || *p
== '<')
1768 else if (*p
== ')' || *p
== '>')
1777 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1779 /* Now update the old "stub" type into a real type. */
1780 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1781 TYPE_DOMAIN_TYPE (mtype
) = type
;
1782 TYPE_FIELDS (mtype
) = argtypes
;
1783 TYPE_NFIELDS (mtype
) = argcount
;
1784 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1785 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1787 TYPE_FLAGS (mtype
) |= TYPE_FLAG_VARARGS
;
1789 xfree (demangled_name
);
1792 /* This is the external interface to check_stub_method, above. This function
1793 unstubs all of the signatures for TYPE's METHOD_ID method name. After
1794 calling this function TYPE_FN_FIELD_STUB will be cleared for each signature
1795 and TYPE_FN_FIELDLIST_NAME will be correct.
1797 This function unfortunately can not die until stabs do. */
1800 check_stub_method_group (struct type
*type
, int method_id
)
1802 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
1803 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1804 int j
, found_stub
= 0;
1806 for (j
= 0; j
< len
; j
++)
1807 if (TYPE_FN_FIELD_STUB (f
, j
))
1810 check_stub_method (type
, method_id
, j
);
1813 /* GNU v3 methods with incorrect names were corrected when we read in
1814 type information, because it was cheaper to do it then. The only GNU v2
1815 methods with incorrect method names are operators and destructors;
1816 destructors were also corrected when we read in type information.
1818 Therefore the only thing we need to handle here are v2 operator
1820 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
1823 char dem_opname
[256];
1825 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
, method_id
),
1826 dem_opname
, DMGL_ANSI
);
1828 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
, method_id
),
1831 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
1835 const struct cplus_struct_type cplus_struct_default
;
1838 allocate_cplus_struct_type (struct type
*type
)
1840 if (!HAVE_CPLUS_STRUCT (type
))
1842 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1843 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1844 *(TYPE_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1848 /* Helper function to initialize the standard scalar types.
1850 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1851 of the string pointed to by name in the type_obstack for that objfile,
1852 and initialize the type name to that copy. There are places (mipsread.c
1853 in particular, where init_type is called with a NULL value for NAME). */
1856 init_type (enum type_code code
, int length
, int flags
, char *name
,
1857 struct objfile
*objfile
)
1859 register struct type
*type
;
1861 type
= alloc_type (objfile
);
1862 TYPE_CODE (type
) = code
;
1863 TYPE_LENGTH (type
) = length
;
1864 TYPE_FLAGS (type
) |= flags
;
1865 if ((name
!= NULL
) && (objfile
!= NULL
))
1868 obsavestring (name
, strlen (name
), &objfile
->type_obstack
);
1872 TYPE_NAME (type
) = name
;
1877 if (name
&& strcmp (name
, "char") == 0)
1878 TYPE_FLAGS (type
) |= TYPE_FLAG_NOSIGN
;
1880 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
1882 INIT_CPLUS_SPECIFIC (type
);
1887 /* Helper function. Create an empty composite type. */
1890 init_composite_type (char *name
, enum type_code code
)
1893 gdb_assert (code
== TYPE_CODE_STRUCT
1894 || code
== TYPE_CODE_UNION
);
1895 t
= init_type (code
, 0, 0, NULL
, NULL
);
1896 TYPE_TAG_NAME (t
) = name
;
1900 /* Helper function. Append a field to a composite type. */
1903 append_composite_type_field (struct type
*t
, char *name
, struct type
*field
)
1906 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
1907 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
1908 sizeof (struct field
) * TYPE_NFIELDS (t
));
1909 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
1910 memset (f
, 0, sizeof f
[0]);
1911 FIELD_TYPE (f
[0]) = field
;
1912 FIELD_NAME (f
[0]) = name
;
1913 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1915 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
1916 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
1918 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
1920 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
1921 if (TYPE_NFIELDS (t
) > 1)
1923 FIELD_BITPOS (f
[0]) = (FIELD_BITPOS (f
[-1])
1924 + TYPE_LENGTH (field
) * TARGET_CHAR_BIT
);
1929 /* Look up a fundamental type for the specified objfile.
1930 May need to construct such a type if this is the first use.
1932 Some object file formats (ELF, COFF, etc) do not define fundamental
1933 types such as "int" or "double". Others (stabs for example), do
1934 define fundamental types.
1936 For the formats which don't provide fundamental types, gdb can create
1937 such types, using defaults reasonable for the current language and
1938 the current target machine.
1940 NOTE: This routine is obsolescent. Each debugging format reader
1941 should manage it's own fundamental types, either creating them from
1942 suitable defaults or reading them from the debugging information,
1943 whichever is appropriate. The DWARF reader has already been
1944 fixed to do this. Once the other readers are fixed, this routine
1945 will go away. Also note that fundamental types should be managed
1946 on a compilation unit basis in a multi-language environment, not
1947 on a linkage unit basis as is done here. */
1951 lookup_fundamental_type (struct objfile
*objfile
, int typeid)
1953 register struct type
**typep
;
1954 register int nbytes
;
1956 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1958 error ("internal error - invalid fundamental type id %d", typeid);
1961 /* If this is the first time we need a fundamental type for this objfile
1962 then we need to initialize the vector of type pointers. */
1964 if (objfile
->fundamental_types
== NULL
)
1966 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1967 objfile
->fundamental_types
= (struct type
**)
1968 obstack_alloc (&objfile
->type_obstack
, nbytes
);
1969 memset ((char *) objfile
->fundamental_types
, 0, nbytes
);
1970 OBJSTAT (objfile
, n_types
+= FT_NUM_MEMBERS
);
1973 /* Look for this particular type in the fundamental type vector. If one is
1974 not found, create and install one appropriate for the current language. */
1976 typep
= objfile
->fundamental_types
+ typeid;
1979 *typep
= create_fundamental_type (objfile
, typeid);
1986 can_dereference (struct type
*t
)
1988 /* FIXME: Should we return true for references as well as pointers? */
1992 && TYPE_CODE (t
) == TYPE_CODE_PTR
1993 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1997 is_integral_type (struct type
*t
)
2002 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
2003 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
2004 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
2005 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
2006 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
2009 /* Check whether BASE is an ancestor or base class or DCLASS
2010 Return 1 if so, and 0 if not.
2011 Note: callers may want to check for identity of the types before
2012 calling this function -- identical types are considered to satisfy
2013 the ancestor relationship even if they're identical */
2016 is_ancestor (struct type
*base
, struct type
*dclass
)
2020 CHECK_TYPEDEF (base
);
2021 CHECK_TYPEDEF (dclass
);
2025 if (TYPE_NAME (base
) && TYPE_NAME (dclass
) &&
2026 !strcmp (TYPE_NAME (base
), TYPE_NAME (dclass
)))
2029 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2030 if (is_ancestor (base
, TYPE_BASECLASS (dclass
, i
)))
2038 /* See whether DCLASS has a virtual table. This routine is aimed at
2039 the HP/Taligent ANSI C++ runtime model, and may not work with other
2040 runtime models. Return 1 => Yes, 0 => No. */
2043 has_vtable (struct type
*dclass
)
2045 /* In the HP ANSI C++ runtime model, a class has a vtable only if it
2046 has virtual functions or virtual bases. */
2050 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
2053 /* First check for the presence of virtual bases */
2054 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
2055 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2056 if (B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
))
2059 /* Next check for virtual functions */
2060 if (TYPE_FN_FIELDLISTS (dclass
))
2061 for (i
= 0; i
< TYPE_NFN_FIELDS (dclass
); i
++)
2062 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, i
), 0))
2065 /* Recurse on non-virtual bases to see if any of them needs a vtable */
2066 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
2067 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2068 if ((!B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
)) &&
2069 (has_vtable (TYPE_FIELD_TYPE (dclass
, i
))))
2072 /* Well, maybe we don't need a virtual table */
2076 /* Return a pointer to the "primary base class" of DCLASS.
2078 A NULL return indicates that DCLASS has no primary base, or that it
2079 couldn't be found (insufficient information).
2081 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
2082 and may not work with other runtime models. */
2085 primary_base_class (struct type
*dclass
)
2087 /* In HP ANSI C++'s runtime model, a "primary base class" of a class
2088 is the first directly inherited, non-virtual base class that
2089 requires a virtual table */
2093 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
2096 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2097 if (!TYPE_FIELD_VIRTUAL (dclass
, i
) &&
2098 has_vtable (TYPE_FIELD_TYPE (dclass
, i
)))
2099 return TYPE_FIELD_TYPE (dclass
, i
);
2104 /* Global manipulated by virtual_base_list[_aux]() */
2106 static struct vbase
*current_vbase_list
= NULL
;
2108 /* Return a pointer to a null-terminated list of struct vbase
2109 items. The vbasetype pointer of each item in the list points to the
2110 type information for a virtual base of the argument DCLASS.
2112 Helper function for virtual_base_list().
2113 Note: the list goes backward, right-to-left. virtual_base_list()
2114 copies the items out in reverse order. */
2117 virtual_base_list_aux (struct type
*dclass
)
2119 struct vbase
*tmp_vbase
;
2122 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
2125 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2127 /* Recurse on this ancestor, first */
2128 virtual_base_list_aux (TYPE_FIELD_TYPE (dclass
, i
));
2130 /* If this current base is itself virtual, add it to the list */
2131 if (BASETYPE_VIA_VIRTUAL (dclass
, i
))
2133 struct type
*basetype
= TYPE_FIELD_TYPE (dclass
, i
);
2135 /* Check if base already recorded */
2136 tmp_vbase
= current_vbase_list
;
2139 if (tmp_vbase
->vbasetype
== basetype
)
2140 break; /* found it */
2141 tmp_vbase
= tmp_vbase
->next
;
2144 if (!tmp_vbase
) /* normal exit from loop */
2146 /* Allocate new item for this virtual base */
2147 tmp_vbase
= (struct vbase
*) xmalloc (sizeof (struct vbase
));
2149 /* Stick it on at the end of the list */
2150 tmp_vbase
->vbasetype
= basetype
;
2151 tmp_vbase
->next
= current_vbase_list
;
2152 current_vbase_list
= tmp_vbase
;
2155 } /* for loop over bases */
2159 /* Compute the list of virtual bases in the right order. Virtual
2160 bases are laid out in the object's memory area in order of their
2161 occurrence in a depth-first, left-to-right search through the
2164 Argument DCLASS is the type whose virtual bases are required.
2165 Return value is the address of a null-terminated array of pointers
2166 to struct type items.
2168 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
2169 and may not work with other runtime models.
2171 This routine merely hands off the argument to virtual_base_list_aux()
2172 and then copies the result into an array to save space. */
2175 virtual_base_list (struct type
*dclass
)
2177 register struct vbase
*tmp_vbase
;
2178 register struct vbase
*tmp_vbase_2
;
2181 struct type
**vbase_array
;
2183 current_vbase_list
= NULL
;
2184 virtual_base_list_aux (dclass
);
2186 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
2191 vbase_array
= (struct type
**) xmalloc ((count
+ 1) * sizeof (struct type
*));
2193 for (i
= count
- 1, tmp_vbase
= current_vbase_list
; i
>= 0; i
--, tmp_vbase
= tmp_vbase
->next
)
2194 vbase_array
[i
] = tmp_vbase
->vbasetype
;
2196 /* Get rid of constructed chain */
2197 tmp_vbase_2
= tmp_vbase
= current_vbase_list
;
2200 tmp_vbase
= tmp_vbase
->next
;
2201 xfree (tmp_vbase_2
);
2202 tmp_vbase_2
= tmp_vbase
;
2205 vbase_array
[count
] = NULL
;
2209 /* Return the length of the virtual base list of the type DCLASS. */
2212 virtual_base_list_length (struct type
*dclass
)
2215 register struct vbase
*tmp_vbase
;
2217 current_vbase_list
= NULL
;
2218 virtual_base_list_aux (dclass
);
2220 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
2225 /* Return the number of elements of the virtual base list of the type
2226 DCLASS, ignoring those appearing in the primary base (and its
2227 primary base, recursively). */
2230 virtual_base_list_length_skip_primaries (struct type
*dclass
)
2233 register struct vbase
*tmp_vbase
;
2234 struct type
*primary
;
2236 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
2239 return virtual_base_list_length (dclass
);
2241 current_vbase_list
= NULL
;
2242 virtual_base_list_aux (dclass
);
2244 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; tmp_vbase
= tmp_vbase
->next
)
2246 if (virtual_base_index (tmp_vbase
->vbasetype
, primary
) >= 0)
2254 /* Return the index (position) of type BASE, which is a virtual base
2255 class of DCLASS, in the latter's virtual base list. A return of -1
2256 indicates "not found" or a problem. */
2259 virtual_base_index (struct type
*base
, struct type
*dclass
)
2261 register struct type
*vbase
;
2264 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
2265 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
2269 vbase
= virtual_base_list (dclass
)[0];
2274 vbase
= virtual_base_list (dclass
)[++i
];
2277 return vbase
? i
: -1;
2282 /* Return the index (position) of type BASE, which is a virtual base
2283 class of DCLASS, in the latter's virtual base list. Skip over all
2284 bases that may appear in the virtual base list of the primary base
2285 class of DCLASS (recursively). A return of -1 indicates "not
2286 found" or a problem. */
2289 virtual_base_index_skip_primaries (struct type
*base
, struct type
*dclass
)
2291 register struct type
*vbase
;
2293 struct type
*primary
;
2295 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
2296 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
2299 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
2303 vbase
= virtual_base_list (dclass
)[0];
2306 if (!primary
|| (virtual_base_index_skip_primaries (vbase
, primary
) < 0))
2310 vbase
= virtual_base_list (dclass
)[++i
];
2313 return vbase
? j
: -1;
2316 /* Return position of a derived class DCLASS in the list of
2317 * primary bases starting with the remotest ancestor.
2318 * Position returned is 0-based. */
2321 class_index_in_primary_list (struct type
*dclass
)
2323 struct type
*pbc
; /* primary base class */
2325 /* Simply recurse on primary base */
2326 pbc
= TYPE_PRIMARY_BASE (dclass
);
2328 return 1 + class_index_in_primary_list (pbc
);
2333 /* Return a count of the number of virtual functions a type has.
2334 * This includes all the virtual functions it inherits from its
2338 /* pai: FIXME This doesn't do the right thing: count redefined virtual
2339 * functions only once (latest redefinition)
2343 count_virtual_fns (struct type
*dclass
)
2345 int fn
, oi
; /* function and overloaded instance indices */
2346 int vfuncs
; /* count to return */
2348 /* recurse on bases that can share virtual table */
2349 struct type
*pbc
= primary_base_class (dclass
);
2351 vfuncs
= count_virtual_fns (pbc
);
2355 for (fn
= 0; fn
< TYPE_NFN_FIELDS (dclass
); fn
++)
2356 for (oi
= 0; oi
< TYPE_FN_FIELDLIST_LENGTH (dclass
, fn
); oi
++)
2357 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, fn
), oi
))
2365 /* Functions for overload resolution begin here */
2367 /* Compare two badness vectors A and B and return the result.
2368 * 0 => A and B are identical
2369 * 1 => A and B are incomparable
2370 * 2 => A is better than B
2371 * 3 => A is worse than B */
2374 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
2378 short found_pos
= 0; /* any positives in c? */
2379 short found_neg
= 0; /* any negatives in c? */
2381 /* differing lengths => incomparable */
2382 if (a
->length
!= b
->length
)
2385 /* Subtract b from a */
2386 for (i
= 0; i
< a
->length
; i
++)
2388 tmp
= a
->rank
[i
] - b
->rank
[i
];
2398 return 1; /* incomparable */
2400 return 3; /* A > B */
2406 return 2; /* A < B */
2408 return 0; /* A == B */
2412 /* Rank a function by comparing its parameter types (PARMS, length NPARMS),
2413 * to the types of an argument list (ARGS, length NARGS).
2414 * Return a pointer to a badness vector. This has NARGS + 1 entries. */
2416 struct badness_vector
*
2417 rank_function (struct type
**parms
, int nparms
, struct type
**args
, int nargs
)
2420 struct badness_vector
*bv
;
2421 int min_len
= nparms
< nargs
? nparms
: nargs
;
2423 bv
= xmalloc (sizeof (struct badness_vector
));
2424 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank */
2425 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
2427 /* First compare the lengths of the supplied lists.
2428 * If there is a mismatch, set it to a high value. */
2430 /* pai/1997-06-03 FIXME: when we have debug info about default
2431 * arguments and ellipsis parameter lists, we should consider those
2432 * and rank the length-match more finely. */
2434 LENGTH_MATCH (bv
) = (nargs
!= nparms
) ? LENGTH_MISMATCH_BADNESS
: 0;
2436 /* Now rank all the parameters of the candidate function */
2437 for (i
= 1; i
<= min_len
; i
++)
2438 bv
->rank
[i
] = rank_one_type (parms
[i
-1], args
[i
-1]);
2440 /* If more arguments than parameters, add dummy entries */
2441 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2442 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2447 /* Compare the names of two integer types, assuming that any sign
2448 qualifiers have been checked already. We do it this way because
2449 there may be an "int" in the name of one of the types. */
2452 integer_types_same_name_p (const char *first
, const char *second
)
2454 int first_p
, second_p
;
2456 /* If both are shorts, return 1; if neither is a short, keep checking. */
2457 first_p
= (strstr (first
, "short") != NULL
);
2458 second_p
= (strstr (second
, "short") != NULL
);
2459 if (first_p
&& second_p
)
2461 if (first_p
|| second_p
)
2464 /* Likewise for long. */
2465 first_p
= (strstr (first
, "long") != NULL
);
2466 second_p
= (strstr (second
, "long") != NULL
);
2467 if (first_p
&& second_p
)
2469 if (first_p
|| second_p
)
2472 /* Likewise for char. */
2473 first_p
= (strstr (first
, "char") != NULL
);
2474 second_p
= (strstr (second
, "char") != NULL
);
2475 if (first_p
&& second_p
)
2477 if (first_p
|| second_p
)
2480 /* They must both be ints. */
2484 /* Compare one type (PARM) for compatibility with another (ARG).
2485 * PARM is intended to be the parameter type of a function; and
2486 * ARG is the supplied argument's type. This function tests if
2487 * the latter can be converted to the former.
2489 * Return 0 if they are identical types;
2490 * Otherwise, return an integer which corresponds to how compatible
2491 * PARM is to ARG. The higher the return value, the worse the match.
2492 * Generally the "bad" conversions are all uniformly assigned a 100 */
2495 rank_one_type (struct type
*parm
, struct type
*arg
)
2497 /* Identical type pointers */
2498 /* However, this still doesn't catch all cases of same type for arg
2499 * and param. The reason is that builtin types are different from
2500 * the same ones constructed from the object. */
2504 /* Resolve typedefs */
2505 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2506 parm
= check_typedef (parm
);
2507 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2508 arg
= check_typedef (arg
);
2511 Well, damnit, if the names are exactly the same,
2512 i'll say they are exactly the same. This happens when we generate
2513 method stubs. The types won't point to the same address, but they
2514 really are the same.
2517 if (TYPE_NAME (parm
) && TYPE_NAME (arg
) &&
2518 !strcmp (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2521 /* Check if identical after resolving typedefs */
2525 /* See through references, since we can almost make non-references
2527 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2528 return (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
))
2529 + REFERENCE_CONVERSION_BADNESS
);
2530 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2531 return (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
)
2532 + REFERENCE_CONVERSION_BADNESS
);
2534 /* Debugging only. */
2535 fprintf_filtered (gdb_stderr
,"------ Arg is %s [%d], parm is %s [%d]\n",
2536 TYPE_NAME (arg
), TYPE_CODE (arg
), TYPE_NAME (parm
), TYPE_CODE (parm
));
2538 /* x -> y means arg of type x being supplied for parameter of type y */
2540 switch (TYPE_CODE (parm
))
2543 switch (TYPE_CODE (arg
))
2546 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2547 return VOID_PTR_CONVERSION_BADNESS
;
2549 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2550 case TYPE_CODE_ARRAY
:
2551 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2552 case TYPE_CODE_FUNC
:
2553 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
);
2555 case TYPE_CODE_ENUM
:
2556 case TYPE_CODE_CHAR
:
2557 case TYPE_CODE_RANGE
:
2558 case TYPE_CODE_BOOL
:
2559 return POINTER_CONVERSION_BADNESS
;
2561 return INCOMPATIBLE_TYPE_BADNESS
;
2563 case TYPE_CODE_ARRAY
:
2564 switch (TYPE_CODE (arg
))
2567 case TYPE_CODE_ARRAY
:
2568 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2570 return INCOMPATIBLE_TYPE_BADNESS
;
2572 case TYPE_CODE_FUNC
:
2573 switch (TYPE_CODE (arg
))
2575 case TYPE_CODE_PTR
: /* funcptr -> func */
2576 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
));
2578 return INCOMPATIBLE_TYPE_BADNESS
;
2581 switch (TYPE_CODE (arg
))
2584 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2586 /* Deal with signed, unsigned, and plain chars and
2587 signed and unsigned ints */
2588 if (TYPE_NOSIGN (parm
))
2590 /* This case only for character types */
2591 if (TYPE_NOSIGN (arg
)) /* plain char -> plain char */
2594 return INTEGER_CONVERSION_BADNESS
; /* signed/unsigned char -> plain char */
2596 else if (TYPE_UNSIGNED (parm
))
2598 if (TYPE_UNSIGNED (arg
))
2600 /* unsigned int -> unsigned int, or unsigned long -> unsigned long */
2601 if (integer_types_same_name_p (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2603 else if (integer_types_same_name_p (TYPE_NAME (arg
), "int")
2604 && integer_types_same_name_p (TYPE_NAME (parm
), "long"))
2605 return INTEGER_PROMOTION_BADNESS
; /* unsigned int -> unsigned long */
2607 return INTEGER_CONVERSION_BADNESS
; /* unsigned long -> unsigned int */
2611 if (integer_types_same_name_p (TYPE_NAME (arg
), "long")
2612 && integer_types_same_name_p (TYPE_NAME (parm
), "int"))
2613 return INTEGER_CONVERSION_BADNESS
; /* signed long -> unsigned int */
2615 return INTEGER_CONVERSION_BADNESS
; /* signed int/long -> unsigned int/long */
2618 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2620 if (integer_types_same_name_p (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2622 else if (integer_types_same_name_p (TYPE_NAME (arg
), "int")
2623 && integer_types_same_name_p (TYPE_NAME (parm
), "long"))
2624 return INTEGER_PROMOTION_BADNESS
;
2626 return INTEGER_CONVERSION_BADNESS
;
2629 return INTEGER_CONVERSION_BADNESS
;
2631 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2632 return INTEGER_PROMOTION_BADNESS
;
2634 return INTEGER_CONVERSION_BADNESS
;
2635 case TYPE_CODE_ENUM
:
2636 case TYPE_CODE_CHAR
:
2637 case TYPE_CODE_RANGE
:
2638 case TYPE_CODE_BOOL
:
2639 return INTEGER_PROMOTION_BADNESS
;
2641 return INT_FLOAT_CONVERSION_BADNESS
;
2643 return NS_POINTER_CONVERSION_BADNESS
;
2645 return INCOMPATIBLE_TYPE_BADNESS
;
2648 case TYPE_CODE_ENUM
:
2649 switch (TYPE_CODE (arg
))
2652 case TYPE_CODE_CHAR
:
2653 case TYPE_CODE_RANGE
:
2654 case TYPE_CODE_BOOL
:
2655 case TYPE_CODE_ENUM
:
2656 return INTEGER_CONVERSION_BADNESS
;
2658 return INT_FLOAT_CONVERSION_BADNESS
;
2660 return INCOMPATIBLE_TYPE_BADNESS
;
2663 case TYPE_CODE_CHAR
:
2664 switch (TYPE_CODE (arg
))
2666 case TYPE_CODE_RANGE
:
2667 case TYPE_CODE_BOOL
:
2668 case TYPE_CODE_ENUM
:
2669 return INTEGER_CONVERSION_BADNESS
;
2671 return INT_FLOAT_CONVERSION_BADNESS
;
2673 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2674 return INTEGER_CONVERSION_BADNESS
;
2675 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2676 return INTEGER_PROMOTION_BADNESS
;
2677 /* >>> !! else fall through !! <<< */
2678 case TYPE_CODE_CHAR
:
2679 /* Deal with signed, unsigned, and plain chars for C++
2680 and with int cases falling through from previous case */
2681 if (TYPE_NOSIGN (parm
))
2683 if (TYPE_NOSIGN (arg
))
2686 return INTEGER_CONVERSION_BADNESS
;
2688 else if (TYPE_UNSIGNED (parm
))
2690 if (TYPE_UNSIGNED (arg
))
2693 return INTEGER_PROMOTION_BADNESS
;
2695 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2698 return INTEGER_CONVERSION_BADNESS
;
2700 return INCOMPATIBLE_TYPE_BADNESS
;
2703 case TYPE_CODE_RANGE
:
2704 switch (TYPE_CODE (arg
))
2707 case TYPE_CODE_CHAR
:
2708 case TYPE_CODE_RANGE
:
2709 case TYPE_CODE_BOOL
:
2710 case TYPE_CODE_ENUM
:
2711 return INTEGER_CONVERSION_BADNESS
;
2713 return INT_FLOAT_CONVERSION_BADNESS
;
2715 return INCOMPATIBLE_TYPE_BADNESS
;
2718 case TYPE_CODE_BOOL
:
2719 switch (TYPE_CODE (arg
))
2722 case TYPE_CODE_CHAR
:
2723 case TYPE_CODE_RANGE
:
2724 case TYPE_CODE_ENUM
:
2727 return BOOLEAN_CONVERSION_BADNESS
;
2728 case TYPE_CODE_BOOL
:
2731 return INCOMPATIBLE_TYPE_BADNESS
;
2735 switch (TYPE_CODE (arg
))
2738 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2739 return FLOAT_PROMOTION_BADNESS
;
2740 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2743 return FLOAT_CONVERSION_BADNESS
;
2745 case TYPE_CODE_BOOL
:
2746 case TYPE_CODE_ENUM
:
2747 case TYPE_CODE_RANGE
:
2748 case TYPE_CODE_CHAR
:
2749 return INT_FLOAT_CONVERSION_BADNESS
;
2751 return INCOMPATIBLE_TYPE_BADNESS
;
2754 case TYPE_CODE_COMPLEX
:
2755 switch (TYPE_CODE (arg
))
2756 { /* Strictly not needed for C++, but... */
2758 return FLOAT_PROMOTION_BADNESS
;
2759 case TYPE_CODE_COMPLEX
:
2762 return INCOMPATIBLE_TYPE_BADNESS
;
2765 case TYPE_CODE_STRUCT
:
2766 /* currently same as TYPE_CODE_CLASS */
2767 switch (TYPE_CODE (arg
))
2769 case TYPE_CODE_STRUCT
:
2770 /* Check for derivation */
2771 if (is_ancestor (parm
, arg
))
2772 return BASE_CONVERSION_BADNESS
;
2773 /* else fall through */
2775 return INCOMPATIBLE_TYPE_BADNESS
;
2778 case TYPE_CODE_UNION
:
2779 switch (TYPE_CODE (arg
))
2781 case TYPE_CODE_UNION
:
2783 return INCOMPATIBLE_TYPE_BADNESS
;
2786 case TYPE_CODE_MEMBER
:
2787 switch (TYPE_CODE (arg
))
2790 return INCOMPATIBLE_TYPE_BADNESS
;
2793 case TYPE_CODE_METHOD
:
2794 switch (TYPE_CODE (arg
))
2798 return INCOMPATIBLE_TYPE_BADNESS
;
2802 switch (TYPE_CODE (arg
))
2806 return INCOMPATIBLE_TYPE_BADNESS
;
2811 switch (TYPE_CODE (arg
))
2815 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0), TYPE_FIELD_TYPE (arg
, 0));
2817 return INCOMPATIBLE_TYPE_BADNESS
;
2820 case TYPE_CODE_VOID
:
2822 return INCOMPATIBLE_TYPE_BADNESS
;
2823 } /* switch (TYPE_CODE (arg)) */
2827 /* End of functions for overload resolution */
2830 print_bit_vector (B_TYPE
*bits
, int nbits
)
2834 for (bitno
= 0; bitno
< nbits
; bitno
++)
2836 if ((bitno
% 8) == 0)
2838 puts_filtered (" ");
2840 if (B_TST (bits
, bitno
))
2842 printf_filtered ("1");
2846 printf_filtered ("0");
2851 /* Note the first arg should be the "this" pointer, we may not want to
2852 include it since we may get into a infinitely recursive situation. */
2855 print_arg_types (struct field
*args
, int nargs
, int spaces
)
2861 for (i
= 0; i
< nargs
; i
++)
2862 recursive_dump_type (args
[i
].type
, spaces
+ 2);
2867 dump_fn_fieldlists (struct type
*type
, int spaces
)
2873 printfi_filtered (spaces
, "fn_fieldlists ");
2874 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2875 printf_filtered ("\n");
2876 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2878 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2879 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2881 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2882 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2884 printf_filtered (") length %d\n",
2885 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2886 for (overload_idx
= 0;
2887 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2890 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2892 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2893 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2895 printf_filtered (")\n");
2896 printfi_filtered (spaces
+ 8, "type ");
2897 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
2898 printf_filtered ("\n");
2900 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2903 printfi_filtered (spaces
+ 8, "args ");
2904 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
2905 printf_filtered ("\n");
2907 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2908 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
, overload_idx
)),
2910 printfi_filtered (spaces
+ 8, "fcontext ");
2911 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2913 printf_filtered ("\n");
2915 printfi_filtered (spaces
+ 8, "is_const %d\n",
2916 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2917 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2918 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2919 printfi_filtered (spaces
+ 8, "is_private %d\n",
2920 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2921 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2922 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2923 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2924 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2925 printfi_filtered (spaces
+ 8, "voffset %u\n",
2926 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2932 print_cplus_stuff (struct type
*type
, int spaces
)
2934 printfi_filtered (spaces
, "n_baseclasses %d\n",
2935 TYPE_N_BASECLASSES (type
));
2936 printfi_filtered (spaces
, "nfn_fields %d\n",
2937 TYPE_NFN_FIELDS (type
));
2938 printfi_filtered (spaces
, "nfn_fields_total %d\n",
2939 TYPE_NFN_FIELDS_TOTAL (type
));
2940 if (TYPE_N_BASECLASSES (type
) > 0)
2942 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2943 TYPE_N_BASECLASSES (type
));
2944 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
2945 printf_filtered (")");
2947 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2948 TYPE_N_BASECLASSES (type
));
2949 puts_filtered ("\n");
2951 if (TYPE_NFIELDS (type
) > 0)
2953 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2955 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
2956 TYPE_NFIELDS (type
));
2957 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
2958 printf_filtered (")");
2959 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2960 TYPE_NFIELDS (type
));
2961 puts_filtered ("\n");
2963 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2965 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
2966 TYPE_NFIELDS (type
));
2967 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
2968 printf_filtered (")");
2969 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2970 TYPE_NFIELDS (type
));
2971 puts_filtered ("\n");
2974 if (TYPE_NFN_FIELDS (type
) > 0)
2976 dump_fn_fieldlists (type
, spaces
);
2981 print_bound_type (int bt
)
2985 case BOUND_CANNOT_BE_DETERMINED
:
2986 printf_filtered ("(BOUND_CANNOT_BE_DETERMINED)");
2988 case BOUND_BY_REF_ON_STACK
:
2989 printf_filtered ("(BOUND_BY_REF_ON_STACK)");
2991 case BOUND_BY_VALUE_ON_STACK
:
2992 printf_filtered ("(BOUND_BY_VALUE_ON_STACK)");
2994 case BOUND_BY_REF_IN_REG
:
2995 printf_filtered ("(BOUND_BY_REF_IN_REG)");
2997 case BOUND_BY_VALUE_IN_REG
:
2998 printf_filtered ("(BOUND_BY_VALUE_IN_REG)");
3001 printf_filtered ("(BOUND_SIMPLE)");
3004 printf_filtered ("(unknown bound type)");
3009 static struct obstack dont_print_type_obstack
;
3012 recursive_dump_type (struct type
*type
, int spaces
)
3017 obstack_begin (&dont_print_type_obstack
, 0);
3019 if (TYPE_NFIELDS (type
) > 0
3020 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
3022 struct type
**first_dont_print
3023 = (struct type
**) obstack_base (&dont_print_type_obstack
);
3025 int i
= (struct type
**) obstack_next_free (&dont_print_type_obstack
)
3030 if (type
== first_dont_print
[i
])
3032 printfi_filtered (spaces
, "type node ");
3033 gdb_print_host_address (type
, gdb_stdout
);
3034 printf_filtered (" <same as already seen type>\n");
3039 obstack_ptr_grow (&dont_print_type_obstack
, type
);
3042 printfi_filtered (spaces
, "type node ");
3043 gdb_print_host_address (type
, gdb_stdout
);
3044 printf_filtered ("\n");
3045 printfi_filtered (spaces
, "name '%s' (",
3046 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
3047 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
3048 printf_filtered (")\n");
3049 printfi_filtered (spaces
, "tagname '%s' (",
3050 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
3051 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
3052 printf_filtered (")\n");
3053 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
3054 switch (TYPE_CODE (type
))
3056 case TYPE_CODE_UNDEF
:
3057 printf_filtered ("(TYPE_CODE_UNDEF)");
3060 printf_filtered ("(TYPE_CODE_PTR)");
3062 case TYPE_CODE_ARRAY
:
3063 printf_filtered ("(TYPE_CODE_ARRAY)");
3065 case TYPE_CODE_STRUCT
:
3066 printf_filtered ("(TYPE_CODE_STRUCT)");
3068 case TYPE_CODE_UNION
:
3069 printf_filtered ("(TYPE_CODE_UNION)");
3071 case TYPE_CODE_ENUM
:
3072 printf_filtered ("(TYPE_CODE_ENUM)");
3074 case TYPE_CODE_FUNC
:
3075 printf_filtered ("(TYPE_CODE_FUNC)");
3078 printf_filtered ("(TYPE_CODE_INT)");
3081 printf_filtered ("(TYPE_CODE_FLT)");
3083 case TYPE_CODE_VOID
:
3084 printf_filtered ("(TYPE_CODE_VOID)");
3087 printf_filtered ("(TYPE_CODE_SET)");
3089 case TYPE_CODE_RANGE
:
3090 printf_filtered ("(TYPE_CODE_RANGE)");
3092 case TYPE_CODE_STRING
:
3093 printf_filtered ("(TYPE_CODE_STRING)");
3095 case TYPE_CODE_BITSTRING
:
3096 printf_filtered ("(TYPE_CODE_BITSTRING)");
3098 case TYPE_CODE_ERROR
:
3099 printf_filtered ("(TYPE_CODE_ERROR)");
3101 case TYPE_CODE_MEMBER
:
3102 printf_filtered ("(TYPE_CODE_MEMBER)");
3104 case TYPE_CODE_METHOD
:
3105 printf_filtered ("(TYPE_CODE_METHOD)");
3108 printf_filtered ("(TYPE_CODE_REF)");
3110 case TYPE_CODE_CHAR
:
3111 printf_filtered ("(TYPE_CODE_CHAR)");
3113 case TYPE_CODE_BOOL
:
3114 printf_filtered ("(TYPE_CODE_BOOL)");
3116 case TYPE_CODE_COMPLEX
:
3117 printf_filtered ("(TYPE_CODE_COMPLEX)");
3119 case TYPE_CODE_TYPEDEF
:
3120 printf_filtered ("(TYPE_CODE_TYPEDEF)");
3122 case TYPE_CODE_TEMPLATE
:
3123 printf_filtered ("(TYPE_CODE_TEMPLATE)");
3125 case TYPE_CODE_TEMPLATE_ARG
:
3126 printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)");
3129 printf_filtered ("(UNKNOWN TYPE CODE)");
3132 puts_filtered ("\n");
3133 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
3134 printfi_filtered (spaces
, "upper_bound_type 0x%x ",
3135 TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
3136 print_bound_type (TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
3137 puts_filtered ("\n");
3138 printfi_filtered (spaces
, "lower_bound_type 0x%x ",
3139 TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
3140 print_bound_type (TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
3141 puts_filtered ("\n");
3142 printfi_filtered (spaces
, "objfile ");
3143 gdb_print_host_address (TYPE_OBJFILE (type
), gdb_stdout
);
3144 printf_filtered ("\n");
3145 printfi_filtered (spaces
, "target_type ");
3146 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
3147 printf_filtered ("\n");
3148 if (TYPE_TARGET_TYPE (type
) != NULL
)
3150 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
3152 printfi_filtered (spaces
, "pointer_type ");
3153 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
3154 printf_filtered ("\n");
3155 printfi_filtered (spaces
, "reference_type ");
3156 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
3157 printf_filtered ("\n");
3158 printfi_filtered (spaces
, "type_chain ");
3159 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
3160 printf_filtered ("\n");
3161 printfi_filtered (spaces
, "instance_flags 0x%x", TYPE_INSTANCE_FLAGS (type
));
3162 if (TYPE_CONST (type
))
3164 puts_filtered (" TYPE_FLAG_CONST");
3166 if (TYPE_VOLATILE (type
))
3168 puts_filtered (" TYPE_FLAG_VOLATILE");
3170 if (TYPE_CODE_SPACE (type
))
3172 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3174 if (TYPE_DATA_SPACE (type
))
3176 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3178 if (TYPE_ADDRESS_CLASS_1 (type
))
3180 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3182 if (TYPE_ADDRESS_CLASS_2 (type
))
3184 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3186 puts_filtered ("\n");
3187 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
3188 if (TYPE_UNSIGNED (type
))
3190 puts_filtered (" TYPE_FLAG_UNSIGNED");
3192 if (TYPE_NOSIGN (type
))
3194 puts_filtered (" TYPE_FLAG_NOSIGN");
3196 if (TYPE_STUB (type
))
3198 puts_filtered (" TYPE_FLAG_STUB");
3200 if (TYPE_TARGET_STUB (type
))
3202 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3204 if (TYPE_STATIC (type
))
3206 puts_filtered (" TYPE_FLAG_STATIC");
3208 if (TYPE_PROTOTYPED (type
))
3210 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3212 if (TYPE_INCOMPLETE (type
))
3214 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3216 if (TYPE_VARARGS (type
))
3218 puts_filtered (" TYPE_FLAG_VARARGS");
3220 /* This is used for things like AltiVec registers on ppc. Gcc emits
3221 an attribute for the array type, which tells whether or not we
3222 have a vector, instead of a regular array. */
3223 if (TYPE_VECTOR (type
))
3225 puts_filtered (" TYPE_FLAG_VECTOR");
3227 puts_filtered ("\n");
3228 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
3229 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
3230 puts_filtered ("\n");
3231 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
3233 printfi_filtered (spaces
+ 2,
3234 "[%d] bitpos %d bitsize %d type ",
3235 idx
, TYPE_FIELD_BITPOS (type
, idx
),
3236 TYPE_FIELD_BITSIZE (type
, idx
));
3237 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
3238 printf_filtered (" name '%s' (",
3239 TYPE_FIELD_NAME (type
, idx
) != NULL
3240 ? TYPE_FIELD_NAME (type
, idx
)
3242 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
3243 printf_filtered (")\n");
3244 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
3246 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
3249 printfi_filtered (spaces
, "vptr_basetype ");
3250 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
3251 puts_filtered ("\n");
3252 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
3254 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
3256 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
3257 switch (TYPE_CODE (type
))
3259 case TYPE_CODE_STRUCT
:
3260 printfi_filtered (spaces
, "cplus_stuff ");
3261 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
3262 puts_filtered ("\n");
3263 print_cplus_stuff (type
, spaces
);
3267 printfi_filtered (spaces
, "floatformat ");
3268 if (TYPE_FLOATFORMAT (type
) == NULL
3269 || TYPE_FLOATFORMAT (type
)->name
== NULL
)
3270 puts_filtered ("(null)");
3272 puts_filtered (TYPE_FLOATFORMAT (type
)->name
);
3273 puts_filtered ("\n");
3277 /* We have to pick one of the union types to be able print and test
3278 the value. Pick cplus_struct_type, even though we know it isn't
3279 any particular one. */
3280 printfi_filtered (spaces
, "type_specific ");
3281 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
3282 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
3284 printf_filtered (" (unknown data form)");
3286 printf_filtered ("\n");
3291 obstack_free (&dont_print_type_obstack
, NULL
);
3294 static void build_gdbtypes (void);
3296 build_gdbtypes (void)
3299 init_type (TYPE_CODE_VOID
, 1,
3301 "void", (struct objfile
*) NULL
);
3303 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3305 | (TARGET_CHAR_SIGNED
? 0 : TYPE_FLAG_UNSIGNED
)),
3306 "char", (struct objfile
*) NULL
);
3307 builtin_type_true_char
=
3308 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3310 "true character", (struct objfile
*) NULL
);
3311 builtin_type_signed_char
=
3312 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3314 "signed char", (struct objfile
*) NULL
);
3315 builtin_type_unsigned_char
=
3316 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3318 "unsigned char", (struct objfile
*) NULL
);
3319 builtin_type_short
=
3320 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
3322 "short", (struct objfile
*) NULL
);
3323 builtin_type_unsigned_short
=
3324 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
3326 "unsigned short", (struct objfile
*) NULL
);
3328 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3330 "int", (struct objfile
*) NULL
);
3331 builtin_type_unsigned_int
=
3332 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3334 "unsigned int", (struct objfile
*) NULL
);
3336 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
3338 "long", (struct objfile
*) NULL
);
3339 builtin_type_unsigned_long
=
3340 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
3342 "unsigned long", (struct objfile
*) NULL
);
3343 builtin_type_long_long
=
3344 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
3346 "long long", (struct objfile
*) NULL
);
3347 builtin_type_unsigned_long_long
=
3348 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
3350 "unsigned long long", (struct objfile
*) NULL
);
3351 builtin_type_float
=
3352 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
3354 "float", (struct objfile
*) NULL
);
3355 /* vinschen@redhat.com 2002-02-08:
3356 The below lines are disabled since they are doing the wrong
3357 thing for non-multiarch targets. They are setting the correct
3358 type of floats for the target but while on multiarch targets
3359 this is done everytime the architecture changes, it's done on
3360 non-multiarch targets only on startup, leaving the wrong values
3361 in even if the architecture changes (eg. from big-endian to
3364 TYPE_FLOATFORMAT (builtin_type_float
) = TARGET_FLOAT_FORMAT
;
3366 builtin_type_double
=
3367 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3369 "double", (struct objfile
*) NULL
);
3371 TYPE_FLOATFORMAT (builtin_type_double
) = TARGET_DOUBLE_FORMAT
;
3373 builtin_type_long_double
=
3374 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3376 "long double", (struct objfile
*) NULL
);
3378 TYPE_FLOATFORMAT (builtin_type_long_double
) = TARGET_LONG_DOUBLE_FORMAT
;
3380 builtin_type_complex
=
3381 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
3383 "complex", (struct objfile
*) NULL
);
3384 TYPE_TARGET_TYPE (builtin_type_complex
) = builtin_type_float
;
3385 builtin_type_double_complex
=
3386 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3388 "double complex", (struct objfile
*) NULL
);
3389 TYPE_TARGET_TYPE (builtin_type_double_complex
) = builtin_type_double
;
3390 builtin_type_string
=
3391 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3393 "string", (struct objfile
*) NULL
);
3395 init_type (TYPE_CODE_INT
, 8 / 8,
3397 "int8_t", (struct objfile
*) NULL
);
3398 builtin_type_uint8
=
3399 init_type (TYPE_CODE_INT
, 8 / 8,
3401 "uint8_t", (struct objfile
*) NULL
);
3402 builtin_type_int16
=
3403 init_type (TYPE_CODE_INT
, 16 / 8,
3405 "int16_t", (struct objfile
*) NULL
);
3406 builtin_type_uint16
=
3407 init_type (TYPE_CODE_INT
, 16 / 8,
3409 "uint16_t", (struct objfile
*) NULL
);
3410 builtin_type_int32
=
3411 init_type (TYPE_CODE_INT
, 32 / 8,
3413 "int32_t", (struct objfile
*) NULL
);
3414 builtin_type_uint32
=
3415 init_type (TYPE_CODE_INT
, 32 / 8,
3417 "uint32_t", (struct objfile
*) NULL
);
3418 builtin_type_int64
=
3419 init_type (TYPE_CODE_INT
, 64 / 8,
3421 "int64_t", (struct objfile
*) NULL
);
3422 builtin_type_uint64
=
3423 init_type (TYPE_CODE_INT
, 64 / 8,
3425 "uint64_t", (struct objfile
*) NULL
);
3426 builtin_type_int128
=
3427 init_type (TYPE_CODE_INT
, 128 / 8,
3429 "int128_t", (struct objfile
*) NULL
);
3430 builtin_type_uint128
=
3431 init_type (TYPE_CODE_INT
, 128 / 8,
3433 "uint128_t", (struct objfile
*) NULL
);
3435 init_type (TYPE_CODE_BOOL
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3437 "bool", (struct objfile
*) NULL
);
3439 /* Add user knob for controlling resolution of opaque types */
3441 (add_set_cmd ("opaque-type-resolution", class_support
, var_boolean
, (char *) &opaque_type_resolution
,
3442 "Set resolution of opaque struct/class/union types (if set before loading symbols).",
3445 opaque_type_resolution
= 1;
3447 /* Build SIMD types. */
3449 = init_simd_type ("__builtin_v4sf", builtin_type_float
, "f", 4);
3451 = init_simd_type ("__builtin_v4si", builtin_type_int32
, "f", 4);
3453 = init_simd_type ("__builtin_v16qi", builtin_type_int8
, "f", 16);
3455 = init_simd_type ("__builtin_v8qi", builtin_type_int8
, "f", 8);
3457 = init_simd_type ("__builtin_v8hi", builtin_type_int16
, "f", 8);
3459 = init_simd_type ("__builtin_v4hi", builtin_type_int16
, "f", 4);
3461 = init_simd_type ("__builtin_v2si", builtin_type_int32
, "f", 2);
3463 /* 128 bit vectors. */
3464 builtin_type_v2_double
= init_vector_type (builtin_type_double
, 2);
3465 builtin_type_v4_float
= init_vector_type (builtin_type_float
, 4);
3466 builtin_type_v2_int64
= init_vector_type (builtin_type_int64
, 2);
3467 builtin_type_v4_int32
= init_vector_type (builtin_type_int32
, 4);
3468 builtin_type_v8_int16
= init_vector_type (builtin_type_int16
, 8);
3469 builtin_type_v16_int8
= init_vector_type (builtin_type_int8
, 16);
3470 /* 64 bit vectors. */
3471 builtin_type_v2_float
= init_vector_type (builtin_type_float
, 2);
3472 builtin_type_v2_int32
= init_vector_type (builtin_type_int32
, 2);
3473 builtin_type_v4_int16
= init_vector_type (builtin_type_int16
, 4);
3474 builtin_type_v8_int8
= init_vector_type (builtin_type_int8
, 8);
3477 builtin_type_vec64
= build_builtin_type_vec64 ();
3478 builtin_type_vec64i
= build_builtin_type_vec64i ();
3479 builtin_type_vec128
= build_builtin_type_vec128 ();
3480 builtin_type_vec128i
= build_builtin_type_vec128i ();
3482 /* Pointer/Address types. */
3484 /* NOTE: on some targets, addresses and pointers are not necessarily
3485 the same --- for example, on the D10V, pointers are 16 bits long,
3486 but addresses are 32 bits long. See doc/gdbint.texinfo,
3487 ``Pointers Are Not Always Addresses''.
3490 - gdb's `struct type' always describes the target's
3492 - gdb's `struct value' objects should always hold values in
3494 - gdb's CORE_ADDR values are addresses in the unified virtual
3495 address space that the assembler and linker work with. Thus,
3496 since target_read_memory takes a CORE_ADDR as an argument, it
3497 can access any memory on the target, even if the processor has
3498 separate code and data address spaces.
3501 - If v is a value holding a D10V code pointer, its contents are
3502 in target form: a big-endian address left-shifted two bits.
3503 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3504 sizeof (void *) == 2 on the target.
3506 In this context, builtin_type_CORE_ADDR is a bit odd: it's a
3507 target type for a value the target will never see. It's only
3508 used to hold the values of (typeless) linker symbols, which are
3509 indeed in the unified virtual address space. */
3510 builtin_type_void_data_ptr
= make_pointer_type (builtin_type_void
, NULL
);
3511 builtin_type_void_func_ptr
3512 = lookup_pointer_type (lookup_function_type (builtin_type_void
));
3513 builtin_type_CORE_ADDR
=
3514 init_type (TYPE_CODE_INT
, TARGET_ADDR_BIT
/ 8,
3516 "__CORE_ADDR", (struct objfile
*) NULL
);
3517 builtin_type_bfd_vma
=
3518 init_type (TYPE_CODE_INT
, TARGET_BFD_VMA_BIT
/ 8,
3520 "__bfd_vma", (struct objfile
*) NULL
);
3523 extern void _initialize_gdbtypes (void);
3525 _initialize_gdbtypes (void)
3527 struct cmd_list_element
*c
;
3530 /* FIXME - For the moment, handle types by swapping them in and out.
3531 Should be using the per-architecture data-pointer and a large
3533 register_gdbarch_swap (&builtin_type_void
, sizeof (struct type
*), NULL
);
3534 register_gdbarch_swap (&builtin_type_char
, sizeof (struct type
*), NULL
);
3535 register_gdbarch_swap (&builtin_type_short
, sizeof (struct type
*), NULL
);
3536 register_gdbarch_swap (&builtin_type_int
, sizeof (struct type
*), NULL
);
3537 register_gdbarch_swap (&builtin_type_long
, sizeof (struct type
*), NULL
);
3538 register_gdbarch_swap (&builtin_type_long_long
, sizeof (struct type
*), NULL
);
3539 register_gdbarch_swap (&builtin_type_signed_char
, sizeof (struct type
*), NULL
);
3540 register_gdbarch_swap (&builtin_type_unsigned_char
, sizeof (struct type
*), NULL
);
3541 register_gdbarch_swap (&builtin_type_unsigned_short
, sizeof (struct type
*), NULL
);
3542 register_gdbarch_swap (&builtin_type_unsigned_int
, sizeof (struct type
*), NULL
);
3543 register_gdbarch_swap (&builtin_type_unsigned_long
, sizeof (struct type
*), NULL
);
3544 register_gdbarch_swap (&builtin_type_unsigned_long_long
, sizeof (struct type
*), NULL
);
3545 register_gdbarch_swap (&builtin_type_float
, sizeof (struct type
*), NULL
);
3546 register_gdbarch_swap (&builtin_type_double
, sizeof (struct type
*), NULL
);
3547 register_gdbarch_swap (&builtin_type_long_double
, sizeof (struct type
*), NULL
);
3548 register_gdbarch_swap (&builtin_type_complex
, sizeof (struct type
*), NULL
);
3549 register_gdbarch_swap (&builtin_type_double_complex
, sizeof (struct type
*), NULL
);
3550 register_gdbarch_swap (&builtin_type_string
, sizeof (struct type
*), NULL
);
3551 register_gdbarch_swap (&builtin_type_int8
, sizeof (struct type
*), NULL
);
3552 register_gdbarch_swap (&builtin_type_uint8
, sizeof (struct type
*), NULL
);
3553 register_gdbarch_swap (&builtin_type_int16
, sizeof (struct type
*), NULL
);
3554 register_gdbarch_swap (&builtin_type_uint16
, sizeof (struct type
*), NULL
);
3555 register_gdbarch_swap (&builtin_type_int32
, sizeof (struct type
*), NULL
);
3556 register_gdbarch_swap (&builtin_type_uint32
, sizeof (struct type
*), NULL
);
3557 register_gdbarch_swap (&builtin_type_int64
, sizeof (struct type
*), NULL
);
3558 register_gdbarch_swap (&builtin_type_uint64
, sizeof (struct type
*), NULL
);
3559 register_gdbarch_swap (&builtin_type_int128
, sizeof (struct type
*), NULL
);
3560 register_gdbarch_swap (&builtin_type_uint128
, sizeof (struct type
*), NULL
);
3561 register_gdbarch_swap (&builtin_type_v4sf
, sizeof (struct type
*), NULL
);
3562 register_gdbarch_swap (&builtin_type_v4si
, sizeof (struct type
*), NULL
);
3563 register_gdbarch_swap (&builtin_type_v16qi
, sizeof (struct type
*), NULL
);
3564 register_gdbarch_swap (&builtin_type_v8qi
, sizeof (struct type
*), NULL
);
3565 register_gdbarch_swap (&builtin_type_v8hi
, sizeof (struct type
*), NULL
);
3566 register_gdbarch_swap (&builtin_type_v4hi
, sizeof (struct type
*), NULL
);
3567 register_gdbarch_swap (&builtin_type_v2si
, sizeof (struct type
*), NULL
);
3568 register_gdbarch_swap (&builtin_type_v2_double
, sizeof (struct type
*), NULL
);
3569 register_gdbarch_swap (&builtin_type_v4_float
, sizeof (struct type
*), NULL
);
3570 register_gdbarch_swap (&builtin_type_v2_int64
, sizeof (struct type
*), NULL
);
3571 register_gdbarch_swap (&builtin_type_v4_int32
, sizeof (struct type
*), NULL
);
3572 register_gdbarch_swap (&builtin_type_v8_int16
, sizeof (struct type
*), NULL
);
3573 register_gdbarch_swap (&builtin_type_v16_int8
, sizeof (struct type
*), NULL
);
3574 register_gdbarch_swap (&builtin_type_v2_float
, sizeof (struct type
*), NULL
);
3575 register_gdbarch_swap (&builtin_type_v2_int32
, sizeof (struct type
*), NULL
);
3576 register_gdbarch_swap (&builtin_type_v8_int8
, sizeof (struct type
*), NULL
);
3577 register_gdbarch_swap (&builtin_type_v4_int16
, sizeof (struct type
*), NULL
);
3578 register_gdbarch_swap (&builtin_type_vec128
, sizeof (struct type
*), NULL
);
3579 register_gdbarch_swap (&builtin_type_vec128i
, sizeof (struct type
*), NULL
);
3580 REGISTER_GDBARCH_SWAP (builtin_type_void_data_ptr
);
3581 REGISTER_GDBARCH_SWAP (builtin_type_void_func_ptr
);
3582 REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR
);
3583 REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma
);
3584 register_gdbarch_swap (NULL
, 0, build_gdbtypes
);
3586 /* Note: These types do not need to be swapped - they are target
3588 builtin_type_ieee_single_big
=
3589 init_type (TYPE_CODE_FLT
, floatformat_ieee_single_big
.totalsize
/ 8,
3590 0, "builtin_type_ieee_single_big", NULL
);
3591 TYPE_FLOATFORMAT (builtin_type_ieee_single_big
) = &floatformat_ieee_single_big
;
3592 builtin_type_ieee_single_little
=
3593 init_type (TYPE_CODE_FLT
, floatformat_ieee_single_little
.totalsize
/ 8,
3594 0, "builtin_type_ieee_single_little", NULL
);
3595 TYPE_FLOATFORMAT (builtin_type_ieee_single_little
) = &floatformat_ieee_single_little
;
3596 builtin_type_ieee_double_big
=
3597 init_type (TYPE_CODE_FLT
, floatformat_ieee_double_big
.totalsize
/ 8,
3598 0, "builtin_type_ieee_double_big", NULL
);
3599 TYPE_FLOATFORMAT (builtin_type_ieee_double_big
) = &floatformat_ieee_double_big
;
3600 builtin_type_ieee_double_little
=
3601 init_type (TYPE_CODE_FLT
, floatformat_ieee_double_little
.totalsize
/ 8,
3602 0, "builtin_type_ieee_double_little", NULL
);
3603 TYPE_FLOATFORMAT (builtin_type_ieee_double_little
) = &floatformat_ieee_double_little
;
3604 builtin_type_ieee_double_littlebyte_bigword
=
3605 init_type (TYPE_CODE_FLT
, floatformat_ieee_double_littlebyte_bigword
.totalsize
/ 8,
3606 0, "builtin_type_ieee_double_littlebyte_bigword", NULL
);
3607 TYPE_FLOATFORMAT (builtin_type_ieee_double_littlebyte_bigword
) = &floatformat_ieee_double_littlebyte_bigword
;
3608 builtin_type_i387_ext
=
3609 init_type (TYPE_CODE_FLT
, floatformat_i387_ext
.totalsize
/ 8,
3610 0, "builtin_type_i387_ext", NULL
);
3611 TYPE_FLOATFORMAT (builtin_type_i387_ext
) = &floatformat_i387_ext
;
3612 builtin_type_m68881_ext
=
3613 init_type (TYPE_CODE_FLT
, floatformat_m68881_ext
.totalsize
/ 8,
3614 0, "builtin_type_m68881_ext", NULL
);
3615 TYPE_FLOATFORMAT (builtin_type_m68881_ext
) = &floatformat_m68881_ext
;
3616 builtin_type_i960_ext
=
3617 init_type (TYPE_CODE_FLT
, floatformat_i960_ext
.totalsize
/ 8,
3618 0, "builtin_type_i960_ext", NULL
);
3619 TYPE_FLOATFORMAT (builtin_type_i960_ext
) = &floatformat_i960_ext
;
3620 builtin_type_m88110_ext
=
3621 init_type (TYPE_CODE_FLT
, floatformat_m88110_ext
.totalsize
/ 8,
3622 0, "builtin_type_m88110_ext", NULL
);
3623 TYPE_FLOATFORMAT (builtin_type_m88110_ext
) = &floatformat_m88110_ext
;
3624 builtin_type_m88110_harris_ext
=
3625 init_type (TYPE_CODE_FLT
, floatformat_m88110_harris_ext
.totalsize
/ 8,
3626 0, "builtin_type_m88110_harris_ext", NULL
);
3627 TYPE_FLOATFORMAT (builtin_type_m88110_harris_ext
) = &floatformat_m88110_harris_ext
;
3628 builtin_type_arm_ext_big
=
3629 init_type (TYPE_CODE_FLT
, floatformat_arm_ext_big
.totalsize
/ 8,
3630 0, "builtin_type_arm_ext_big", NULL
);
3631 TYPE_FLOATFORMAT (builtin_type_arm_ext_big
) = &floatformat_arm_ext_big
;
3632 builtin_type_arm_ext_littlebyte_bigword
=
3633 init_type (TYPE_CODE_FLT
, floatformat_arm_ext_littlebyte_bigword
.totalsize
/ 8,
3634 0, "builtin_type_arm_ext_littlebyte_bigword", NULL
);
3635 TYPE_FLOATFORMAT (builtin_type_arm_ext_littlebyte_bigword
) = &floatformat_arm_ext_littlebyte_bigword
;
3636 builtin_type_ia64_spill_big
=
3637 init_type (TYPE_CODE_FLT
, floatformat_ia64_spill_big
.totalsize
/ 8,
3638 0, "builtin_type_ia64_spill_big", NULL
);
3639 TYPE_FLOATFORMAT (builtin_type_ia64_spill_big
) = &floatformat_ia64_spill_big
;
3640 builtin_type_ia64_spill_little
=
3641 init_type (TYPE_CODE_FLT
, floatformat_ia64_spill_little
.totalsize
/ 8,
3642 0, "builtin_type_ia64_spill_little", NULL
);
3643 TYPE_FLOATFORMAT (builtin_type_ia64_spill_little
) = &floatformat_ia64_spill_little
;
3644 builtin_type_ia64_quad_big
=
3645 init_type (TYPE_CODE_FLT
, floatformat_ia64_quad_big
.totalsize
/ 8,
3646 0, "builtin_type_ia64_quad_big", NULL
);
3647 TYPE_FLOATFORMAT (builtin_type_ia64_quad_big
) = &floatformat_ia64_quad_big
;
3648 builtin_type_ia64_quad_little
=
3649 init_type (TYPE_CODE_FLT
, floatformat_ia64_quad_little
.totalsize
/ 8,
3650 0, "builtin_type_ia64_quad_little", NULL
);
3651 TYPE_FLOATFORMAT (builtin_type_ia64_quad_little
) = &floatformat_ia64_quad_little
;
3654 add_set_cmd ("overload", no_class
, var_zinteger
, (char *) &overload_debug
,
3655 "Set debugging of C++ overloading.\n\
3656 When enabled, ranking of the functions\n\
3657 is displayed.", &setdebuglist
),