1 /* Support routines for manipulating internal types for GDB.
2 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
4 Contributed by Cygnus Support, using pieces from other GDB modules.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 #include "gdb_string.h"
30 #include "expression.h"
35 #include "complaints.h"
39 #include "gdb_assert.h"
41 /* These variables point to the objects
42 representing the predefined C data types. */
44 struct type
*builtin_type_void
;
45 struct type
*builtin_type_char
;
46 struct type
*builtin_type_true_char
;
47 struct type
*builtin_type_short
;
48 struct type
*builtin_type_int
;
49 struct type
*builtin_type_long
;
50 struct type
*builtin_type_long_long
;
51 struct type
*builtin_type_signed_char
;
52 struct type
*builtin_type_unsigned_char
;
53 struct type
*builtin_type_unsigned_short
;
54 struct type
*builtin_type_unsigned_int
;
55 struct type
*builtin_type_unsigned_long
;
56 struct type
*builtin_type_unsigned_long_long
;
57 struct type
*builtin_type_float
;
58 struct type
*builtin_type_double
;
59 struct type
*builtin_type_long_double
;
60 struct type
*builtin_type_complex
;
61 struct type
*builtin_type_double_complex
;
62 struct type
*builtin_type_string
;
63 struct type
*builtin_type_int8
;
64 struct type
*builtin_type_uint8
;
65 struct type
*builtin_type_int16
;
66 struct type
*builtin_type_uint16
;
67 struct type
*builtin_type_int32
;
68 struct type
*builtin_type_uint32
;
69 struct type
*builtin_type_int64
;
70 struct type
*builtin_type_uint64
;
71 struct type
*builtin_type_int128
;
72 struct type
*builtin_type_uint128
;
73 struct type
*builtin_type_bool
;
75 /* 128 bit long vector types */
76 struct type
*builtin_type_v2_double
;
77 struct type
*builtin_type_v4_float
;
78 struct type
*builtin_type_v2_int64
;
79 struct type
*builtin_type_v4_int32
;
80 struct type
*builtin_type_v8_int16
;
81 struct type
*builtin_type_v16_int8
;
82 /* 64 bit long vector types */
83 struct type
*builtin_type_v2_float
;
84 struct type
*builtin_type_v2_int32
;
85 struct type
*builtin_type_v4_int16
;
86 struct type
*builtin_type_v8_int8
;
88 struct type
*builtin_type_v4sf
;
89 struct type
*builtin_type_v4si
;
90 struct type
*builtin_type_v16qi
;
91 struct type
*builtin_type_v8qi
;
92 struct type
*builtin_type_v8hi
;
93 struct type
*builtin_type_v4hi
;
94 struct type
*builtin_type_v2si
;
95 struct type
*builtin_type_vec64
;
96 struct type
*builtin_type_vec64i
;
97 struct type
*builtin_type_vec128
;
98 struct type
*builtin_type_vec128i
;
99 struct type
*builtin_type_ieee_single_big
;
100 struct type
*builtin_type_ieee_single_little
;
101 struct type
*builtin_type_ieee_double_big
;
102 struct type
*builtin_type_ieee_double_little
;
103 struct type
*builtin_type_ieee_double_littlebyte_bigword
;
104 struct type
*builtin_type_i387_ext
;
105 struct type
*builtin_type_m68881_ext
;
106 struct type
*builtin_type_i960_ext
;
107 struct type
*builtin_type_m88110_ext
;
108 struct type
*builtin_type_m88110_harris_ext
;
109 struct type
*builtin_type_arm_ext_big
;
110 struct type
*builtin_type_arm_ext_littlebyte_bigword
;
111 struct type
*builtin_type_ia64_spill_big
;
112 struct type
*builtin_type_ia64_spill_little
;
113 struct type
*builtin_type_ia64_quad_big
;
114 struct type
*builtin_type_ia64_quad_little
;
115 struct type
*builtin_type_void_data_ptr
;
116 struct type
*builtin_type_void_func_ptr
;
117 struct type
*builtin_type_CORE_ADDR
;
118 struct type
*builtin_type_bfd_vma
;
120 int opaque_type_resolution
= 1;
121 int overload_debug
= 0;
127 }; /* maximum extension is 128! FIXME */
129 static void add_name (struct extra
*, char *);
130 static void add_mangled_type (struct extra
*, struct type
*);
132 static void cfront_mangle_name (struct type
*, int, int);
134 static void print_bit_vector (B_TYPE
*, int);
135 static void print_arg_types (struct field
*, int, int);
136 static void dump_fn_fieldlists (struct type
*, int);
137 static void print_cplus_stuff (struct type
*, int);
138 static void virtual_base_list_aux (struct type
*dclass
);
141 /* Alloc a new type structure and fill it with some defaults. If
142 OBJFILE is non-NULL, then allocate the space for the type structure
143 in that objfile's type_obstack. Otherwise allocate the new type structure
144 by xmalloc () (for permanent types). */
147 alloc_type (struct objfile
*objfile
)
149 register struct type
*type
;
151 /* Alloc the structure and start off with all fields zeroed. */
155 type
= xmalloc (sizeof (struct type
));
156 memset (type
, 0, sizeof (struct type
));
157 TYPE_MAIN_TYPE (type
) = xmalloc (sizeof (struct main_type
));
161 type
= obstack_alloc (&objfile
->type_obstack
,
162 sizeof (struct type
));
163 memset (type
, 0, sizeof (struct type
));
164 TYPE_MAIN_TYPE (type
) = obstack_alloc (&objfile
->type_obstack
,
165 sizeof (struct main_type
));
166 OBJSTAT (objfile
, n_types
++);
168 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
170 /* Initialize the fields that might not be zero. */
172 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
173 TYPE_OBJFILE (type
) = objfile
;
174 TYPE_VPTR_FIELDNO (type
) = -1;
175 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
180 /* Alloc a new type instance structure, fill it with some defaults,
181 and point it at OLDTYPE. Allocate the new type instance from the
182 same place as OLDTYPE. */
185 alloc_type_instance (struct type
*oldtype
)
189 /* Allocate the structure. */
191 if (TYPE_OBJFILE (oldtype
) == NULL
)
193 type
= xmalloc (sizeof (struct type
));
194 memset (type
, 0, sizeof (struct type
));
198 type
= obstack_alloc (&TYPE_OBJFILE (oldtype
)->type_obstack
,
199 sizeof (struct type
));
200 memset (type
, 0, sizeof (struct type
));
202 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
204 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
209 /* Clear all remnants of the previous type at TYPE, in preparation for
210 replacing it with something else. */
212 smash_type (struct type
*type
)
214 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
216 /* For now, delete the rings. */
217 TYPE_CHAIN (type
) = type
;
219 /* For now, leave the pointer/reference types alone. */
222 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
223 to a pointer to memory where the pointer type should be stored.
224 If *TYPEPTR is zero, update it to point to the pointer type we return.
225 We allocate new memory if needed. */
228 make_pointer_type (struct type
*type
, struct type
**typeptr
)
230 register struct type
*ntype
; /* New type */
231 struct objfile
*objfile
;
233 ntype
= TYPE_POINTER_TYPE (type
);
238 return ntype
; /* Don't care about alloc, and have new type. */
239 else if (*typeptr
== 0)
241 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
246 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
248 ntype
= alloc_type (TYPE_OBJFILE (type
));
253 /* We have storage, but need to reset it. */
256 objfile
= TYPE_OBJFILE (ntype
);
258 TYPE_OBJFILE (ntype
) = objfile
;
261 TYPE_TARGET_TYPE (ntype
) = type
;
262 TYPE_POINTER_TYPE (type
) = ntype
;
264 /* FIXME! Assume the machine has only one representation for pointers! */
266 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
267 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
269 /* Mark pointers as unsigned. The target converts between pointers
270 and addresses (CORE_ADDRs) using POINTER_TO_ADDRESS() and
271 ADDRESS_TO_POINTER(). */
272 TYPE_FLAGS (ntype
) |= TYPE_FLAG_UNSIGNED
;
274 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
275 TYPE_POINTER_TYPE (type
) = ntype
;
280 /* Given a type TYPE, return a type of pointers to that type.
281 May need to construct such a type if this is the first use. */
284 lookup_pointer_type (struct type
*type
)
286 return make_pointer_type (type
, (struct type
**) 0);
289 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero, points
290 to a pointer to memory where the reference type should be stored.
291 If *TYPEPTR is zero, update it to point to the reference type we return.
292 We allocate new memory if needed. */
295 make_reference_type (struct type
*type
, struct type
**typeptr
)
297 register struct type
*ntype
; /* New type */
298 struct objfile
*objfile
;
300 ntype
= TYPE_REFERENCE_TYPE (type
);
305 return ntype
; /* Don't care about alloc, and have new type. */
306 else if (*typeptr
== 0)
308 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
313 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
315 ntype
= alloc_type (TYPE_OBJFILE (type
));
320 /* We have storage, but need to reset it. */
323 objfile
= TYPE_OBJFILE (ntype
);
325 TYPE_OBJFILE (ntype
) = objfile
;
328 TYPE_TARGET_TYPE (ntype
) = type
;
329 TYPE_REFERENCE_TYPE (type
) = ntype
;
331 /* FIXME! Assume the machine has only one representation for references,
332 and that it matches the (only) representation for pointers! */
334 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
335 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
337 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
338 TYPE_REFERENCE_TYPE (type
) = ntype
;
343 /* Same as above, but caller doesn't care about memory allocation details. */
346 lookup_reference_type (struct type
*type
)
348 return make_reference_type (type
, (struct type
**) 0);
351 /* Lookup a function type that returns type TYPE. TYPEPTR, if nonzero, points
352 to a pointer to memory where the function type should be stored.
353 If *TYPEPTR is zero, update it to point to the function type we return.
354 We allocate new memory if needed. */
357 make_function_type (struct type
*type
, struct type
**typeptr
)
359 register struct type
*ntype
; /* New type */
360 struct objfile
*objfile
;
362 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
364 ntype
= alloc_type (TYPE_OBJFILE (type
));
369 /* We have storage, but need to reset it. */
372 objfile
= TYPE_OBJFILE (ntype
);
374 TYPE_OBJFILE (ntype
) = objfile
;
377 TYPE_TARGET_TYPE (ntype
) = type
;
379 TYPE_LENGTH (ntype
) = 1;
380 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
386 /* Given a type TYPE, return a type of functions that return that type.
387 May need to construct such a type if this is the first use. */
390 lookup_function_type (struct type
*type
)
392 return make_function_type (type
, (struct type
**) 0);
395 /* Identify address space identifier by name --
396 return the integer flag defined in gdbtypes.h. */
398 address_space_name_to_int (char *space_identifier
)
400 /* Check for known address space delimiters. */
401 if (!strcmp (space_identifier
, "code"))
402 return TYPE_FLAG_CODE_SPACE
;
403 else if (!strcmp (space_identifier
, "data"))
404 return TYPE_FLAG_DATA_SPACE
;
406 error ("Unknown address space specifier: \"%s\"", space_identifier
);
409 /* Identify address space identifier by integer flag as defined in
410 gdbtypes.h -- return the string version of the adress space name. */
413 address_space_int_to_name (int space_flag
)
415 if (space_flag
& TYPE_FLAG_CODE_SPACE
)
417 else if (space_flag
& TYPE_FLAG_DATA_SPACE
)
423 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
424 If STORAGE is non-NULL, create the new type instance there. */
427 make_qualified_type (struct type
*type
, int new_flags
,
428 struct type
*storage
)
434 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
436 ntype
= TYPE_CHAIN (ntype
);
437 } while (ntype
!= type
);
439 /* Create a new type instance. */
441 ntype
= alloc_type_instance (type
);
445 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
446 TYPE_CHAIN (ntype
) = ntype
;
449 /* Pointers or references to the original type are not relevant to
451 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
452 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
454 /* Chain the new qualified type to the old type. */
455 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
456 TYPE_CHAIN (type
) = ntype
;
458 /* Now set the instance flags and return the new type. */
459 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
464 /* Make an address-space-delimited variant of a type -- a type that
465 is identical to the one supplied except that it has an address
466 space attribute attached to it (such as "code" or "data").
468 This is for Harvard architectures. */
471 make_type_with_address_space (struct type
*type
, int space_flag
)
474 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
475 & ~(TYPE_FLAG_CODE_SPACE
| TYPE_FLAG_DATA_SPACE
))
478 return make_qualified_type (type
, new_flags
, NULL
);
481 /* Make a "c-v" variant of a type -- a type that is identical to the
482 one supplied except that it may have const or volatile attributes
483 CNST is a flag for setting the const attribute
484 VOLTL is a flag for setting the volatile attribute
485 TYPE is the base type whose variant we are creating.
486 TYPEPTR, if nonzero, points
487 to a pointer to memory where the reference type should be stored.
488 If *TYPEPTR is zero, update it to point to the reference type we return.
489 We allocate new memory if needed. */
492 make_cv_type (int cnst
, int voltl
, struct type
*type
, struct type
**typeptr
)
494 register struct type
*ntype
; /* New type */
495 register struct type
*tmp_type
= type
; /* tmp type */
496 struct objfile
*objfile
;
498 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
499 & ~(TYPE_FLAG_CONST
| TYPE_FLAG_VOLATILE
));
502 new_flags
|= TYPE_FLAG_CONST
;
505 new_flags
|= TYPE_FLAG_VOLATILE
;
507 if (typeptr
&& *typeptr
!= NULL
)
509 /* Objfile is per-core-type. This const-qualified type had best
510 belong to the same objfile as the type it is qualifying, unless
511 we are overwriting a stub type, in which case the safest thing
512 to do is to copy the core type into the new objfile. */
514 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
)
515 || TYPE_STUB (*typeptr
));
516 if (TYPE_OBJFILE (*typeptr
) != TYPE_OBJFILE (type
))
518 TYPE_MAIN_TYPE (*typeptr
)
519 = TYPE_ALLOC (*typeptr
, sizeof (struct main_type
));
520 *TYPE_MAIN_TYPE (*typeptr
)
521 = *TYPE_MAIN_TYPE (type
);
525 ntype
= make_qualified_type (type
, new_flags
, typeptr
? *typeptr
: NULL
);
533 /* Replace the contents of ntype with the type *type. This changes the
534 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
535 the changes are propogated to all types in the TYPE_CHAIN.
537 In order to build recursive types, it's inevitable that we'll need
538 to update types in place --- but this sort of indiscriminate
539 smashing is ugly, and needs to be replaced with something more
540 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
541 clear if more steps are needed. */
543 replace_type (struct type
*ntype
, struct type
*type
)
545 struct type
*cv_chain
, *as_chain
, *ptr
, *ref
;
547 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
549 /* Assert that the two types have equivalent instance qualifiers.
550 This should be true for at least all of our debug readers. */
551 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
554 /* Implement direct support for MEMBER_TYPE in GNU C++.
555 May need to construct such a type if this is the first use.
556 The TYPE is the type of the member. The DOMAIN is the type
557 of the aggregate that the member belongs to. */
560 lookup_member_type (struct type
*type
, struct type
*domain
)
562 register struct type
*mtype
;
564 mtype
= alloc_type (TYPE_OBJFILE (type
));
565 smash_to_member_type (mtype
, domain
, type
);
569 /* Allocate a stub method whose return type is TYPE.
570 This apparently happens for speed of symbol reading, since parsing
571 out the arguments to the method is cpu-intensive, the way we are doing
572 it. So, we will fill in arguments later.
573 This always returns a fresh type. */
576 allocate_stub_method (struct type
*type
)
580 mtype
= init_type (TYPE_CODE_METHOD
, 1, TYPE_FLAG_STUB
, NULL
,
581 TYPE_OBJFILE (type
));
582 TYPE_TARGET_TYPE (mtype
) = type
;
583 /* _DOMAIN_TYPE (mtype) = unknown yet */
587 /* Create a range type using either a blank type supplied in RESULT_TYPE,
588 or creating a new type, inheriting the objfile from INDEX_TYPE.
590 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
591 HIGH_BOUND, inclusive.
593 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
594 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
597 create_range_type (struct type
*result_type
, struct type
*index_type
,
598 int low_bound
, int high_bound
)
600 if (result_type
== NULL
)
602 result_type
= alloc_type (TYPE_OBJFILE (index_type
));
604 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
605 TYPE_TARGET_TYPE (result_type
) = index_type
;
606 if (TYPE_STUB (index_type
))
607 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
609 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
610 TYPE_NFIELDS (result_type
) = 2;
611 TYPE_FIELDS (result_type
) = (struct field
*)
612 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
613 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
614 TYPE_FIELD_BITPOS (result_type
, 0) = low_bound
;
615 TYPE_FIELD_BITPOS (result_type
, 1) = high_bound
;
616 TYPE_FIELD_TYPE (result_type
, 0) = builtin_type_int
; /* FIXME */
617 TYPE_FIELD_TYPE (result_type
, 1) = builtin_type_int
; /* FIXME */
620 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
622 return (result_type
);
625 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE.
626 Return 1 of type is a range type, 0 if it is discrete (and bounds
627 will fit in LONGEST), or -1 otherwise. */
630 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
632 CHECK_TYPEDEF (type
);
633 switch (TYPE_CODE (type
))
635 case TYPE_CODE_RANGE
:
636 *lowp
= TYPE_LOW_BOUND (type
);
637 *highp
= TYPE_HIGH_BOUND (type
);
640 if (TYPE_NFIELDS (type
) > 0)
642 /* The enums may not be sorted by value, so search all
646 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
647 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
649 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
650 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
651 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
652 *highp
= TYPE_FIELD_BITPOS (type
, i
);
655 /* Set unsigned indicator if warranted. */
658 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
672 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
674 if (!TYPE_UNSIGNED (type
))
676 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
680 /* ... fall through for unsigned ints ... */
683 /* This round-about calculation is to avoid shifting by
684 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
685 if TYPE_LENGTH (type) == sizeof (LONGEST). */
686 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
687 *highp
= (*highp
- 1) | *highp
;
694 /* Create an array type using either a blank type supplied in RESULT_TYPE,
695 or creating a new type, inheriting the objfile from RANGE_TYPE.
697 Elements will be of type ELEMENT_TYPE, the indices will be of type
700 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
701 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
704 create_array_type (struct type
*result_type
, struct type
*element_type
,
705 struct type
*range_type
)
707 LONGEST low_bound
, high_bound
;
709 if (result_type
== NULL
)
711 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
713 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
714 TYPE_TARGET_TYPE (result_type
) = element_type
;
715 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
716 low_bound
= high_bound
= 0;
717 CHECK_TYPEDEF (element_type
);
718 TYPE_LENGTH (result_type
) =
719 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
720 TYPE_NFIELDS (result_type
) = 1;
721 TYPE_FIELDS (result_type
) =
722 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
723 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
724 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
725 TYPE_VPTR_FIELDNO (result_type
) = -1;
727 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
728 if (TYPE_LENGTH (result_type
) == 0)
729 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
731 return (result_type
);
734 /* Create a string type using either a blank type supplied in RESULT_TYPE,
735 or creating a new type. String types are similar enough to array of
736 char types that we can use create_array_type to build the basic type
737 and then bash it into a string type.
739 For fixed length strings, the range type contains 0 as the lower
740 bound and the length of the string minus one as the upper bound.
742 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
743 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
746 create_string_type (struct type
*result_type
, struct type
*range_type
)
748 result_type
= create_array_type (result_type
,
749 *current_language
->string_char_type
,
751 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
752 return (result_type
);
756 create_set_type (struct type
*result_type
, struct type
*domain_type
)
758 LONGEST low_bound
, high_bound
, bit_length
;
759 if (result_type
== NULL
)
761 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
763 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
764 TYPE_NFIELDS (result_type
) = 1;
765 TYPE_FIELDS (result_type
) = (struct field
*)
766 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
767 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
769 if (!TYPE_STUB (domain_type
))
771 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
772 low_bound
= high_bound
= 0;
773 bit_length
= high_bound
- low_bound
+ 1;
774 TYPE_LENGTH (result_type
)
775 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
777 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
780 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
782 return (result_type
);
785 /* Construct and return a type of the form:
786 struct NAME { ELT_TYPE ELT_NAME[N]; }
787 We use these types for SIMD registers. For example, the type of
788 the SSE registers on the late x86-family processors is:
789 struct __builtin_v4sf { float f[4]; }
790 built by the function call:
791 init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4)
792 The type returned is a permanent type, allocated using malloc; it
793 doesn't live in any objfile's obstack. */
795 init_simd_type (char *name
,
796 struct type
*elt_type
,
800 struct type
*simd_type
;
801 struct type
*array_type
;
803 simd_type
= init_composite_type (name
, TYPE_CODE_STRUCT
);
804 array_type
= create_array_type (0, elt_type
,
805 create_range_type (0, builtin_type_int
,
807 append_composite_type_field (simd_type
, elt_name
, array_type
);
812 init_vector_type (struct type
*elt_type
, int n
)
814 struct type
*array_type
;
816 array_type
= create_array_type (0, elt_type
,
817 create_range_type (0, builtin_type_int
,
819 TYPE_FLAGS (array_type
) |= TYPE_FLAG_VECTOR
;
824 build_builtin_type_vec64 (void)
826 /* Construct a type for the 64 bit registers. The type we're
829 union __gdb_builtin_type_vec64
841 t
= init_composite_type ("__gdb_builtin_type_vec64", TYPE_CODE_UNION
);
842 append_composite_type_field (t
, "uint64", builtin_type_int64
);
843 append_composite_type_field (t
, "v2_float", builtin_type_v2_float
);
844 append_composite_type_field (t
, "v2_int32", builtin_type_v2_int32
);
845 append_composite_type_field (t
, "v4_int16", builtin_type_v4_int16
);
846 append_composite_type_field (t
, "v8_int8", builtin_type_v8_int8
);
848 TYPE_FLAGS (t
) |= TYPE_FLAG_VECTOR
;
849 TYPE_NAME (t
) = "builtin_type_vec64";
854 build_builtin_type_vec64i (void)
856 /* Construct a type for the 64 bit registers. The type we're
859 union __gdb_builtin_type_vec64i
870 t
= init_composite_type ("__gdb_builtin_type_vec64i", TYPE_CODE_UNION
);
871 append_composite_type_field (t
, "uint64", builtin_type_int64
);
872 append_composite_type_field (t
, "v2_int32", builtin_type_v2_int32
);
873 append_composite_type_field (t
, "v4_int16", builtin_type_v4_int16
);
874 append_composite_type_field (t
, "v8_int8", builtin_type_v8_int8
);
876 TYPE_FLAGS (t
) |= TYPE_FLAG_VECTOR
;
877 TYPE_NAME (t
) = "builtin_type_vec64i";
882 build_builtin_type_vec128 (void)
884 /* Construct a type for the 128 bit registers. The type we're
887 union __gdb_builtin_type_vec128
899 t
= init_composite_type ("__gdb_builtin_type_vec128", TYPE_CODE_UNION
);
900 append_composite_type_field (t
, "uint128", builtin_type_int128
);
901 append_composite_type_field (t
, "v4_float", builtin_type_v4_float
);
902 append_composite_type_field (t
, "v4_int32", builtin_type_v4_int32
);
903 append_composite_type_field (t
, "v8_int16", builtin_type_v8_int16
);
904 append_composite_type_field (t
, "v16_int8", builtin_type_v16_int8
);
906 TYPE_FLAGS (t
) |= TYPE_FLAG_VECTOR
;
907 TYPE_NAME (t
) = "builtin_type_vec128";
912 build_builtin_type_vec128i (void)
914 /* 128-bit Intel SIMD registers */
917 t
= init_composite_type ("__gdb_builtin_type_vec128i", TYPE_CODE_UNION
);
918 append_composite_type_field (t
, "v4_float", builtin_type_v4_float
);
919 append_composite_type_field (t
, "v2_double", builtin_type_v2_double
);
920 append_composite_type_field (t
, "v16_int8", builtin_type_v16_int8
);
921 append_composite_type_field (t
, "v8_int16", builtin_type_v8_int16
);
922 append_composite_type_field (t
, "v4_int32", builtin_type_v4_int32
);
923 append_composite_type_field (t
, "v2_int64", builtin_type_v2_int64
);
924 append_composite_type_field (t
, "uint128", builtin_type_int128
);
926 TYPE_FLAGS (t
) |= TYPE_FLAG_VECTOR
;
927 TYPE_NAME (t
) = "builtin_type_vec128i";
931 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
932 A MEMBER is a wierd thing -- it amounts to a typed offset into
933 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
934 include the offset (that's the value of the MEMBER itself), but does
935 include the structure type into which it points (for some reason).
937 When "smashing" the type, we preserve the objfile that the
938 old type pointed to, since we aren't changing where the type is actually
942 smash_to_member_type (struct type
*type
, struct type
*domain
,
943 struct type
*to_type
)
945 struct objfile
*objfile
;
947 objfile
= TYPE_OBJFILE (type
);
950 TYPE_OBJFILE (type
) = objfile
;
951 TYPE_TARGET_TYPE (type
) = to_type
;
952 TYPE_DOMAIN_TYPE (type
) = domain
;
953 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
954 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
957 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
958 METHOD just means `function that gets an extra "this" argument'.
960 When "smashing" the type, we preserve the objfile that the
961 old type pointed to, since we aren't changing where the type is actually
965 smash_to_method_type (struct type
*type
, struct type
*domain
,
966 struct type
*to_type
, struct field
*args
,
967 int nargs
, int varargs
)
969 struct objfile
*objfile
;
971 objfile
= TYPE_OBJFILE (type
);
974 TYPE_OBJFILE (type
) = objfile
;
975 TYPE_TARGET_TYPE (type
) = to_type
;
976 TYPE_DOMAIN_TYPE (type
) = domain
;
977 TYPE_FIELDS (type
) = args
;
978 TYPE_NFIELDS (type
) = nargs
;
980 TYPE_FLAGS (type
) |= TYPE_FLAG_VARARGS
;
981 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
982 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
985 /* Return a typename for a struct/union/enum type without "struct ",
986 "union ", or "enum ". If the type has a NULL name, return NULL. */
989 type_name_no_tag (register const struct type
*type
)
991 if (TYPE_TAG_NAME (type
) != NULL
)
992 return TYPE_TAG_NAME (type
);
994 /* Is there code which expects this to return the name if there is no
995 tag name? My guess is that this is mainly used for C++ in cases where
996 the two will always be the same. */
997 return TYPE_NAME (type
);
1000 /* Lookup a primitive type named NAME.
1001 Return zero if NAME is not a primitive type. */
1004 lookup_primitive_typename (char *name
)
1006 struct type
**const *p
;
1008 for (p
= current_language
->la_builtin_type_vector
; *p
!= NULL
; p
++)
1010 if (STREQ (TYPE_NAME (**p
), name
))
1018 /* Lookup a typedef or primitive type named NAME,
1019 visible in lexical block BLOCK.
1020 If NOERR is nonzero, return zero if NAME is not suitably defined. */
1023 lookup_typename (char *name
, struct block
*block
, int noerr
)
1025 register struct symbol
*sym
;
1026 register struct type
*tmp
;
1028 sym
= lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
1029 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1031 tmp
= lookup_primitive_typename (name
);
1036 else if (!tmp
&& noerr
)
1042 error ("No type named %s.", name
);
1045 return (SYMBOL_TYPE (sym
));
1049 lookup_unsigned_typename (char *name
)
1051 char *uns
= alloca (strlen (name
) + 10);
1053 strcpy (uns
, "unsigned ");
1054 strcpy (uns
+ 9, name
);
1055 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
1059 lookup_signed_typename (char *name
)
1062 char *uns
= alloca (strlen (name
) + 8);
1064 strcpy (uns
, "signed ");
1065 strcpy (uns
+ 7, name
);
1066 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
1067 /* If we don't find "signed FOO" just try again with plain "FOO". */
1070 return lookup_typename (name
, (struct block
*) NULL
, 0);
1073 /* Lookup a structure type named "struct NAME",
1074 visible in lexical block BLOCK. */
1077 lookup_struct (char *name
, struct block
*block
)
1079 register struct symbol
*sym
;
1081 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
1082 (struct symtab
**) NULL
);
1086 error ("No struct type named %s.", name
);
1088 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1090 error ("This context has class, union or enum %s, not a struct.", name
);
1092 return (SYMBOL_TYPE (sym
));
1095 /* Lookup a union type named "union NAME",
1096 visible in lexical block BLOCK. */
1099 lookup_union (char *name
, struct block
*block
)
1101 register struct symbol
*sym
;
1104 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
1105 (struct symtab
**) NULL
);
1108 error ("No union type named %s.", name
);
1110 t
= SYMBOL_TYPE (sym
);
1112 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1115 /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
1116 * a further "declared_type" field to discover it is really a union.
1118 if (HAVE_CPLUS_STRUCT (t
))
1119 if (TYPE_DECLARED_TYPE (t
) == DECLARED_TYPE_UNION
)
1122 /* If we get here, it's not a union */
1123 error ("This context has class, struct or enum %s, not a union.", name
);
1127 /* Lookup an enum type named "enum NAME",
1128 visible in lexical block BLOCK. */
1131 lookup_enum (char *name
, struct block
*block
)
1133 register struct symbol
*sym
;
1135 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
1136 (struct symtab
**) NULL
);
1139 error ("No enum type named %s.", name
);
1141 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1143 error ("This context has class, struct or union %s, not an enum.", name
);
1145 return (SYMBOL_TYPE (sym
));
1148 /* Lookup a template type named "template NAME<TYPE>",
1149 visible in lexical block BLOCK. */
1152 lookup_template_type (char *name
, struct type
*type
, struct block
*block
)
1155 char *nam
= (char *) alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1158 strcat (nam
, TYPE_NAME (type
));
1159 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1161 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
1165 error ("No template type named %s.", name
);
1167 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1169 error ("This context has class, union or enum %s, not a struct.", name
);
1171 return (SYMBOL_TYPE (sym
));
1174 /* Given a type TYPE, lookup the type of the component of type named NAME.
1176 TYPE can be either a struct or union, or a pointer or reference to a struct or
1177 union. If it is a pointer or reference, its target type is automatically used.
1178 Thus '.' and '->' are interchangable, as specified for the definitions of the
1179 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
1181 If NOERR is nonzero, return zero if NAME is not suitably defined.
1182 If NAME is the name of a baseclass type, return that type. */
1185 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
1191 CHECK_TYPEDEF (type
);
1192 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1193 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1195 type
= TYPE_TARGET_TYPE (type
);
1198 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
1199 TYPE_CODE (type
) != TYPE_CODE_UNION
)
1201 target_terminal_ours ();
1202 gdb_flush (gdb_stdout
);
1203 fprintf_unfiltered (gdb_stderr
, "Type ");
1204 type_print (type
, "", gdb_stderr
, -1);
1205 error (" is not a structure or union type.");
1209 /* FIXME: This change put in by Michael seems incorrect for the case where
1210 the structure tag name is the same as the member name. I.E. when doing
1211 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
1216 typename
= type_name_no_tag (type
);
1217 if (typename
!= NULL
&& STREQ (typename
, name
))
1222 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1224 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1226 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1228 return TYPE_FIELD_TYPE (type
, i
);
1232 /* OK, it's not in this class. Recursively check the baseclasses. */
1233 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1237 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, noerr
);
1249 target_terminal_ours ();
1250 gdb_flush (gdb_stdout
);
1251 fprintf_unfiltered (gdb_stderr
, "Type ");
1252 type_print (type
, "", gdb_stderr
, -1);
1253 fprintf_unfiltered (gdb_stderr
, " has no component named ");
1254 fputs_filtered (name
, gdb_stderr
);
1256 return (struct type
*) -1; /* For lint */
1259 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
1260 valid. Callers should be aware that in some cases (for example,
1261 the type or one of its baseclasses is a stub type and we are
1262 debugging a .o file), this function will not be able to find the virtual
1263 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
1264 will remain NULL. */
1267 fill_in_vptr_fieldno (struct type
*type
)
1269 CHECK_TYPEDEF (type
);
1271 if (TYPE_VPTR_FIELDNO (type
) < 0)
1275 /* We must start at zero in case the first (and only) baseclass is
1276 virtual (and hence we cannot share the table pointer). */
1277 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1279 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, i
));
1280 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
)) >= 0)
1282 TYPE_VPTR_FIELDNO (type
)
1283 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
));
1284 TYPE_VPTR_BASETYPE (type
)
1285 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type
, i
));
1292 /* Find the method and field indices for the destructor in class type T.
1293 Return 1 if the destructor was found, otherwise, return 0. */
1296 get_destructor_fn_field (struct type
*t
, int *method_indexp
, int *field_indexp
)
1300 for (i
= 0; i
< TYPE_NFN_FIELDS (t
); i
++)
1303 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1305 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (t
, i
); j
++)
1307 if (is_destructor_name (TYPE_FN_FIELD_PHYSNAME (f
, j
)) != 0)
1318 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1320 If this is a stubbed struct (i.e. declared as struct foo *), see if
1321 we can find a full definition in some other file. If so, copy this
1322 definition, so we can use it in future. There used to be a comment (but
1323 not any code) that if we don't find a full definition, we'd set a flag
1324 so we don't spend time in the future checking the same type. That would
1325 be a mistake, though--we might load in more symbols which contain a
1326 full definition for the type.
1328 This used to be coded as a macro, but I don't think it is called
1329 often enough to merit such treatment. */
1331 struct complaint stub_noname_complaint
=
1332 {"stub type has NULL name", 0, 0};
1335 check_typedef (struct type
*type
)
1337 struct type
*orig_type
= type
;
1338 int is_const
, is_volatile
;
1340 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1342 if (!TYPE_TARGET_TYPE (type
))
1347 /* It is dangerous to call lookup_symbol if we are currently
1348 reading a symtab. Infinite recursion is one danger. */
1349 if (currently_reading_symtab
)
1352 name
= type_name_no_tag (type
);
1353 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1354 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
1355 as appropriate? (this code was written before TYPE_NAME and
1356 TYPE_TAG_NAME were separate). */
1359 complain (&stub_noname_complaint
);
1362 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
1363 (struct symtab
**) NULL
);
1365 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1367 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
); /* TYPE_CODE_UNDEF */
1369 type
= TYPE_TARGET_TYPE (type
);
1372 is_const
= TYPE_CONST (type
);
1373 is_volatile
= TYPE_VOLATILE (type
);
1375 /* If this is a struct/class/union with no fields, then check whether a
1376 full definition exists somewhere else. This is for systems where a
1377 type definition with no fields is issued for such types, instead of
1378 identifying them as stub types in the first place */
1380 if (TYPE_IS_OPAQUE (type
) && opaque_type_resolution
&& !currently_reading_symtab
)
1382 char *name
= type_name_no_tag (type
);
1383 struct type
*newtype
;
1386 complain (&stub_noname_complaint
);
1389 newtype
= lookup_transparent_type (name
);
1391 make_cv_type (is_const
, is_volatile
, newtype
, &type
);
1393 /* Otherwise, rely on the stub flag being set for opaque/stubbed types */
1394 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1396 char *name
= type_name_no_tag (type
);
1397 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1398 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
1399 as appropriate? (this code was written before TYPE_NAME and
1400 TYPE_TAG_NAME were separate). */
1404 complain (&stub_noname_complaint
);
1407 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0, (struct symtab
**) NULL
);
1409 make_cv_type (is_const
, is_volatile
, SYMBOL_TYPE (sym
), &type
);
1412 if (TYPE_TARGET_STUB (type
))
1414 struct type
*range_type
;
1415 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1417 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1420 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1421 && TYPE_NFIELDS (type
) == 1
1422 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
1423 == TYPE_CODE_RANGE
))
1425 /* Now recompute the length of the array type, based on its
1426 number of elements and the target type's length. */
1427 TYPE_LENGTH (type
) =
1428 ((TYPE_FIELD_BITPOS (range_type
, 1)
1429 - TYPE_FIELD_BITPOS (range_type
, 0)
1431 * TYPE_LENGTH (target_type
));
1432 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1434 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1436 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1437 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1440 /* Cache TYPE_LENGTH for future use. */
1441 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1445 /* New code added to support parsing of Cfront stabs strings */
1446 #define INIT_EXTRA { pextras->len=0; pextras->str[0]='\0'; }
1447 #define ADD_EXTRA(c) { pextras->str[pextras->len++]=c; }
1450 add_name (struct extra
*pextras
, char *n
)
1454 if ((nlen
= (n
? strlen (n
) : 0)) == 0)
1456 sprintf (pextras
->str
+ pextras
->len
, "%d%s", nlen
, n
);
1457 pextras
->len
= strlen (pextras
->str
);
1461 add_mangled_type (struct extra
*pextras
, struct type
*t
)
1463 enum type_code tcode
;
1467 tcode
= TYPE_CODE (t
);
1468 tlen
= TYPE_LENGTH (t
);
1469 tflags
= TYPE_FLAGS (t
);
1470 tname
= TYPE_NAME (t
);
1471 /* args of "..." seem to get mangled as "e" */
1489 if ((pname
= strrchr (tname
, 'l'), pname
) && !strcmp (pname
, "long"))
1502 static struct complaint msg
=
1503 {"Bad int type code length x%x\n", 0, 0};
1505 complain (&msg
, tlen
);
1524 static struct complaint msg
=
1525 {"Bad float type code length x%x\n", 0, 0};
1526 complain (&msg
, tlen
);
1532 /* followed by what it's a ref to */
1536 /* followed by what it's a ptr to */
1538 case TYPE_CODE_TYPEDEF
:
1540 static struct complaint msg
=
1541 {"Typedefs in overloaded functions not yet supported\n", 0, 0};
1544 /* followed by type bytes & name */
1546 case TYPE_CODE_FUNC
:
1548 /* followed by func's arg '_' & ret types */
1550 case TYPE_CODE_VOID
:
1553 case TYPE_CODE_METHOD
:
1555 /* followed by name of class and func's arg '_' & ret types */
1556 add_name (pextras
, tname
);
1557 ADD_EXTRA ('F'); /* then mangle function */
1559 case TYPE_CODE_STRUCT
: /* C struct */
1560 case TYPE_CODE_UNION
: /* C union */
1561 case TYPE_CODE_ENUM
: /* Enumeration type */
1562 /* followed by name of type */
1563 add_name (pextras
, tname
);
1566 /* errors possible types/not supported */
1567 case TYPE_CODE_CHAR
:
1568 case TYPE_CODE_ARRAY
: /* Array type */
1569 case TYPE_CODE_MEMBER
: /* Member type */
1570 case TYPE_CODE_BOOL
:
1571 case TYPE_CODE_COMPLEX
: /* Complex float */
1572 case TYPE_CODE_UNDEF
:
1573 case TYPE_CODE_SET
: /* Pascal sets */
1574 case TYPE_CODE_RANGE
:
1575 case TYPE_CODE_STRING
:
1576 case TYPE_CODE_BITSTRING
:
1577 case TYPE_CODE_ERROR
:
1580 static struct complaint msg
=
1581 {"Unknown type code x%x\n", 0, 0};
1582 complain (&msg
, tcode
);
1585 if (TYPE_TARGET_TYPE (t
))
1586 add_mangled_type (pextras
, TYPE_TARGET_TYPE (t
));
1591 cfront_mangle_name (struct type
*type
, int i
, int j
)
1594 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
1596 f
= TYPE_FN_FIELDLIST1 (type
, i
); /* moved from below */
1598 /* kludge to support cfront methods - gdb expects to find "F" for
1599 ARM_mangled names, so when we mangle, we have to add it here */
1603 char *arm_mangled_name
;
1604 struct fn_field
*method
= &f
[j
];
1605 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1606 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1607 char *newname
= type_name_no_tag (type
);
1609 struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
1610 int nargs
= TYPE_NFIELDS (ftype
); /* number of args */
1611 struct extra extras
, *pextras
= &extras
;
1614 if (TYPE_FN_FIELD_STATIC_P (f
, j
)) /* j for sublist within this list */
1617 /* add args here! */
1618 if (nargs
<= 1) /* no args besides this */
1622 for (k
= 1; k
< nargs
; k
++)
1625 t
= TYPE_FIELD_TYPE (ftype
, k
);
1626 add_mangled_type (pextras
, t
);
1630 printf ("add_mangled_type: %s\n", extras
.str
); /* FIXME */
1631 xasprintf (&arm_mangled_name
, "%s%s", mangled_name
, extras
.str
);
1632 xfree (mangled_name
);
1633 mangled_name
= arm_mangled_name
;
1639 /* End of new code added to support parsing of Cfront stabs strings */
1641 /* Parse a type expression in the string [P..P+LENGTH). If an error occurs,
1642 silently return builtin_type_void. */
1645 safe_parse_type (char *p
, int length
)
1647 struct ui_file
*saved_gdb_stderr
;
1650 /* Suppress error messages. */
1651 saved_gdb_stderr
= gdb_stderr
;
1652 gdb_stderr
= ui_file_new ();
1654 /* Call parse_and_eval_type() without fear of longjmp()s. */
1655 if (!gdb_parse_and_eval_type (p
, length
, &type
))
1656 type
= builtin_type_void
;
1658 /* Stop suppressing error messages. */
1659 ui_file_delete (gdb_stderr
);
1660 gdb_stderr
= saved_gdb_stderr
;
1665 /* Ugly hack to convert method stubs into method types.
1667 He ain't kiddin'. This demangles the name of the method into a string
1668 including argument types, parses out each argument type, generates
1669 a string casting a zero to that type, evaluates the string, and stuffs
1670 the resulting type into an argtype vector!!! Then it knows the type
1671 of the whole function (including argument types for overloading),
1672 which info used to be in the stab's but was removed to hack back
1673 the space required for them. */
1676 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1679 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1680 char *demangled_name
= cplus_demangle (mangled_name
,
1681 DMGL_PARAMS
| DMGL_ANSI
);
1682 char *argtypetext
, *p
;
1683 int depth
= 0, argcount
= 1;
1684 struct field
*argtypes
;
1687 /* Make sure we got back a function string that we can use. */
1689 p
= strchr (demangled_name
, '(');
1693 if (demangled_name
== NULL
|| p
== NULL
)
1694 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
1696 /* Now, read in the parameters that define this type. */
1701 if (*p
== '(' || *p
== '<')
1705 else if (*p
== ')' || *p
== '>')
1709 else if (*p
== ',' && depth
== 0)
1717 /* If we read one argument and it was ``void'', don't count it. */
1718 if (strncmp (argtypetext
, "(void)", 6) == 0)
1721 /* We need one extra slot, for the THIS pointer. */
1723 argtypes
= (struct field
*)
1724 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
1727 /* Add THIS pointer for non-static methods. */
1728 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1729 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
1733 argtypes
[0].type
= lookup_pointer_type (type
);
1737 if (*p
!= ')') /* () means no args, skip while */
1742 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1744 /* Avoid parsing of ellipsis, they will be handled below.
1745 Also avoid ``void'' as above. */
1746 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
1747 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
1749 argtypes
[argcount
].type
=
1750 safe_parse_type (argtypetext
, p
- argtypetext
);
1753 argtypetext
= p
+ 1;
1756 if (*p
== '(' || *p
== '<')
1760 else if (*p
== ')' || *p
== '>')
1769 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1771 /* Now update the old "stub" type into a real type. */
1772 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1773 TYPE_DOMAIN_TYPE (mtype
) = type
;
1774 TYPE_FIELDS (mtype
) = argtypes
;
1775 TYPE_NFIELDS (mtype
) = argcount
;
1776 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1777 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1779 TYPE_FLAGS (mtype
) |= TYPE_FLAG_VARARGS
;
1781 xfree (demangled_name
);
1784 /* This is the external interface to check_stub_method, above. This function
1785 unstubs all of the signatures for TYPE's METHOD_ID method name. After
1786 calling this function TYPE_FN_FIELD_STUB will be cleared for each signature
1787 and TYPE_FN_FIELDLIST_NAME will be correct.
1789 This function unfortunately can not die until stabs do. */
1792 check_stub_method_group (struct type
*type
, int method_id
)
1794 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
1795 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1796 int j
, found_stub
= 0;
1798 for (j
= 0; j
< len
; j
++)
1799 if (TYPE_FN_FIELD_STUB (f
, j
))
1802 check_stub_method (type
, method_id
, j
);
1805 /* GNU v3 methods with incorrect names were corrected when we read in
1806 type information, because it was cheaper to do it then. The only GNU v2
1807 methods with incorrect method names are operators and destructors;
1808 destructors were also corrected when we read in type information.
1810 Therefore the only thing we need to handle here are v2 operator
1812 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
1815 char dem_opname
[256];
1817 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
, method_id
),
1818 dem_opname
, DMGL_ANSI
);
1820 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
, method_id
),
1823 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
1827 const struct cplus_struct_type cplus_struct_default
;
1830 allocate_cplus_struct_type (struct type
*type
)
1832 if (!HAVE_CPLUS_STRUCT (type
))
1834 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1835 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1836 *(TYPE_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1840 /* Helper function to initialize the standard scalar types.
1842 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1843 of the string pointed to by name in the type_obstack for that objfile,
1844 and initialize the type name to that copy. There are places (mipsread.c
1845 in particular, where init_type is called with a NULL value for NAME). */
1848 init_type (enum type_code code
, int length
, int flags
, char *name
,
1849 struct objfile
*objfile
)
1851 register struct type
*type
;
1853 type
= alloc_type (objfile
);
1854 TYPE_CODE (type
) = code
;
1855 TYPE_LENGTH (type
) = length
;
1856 TYPE_FLAGS (type
) |= flags
;
1857 if ((name
!= NULL
) && (objfile
!= NULL
))
1860 obsavestring (name
, strlen (name
), &objfile
->type_obstack
);
1864 TYPE_NAME (type
) = name
;
1869 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
1871 INIT_CPLUS_SPECIFIC (type
);
1876 /* Helper function. Create an empty composite type. */
1879 init_composite_type (char *name
, enum type_code code
)
1882 gdb_assert (code
== TYPE_CODE_STRUCT
1883 || code
== TYPE_CODE_UNION
);
1884 t
= init_type (code
, 0, 0, NULL
, NULL
);
1885 TYPE_TAG_NAME (t
) = name
;
1889 /* Helper function. Append a field to a composite type. */
1892 append_composite_type_field (struct type
*t
, char *name
, struct type
*field
)
1895 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
1896 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
1897 sizeof (struct field
) * TYPE_NFIELDS (t
));
1898 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
1899 memset (f
, 0, sizeof f
[0]);
1900 FIELD_TYPE (f
[0]) = field
;
1901 FIELD_NAME (f
[0]) = name
;
1902 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1904 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
1905 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
1907 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
1909 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
1910 if (TYPE_NFIELDS (t
) > 1)
1912 FIELD_BITPOS (f
[0]) = (FIELD_BITPOS (f
[-1])
1913 + TYPE_LENGTH (field
) * TARGET_CHAR_BIT
);
1918 /* Look up a fundamental type for the specified objfile.
1919 May need to construct such a type if this is the first use.
1921 Some object file formats (ELF, COFF, etc) do not define fundamental
1922 types such as "int" or "double". Others (stabs for example), do
1923 define fundamental types.
1925 For the formats which don't provide fundamental types, gdb can create
1926 such types, using defaults reasonable for the current language and
1927 the current target machine.
1929 NOTE: This routine is obsolescent. Each debugging format reader
1930 should manage it's own fundamental types, either creating them from
1931 suitable defaults or reading them from the debugging information,
1932 whichever is appropriate. The DWARF reader has already been
1933 fixed to do this. Once the other readers are fixed, this routine
1934 will go away. Also note that fundamental types should be managed
1935 on a compilation unit basis in a multi-language environment, not
1936 on a linkage unit basis as is done here. */
1940 lookup_fundamental_type (struct objfile
*objfile
, int typeid)
1942 register struct type
**typep
;
1943 register int nbytes
;
1945 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1947 error ("internal error - invalid fundamental type id %d", typeid);
1950 /* If this is the first time we need a fundamental type for this objfile
1951 then we need to initialize the vector of type pointers. */
1953 if (objfile
->fundamental_types
== NULL
)
1955 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1956 objfile
->fundamental_types
= (struct type
**)
1957 obstack_alloc (&objfile
->type_obstack
, nbytes
);
1958 memset ((char *) objfile
->fundamental_types
, 0, nbytes
);
1959 OBJSTAT (objfile
, n_types
+= FT_NUM_MEMBERS
);
1962 /* Look for this particular type in the fundamental type vector. If one is
1963 not found, create and install one appropriate for the current language. */
1965 typep
= objfile
->fundamental_types
+ typeid;
1968 *typep
= create_fundamental_type (objfile
, typeid);
1975 can_dereference (struct type
*t
)
1977 /* FIXME: Should we return true for references as well as pointers? */
1981 && TYPE_CODE (t
) == TYPE_CODE_PTR
1982 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1986 is_integral_type (struct type
*t
)
1991 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
1992 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
1993 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
1994 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
1995 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
1998 /* (OBSOLETE) Chill (OBSOLETE) varying string and arrays are
1999 represented as follows:
2001 struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
2003 Return true if TYPE is such a (OBSOLETE) Chill (OBSOLETE) varying
2007 /* OBSOLETE chill_varying_type (struct type *type) */
2009 /* OBSOLETE if (TYPE_CODE (type) != TYPE_CODE_STRUCT */
2010 /* OBSOLETE || TYPE_NFIELDS (type) != 2 */
2011 /* OBSOLETE || strcmp (TYPE_FIELD_NAME (type, 0), "__var_length") != 0) */
2012 /* OBSOLETE return 0; */
2013 /* OBSOLETE return 1; */
2016 /* Check whether BASE is an ancestor or base class or DCLASS
2017 Return 1 if so, and 0 if not.
2018 Note: callers may want to check for identity of the types before
2019 calling this function -- identical types are considered to satisfy
2020 the ancestor relationship even if they're identical */
2023 is_ancestor (struct type
*base
, struct type
*dclass
)
2027 CHECK_TYPEDEF (base
);
2028 CHECK_TYPEDEF (dclass
);
2032 if (TYPE_NAME (base
) && TYPE_NAME (dclass
) &&
2033 !strcmp (TYPE_NAME (base
), TYPE_NAME (dclass
)))
2036 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2037 if (is_ancestor (base
, TYPE_BASECLASS (dclass
, i
)))
2045 /* See whether DCLASS has a virtual table. This routine is aimed at
2046 the HP/Taligent ANSI C++ runtime model, and may not work with other
2047 runtime models. Return 1 => Yes, 0 => No. */
2050 has_vtable (struct type
*dclass
)
2052 /* In the HP ANSI C++ runtime model, a class has a vtable only if it
2053 has virtual functions or virtual bases. */
2057 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
2060 /* First check for the presence of virtual bases */
2061 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
2062 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2063 if (B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
))
2066 /* Next check for virtual functions */
2067 if (TYPE_FN_FIELDLISTS (dclass
))
2068 for (i
= 0; i
< TYPE_NFN_FIELDS (dclass
); i
++)
2069 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, i
), 0))
2072 /* Recurse on non-virtual bases to see if any of them needs a vtable */
2073 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
2074 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2075 if ((!B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
)) &&
2076 (has_vtable (TYPE_FIELD_TYPE (dclass
, i
))))
2079 /* Well, maybe we don't need a virtual table */
2083 /* Return a pointer to the "primary base class" of DCLASS.
2085 A NULL return indicates that DCLASS has no primary base, or that it
2086 couldn't be found (insufficient information).
2088 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
2089 and may not work with other runtime models. */
2092 primary_base_class (struct type
*dclass
)
2094 /* In HP ANSI C++'s runtime model, a "primary base class" of a class
2095 is the first directly inherited, non-virtual base class that
2096 requires a virtual table */
2100 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
2103 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2104 if (!TYPE_FIELD_VIRTUAL (dclass
, i
) &&
2105 has_vtable (TYPE_FIELD_TYPE (dclass
, i
)))
2106 return TYPE_FIELD_TYPE (dclass
, i
);
2111 /* Global manipulated by virtual_base_list[_aux]() */
2113 static struct vbase
*current_vbase_list
= NULL
;
2115 /* Return a pointer to a null-terminated list of struct vbase
2116 items. The vbasetype pointer of each item in the list points to the
2117 type information for a virtual base of the argument DCLASS.
2119 Helper function for virtual_base_list().
2120 Note: the list goes backward, right-to-left. virtual_base_list()
2121 copies the items out in reverse order. */
2124 virtual_base_list_aux (struct type
*dclass
)
2126 struct vbase
*tmp_vbase
;
2129 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
2132 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2134 /* Recurse on this ancestor, first */
2135 virtual_base_list_aux (TYPE_FIELD_TYPE (dclass
, i
));
2137 /* If this current base is itself virtual, add it to the list */
2138 if (BASETYPE_VIA_VIRTUAL (dclass
, i
))
2140 struct type
*basetype
= TYPE_FIELD_TYPE (dclass
, i
);
2142 /* Check if base already recorded */
2143 tmp_vbase
= current_vbase_list
;
2146 if (tmp_vbase
->vbasetype
== basetype
)
2147 break; /* found it */
2148 tmp_vbase
= tmp_vbase
->next
;
2151 if (!tmp_vbase
) /* normal exit from loop */
2153 /* Allocate new item for this virtual base */
2154 tmp_vbase
= (struct vbase
*) xmalloc (sizeof (struct vbase
));
2156 /* Stick it on at the end of the list */
2157 tmp_vbase
->vbasetype
= basetype
;
2158 tmp_vbase
->next
= current_vbase_list
;
2159 current_vbase_list
= tmp_vbase
;
2162 } /* for loop over bases */
2166 /* Compute the list of virtual bases in the right order. Virtual
2167 bases are laid out in the object's memory area in order of their
2168 occurrence in a depth-first, left-to-right search through the
2171 Argument DCLASS is the type whose virtual bases are required.
2172 Return value is the address of a null-terminated array of pointers
2173 to struct type items.
2175 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
2176 and may not work with other runtime models.
2178 This routine merely hands off the argument to virtual_base_list_aux()
2179 and then copies the result into an array to save space. */
2182 virtual_base_list (struct type
*dclass
)
2184 register struct vbase
*tmp_vbase
;
2185 register struct vbase
*tmp_vbase_2
;
2188 struct type
**vbase_array
;
2190 current_vbase_list
= NULL
;
2191 virtual_base_list_aux (dclass
);
2193 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
2198 vbase_array
= (struct type
**) xmalloc ((count
+ 1) * sizeof (struct type
*));
2200 for (i
= count
- 1, tmp_vbase
= current_vbase_list
; i
>= 0; i
--, tmp_vbase
= tmp_vbase
->next
)
2201 vbase_array
[i
] = tmp_vbase
->vbasetype
;
2203 /* Get rid of constructed chain */
2204 tmp_vbase_2
= tmp_vbase
= current_vbase_list
;
2207 tmp_vbase
= tmp_vbase
->next
;
2208 xfree (tmp_vbase_2
);
2209 tmp_vbase_2
= tmp_vbase
;
2212 vbase_array
[count
] = NULL
;
2216 /* Return the length of the virtual base list of the type DCLASS. */
2219 virtual_base_list_length (struct type
*dclass
)
2222 register struct vbase
*tmp_vbase
;
2224 current_vbase_list
= NULL
;
2225 virtual_base_list_aux (dclass
);
2227 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
2232 /* Return the number of elements of the virtual base list of the type
2233 DCLASS, ignoring those appearing in the primary base (and its
2234 primary base, recursively). */
2237 virtual_base_list_length_skip_primaries (struct type
*dclass
)
2240 register struct vbase
*tmp_vbase
;
2241 struct type
*primary
;
2243 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
2246 return virtual_base_list_length (dclass
);
2248 current_vbase_list
= NULL
;
2249 virtual_base_list_aux (dclass
);
2251 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; tmp_vbase
= tmp_vbase
->next
)
2253 if (virtual_base_index (tmp_vbase
->vbasetype
, primary
) >= 0)
2261 /* Return the index (position) of type BASE, which is a virtual base
2262 class of DCLASS, in the latter's virtual base list. A return of -1
2263 indicates "not found" or a problem. */
2266 virtual_base_index (struct type
*base
, struct type
*dclass
)
2268 register struct type
*vbase
;
2271 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
2272 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
2276 vbase
= virtual_base_list (dclass
)[0];
2281 vbase
= virtual_base_list (dclass
)[++i
];
2284 return vbase
? i
: -1;
2289 /* Return the index (position) of type BASE, which is a virtual base
2290 class of DCLASS, in the latter's virtual base list. Skip over all
2291 bases that may appear in the virtual base list of the primary base
2292 class of DCLASS (recursively). A return of -1 indicates "not
2293 found" or a problem. */
2296 virtual_base_index_skip_primaries (struct type
*base
, struct type
*dclass
)
2298 register struct type
*vbase
;
2300 struct type
*primary
;
2302 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
2303 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
2306 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
2310 vbase
= virtual_base_list (dclass
)[0];
2313 if (!primary
|| (virtual_base_index_skip_primaries (vbase
, primary
) < 0))
2317 vbase
= virtual_base_list (dclass
)[++i
];
2320 return vbase
? j
: -1;
2323 /* Return position of a derived class DCLASS in the list of
2324 * primary bases starting with the remotest ancestor.
2325 * Position returned is 0-based. */
2328 class_index_in_primary_list (struct type
*dclass
)
2330 struct type
*pbc
; /* primary base class */
2332 /* Simply recurse on primary base */
2333 pbc
= TYPE_PRIMARY_BASE (dclass
);
2335 return 1 + class_index_in_primary_list (pbc
);
2340 /* Return a count of the number of virtual functions a type has.
2341 * This includes all the virtual functions it inherits from its
2345 /* pai: FIXME This doesn't do the right thing: count redefined virtual
2346 * functions only once (latest redefinition)
2350 count_virtual_fns (struct type
*dclass
)
2352 int fn
, oi
; /* function and overloaded instance indices */
2353 int vfuncs
; /* count to return */
2355 /* recurse on bases that can share virtual table */
2356 struct type
*pbc
= primary_base_class (dclass
);
2358 vfuncs
= count_virtual_fns (pbc
);
2362 for (fn
= 0; fn
< TYPE_NFN_FIELDS (dclass
); fn
++)
2363 for (oi
= 0; oi
< TYPE_FN_FIELDLIST_LENGTH (dclass
, fn
); oi
++)
2364 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, fn
), oi
))
2372 /* Functions for overload resolution begin here */
2374 /* Compare two badness vectors A and B and return the result.
2375 * 0 => A and B are identical
2376 * 1 => A and B are incomparable
2377 * 2 => A is better than B
2378 * 3 => A is worse than B */
2381 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
2385 short found_pos
= 0; /* any positives in c? */
2386 short found_neg
= 0; /* any negatives in c? */
2388 /* differing lengths => incomparable */
2389 if (a
->length
!= b
->length
)
2392 /* Subtract b from a */
2393 for (i
= 0; i
< a
->length
; i
++)
2395 tmp
= a
->rank
[i
] - b
->rank
[i
];
2405 return 1; /* incomparable */
2407 return 3; /* A > B */
2413 return 2; /* A < B */
2415 return 0; /* A == B */
2419 /* Rank a function by comparing its parameter types (PARMS, length NPARMS),
2420 * to the types of an argument list (ARGS, length NARGS).
2421 * Return a pointer to a badness vector. This has NARGS + 1 entries. */
2423 struct badness_vector
*
2424 rank_function (struct type
**parms
, int nparms
, struct type
**args
, int nargs
)
2427 struct badness_vector
*bv
;
2428 int min_len
= nparms
< nargs
? nparms
: nargs
;
2430 bv
= xmalloc (sizeof (struct badness_vector
));
2431 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank */
2432 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
2434 /* First compare the lengths of the supplied lists.
2435 * If there is a mismatch, set it to a high value. */
2437 /* pai/1997-06-03 FIXME: when we have debug info about default
2438 * arguments and ellipsis parameter lists, we should consider those
2439 * and rank the length-match more finely. */
2441 LENGTH_MATCH (bv
) = (nargs
!= nparms
) ? LENGTH_MISMATCH_BADNESS
: 0;
2443 /* Now rank all the parameters of the candidate function */
2444 for (i
= 1; i
<= min_len
; i
++)
2445 bv
->rank
[i
] = rank_one_type (parms
[i
-1], args
[i
-1]);
2447 /* If more arguments than parameters, add dummy entries */
2448 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2449 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2454 /* Compare one type (PARM) for compatibility with another (ARG).
2455 * PARM is intended to be the parameter type of a function; and
2456 * ARG is the supplied argument's type. This function tests if
2457 * the latter can be converted to the former.
2459 * Return 0 if they are identical types;
2460 * Otherwise, return an integer which corresponds to how compatible
2461 * PARM is to ARG. The higher the return value, the worse the match.
2462 * Generally the "bad" conversions are all uniformly assigned a 100 */
2465 rank_one_type (struct type
*parm
, struct type
*arg
)
2467 /* Identical type pointers */
2468 /* However, this still doesn't catch all cases of same type for arg
2469 * and param. The reason is that builtin types are different from
2470 * the same ones constructed from the object. */
2474 /* Resolve typedefs */
2475 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2476 parm
= check_typedef (parm
);
2477 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2478 arg
= check_typedef (arg
);
2481 Well, damnit, if the names are exactly the same,
2482 i'll say they are exactly the same. This happens when we generate
2483 method stubs. The types won't point to the same address, but they
2484 really are the same.
2487 if (TYPE_NAME (parm
) && TYPE_NAME (arg
) &&
2488 !strcmp (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2491 /* Check if identical after resolving typedefs */
2495 /* See through references, since we can almost make non-references
2497 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2498 return (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
))
2499 + REFERENCE_CONVERSION_BADNESS
);
2500 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2501 return (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
)
2502 + REFERENCE_CONVERSION_BADNESS
);
2504 /* Debugging only. */
2505 fprintf_filtered (gdb_stderr
,"------ Arg is %s [%d], parm is %s [%d]\n",
2506 TYPE_NAME (arg
), TYPE_CODE (arg
), TYPE_NAME (parm
), TYPE_CODE (parm
));
2508 /* x -> y means arg of type x being supplied for parameter of type y */
2510 switch (TYPE_CODE (parm
))
2513 switch (TYPE_CODE (arg
))
2516 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2517 return VOID_PTR_CONVERSION_BADNESS
;
2519 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2520 case TYPE_CODE_ARRAY
:
2521 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2522 case TYPE_CODE_FUNC
:
2523 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
);
2525 case TYPE_CODE_ENUM
:
2526 case TYPE_CODE_CHAR
:
2527 case TYPE_CODE_RANGE
:
2528 case TYPE_CODE_BOOL
:
2529 return POINTER_CONVERSION_BADNESS
;
2531 return INCOMPATIBLE_TYPE_BADNESS
;
2533 case TYPE_CODE_ARRAY
:
2534 switch (TYPE_CODE (arg
))
2537 case TYPE_CODE_ARRAY
:
2538 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2540 return INCOMPATIBLE_TYPE_BADNESS
;
2542 case TYPE_CODE_FUNC
:
2543 switch (TYPE_CODE (arg
))
2545 case TYPE_CODE_PTR
: /* funcptr -> func */
2546 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
));
2548 return INCOMPATIBLE_TYPE_BADNESS
;
2551 switch (TYPE_CODE (arg
))
2554 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2556 /* Deal with signed, unsigned, and plain chars and
2557 signed and unsigned ints */
2558 if (TYPE_NOSIGN (parm
))
2560 /* This case only for character types */
2561 if (TYPE_NOSIGN (arg
)) /* plain char -> plain char */
2564 return INTEGER_COERCION_BADNESS
; /* signed/unsigned char -> plain char */
2566 else if (TYPE_UNSIGNED (parm
))
2568 if (TYPE_UNSIGNED (arg
))
2570 if (!strcmp_iw (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2571 return 0; /* unsigned int -> unsigned int, or unsigned long -> unsigned long */
2572 else if (!strcmp_iw (TYPE_NAME (arg
), "int") && !strcmp_iw (TYPE_NAME (parm
), "long"))
2573 return INTEGER_PROMOTION_BADNESS
; /* unsigned int -> unsigned long */
2575 return INTEGER_COERCION_BADNESS
; /* unsigned long -> unsigned int */
2579 if (!strcmp_iw (TYPE_NAME (arg
), "long") && !strcmp_iw (TYPE_NAME (parm
), "int"))
2580 return INTEGER_COERCION_BADNESS
; /* signed long -> unsigned int */
2582 return INTEGER_CONVERSION_BADNESS
; /* signed int/long -> unsigned int/long */
2585 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2587 if (!strcmp_iw (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2589 else if (!strcmp_iw (TYPE_NAME (arg
), "int") && !strcmp_iw (TYPE_NAME (parm
), "long"))
2590 return INTEGER_PROMOTION_BADNESS
;
2592 return INTEGER_COERCION_BADNESS
;
2595 return INTEGER_COERCION_BADNESS
;
2597 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2598 return INTEGER_PROMOTION_BADNESS
;
2600 return INTEGER_COERCION_BADNESS
;
2601 case TYPE_CODE_ENUM
:
2602 case TYPE_CODE_CHAR
:
2603 case TYPE_CODE_RANGE
:
2604 case TYPE_CODE_BOOL
:
2605 return INTEGER_PROMOTION_BADNESS
;
2607 return INT_FLOAT_CONVERSION_BADNESS
;
2609 return NS_POINTER_CONVERSION_BADNESS
;
2611 return INCOMPATIBLE_TYPE_BADNESS
;
2614 case TYPE_CODE_ENUM
:
2615 switch (TYPE_CODE (arg
))
2618 case TYPE_CODE_CHAR
:
2619 case TYPE_CODE_RANGE
:
2620 case TYPE_CODE_BOOL
:
2621 case TYPE_CODE_ENUM
:
2622 return INTEGER_COERCION_BADNESS
;
2624 return INT_FLOAT_CONVERSION_BADNESS
;
2626 return INCOMPATIBLE_TYPE_BADNESS
;
2629 case TYPE_CODE_CHAR
:
2630 switch (TYPE_CODE (arg
))
2632 case TYPE_CODE_RANGE
:
2633 case TYPE_CODE_BOOL
:
2634 case TYPE_CODE_ENUM
:
2635 return INTEGER_COERCION_BADNESS
;
2637 return INT_FLOAT_CONVERSION_BADNESS
;
2639 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2640 return INTEGER_COERCION_BADNESS
;
2641 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2642 return INTEGER_PROMOTION_BADNESS
;
2643 /* >>> !! else fall through !! <<< */
2644 case TYPE_CODE_CHAR
:
2645 /* Deal with signed, unsigned, and plain chars for C++
2646 and with int cases falling through from previous case */
2647 if (TYPE_NOSIGN (parm
))
2649 if (TYPE_NOSIGN (arg
))
2652 return INTEGER_COERCION_BADNESS
;
2654 else if (TYPE_UNSIGNED (parm
))
2656 if (TYPE_UNSIGNED (arg
))
2659 return INTEGER_PROMOTION_BADNESS
;
2661 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2664 return INTEGER_COERCION_BADNESS
;
2666 return INCOMPATIBLE_TYPE_BADNESS
;
2669 case TYPE_CODE_RANGE
:
2670 switch (TYPE_CODE (arg
))
2673 case TYPE_CODE_CHAR
:
2674 case TYPE_CODE_RANGE
:
2675 case TYPE_CODE_BOOL
:
2676 case TYPE_CODE_ENUM
:
2677 return INTEGER_COERCION_BADNESS
;
2679 return INT_FLOAT_CONVERSION_BADNESS
;
2681 return INCOMPATIBLE_TYPE_BADNESS
;
2684 case TYPE_CODE_BOOL
:
2685 switch (TYPE_CODE (arg
))
2688 case TYPE_CODE_CHAR
:
2689 case TYPE_CODE_RANGE
:
2690 case TYPE_CODE_ENUM
:
2693 return BOOLEAN_CONVERSION_BADNESS
;
2694 case TYPE_CODE_BOOL
:
2697 return INCOMPATIBLE_TYPE_BADNESS
;
2701 switch (TYPE_CODE (arg
))
2704 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2705 return FLOAT_PROMOTION_BADNESS
;
2706 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2709 return FLOAT_CONVERSION_BADNESS
;
2711 case TYPE_CODE_BOOL
:
2712 case TYPE_CODE_ENUM
:
2713 case TYPE_CODE_RANGE
:
2714 case TYPE_CODE_CHAR
:
2715 return INT_FLOAT_CONVERSION_BADNESS
;
2717 return INCOMPATIBLE_TYPE_BADNESS
;
2720 case TYPE_CODE_COMPLEX
:
2721 switch (TYPE_CODE (arg
))
2722 { /* Strictly not needed for C++, but... */
2724 return FLOAT_PROMOTION_BADNESS
;
2725 case TYPE_CODE_COMPLEX
:
2728 return INCOMPATIBLE_TYPE_BADNESS
;
2731 case TYPE_CODE_STRUCT
:
2732 /* currently same as TYPE_CODE_CLASS */
2733 switch (TYPE_CODE (arg
))
2735 case TYPE_CODE_STRUCT
:
2736 /* Check for derivation */
2737 if (is_ancestor (parm
, arg
))
2738 return BASE_CONVERSION_BADNESS
;
2739 /* else fall through */
2741 return INCOMPATIBLE_TYPE_BADNESS
;
2744 case TYPE_CODE_UNION
:
2745 switch (TYPE_CODE (arg
))
2747 case TYPE_CODE_UNION
:
2749 return INCOMPATIBLE_TYPE_BADNESS
;
2752 case TYPE_CODE_MEMBER
:
2753 switch (TYPE_CODE (arg
))
2756 return INCOMPATIBLE_TYPE_BADNESS
;
2759 case TYPE_CODE_METHOD
:
2760 switch (TYPE_CODE (arg
))
2764 return INCOMPATIBLE_TYPE_BADNESS
;
2768 switch (TYPE_CODE (arg
))
2772 return INCOMPATIBLE_TYPE_BADNESS
;
2777 switch (TYPE_CODE (arg
))
2781 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0), TYPE_FIELD_TYPE (arg
, 0));
2783 return INCOMPATIBLE_TYPE_BADNESS
;
2786 case TYPE_CODE_VOID
:
2788 return INCOMPATIBLE_TYPE_BADNESS
;
2789 } /* switch (TYPE_CODE (arg)) */
2793 /* End of functions for overload resolution */
2796 print_bit_vector (B_TYPE
*bits
, int nbits
)
2800 for (bitno
= 0; bitno
< nbits
; bitno
++)
2802 if ((bitno
% 8) == 0)
2804 puts_filtered (" ");
2806 if (B_TST (bits
, bitno
))
2808 printf_filtered ("1");
2812 printf_filtered ("0");
2817 /* Note the first arg should be the "this" pointer, we may not want to
2818 include it since we may get into a infinitely recursive situation. */
2821 print_arg_types (struct field
*args
, int nargs
, int spaces
)
2827 for (i
= 0; i
< nargs
; i
++)
2828 recursive_dump_type (args
[i
].type
, spaces
+ 2);
2833 dump_fn_fieldlists (struct type
*type
, int spaces
)
2839 printfi_filtered (spaces
, "fn_fieldlists ");
2840 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2841 printf_filtered ("\n");
2842 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2844 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2845 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2847 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2848 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2850 printf_filtered (") length %d\n",
2851 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2852 for (overload_idx
= 0;
2853 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2856 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2858 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2859 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2861 printf_filtered (")\n");
2862 printfi_filtered (spaces
+ 8, "type ");
2863 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
2864 printf_filtered ("\n");
2866 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2869 printfi_filtered (spaces
+ 8, "args ");
2870 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
2871 printf_filtered ("\n");
2873 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2874 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
, overload_idx
)),
2876 printfi_filtered (spaces
+ 8, "fcontext ");
2877 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2879 printf_filtered ("\n");
2881 printfi_filtered (spaces
+ 8, "is_const %d\n",
2882 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2883 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2884 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2885 printfi_filtered (spaces
+ 8, "is_private %d\n",
2886 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2887 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2888 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2889 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2890 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2891 printfi_filtered (spaces
+ 8, "voffset %u\n",
2892 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2898 print_cplus_stuff (struct type
*type
, int spaces
)
2900 printfi_filtered (spaces
, "n_baseclasses %d\n",
2901 TYPE_N_BASECLASSES (type
));
2902 printfi_filtered (spaces
, "nfn_fields %d\n",
2903 TYPE_NFN_FIELDS (type
));
2904 printfi_filtered (spaces
, "nfn_fields_total %d\n",
2905 TYPE_NFN_FIELDS_TOTAL (type
));
2906 if (TYPE_N_BASECLASSES (type
) > 0)
2908 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2909 TYPE_N_BASECLASSES (type
));
2910 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
2911 printf_filtered (")");
2913 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2914 TYPE_N_BASECLASSES (type
));
2915 puts_filtered ("\n");
2917 if (TYPE_NFIELDS (type
) > 0)
2919 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2921 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
2922 TYPE_NFIELDS (type
));
2923 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
2924 printf_filtered (")");
2925 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2926 TYPE_NFIELDS (type
));
2927 puts_filtered ("\n");
2929 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2931 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
2932 TYPE_NFIELDS (type
));
2933 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
2934 printf_filtered (")");
2935 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2936 TYPE_NFIELDS (type
));
2937 puts_filtered ("\n");
2940 if (TYPE_NFN_FIELDS (type
) > 0)
2942 dump_fn_fieldlists (type
, spaces
);
2947 print_bound_type (int bt
)
2951 case BOUND_CANNOT_BE_DETERMINED
:
2952 printf_filtered ("(BOUND_CANNOT_BE_DETERMINED)");
2954 case BOUND_BY_REF_ON_STACK
:
2955 printf_filtered ("(BOUND_BY_REF_ON_STACK)");
2957 case BOUND_BY_VALUE_ON_STACK
:
2958 printf_filtered ("(BOUND_BY_VALUE_ON_STACK)");
2960 case BOUND_BY_REF_IN_REG
:
2961 printf_filtered ("(BOUND_BY_REF_IN_REG)");
2963 case BOUND_BY_VALUE_IN_REG
:
2964 printf_filtered ("(BOUND_BY_VALUE_IN_REG)");
2967 printf_filtered ("(BOUND_SIMPLE)");
2970 printf_filtered ("(unknown bound type)");
2975 static struct obstack dont_print_type_obstack
;
2978 recursive_dump_type (struct type
*type
, int spaces
)
2983 obstack_begin (&dont_print_type_obstack
, 0);
2985 if (TYPE_NFIELDS (type
) > 0
2986 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
2988 struct type
**first_dont_print
2989 = (struct type
**) obstack_base (&dont_print_type_obstack
);
2991 int i
= (struct type
**) obstack_next_free (&dont_print_type_obstack
)
2996 if (type
== first_dont_print
[i
])
2998 printfi_filtered (spaces
, "type node ");
2999 gdb_print_host_address (type
, gdb_stdout
);
3000 printf_filtered (" <same as already seen type>\n");
3005 obstack_ptr_grow (&dont_print_type_obstack
, type
);
3008 printfi_filtered (spaces
, "type node ");
3009 gdb_print_host_address (type
, gdb_stdout
);
3010 printf_filtered ("\n");
3011 printfi_filtered (spaces
, "name '%s' (",
3012 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
3013 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
3014 printf_filtered (")\n");
3015 printfi_filtered (spaces
, "tagname '%s' (",
3016 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
3017 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
3018 printf_filtered (")\n");
3019 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
3020 switch (TYPE_CODE (type
))
3022 case TYPE_CODE_UNDEF
:
3023 printf_filtered ("(TYPE_CODE_UNDEF)");
3026 printf_filtered ("(TYPE_CODE_PTR)");
3028 case TYPE_CODE_ARRAY
:
3029 printf_filtered ("(TYPE_CODE_ARRAY)");
3031 case TYPE_CODE_STRUCT
:
3032 printf_filtered ("(TYPE_CODE_STRUCT)");
3034 case TYPE_CODE_UNION
:
3035 printf_filtered ("(TYPE_CODE_UNION)");
3037 case TYPE_CODE_ENUM
:
3038 printf_filtered ("(TYPE_CODE_ENUM)");
3040 case TYPE_CODE_FUNC
:
3041 printf_filtered ("(TYPE_CODE_FUNC)");
3044 printf_filtered ("(TYPE_CODE_INT)");
3047 printf_filtered ("(TYPE_CODE_FLT)");
3049 case TYPE_CODE_VOID
:
3050 printf_filtered ("(TYPE_CODE_VOID)");
3053 printf_filtered ("(TYPE_CODE_SET)");
3055 case TYPE_CODE_RANGE
:
3056 printf_filtered ("(TYPE_CODE_RANGE)");
3058 case TYPE_CODE_STRING
:
3059 printf_filtered ("(TYPE_CODE_STRING)");
3061 case TYPE_CODE_BITSTRING
:
3062 printf_filtered ("(TYPE_CODE_BITSTRING)");
3064 case TYPE_CODE_ERROR
:
3065 printf_filtered ("(TYPE_CODE_ERROR)");
3067 case TYPE_CODE_MEMBER
:
3068 printf_filtered ("(TYPE_CODE_MEMBER)");
3070 case TYPE_CODE_METHOD
:
3071 printf_filtered ("(TYPE_CODE_METHOD)");
3074 printf_filtered ("(TYPE_CODE_REF)");
3076 case TYPE_CODE_CHAR
:
3077 printf_filtered ("(TYPE_CODE_CHAR)");
3079 case TYPE_CODE_BOOL
:
3080 printf_filtered ("(TYPE_CODE_BOOL)");
3082 case TYPE_CODE_COMPLEX
:
3083 printf_filtered ("(TYPE_CODE_COMPLEX)");
3085 case TYPE_CODE_TYPEDEF
:
3086 printf_filtered ("(TYPE_CODE_TYPEDEF)");
3088 case TYPE_CODE_TEMPLATE
:
3089 printf_filtered ("(TYPE_CODE_TEMPLATE)");
3091 case TYPE_CODE_TEMPLATE_ARG
:
3092 printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)");
3095 printf_filtered ("(UNKNOWN TYPE CODE)");
3098 puts_filtered ("\n");
3099 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
3100 printfi_filtered (spaces
, "upper_bound_type 0x%x ",
3101 TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
3102 print_bound_type (TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
3103 puts_filtered ("\n");
3104 printfi_filtered (spaces
, "lower_bound_type 0x%x ",
3105 TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
3106 print_bound_type (TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
3107 puts_filtered ("\n");
3108 printfi_filtered (spaces
, "objfile ");
3109 gdb_print_host_address (TYPE_OBJFILE (type
), gdb_stdout
);
3110 printf_filtered ("\n");
3111 printfi_filtered (spaces
, "target_type ");
3112 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
3113 printf_filtered ("\n");
3114 if (TYPE_TARGET_TYPE (type
) != NULL
)
3116 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
3118 printfi_filtered (spaces
, "pointer_type ");
3119 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
3120 printf_filtered ("\n");
3121 printfi_filtered (spaces
, "reference_type ");
3122 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
3123 printf_filtered ("\n");
3124 printfi_filtered (spaces
, "type_chain ");
3125 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
3126 printf_filtered ("\n");
3127 printfi_filtered (spaces
, "instance_flags 0x%x", TYPE_INSTANCE_FLAGS (type
));
3128 if (TYPE_CONST (type
))
3130 puts_filtered (" TYPE_FLAG_CONST");
3132 if (TYPE_VOLATILE (type
))
3134 puts_filtered (" TYPE_FLAG_VOLATILE");
3136 if (TYPE_CODE_SPACE (type
))
3138 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3140 if (TYPE_DATA_SPACE (type
))
3142 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3144 puts_filtered ("\n");
3145 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
3146 if (TYPE_UNSIGNED (type
))
3148 puts_filtered (" TYPE_FLAG_UNSIGNED");
3150 if (TYPE_NOSIGN (type
))
3152 puts_filtered (" TYPE_FLAG_NOSIGN");
3154 if (TYPE_STUB (type
))
3156 puts_filtered (" TYPE_FLAG_STUB");
3158 if (TYPE_TARGET_STUB (type
))
3160 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3162 if (TYPE_STATIC (type
))
3164 puts_filtered (" TYPE_FLAG_STATIC");
3166 if (TYPE_PROTOTYPED (type
))
3168 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3170 if (TYPE_INCOMPLETE (type
))
3172 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3174 if (TYPE_VARARGS (type
))
3176 puts_filtered (" TYPE_FLAG_VARARGS");
3178 /* This is used for things like AltiVec registers on ppc. Gcc emits
3179 an attribute for the array type, which tells whether or not we
3180 have a vector, instead of a regular array. */
3181 if (TYPE_VECTOR (type
))
3183 puts_filtered (" TYPE_FLAG_VECTOR");
3185 puts_filtered ("\n");
3186 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
3187 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
3188 puts_filtered ("\n");
3189 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
3191 printfi_filtered (spaces
+ 2,
3192 "[%d] bitpos %d bitsize %d type ",
3193 idx
, TYPE_FIELD_BITPOS (type
, idx
),
3194 TYPE_FIELD_BITSIZE (type
, idx
));
3195 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
3196 printf_filtered (" name '%s' (",
3197 TYPE_FIELD_NAME (type
, idx
) != NULL
3198 ? TYPE_FIELD_NAME (type
, idx
)
3200 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
3201 printf_filtered (")\n");
3202 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
3204 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
3207 printfi_filtered (spaces
, "vptr_basetype ");
3208 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
3209 puts_filtered ("\n");
3210 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
3212 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
3214 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
3215 switch (TYPE_CODE (type
))
3217 case TYPE_CODE_STRUCT
:
3218 printfi_filtered (spaces
, "cplus_stuff ");
3219 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
3220 puts_filtered ("\n");
3221 print_cplus_stuff (type
, spaces
);
3225 printfi_filtered (spaces
, "floatformat ");
3226 if (TYPE_FLOATFORMAT (type
) == NULL
3227 || TYPE_FLOATFORMAT (type
)->name
== NULL
)
3228 puts_filtered ("(null)");
3230 puts_filtered (TYPE_FLOATFORMAT (type
)->name
);
3231 puts_filtered ("\n");
3235 /* We have to pick one of the union types to be able print and test
3236 the value. Pick cplus_struct_type, even though we know it isn't
3237 any particular one. */
3238 printfi_filtered (spaces
, "type_specific ");
3239 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
3240 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
3242 printf_filtered (" (unknown data form)");
3244 printf_filtered ("\n");
3249 obstack_free (&dont_print_type_obstack
, NULL
);
3252 static void build_gdbtypes (void);
3254 build_gdbtypes (void)
3257 init_type (TYPE_CODE_VOID
, 1,
3259 "void", (struct objfile
*) NULL
);
3261 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3263 | (TARGET_CHAR_SIGNED
? 0 : TYPE_FLAG_UNSIGNED
)),
3264 "char", (struct objfile
*) NULL
);
3265 builtin_type_true_char
=
3266 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3268 "true character", (struct objfile
*) NULL
);
3269 builtin_type_signed_char
=
3270 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3272 "signed char", (struct objfile
*) NULL
);
3273 builtin_type_unsigned_char
=
3274 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3276 "unsigned char", (struct objfile
*) NULL
);
3277 builtin_type_short
=
3278 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
3280 "short", (struct objfile
*) NULL
);
3281 builtin_type_unsigned_short
=
3282 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
3284 "unsigned short", (struct objfile
*) NULL
);
3286 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3288 "int", (struct objfile
*) NULL
);
3289 builtin_type_unsigned_int
=
3290 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3292 "unsigned int", (struct objfile
*) NULL
);
3294 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
3296 "long", (struct objfile
*) NULL
);
3297 builtin_type_unsigned_long
=
3298 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
3300 "unsigned long", (struct objfile
*) NULL
);
3301 builtin_type_long_long
=
3302 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
3304 "long long", (struct objfile
*) NULL
);
3305 builtin_type_unsigned_long_long
=
3306 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
3308 "unsigned long long", (struct objfile
*) NULL
);
3309 builtin_type_float
=
3310 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
3312 "float", (struct objfile
*) NULL
);
3313 /* vinschen@redhat.com 2002-02-08:
3314 The below lines are disabled since they are doing the wrong
3315 thing for non-multiarch targets. They are setting the correct
3316 type of floats for the target but while on multiarch targets
3317 this is done everytime the architecture changes, it's done on
3318 non-multiarch targets only on startup, leaving the wrong values
3319 in even if the architecture changes (eg. from big-endian to
3322 TYPE_FLOATFORMAT (builtin_type_float
) = TARGET_FLOAT_FORMAT
;
3324 builtin_type_double
=
3325 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3327 "double", (struct objfile
*) NULL
);
3329 TYPE_FLOATFORMAT (builtin_type_double
) = TARGET_DOUBLE_FORMAT
;
3331 builtin_type_long_double
=
3332 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3334 "long double", (struct objfile
*) NULL
);
3336 TYPE_FLOATFORMAT (builtin_type_long_double
) = TARGET_LONG_DOUBLE_FORMAT
;
3338 builtin_type_complex
=
3339 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
3341 "complex", (struct objfile
*) NULL
);
3342 TYPE_TARGET_TYPE (builtin_type_complex
) = builtin_type_float
;
3343 builtin_type_double_complex
=
3344 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3346 "double complex", (struct objfile
*) NULL
);
3347 TYPE_TARGET_TYPE (builtin_type_double_complex
) = builtin_type_double
;
3348 builtin_type_string
=
3349 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3351 "string", (struct objfile
*) NULL
);
3353 init_type (TYPE_CODE_INT
, 8 / 8,
3355 "int8_t", (struct objfile
*) NULL
);
3356 builtin_type_uint8
=
3357 init_type (TYPE_CODE_INT
, 8 / 8,
3359 "uint8_t", (struct objfile
*) NULL
);
3360 builtin_type_int16
=
3361 init_type (TYPE_CODE_INT
, 16 / 8,
3363 "int16_t", (struct objfile
*) NULL
);
3364 builtin_type_uint16
=
3365 init_type (TYPE_CODE_INT
, 16 / 8,
3367 "uint16_t", (struct objfile
*) NULL
);
3368 builtin_type_int32
=
3369 init_type (TYPE_CODE_INT
, 32 / 8,
3371 "int32_t", (struct objfile
*) NULL
);
3372 builtin_type_uint32
=
3373 init_type (TYPE_CODE_INT
, 32 / 8,
3375 "uint32_t", (struct objfile
*) NULL
);
3376 builtin_type_int64
=
3377 init_type (TYPE_CODE_INT
, 64 / 8,
3379 "int64_t", (struct objfile
*) NULL
);
3380 builtin_type_uint64
=
3381 init_type (TYPE_CODE_INT
, 64 / 8,
3383 "uint64_t", (struct objfile
*) NULL
);
3384 builtin_type_int128
=
3385 init_type (TYPE_CODE_INT
, 128 / 8,
3387 "int128_t", (struct objfile
*) NULL
);
3388 builtin_type_uint128
=
3389 init_type (TYPE_CODE_INT
, 128 / 8,
3391 "uint128_t", (struct objfile
*) NULL
);
3393 init_type (TYPE_CODE_BOOL
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3395 "bool", (struct objfile
*) NULL
);
3397 /* Add user knob for controlling resolution of opaque types */
3399 (add_set_cmd ("opaque-type-resolution", class_support
, var_boolean
, (char *) &opaque_type_resolution
,
3400 "Set resolution of opaque struct/class/union types (if set before loading symbols).",
3403 opaque_type_resolution
= 1;
3405 /* Build SIMD types. */
3407 = init_simd_type ("__builtin_v4sf", builtin_type_float
, "f", 4);
3409 = init_simd_type ("__builtin_v4si", builtin_type_int32
, "f", 4);
3411 = init_simd_type ("__builtin_v16qi", builtin_type_int8
, "f", 16);
3413 = init_simd_type ("__builtin_v8qi", builtin_type_int8
, "f", 8);
3415 = init_simd_type ("__builtin_v8hi", builtin_type_int16
, "f", 8);
3417 = init_simd_type ("__builtin_v4hi", builtin_type_int16
, "f", 4);
3419 = init_simd_type ("__builtin_v2si", builtin_type_int32
, "f", 2);
3421 /* 128 bit vectors. */
3422 builtin_type_v2_double
= init_vector_type (builtin_type_double
, 2);
3423 builtin_type_v4_float
= init_vector_type (builtin_type_float
, 4);
3424 builtin_type_v2_int64
= init_vector_type (builtin_type_int64
, 2);
3425 builtin_type_v4_int32
= init_vector_type (builtin_type_int32
, 4);
3426 builtin_type_v8_int16
= init_vector_type (builtin_type_int16
, 8);
3427 builtin_type_v16_int8
= init_vector_type (builtin_type_int8
, 16);
3428 /* 64 bit vectors. */
3429 builtin_type_v2_float
= init_vector_type (builtin_type_float
, 2);
3430 builtin_type_v2_int32
= init_vector_type (builtin_type_int32
, 2);
3431 builtin_type_v4_int16
= init_vector_type (builtin_type_int16
, 4);
3432 builtin_type_v8_int8
= init_vector_type (builtin_type_int8
, 8);
3435 builtin_type_vec64
= build_builtin_type_vec64 ();
3436 builtin_type_vec64i
= build_builtin_type_vec64i ();
3437 builtin_type_vec128
= build_builtin_type_vec128 ();
3438 builtin_type_vec128i
= build_builtin_type_vec128i ();
3440 /* Pointer/Address types. */
3442 /* NOTE: on some targets, addresses and pointers are not necessarily
3443 the same --- for example, on the D10V, pointers are 16 bits long,
3444 but addresses are 32 bits long. See doc/gdbint.texinfo,
3445 ``Pointers Are Not Always Addresses''.
3448 - gdb's `struct type' always describes the target's
3450 - gdb's `struct value' objects should always hold values in
3452 - gdb's CORE_ADDR values are addresses in the unified virtual
3453 address space that the assembler and linker work with. Thus,
3454 since target_read_memory takes a CORE_ADDR as an argument, it
3455 can access any memory on the target, even if the processor has
3456 separate code and data address spaces.
3459 - If v is a value holding a D10V code pointer, its contents are
3460 in target form: a big-endian address left-shifted two bits.
3461 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3462 sizeof (void *) == 2 on the target.
3464 In this context, builtin_type_CORE_ADDR is a bit odd: it's a
3465 target type for a value the target will never see. It's only
3466 used to hold the values of (typeless) linker symbols, which are
3467 indeed in the unified virtual address space. */
3468 builtin_type_void_data_ptr
= make_pointer_type (builtin_type_void
, NULL
);
3469 builtin_type_void_func_ptr
3470 = lookup_pointer_type (lookup_function_type (builtin_type_void
));
3471 builtin_type_CORE_ADDR
=
3472 init_type (TYPE_CODE_INT
, TARGET_ADDR_BIT
/ 8,
3474 "__CORE_ADDR", (struct objfile
*) NULL
);
3475 builtin_type_bfd_vma
=
3476 init_type (TYPE_CODE_INT
, TARGET_BFD_VMA_BIT
/ 8,
3478 "__bfd_vma", (struct objfile
*) NULL
);
3481 extern void _initialize_gdbtypes (void);
3483 _initialize_gdbtypes (void)
3485 struct cmd_list_element
*c
;
3488 /* FIXME - For the moment, handle types by swapping them in and out.
3489 Should be using the per-architecture data-pointer and a large
3491 register_gdbarch_swap (&builtin_type_void
, sizeof (struct type
*), NULL
);
3492 register_gdbarch_swap (&builtin_type_char
, sizeof (struct type
*), NULL
);
3493 register_gdbarch_swap (&builtin_type_short
, sizeof (struct type
*), NULL
);
3494 register_gdbarch_swap (&builtin_type_int
, sizeof (struct type
*), NULL
);
3495 register_gdbarch_swap (&builtin_type_long
, sizeof (struct type
*), NULL
);
3496 register_gdbarch_swap (&builtin_type_long_long
, sizeof (struct type
*), NULL
);
3497 register_gdbarch_swap (&builtin_type_signed_char
, sizeof (struct type
*), NULL
);
3498 register_gdbarch_swap (&builtin_type_unsigned_char
, sizeof (struct type
*), NULL
);
3499 register_gdbarch_swap (&builtin_type_unsigned_short
, sizeof (struct type
*), NULL
);
3500 register_gdbarch_swap (&builtin_type_unsigned_int
, sizeof (struct type
*), NULL
);
3501 register_gdbarch_swap (&builtin_type_unsigned_long
, sizeof (struct type
*), NULL
);
3502 register_gdbarch_swap (&builtin_type_unsigned_long_long
, sizeof (struct type
*), NULL
);
3503 register_gdbarch_swap (&builtin_type_float
, sizeof (struct type
*), NULL
);
3504 register_gdbarch_swap (&builtin_type_double
, sizeof (struct type
*), NULL
);
3505 register_gdbarch_swap (&builtin_type_long_double
, sizeof (struct type
*), NULL
);
3506 register_gdbarch_swap (&builtin_type_complex
, sizeof (struct type
*), NULL
);
3507 register_gdbarch_swap (&builtin_type_double_complex
, sizeof (struct type
*), NULL
);
3508 register_gdbarch_swap (&builtin_type_string
, sizeof (struct type
*), NULL
);
3509 register_gdbarch_swap (&builtin_type_int8
, sizeof (struct type
*), NULL
);
3510 register_gdbarch_swap (&builtin_type_uint8
, sizeof (struct type
*), NULL
);
3511 register_gdbarch_swap (&builtin_type_int16
, sizeof (struct type
*), NULL
);
3512 register_gdbarch_swap (&builtin_type_uint16
, sizeof (struct type
*), NULL
);
3513 register_gdbarch_swap (&builtin_type_int32
, sizeof (struct type
*), NULL
);
3514 register_gdbarch_swap (&builtin_type_uint32
, sizeof (struct type
*), NULL
);
3515 register_gdbarch_swap (&builtin_type_int64
, sizeof (struct type
*), NULL
);
3516 register_gdbarch_swap (&builtin_type_uint64
, sizeof (struct type
*), NULL
);
3517 register_gdbarch_swap (&builtin_type_int128
, sizeof (struct type
*), NULL
);
3518 register_gdbarch_swap (&builtin_type_uint128
, sizeof (struct type
*), NULL
);
3519 register_gdbarch_swap (&builtin_type_v4sf
, sizeof (struct type
*), NULL
);
3520 register_gdbarch_swap (&builtin_type_v4si
, sizeof (struct type
*), NULL
);
3521 register_gdbarch_swap (&builtin_type_v16qi
, sizeof (struct type
*), NULL
);
3522 register_gdbarch_swap (&builtin_type_v8qi
, sizeof (struct type
*), NULL
);
3523 register_gdbarch_swap (&builtin_type_v8hi
, sizeof (struct type
*), NULL
);
3524 register_gdbarch_swap (&builtin_type_v4hi
, sizeof (struct type
*), NULL
);
3525 register_gdbarch_swap (&builtin_type_v2si
, sizeof (struct type
*), NULL
);
3526 register_gdbarch_swap (&builtin_type_v2_double
, sizeof (struct type
*), NULL
);
3527 register_gdbarch_swap (&builtin_type_v4_float
, sizeof (struct type
*), NULL
);
3528 register_gdbarch_swap (&builtin_type_v2_int64
, sizeof (struct type
*), NULL
);
3529 register_gdbarch_swap (&builtin_type_v4_int32
, sizeof (struct type
*), NULL
);
3530 register_gdbarch_swap (&builtin_type_v8_int16
, sizeof (struct type
*), NULL
);
3531 register_gdbarch_swap (&builtin_type_v16_int8
, sizeof (struct type
*), NULL
);
3532 register_gdbarch_swap (&builtin_type_v2_float
, sizeof (struct type
*), NULL
);
3533 register_gdbarch_swap (&builtin_type_v2_int32
, sizeof (struct type
*), NULL
);
3534 register_gdbarch_swap (&builtin_type_v8_int8
, sizeof (struct type
*), NULL
);
3535 register_gdbarch_swap (&builtin_type_v4_int16
, sizeof (struct type
*), NULL
);
3536 register_gdbarch_swap (&builtin_type_vec128
, sizeof (struct type
*), NULL
);
3537 register_gdbarch_swap (&builtin_type_vec128i
, sizeof (struct type
*), NULL
);
3538 REGISTER_GDBARCH_SWAP (builtin_type_void_data_ptr
);
3539 REGISTER_GDBARCH_SWAP (builtin_type_void_func_ptr
);
3540 REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR
);
3541 REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma
);
3542 register_gdbarch_swap (NULL
, 0, build_gdbtypes
);
3544 /* Note: These types do not need to be swapped - they are target
3546 builtin_type_ieee_single_big
=
3547 init_type (TYPE_CODE_FLT
, floatformat_ieee_single_big
.totalsize
/ 8,
3548 0, "builtin_type_ieee_single_big", NULL
);
3549 TYPE_FLOATFORMAT (builtin_type_ieee_single_big
) = &floatformat_ieee_single_big
;
3550 builtin_type_ieee_single_little
=
3551 init_type (TYPE_CODE_FLT
, floatformat_ieee_single_little
.totalsize
/ 8,
3552 0, "builtin_type_ieee_single_little", NULL
);
3553 TYPE_FLOATFORMAT (builtin_type_ieee_single_little
) = &floatformat_ieee_single_little
;
3554 builtin_type_ieee_double_big
=
3555 init_type (TYPE_CODE_FLT
, floatformat_ieee_double_big
.totalsize
/ 8,
3556 0, "builtin_type_ieee_double_big", NULL
);
3557 TYPE_FLOATFORMAT (builtin_type_ieee_double_big
) = &floatformat_ieee_double_big
;
3558 builtin_type_ieee_double_little
=
3559 init_type (TYPE_CODE_FLT
, floatformat_ieee_double_little
.totalsize
/ 8,
3560 0, "builtin_type_ieee_double_little", NULL
);
3561 TYPE_FLOATFORMAT (builtin_type_ieee_double_little
) = &floatformat_ieee_double_little
;
3562 builtin_type_ieee_double_littlebyte_bigword
=
3563 init_type (TYPE_CODE_FLT
, floatformat_ieee_double_littlebyte_bigword
.totalsize
/ 8,
3564 0, "builtin_type_ieee_double_littlebyte_bigword", NULL
);
3565 TYPE_FLOATFORMAT (builtin_type_ieee_double_littlebyte_bigword
) = &floatformat_ieee_double_littlebyte_bigword
;
3566 builtin_type_i387_ext
=
3567 init_type (TYPE_CODE_FLT
, floatformat_i387_ext
.totalsize
/ 8,
3568 0, "builtin_type_i387_ext", NULL
);
3569 TYPE_FLOATFORMAT (builtin_type_i387_ext
) = &floatformat_i387_ext
;
3570 builtin_type_m68881_ext
=
3571 init_type (TYPE_CODE_FLT
, floatformat_m68881_ext
.totalsize
/ 8,
3572 0, "builtin_type_m68881_ext", NULL
);
3573 TYPE_FLOATFORMAT (builtin_type_m68881_ext
) = &floatformat_m68881_ext
;
3574 builtin_type_i960_ext
=
3575 init_type (TYPE_CODE_FLT
, floatformat_i960_ext
.totalsize
/ 8,
3576 0, "builtin_type_i960_ext", NULL
);
3577 TYPE_FLOATFORMAT (builtin_type_i960_ext
) = &floatformat_i960_ext
;
3578 builtin_type_m88110_ext
=
3579 init_type (TYPE_CODE_FLT
, floatformat_m88110_ext
.totalsize
/ 8,
3580 0, "builtin_type_m88110_ext", NULL
);
3581 TYPE_FLOATFORMAT (builtin_type_m88110_ext
) = &floatformat_m88110_ext
;
3582 builtin_type_m88110_harris_ext
=
3583 init_type (TYPE_CODE_FLT
, floatformat_m88110_harris_ext
.totalsize
/ 8,
3584 0, "builtin_type_m88110_harris_ext", NULL
);
3585 TYPE_FLOATFORMAT (builtin_type_m88110_harris_ext
) = &floatformat_m88110_harris_ext
;
3586 builtin_type_arm_ext_big
=
3587 init_type (TYPE_CODE_FLT
, floatformat_arm_ext_big
.totalsize
/ 8,
3588 0, "builtin_type_arm_ext_big", NULL
);
3589 TYPE_FLOATFORMAT (builtin_type_arm_ext_big
) = &floatformat_arm_ext_big
;
3590 builtin_type_arm_ext_littlebyte_bigword
=
3591 init_type (TYPE_CODE_FLT
, floatformat_arm_ext_littlebyte_bigword
.totalsize
/ 8,
3592 0, "builtin_type_arm_ext_littlebyte_bigword", NULL
);
3593 TYPE_FLOATFORMAT (builtin_type_arm_ext_littlebyte_bigword
) = &floatformat_arm_ext_littlebyte_bigword
;
3594 builtin_type_ia64_spill_big
=
3595 init_type (TYPE_CODE_FLT
, floatformat_ia64_spill_big
.totalsize
/ 8,
3596 0, "builtin_type_ia64_spill_big", NULL
);
3597 TYPE_FLOATFORMAT (builtin_type_ia64_spill_big
) = &floatformat_ia64_spill_big
;
3598 builtin_type_ia64_spill_little
=
3599 init_type (TYPE_CODE_FLT
, floatformat_ia64_spill_little
.totalsize
/ 8,
3600 0, "builtin_type_ia64_spill_little", NULL
);
3601 TYPE_FLOATFORMAT (builtin_type_ia64_spill_little
) = &floatformat_ia64_spill_little
;
3602 builtin_type_ia64_quad_big
=
3603 init_type (TYPE_CODE_FLT
, floatformat_ia64_quad_big
.totalsize
/ 8,
3604 0, "builtin_type_ia64_quad_big", NULL
);
3605 TYPE_FLOATFORMAT (builtin_type_ia64_quad_big
) = &floatformat_ia64_quad_big
;
3606 builtin_type_ia64_quad_little
=
3607 init_type (TYPE_CODE_FLT
, floatformat_ia64_quad_little
.totalsize
/ 8,
3608 0, "builtin_type_ia64_quad_little", NULL
);
3609 TYPE_FLOATFORMAT (builtin_type_ia64_quad_little
) = &floatformat_ia64_quad_little
;
3612 add_set_cmd ("overload", no_class
, var_zinteger
, (char *) &overload_debug
,
3613 "Set debugging of C++ overloading.\n\
3614 When enabled, ranking of the functions\n\
3615 is displayed.", &setdebuglist
),