1 /* Support routines for manipulating internal types for GDB.
2 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004 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_int0
;
64 struct type
*builtin_type_int8
;
65 struct type
*builtin_type_uint8
;
66 struct type
*builtin_type_int16
;
67 struct type
*builtin_type_uint16
;
68 struct type
*builtin_type_int32
;
69 struct type
*builtin_type_uint32
;
70 struct type
*builtin_type_int64
;
71 struct type
*builtin_type_uint64
;
72 struct type
*builtin_type_int128
;
73 struct type
*builtin_type_uint128
;
74 struct type
*builtin_type_bool
;
76 /* 128 bit long vector types */
77 struct type
*builtin_type_v2_double
;
78 struct type
*builtin_type_v4_float
;
79 struct type
*builtin_type_v2_int64
;
80 struct type
*builtin_type_v4_int32
;
81 struct type
*builtin_type_v8_int16
;
82 struct type
*builtin_type_v16_int8
;
83 /* 64 bit long vector types */
84 struct type
*builtin_type_v2_float
;
85 struct type
*builtin_type_v2_int32
;
86 struct type
*builtin_type_v4_int16
;
87 struct type
*builtin_type_v8_int8
;
89 struct type
*builtin_type_v4sf
;
90 struct type
*builtin_type_v4si
;
91 struct type
*builtin_type_v16qi
;
92 struct type
*builtin_type_v8qi
;
93 struct type
*builtin_type_v8hi
;
94 struct type
*builtin_type_v4hi
;
95 struct type
*builtin_type_v2si
;
96 struct type
*builtin_type_vec64
;
97 struct type
*builtin_type_vec64i
;
98 struct type
*builtin_type_vec128
;
99 struct type
*builtin_type_vec128i
;
100 struct type
*builtin_type_ieee_single_big
;
101 struct type
*builtin_type_ieee_single_little
;
102 struct type
*builtin_type_ieee_double_big
;
103 struct type
*builtin_type_ieee_double_little
;
104 struct type
*builtin_type_ieee_double_littlebyte_bigword
;
105 struct type
*builtin_type_i387_ext
;
106 struct type
*builtin_type_m68881_ext
;
107 struct type
*builtin_type_i960_ext
;
108 struct type
*builtin_type_m88110_ext
;
109 struct type
*builtin_type_m88110_harris_ext
;
110 struct type
*builtin_type_arm_ext_big
;
111 struct type
*builtin_type_arm_ext_littlebyte_bigword
;
112 struct type
*builtin_type_ia64_spill_big
;
113 struct type
*builtin_type_ia64_spill_little
;
114 struct type
*builtin_type_ia64_quad_big
;
115 struct type
*builtin_type_ia64_quad_little
;
116 struct type
*builtin_type_void_data_ptr
;
117 struct type
*builtin_type_void_func_ptr
;
118 struct type
*builtin_type_CORE_ADDR
;
119 struct type
*builtin_type_bfd_vma
;
121 int opaque_type_resolution
= 1;
122 int overload_debug
= 0;
128 }; /* maximum extension is 128! FIXME */
130 static void print_bit_vector (B_TYPE
*, int);
131 static void print_arg_types (struct field
*, int, int);
132 static void dump_fn_fieldlists (struct type
*, int);
133 static void print_cplus_stuff (struct type
*, int);
134 static void virtual_base_list_aux (struct type
*dclass
);
137 /* Alloc a new type structure and fill it with some defaults. If
138 OBJFILE is non-NULL, then allocate the space for the type structure
139 in that objfile's objfile_obstack. Otherwise allocate the new type structure
140 by xmalloc () (for permanent types). */
143 alloc_type (struct objfile
*objfile
)
147 /* Alloc the structure and start off with all fields zeroed. */
151 type
= xmalloc (sizeof (struct type
));
152 memset (type
, 0, sizeof (struct type
));
153 TYPE_MAIN_TYPE (type
) = xmalloc (sizeof (struct main_type
));
157 type
= obstack_alloc (&objfile
->objfile_obstack
,
158 sizeof (struct type
));
159 memset (type
, 0, sizeof (struct type
));
160 TYPE_MAIN_TYPE (type
) = obstack_alloc (&objfile
->objfile_obstack
,
161 sizeof (struct main_type
));
162 OBJSTAT (objfile
, n_types
++);
164 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
166 /* Initialize the fields that might not be zero. */
168 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
169 TYPE_OBJFILE (type
) = objfile
;
170 TYPE_VPTR_FIELDNO (type
) = -1;
171 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
176 /* Alloc a new type instance structure, fill it with some defaults,
177 and point it at OLDTYPE. Allocate the new type instance from the
178 same place as OLDTYPE. */
181 alloc_type_instance (struct type
*oldtype
)
185 /* Allocate the structure. */
187 if (TYPE_OBJFILE (oldtype
) == NULL
)
189 type
= xmalloc (sizeof (struct type
));
190 memset (type
, 0, sizeof (struct type
));
194 type
= obstack_alloc (&TYPE_OBJFILE (oldtype
)->objfile_obstack
,
195 sizeof (struct type
));
196 memset (type
, 0, sizeof (struct type
));
198 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
200 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
205 /* Clear all remnants of the previous type at TYPE, in preparation for
206 replacing it with something else. */
208 smash_type (struct type
*type
)
210 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
212 /* For now, delete the rings. */
213 TYPE_CHAIN (type
) = type
;
215 /* For now, leave the pointer/reference types alone. */
218 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
219 to a pointer to memory where the pointer type should be stored.
220 If *TYPEPTR is zero, update it to point to the pointer type we return.
221 We allocate new memory if needed. */
224 make_pointer_type (struct type
*type
, struct type
**typeptr
)
226 struct type
*ntype
; /* New type */
227 struct objfile
*objfile
;
229 ntype
= TYPE_POINTER_TYPE (type
);
234 return ntype
; /* Don't care about alloc, and have new type. */
235 else if (*typeptr
== 0)
237 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
242 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
244 ntype
= alloc_type (TYPE_OBJFILE (type
));
249 /* We have storage, but need to reset it. */
252 objfile
= TYPE_OBJFILE (ntype
);
254 TYPE_OBJFILE (ntype
) = objfile
;
257 TYPE_TARGET_TYPE (ntype
) = type
;
258 TYPE_POINTER_TYPE (type
) = ntype
;
260 /* FIXME! Assume the machine has only one representation for pointers! */
262 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
263 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
265 /* Mark pointers as unsigned. The target converts between pointers
266 and addresses (CORE_ADDRs) using POINTER_TO_ADDRESS() and
267 ADDRESS_TO_POINTER(). */
268 TYPE_FLAGS (ntype
) |= TYPE_FLAG_UNSIGNED
;
270 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
271 TYPE_POINTER_TYPE (type
) = ntype
;
276 /* Given a type TYPE, return a type of pointers to that type.
277 May need to construct such a type if this is the first use. */
280 lookup_pointer_type (struct type
*type
)
282 return make_pointer_type (type
, (struct type
**) 0);
285 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero, points
286 to a pointer to memory where the reference type should be stored.
287 If *TYPEPTR is zero, update it to point to the reference type we return.
288 We allocate new memory if needed. */
291 make_reference_type (struct type
*type
, struct type
**typeptr
)
293 struct type
*ntype
; /* New type */
294 struct objfile
*objfile
;
296 ntype
= TYPE_REFERENCE_TYPE (type
);
301 return ntype
; /* Don't care about alloc, and have new type. */
302 else if (*typeptr
== 0)
304 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
309 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
311 ntype
= alloc_type (TYPE_OBJFILE (type
));
316 /* We have storage, but need to reset it. */
319 objfile
= TYPE_OBJFILE (ntype
);
321 TYPE_OBJFILE (ntype
) = objfile
;
324 TYPE_TARGET_TYPE (ntype
) = type
;
325 TYPE_REFERENCE_TYPE (type
) = ntype
;
327 /* FIXME! Assume the machine has only one representation for references,
328 and that it matches the (only) representation for pointers! */
330 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
331 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
333 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
334 TYPE_REFERENCE_TYPE (type
) = ntype
;
339 /* Same as above, but caller doesn't care about memory allocation details. */
342 lookup_reference_type (struct type
*type
)
344 return make_reference_type (type
, (struct type
**) 0);
347 /* Lookup a function type that returns type TYPE. TYPEPTR, if nonzero, points
348 to a pointer to memory where the function type should be stored.
349 If *TYPEPTR is zero, update it to point to the function type we return.
350 We allocate new memory if needed. */
353 make_function_type (struct type
*type
, struct type
**typeptr
)
355 struct type
*ntype
; /* New type */
356 struct objfile
*objfile
;
358 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
360 ntype
= alloc_type (TYPE_OBJFILE (type
));
365 /* We have storage, but need to reset it. */
368 objfile
= TYPE_OBJFILE (ntype
);
370 TYPE_OBJFILE (ntype
) = objfile
;
373 TYPE_TARGET_TYPE (ntype
) = type
;
375 TYPE_LENGTH (ntype
) = 1;
376 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
382 /* Given a type TYPE, return a type of functions that return that type.
383 May need to construct such a type if this is the first use. */
386 lookup_function_type (struct type
*type
)
388 return make_function_type (type
, (struct type
**) 0);
391 /* Identify address space identifier by name --
392 return the integer flag defined in gdbtypes.h. */
394 address_space_name_to_int (char *space_identifier
)
396 struct gdbarch
*gdbarch
= current_gdbarch
;
398 /* Check for known address space delimiters. */
399 if (!strcmp (space_identifier
, "code"))
400 return TYPE_FLAG_CODE_SPACE
;
401 else if (!strcmp (space_identifier
, "data"))
402 return TYPE_FLAG_DATA_SPACE
;
403 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
404 && gdbarch_address_class_name_to_type_flags (gdbarch
,
409 error ("Unknown address space specifier: \"%s\"", space_identifier
);
412 /* Identify address space identifier by integer flag as defined in
413 gdbtypes.h -- return the string version of the adress space name. */
416 address_space_int_to_name (int space_flag
)
418 struct gdbarch
*gdbarch
= current_gdbarch
;
419 if (space_flag
& TYPE_FLAG_CODE_SPACE
)
421 else if (space_flag
& TYPE_FLAG_DATA_SPACE
)
423 else if ((space_flag
& TYPE_FLAG_ADDRESS_CLASS_ALL
)
424 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
425 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
430 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
431 If STORAGE is non-NULL, create the new type instance there. */
434 make_qualified_type (struct type
*type
, int new_flags
,
435 struct type
*storage
)
441 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
443 ntype
= TYPE_CHAIN (ntype
);
444 } while (ntype
!= type
);
446 /* Create a new type instance. */
448 ntype
= alloc_type_instance (type
);
452 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
453 TYPE_CHAIN (ntype
) = ntype
;
456 /* Pointers or references to the original type are not relevant to
458 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
459 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
461 /* Chain the new qualified type to the old type. */
462 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
463 TYPE_CHAIN (type
) = ntype
;
465 /* Now set the instance flags and return the new type. */
466 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
468 /* Set length of new type to that of the original type. */
469 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
474 /* Make an address-space-delimited variant of a type -- a type that
475 is identical to the one supplied except that it has an address
476 space attribute attached to it (such as "code" or "data").
478 The space attributes "code" and "data" are for Harvard architectures.
479 The address space attributes are for architectures which have
480 alternately sized pointers or pointers with alternate representations. */
483 make_type_with_address_space (struct type
*type
, int space_flag
)
486 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
487 & ~(TYPE_FLAG_CODE_SPACE
| TYPE_FLAG_DATA_SPACE
488 | TYPE_FLAG_ADDRESS_CLASS_ALL
))
491 return make_qualified_type (type
, new_flags
, NULL
);
494 /* Make a "c-v" variant of a type -- a type that is identical to the
495 one supplied except that it may have const or volatile attributes
496 CNST is a flag for setting the const attribute
497 VOLTL is a flag for setting the volatile attribute
498 TYPE is the base type whose variant we are creating.
499 TYPEPTR, if nonzero, points
500 to a pointer to memory where the reference type should be stored.
501 If *TYPEPTR is zero, update it to point to the reference type we return.
502 We allocate new memory if needed. */
505 make_cv_type (int cnst
, int voltl
, struct type
*type
, struct type
**typeptr
)
507 struct type
*ntype
; /* New type */
508 struct type
*tmp_type
= type
; /* tmp type */
509 struct objfile
*objfile
;
511 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
512 & ~(TYPE_FLAG_CONST
| TYPE_FLAG_VOLATILE
));
515 new_flags
|= TYPE_FLAG_CONST
;
518 new_flags
|= TYPE_FLAG_VOLATILE
;
520 if (typeptr
&& *typeptr
!= NULL
)
522 /* Objfile is per-core-type. This const-qualified type had best
523 belong to the same objfile as the type it is qualifying, unless
524 we are overwriting a stub type, in which case the safest thing
525 to do is to copy the core type into the new objfile. */
527 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
)
528 || TYPE_STUB (*typeptr
));
529 if (TYPE_OBJFILE (*typeptr
) != TYPE_OBJFILE (type
))
531 TYPE_MAIN_TYPE (*typeptr
)
532 = TYPE_ALLOC (*typeptr
, sizeof (struct main_type
));
533 *TYPE_MAIN_TYPE (*typeptr
)
534 = *TYPE_MAIN_TYPE (type
);
538 ntype
= make_qualified_type (type
, new_flags
, typeptr
? *typeptr
: NULL
);
546 /* Replace the contents of ntype with the type *type. This changes the
547 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
548 the changes are propogated to all types in the TYPE_CHAIN.
550 In order to build recursive types, it's inevitable that we'll need
551 to update types in place --- but this sort of indiscriminate
552 smashing is ugly, and needs to be replaced with something more
553 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
554 clear if more steps are needed. */
556 replace_type (struct type
*ntype
, struct type
*type
)
560 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
562 /* The type length is not a part of the main type. Update it for each
563 type on the variant chain. */
566 /* Assert that this element of the chain has no address-class bits
567 set in its flags. Such type variants might have type lengths
568 which are supposed to be different from the non-address-class
569 variants. This assertion shouldn't ever be triggered because
570 symbol readers which do construct address-class variants don't
571 call replace_type(). */
572 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
574 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
575 chain
= TYPE_CHAIN (chain
);
576 } while (ntype
!= chain
);
578 /* Assert that the two types have equivalent instance qualifiers.
579 This should be true for at least all of our debug readers. */
580 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
583 /* Implement direct support for MEMBER_TYPE in GNU C++.
584 May need to construct such a type if this is the first use.
585 The TYPE is the type of the member. The DOMAIN is the type
586 of the aggregate that the member belongs to. */
589 lookup_member_type (struct type
*type
, struct type
*domain
)
593 mtype
= alloc_type (TYPE_OBJFILE (type
));
594 smash_to_member_type (mtype
, domain
, type
);
598 /* Allocate a stub method whose return type is TYPE.
599 This apparently happens for speed of symbol reading, since parsing
600 out the arguments to the method is cpu-intensive, the way we are doing
601 it. So, we will fill in arguments later.
602 This always returns a fresh type. */
605 allocate_stub_method (struct type
*type
)
609 mtype
= init_type (TYPE_CODE_METHOD
, 1, TYPE_FLAG_STUB
, NULL
,
610 TYPE_OBJFILE (type
));
611 TYPE_TARGET_TYPE (mtype
) = type
;
612 /* _DOMAIN_TYPE (mtype) = unknown yet */
616 /* Create a range type using either a blank type supplied in RESULT_TYPE,
617 or creating a new type, inheriting the objfile from INDEX_TYPE.
619 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
620 HIGH_BOUND, inclusive.
622 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
623 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
626 create_range_type (struct type
*result_type
, struct type
*index_type
,
627 int low_bound
, int high_bound
)
629 if (result_type
== NULL
)
631 result_type
= alloc_type (TYPE_OBJFILE (index_type
));
633 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
634 TYPE_TARGET_TYPE (result_type
) = index_type
;
635 if (TYPE_STUB (index_type
))
636 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
638 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
639 TYPE_NFIELDS (result_type
) = 2;
640 TYPE_FIELDS (result_type
) = (struct field
*)
641 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
642 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
643 TYPE_FIELD_BITPOS (result_type
, 0) = low_bound
;
644 TYPE_FIELD_BITPOS (result_type
, 1) = high_bound
;
645 TYPE_FIELD_TYPE (result_type
, 0) = builtin_type_int
; /* FIXME */
646 TYPE_FIELD_TYPE (result_type
, 1) = builtin_type_int
; /* FIXME */
649 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
651 return (result_type
);
654 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE.
655 Return 1 of type is a range type, 0 if it is discrete (and bounds
656 will fit in LONGEST), or -1 otherwise. */
659 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
661 CHECK_TYPEDEF (type
);
662 switch (TYPE_CODE (type
))
664 case TYPE_CODE_RANGE
:
665 *lowp
= TYPE_LOW_BOUND (type
);
666 *highp
= TYPE_HIGH_BOUND (type
);
669 if (TYPE_NFIELDS (type
) > 0)
671 /* The enums may not be sorted by value, so search all
675 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
676 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
678 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
679 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
680 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
681 *highp
= TYPE_FIELD_BITPOS (type
, i
);
684 /* Set unsigned indicator if warranted. */
687 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
701 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
703 if (!TYPE_UNSIGNED (type
))
705 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
709 /* ... fall through for unsigned ints ... */
712 /* This round-about calculation is to avoid shifting by
713 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
714 if TYPE_LENGTH (type) == sizeof (LONGEST). */
715 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
716 *highp
= (*highp
- 1) | *highp
;
723 /* Create an array type using either a blank type supplied in RESULT_TYPE,
724 or creating a new type, inheriting the objfile from RANGE_TYPE.
726 Elements will be of type ELEMENT_TYPE, the indices will be of type
729 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
730 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
733 create_array_type (struct type
*result_type
, struct type
*element_type
,
734 struct type
*range_type
)
736 LONGEST low_bound
, high_bound
;
738 if (result_type
== NULL
)
740 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
742 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
743 TYPE_TARGET_TYPE (result_type
) = element_type
;
744 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
745 low_bound
= high_bound
= 0;
746 CHECK_TYPEDEF (element_type
);
747 TYPE_LENGTH (result_type
) =
748 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
749 TYPE_NFIELDS (result_type
) = 1;
750 TYPE_FIELDS (result_type
) =
751 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
752 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
753 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
754 TYPE_VPTR_FIELDNO (result_type
) = -1;
756 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
757 if (TYPE_LENGTH (result_type
) == 0)
758 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
760 return (result_type
);
763 /* Create a string type using either a blank type supplied in RESULT_TYPE,
764 or creating a new type. String types are similar enough to array of
765 char types that we can use create_array_type to build the basic type
766 and then bash it into a string type.
768 For fixed length strings, the range type contains 0 as the lower
769 bound and the length of the string minus one as the upper bound.
771 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
772 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
775 create_string_type (struct type
*result_type
, struct type
*range_type
)
777 struct type
*string_char_type
;
779 string_char_type
= language_string_char_type (current_language
,
781 result_type
= create_array_type (result_type
,
784 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
785 return (result_type
);
789 create_set_type (struct type
*result_type
, struct type
*domain_type
)
791 LONGEST low_bound
, high_bound
, bit_length
;
792 if (result_type
== NULL
)
794 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
796 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
797 TYPE_NFIELDS (result_type
) = 1;
798 TYPE_FIELDS (result_type
) = (struct field
*)
799 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
800 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
802 if (!TYPE_STUB (domain_type
))
804 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
805 low_bound
= high_bound
= 0;
806 bit_length
= high_bound
- low_bound
+ 1;
807 TYPE_LENGTH (result_type
)
808 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
810 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
813 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
815 return (result_type
);
818 /* Construct and return a type of the form:
819 struct NAME { ELT_TYPE ELT_NAME[N]; }
820 We use these types for SIMD registers. For example, the type of
821 the SSE registers on the late x86-family processors is:
822 struct __builtin_v4sf { float f[4]; }
823 built by the function call:
824 init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4)
825 The type returned is a permanent type, allocated using malloc; it
826 doesn't live in any objfile's obstack. */
828 init_simd_type (char *name
,
829 struct type
*elt_type
,
833 struct type
*simd_type
;
834 struct type
*array_type
;
836 simd_type
= init_composite_type (name
, TYPE_CODE_STRUCT
);
837 array_type
= create_array_type (0, elt_type
,
838 create_range_type (0, builtin_type_int
,
840 append_composite_type_field (simd_type
, elt_name
, array_type
);
845 init_vector_type (struct type
*elt_type
, int n
)
847 struct type
*array_type
;
849 array_type
= create_array_type (0, elt_type
,
850 create_range_type (0, builtin_type_int
,
852 TYPE_FLAGS (array_type
) |= TYPE_FLAG_VECTOR
;
857 build_builtin_type_vec64 (void)
859 /* Construct a type for the 64 bit registers. The type we're
862 union __gdb_builtin_type_vec64
874 t
= init_composite_type ("__gdb_builtin_type_vec64", TYPE_CODE_UNION
);
875 append_composite_type_field (t
, "uint64", builtin_type_int64
);
876 append_composite_type_field (t
, "v2_float", builtin_type_v2_float
);
877 append_composite_type_field (t
, "v2_int32", builtin_type_v2_int32
);
878 append_composite_type_field (t
, "v4_int16", builtin_type_v4_int16
);
879 append_composite_type_field (t
, "v8_int8", builtin_type_v8_int8
);
881 TYPE_FLAGS (t
) |= TYPE_FLAG_VECTOR
;
882 TYPE_NAME (t
) = "builtin_type_vec64";
887 build_builtin_type_vec64i (void)
889 /* Construct a type for the 64 bit registers. The type we're
892 union __gdb_builtin_type_vec64i
903 t
= init_composite_type ("__gdb_builtin_type_vec64i", TYPE_CODE_UNION
);
904 append_composite_type_field (t
, "uint64", builtin_type_int64
);
905 append_composite_type_field (t
, "v2_int32", builtin_type_v2_int32
);
906 append_composite_type_field (t
, "v4_int16", builtin_type_v4_int16
);
907 append_composite_type_field (t
, "v8_int8", builtin_type_v8_int8
);
909 TYPE_FLAGS (t
) |= TYPE_FLAG_VECTOR
;
910 TYPE_NAME (t
) = "builtin_type_vec64i";
915 build_builtin_type_vec128 (void)
917 /* Construct a type for the 128 bit registers. The type we're
920 union __gdb_builtin_type_vec128
932 t
= init_composite_type ("__gdb_builtin_type_vec128", TYPE_CODE_UNION
);
933 append_composite_type_field (t
, "uint128", builtin_type_int128
);
934 append_composite_type_field (t
, "v4_float", builtin_type_v4_float
);
935 append_composite_type_field (t
, "v4_int32", builtin_type_v4_int32
);
936 append_composite_type_field (t
, "v8_int16", builtin_type_v8_int16
);
937 append_composite_type_field (t
, "v16_int8", builtin_type_v16_int8
);
939 TYPE_FLAGS (t
) |= TYPE_FLAG_VECTOR
;
940 TYPE_NAME (t
) = "builtin_type_vec128";
945 build_builtin_type_vec128i (void)
947 /* 128-bit Intel SIMD registers */
950 t
= init_composite_type ("__gdb_builtin_type_vec128i", TYPE_CODE_UNION
);
951 append_composite_type_field (t
, "v4_float", builtin_type_v4_float
);
952 append_composite_type_field (t
, "v2_double", builtin_type_v2_double
);
953 append_composite_type_field (t
, "v16_int8", builtin_type_v16_int8
);
954 append_composite_type_field (t
, "v8_int16", builtin_type_v8_int16
);
955 append_composite_type_field (t
, "v4_int32", builtin_type_v4_int32
);
956 append_composite_type_field (t
, "v2_int64", builtin_type_v2_int64
);
957 append_composite_type_field (t
, "uint128", builtin_type_int128
);
959 TYPE_FLAGS (t
) |= TYPE_FLAG_VECTOR
;
960 TYPE_NAME (t
) = "builtin_type_vec128i";
964 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
965 A MEMBER is a wierd thing -- it amounts to a typed offset into
966 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
967 include the offset (that's the value of the MEMBER itself), but does
968 include the structure type into which it points (for some reason).
970 When "smashing" the type, we preserve the objfile that the
971 old type pointed to, since we aren't changing where the type is actually
975 smash_to_member_type (struct type
*type
, struct type
*domain
,
976 struct type
*to_type
)
978 struct objfile
*objfile
;
980 objfile
= TYPE_OBJFILE (type
);
983 TYPE_OBJFILE (type
) = objfile
;
984 TYPE_TARGET_TYPE (type
) = to_type
;
985 TYPE_DOMAIN_TYPE (type
) = domain
;
986 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
987 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
990 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
991 METHOD just means `function that gets an extra "this" argument'.
993 When "smashing" the type, we preserve the objfile that the
994 old type pointed to, since we aren't changing where the type is actually
998 smash_to_method_type (struct type
*type
, struct type
*domain
,
999 struct type
*to_type
, struct field
*args
,
1000 int nargs
, int varargs
)
1002 struct objfile
*objfile
;
1004 objfile
= TYPE_OBJFILE (type
);
1007 TYPE_OBJFILE (type
) = objfile
;
1008 TYPE_TARGET_TYPE (type
) = to_type
;
1009 TYPE_DOMAIN_TYPE (type
) = domain
;
1010 TYPE_FIELDS (type
) = args
;
1011 TYPE_NFIELDS (type
) = nargs
;
1013 TYPE_FLAGS (type
) |= TYPE_FLAG_VARARGS
;
1014 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1015 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
1018 /* Return a typename for a struct/union/enum type without "struct ",
1019 "union ", or "enum ". If the type has a NULL name, return NULL. */
1022 type_name_no_tag (const struct type
*type
)
1024 if (TYPE_TAG_NAME (type
) != NULL
)
1025 return TYPE_TAG_NAME (type
);
1027 /* Is there code which expects this to return the name if there is no
1028 tag name? My guess is that this is mainly used for C++ in cases where
1029 the two will always be the same. */
1030 return TYPE_NAME (type
);
1033 /* Lookup a primitive type named NAME.
1034 Return zero if NAME is not a primitive type. */
1037 lookup_primitive_typename (char *name
)
1039 return language_lookup_primitive_type_by_name (current_language
,
1044 /* Lookup a typedef or primitive type named NAME,
1045 visible in lexical block BLOCK.
1046 If NOERR is nonzero, return zero if NAME is not suitably defined. */
1049 lookup_typename (char *name
, struct block
*block
, int noerr
)
1054 sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, 0, (struct symtab
**) NULL
);
1055 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1057 tmp
= lookup_primitive_typename (name
);
1062 else if (!tmp
&& noerr
)
1068 error ("No type named %s.", name
);
1071 return (SYMBOL_TYPE (sym
));
1075 lookup_unsigned_typename (char *name
)
1077 char *uns
= alloca (strlen (name
) + 10);
1079 strcpy (uns
, "unsigned ");
1080 strcpy (uns
+ 9, name
);
1081 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
1085 lookup_signed_typename (char *name
)
1088 char *uns
= alloca (strlen (name
) + 8);
1090 strcpy (uns
, "signed ");
1091 strcpy (uns
+ 7, name
);
1092 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
1093 /* If we don't find "signed FOO" just try again with plain "FOO". */
1096 return lookup_typename (name
, (struct block
*) NULL
, 0);
1099 /* Lookup a structure type named "struct NAME",
1100 visible in lexical block BLOCK. */
1103 lookup_struct (char *name
, struct block
*block
)
1107 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
1108 (struct symtab
**) NULL
);
1112 error ("No struct type named %s.", name
);
1114 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1116 error ("This context has class, union or enum %s, not a struct.", name
);
1118 return (SYMBOL_TYPE (sym
));
1121 /* Lookup a union type named "union NAME",
1122 visible in lexical block BLOCK. */
1125 lookup_union (char *name
, struct block
*block
)
1130 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
1131 (struct symtab
**) NULL
);
1134 error ("No union type named %s.", name
);
1136 t
= SYMBOL_TYPE (sym
);
1138 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1141 /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
1142 * a further "declared_type" field to discover it is really a union.
1144 if (HAVE_CPLUS_STRUCT (t
))
1145 if (TYPE_DECLARED_TYPE (t
) == DECLARED_TYPE_UNION
)
1148 /* If we get here, it's not a union */
1149 error ("This context has class, struct or enum %s, not a union.", name
);
1153 /* Lookup an enum type named "enum NAME",
1154 visible in lexical block BLOCK. */
1157 lookup_enum (char *name
, struct block
*block
)
1161 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
1162 (struct symtab
**) NULL
);
1165 error ("No enum type named %s.", name
);
1167 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1169 error ("This context has class, struct or union %s, not an enum.", name
);
1171 return (SYMBOL_TYPE (sym
));
1174 /* Lookup a template type named "template NAME<TYPE>",
1175 visible in lexical block BLOCK. */
1178 lookup_template_type (char *name
, struct type
*type
, struct block
*block
)
1181 char *nam
= (char *) alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1184 strcat (nam
, TYPE_NAME (type
));
1185 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1187 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0, (struct symtab
**) NULL
);
1191 error ("No template type named %s.", name
);
1193 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1195 error ("This context has class, union or enum %s, not a struct.", name
);
1197 return (SYMBOL_TYPE (sym
));
1200 /* Given a type TYPE, lookup the type of the component of type named NAME.
1202 TYPE can be either a struct or union, or a pointer or reference to a struct or
1203 union. If it is a pointer or reference, its target type is automatically used.
1204 Thus '.' and '->' are interchangable, as specified for the definitions of the
1205 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
1207 If NOERR is nonzero, return zero if NAME is not suitably defined.
1208 If NAME is the name of a baseclass type, return that type. */
1211 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
1217 CHECK_TYPEDEF (type
);
1218 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1219 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1221 type
= TYPE_TARGET_TYPE (type
);
1224 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
1225 TYPE_CODE (type
) != TYPE_CODE_UNION
)
1227 target_terminal_ours ();
1228 gdb_flush (gdb_stdout
);
1229 fprintf_unfiltered (gdb_stderr
, "Type ");
1230 type_print (type
, "", gdb_stderr
, -1);
1231 error (" is not a structure or union type.");
1235 /* FIXME: This change put in by Michael seems incorrect for the case where
1236 the structure tag name is the same as the member name. I.E. when doing
1237 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
1242 typename
= type_name_no_tag (type
);
1243 if (typename
!= NULL
&& strcmp (typename
, name
) == 0)
1248 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1250 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1252 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1254 return TYPE_FIELD_TYPE (type
, i
);
1258 /* OK, it's not in this class. Recursively check the baseclasses. */
1259 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1263 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, noerr
);
1275 target_terminal_ours ();
1276 gdb_flush (gdb_stdout
);
1277 fprintf_unfiltered (gdb_stderr
, "Type ");
1278 type_print (type
, "", gdb_stderr
, -1);
1279 fprintf_unfiltered (gdb_stderr
, " has no component named ");
1280 fputs_filtered (name
, gdb_stderr
);
1282 return (struct type
*) -1; /* For lint */
1285 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
1286 valid. Callers should be aware that in some cases (for example,
1287 the type or one of its baseclasses is a stub type and we are
1288 debugging a .o file), this function will not be able to find the virtual
1289 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
1290 will remain NULL. */
1293 fill_in_vptr_fieldno (struct type
*type
)
1295 CHECK_TYPEDEF (type
);
1297 if (TYPE_VPTR_FIELDNO (type
) < 0)
1301 /* We must start at zero in case the first (and only) baseclass is
1302 virtual (and hence we cannot share the table pointer). */
1303 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1305 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1306 fill_in_vptr_fieldno (baseclass
);
1307 if (TYPE_VPTR_FIELDNO (baseclass
) >= 0)
1309 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (baseclass
);
1310 TYPE_VPTR_BASETYPE (type
) = TYPE_VPTR_BASETYPE (baseclass
);
1317 /* Find the method and field indices for the destructor in class type T.
1318 Return 1 if the destructor was found, otherwise, return 0. */
1321 get_destructor_fn_field (struct type
*t
, int *method_indexp
, int *field_indexp
)
1325 for (i
= 0; i
< TYPE_NFN_FIELDS (t
); i
++)
1328 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1330 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (t
, i
); j
++)
1332 if (is_destructor_name (TYPE_FN_FIELD_PHYSNAME (f
, j
)) != 0)
1344 stub_noname_complaint (void)
1346 complaint (&symfile_complaints
, "stub type has NULL name");
1349 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1351 If this is a stubbed struct (i.e. declared as struct foo *), see if
1352 we can find a full definition in some other file. If so, copy this
1353 definition, so we can use it in future. There used to be a comment (but
1354 not any code) that if we don't find a full definition, we'd set a flag
1355 so we don't spend time in the future checking the same type. That would
1356 be a mistake, though--we might load in more symbols which contain a
1357 full definition for the type.
1359 This used to be coded as a macro, but I don't think it is called
1360 often enough to merit such treatment. */
1362 /* Find the real type of TYPE. This function returns the real type, after
1363 removing all layers of typedefs and completing opaque or stub types.
1364 Completion changes the TYPE argument, but stripping of typedefs does
1368 check_typedef (struct type
*type
)
1370 struct type
*orig_type
= type
;
1371 int is_const
, is_volatile
;
1373 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1375 if (!TYPE_TARGET_TYPE (type
))
1380 /* It is dangerous to call lookup_symbol if we are currently
1381 reading a symtab. Infinite recursion is one danger. */
1382 if (currently_reading_symtab
)
1385 name
= type_name_no_tag (type
);
1386 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1387 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1388 as appropriate? (this code was written before TYPE_NAME and
1389 TYPE_TAG_NAME were separate). */
1392 stub_noname_complaint ();
1395 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0,
1396 (struct symtab
**) NULL
);
1398 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1400 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
); /* TYPE_CODE_UNDEF */
1402 type
= TYPE_TARGET_TYPE (type
);
1405 is_const
= TYPE_CONST (type
);
1406 is_volatile
= TYPE_VOLATILE (type
);
1408 /* If this is a struct/class/union with no fields, then check whether a
1409 full definition exists somewhere else. This is for systems where a
1410 type definition with no fields is issued for such types, instead of
1411 identifying them as stub types in the first place */
1413 if (TYPE_IS_OPAQUE (type
) && opaque_type_resolution
&& !currently_reading_symtab
)
1415 char *name
= type_name_no_tag (type
);
1416 struct type
*newtype
;
1419 stub_noname_complaint ();
1422 newtype
= lookup_transparent_type (name
);
1424 make_cv_type (is_const
, is_volatile
, newtype
, &type
);
1426 /* Otherwise, rely on the stub flag being set for opaque/stubbed types */
1427 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1429 char *name
= type_name_no_tag (type
);
1430 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1431 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1432 as appropriate? (this code was written before TYPE_NAME and
1433 TYPE_TAG_NAME were separate). */
1437 stub_noname_complaint ();
1440 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0, (struct symtab
**) NULL
);
1442 make_cv_type (is_const
, is_volatile
, SYMBOL_TYPE (sym
), &type
);
1445 if (TYPE_TARGET_STUB (type
))
1447 struct type
*range_type
;
1448 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1450 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1453 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1454 && TYPE_NFIELDS (type
) == 1
1455 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
1456 == TYPE_CODE_RANGE
))
1458 /* Now recompute the length of the array type, based on its
1459 number of elements and the target type's length. */
1460 TYPE_LENGTH (type
) =
1461 ((TYPE_FIELD_BITPOS (range_type
, 1)
1462 - TYPE_FIELD_BITPOS (range_type
, 0)
1464 * TYPE_LENGTH (target_type
));
1465 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1467 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1469 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1470 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1473 /* Cache TYPE_LENGTH for future use. */
1474 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1478 /* Parse a type expression in the string [P..P+LENGTH). If an error occurs,
1479 silently return builtin_type_void. */
1481 static struct type
*
1482 safe_parse_type (char *p
, int length
)
1484 struct ui_file
*saved_gdb_stderr
;
1487 /* Suppress error messages. */
1488 saved_gdb_stderr
= gdb_stderr
;
1489 gdb_stderr
= ui_file_new ();
1491 /* Call parse_and_eval_type() without fear of longjmp()s. */
1492 if (!gdb_parse_and_eval_type (p
, length
, &type
))
1493 type
= builtin_type_void
;
1495 /* Stop suppressing error messages. */
1496 ui_file_delete (gdb_stderr
);
1497 gdb_stderr
= saved_gdb_stderr
;
1502 /* Ugly hack to convert method stubs into method types.
1504 He ain't kiddin'. This demangles the name of the method into a string
1505 including argument types, parses out each argument type, generates
1506 a string casting a zero to that type, evaluates the string, and stuffs
1507 the resulting type into an argtype vector!!! Then it knows the type
1508 of the whole function (including argument types for overloading),
1509 which info used to be in the stab's but was removed to hack back
1510 the space required for them. */
1513 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1516 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1517 char *demangled_name
= cplus_demangle (mangled_name
,
1518 DMGL_PARAMS
| DMGL_ANSI
);
1519 char *argtypetext
, *p
;
1520 int depth
= 0, argcount
= 1;
1521 struct field
*argtypes
;
1524 /* Make sure we got back a function string that we can use. */
1526 p
= strchr (demangled_name
, '(');
1530 if (demangled_name
== NULL
|| p
== NULL
)
1531 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
1533 /* Now, read in the parameters that define this type. */
1538 if (*p
== '(' || *p
== '<')
1542 else if (*p
== ')' || *p
== '>')
1546 else if (*p
== ',' && depth
== 0)
1554 /* If we read one argument and it was ``void'', don't count it. */
1555 if (strncmp (argtypetext
, "(void)", 6) == 0)
1558 /* We need one extra slot, for the THIS pointer. */
1560 argtypes
= (struct field
*)
1561 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
1564 /* Add THIS pointer for non-static methods. */
1565 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1566 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
1570 argtypes
[0].type
= lookup_pointer_type (type
);
1574 if (*p
!= ')') /* () means no args, skip while */
1579 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1581 /* Avoid parsing of ellipsis, they will be handled below.
1582 Also avoid ``void'' as above. */
1583 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
1584 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
1586 argtypes
[argcount
].type
=
1587 safe_parse_type (argtypetext
, p
- argtypetext
);
1590 argtypetext
= p
+ 1;
1593 if (*p
== '(' || *p
== '<')
1597 else if (*p
== ')' || *p
== '>')
1606 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1608 /* Now update the old "stub" type into a real type. */
1609 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1610 TYPE_DOMAIN_TYPE (mtype
) = type
;
1611 TYPE_FIELDS (mtype
) = argtypes
;
1612 TYPE_NFIELDS (mtype
) = argcount
;
1613 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1614 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1616 TYPE_FLAGS (mtype
) |= TYPE_FLAG_VARARGS
;
1618 xfree (demangled_name
);
1621 /* This is the external interface to check_stub_method, above. This function
1622 unstubs all of the signatures for TYPE's METHOD_ID method name. After
1623 calling this function TYPE_FN_FIELD_STUB will be cleared for each signature
1624 and TYPE_FN_FIELDLIST_NAME will be correct.
1626 This function unfortunately can not die until stabs do. */
1629 check_stub_method_group (struct type
*type
, int method_id
)
1631 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
1632 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1633 int j
, found_stub
= 0;
1635 for (j
= 0; j
< len
; j
++)
1636 if (TYPE_FN_FIELD_STUB (f
, j
))
1639 check_stub_method (type
, method_id
, j
);
1642 /* GNU v3 methods with incorrect names were corrected when we read in
1643 type information, because it was cheaper to do it then. The only GNU v2
1644 methods with incorrect method names are operators and destructors;
1645 destructors were also corrected when we read in type information.
1647 Therefore the only thing we need to handle here are v2 operator
1649 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
1652 char dem_opname
[256];
1654 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
, method_id
),
1655 dem_opname
, DMGL_ANSI
);
1657 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
, method_id
),
1660 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
1664 const struct cplus_struct_type cplus_struct_default
;
1667 allocate_cplus_struct_type (struct type
*type
)
1669 if (!HAVE_CPLUS_STRUCT (type
))
1671 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1672 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1673 *(TYPE_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1677 /* Helper function to initialize the standard scalar types.
1679 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1680 of the string pointed to by name in the objfile_obstack for that objfile,
1681 and initialize the type name to that copy. There are places (mipsread.c
1682 in particular, where init_type is called with a NULL value for NAME). */
1685 init_type (enum type_code code
, int length
, int flags
, char *name
,
1686 struct objfile
*objfile
)
1690 type
= alloc_type (objfile
);
1691 TYPE_CODE (type
) = code
;
1692 TYPE_LENGTH (type
) = length
;
1693 TYPE_FLAGS (type
) |= flags
;
1694 if ((name
!= NULL
) && (objfile
!= NULL
))
1697 obsavestring (name
, strlen (name
), &objfile
->objfile_obstack
);
1701 TYPE_NAME (type
) = name
;
1706 if (name
&& strcmp (name
, "char") == 0)
1707 TYPE_FLAGS (type
) |= TYPE_FLAG_NOSIGN
;
1709 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
1710 || code
== TYPE_CODE_NAMESPACE
)
1712 INIT_CPLUS_SPECIFIC (type
);
1717 /* Helper function. Create an empty composite type. */
1720 init_composite_type (char *name
, enum type_code code
)
1723 gdb_assert (code
== TYPE_CODE_STRUCT
1724 || code
== TYPE_CODE_UNION
);
1725 t
= init_type (code
, 0, 0, NULL
, NULL
);
1726 TYPE_TAG_NAME (t
) = name
;
1730 /* Helper function. Append a field to a composite type. */
1733 append_composite_type_field (struct type
*t
, char *name
, struct type
*field
)
1736 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
1737 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
1738 sizeof (struct field
) * TYPE_NFIELDS (t
));
1739 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
1740 memset (f
, 0, sizeof f
[0]);
1741 FIELD_TYPE (f
[0]) = field
;
1742 FIELD_NAME (f
[0]) = name
;
1743 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1745 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
1746 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
1748 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
1750 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
1751 if (TYPE_NFIELDS (t
) > 1)
1753 FIELD_BITPOS (f
[0]) = (FIELD_BITPOS (f
[-1])
1754 + TYPE_LENGTH (field
) * TARGET_CHAR_BIT
);
1759 /* Look up a fundamental type for the specified objfile.
1760 May need to construct such a type if this is the first use.
1762 Some object file formats (ELF, COFF, etc) do not define fundamental
1763 types such as "int" or "double". Others (stabs for example), do
1764 define fundamental types.
1766 For the formats which don't provide fundamental types, gdb can create
1767 such types, using defaults reasonable for the current language and
1768 the current target machine.
1770 NOTE: This routine is obsolescent. Each debugging format reader
1771 should manage it's own fundamental types, either creating them from
1772 suitable defaults or reading them from the debugging information,
1773 whichever is appropriate. The DWARF reader has already been
1774 fixed to do this. Once the other readers are fixed, this routine
1775 will go away. Also note that fundamental types should be managed
1776 on a compilation unit basis in a multi-language environment, not
1777 on a linkage unit basis as is done here. */
1781 lookup_fundamental_type (struct objfile
*objfile
, int typeid)
1783 struct type
**typep
;
1786 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1788 error ("internal error - invalid fundamental type id %d", typeid);
1791 /* If this is the first time we need a fundamental type for this objfile
1792 then we need to initialize the vector of type pointers. */
1794 if (objfile
->fundamental_types
== NULL
)
1796 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1797 objfile
->fundamental_types
= (struct type
**)
1798 obstack_alloc (&objfile
->objfile_obstack
, nbytes
);
1799 memset ((char *) objfile
->fundamental_types
, 0, nbytes
);
1800 OBJSTAT (objfile
, n_types
+= FT_NUM_MEMBERS
);
1803 /* Look for this particular type in the fundamental type vector. If one is
1804 not found, create and install one appropriate for the current language. */
1806 typep
= objfile
->fundamental_types
+ typeid;
1809 *typep
= create_fundamental_type (objfile
, typeid);
1816 can_dereference (struct type
*t
)
1818 /* FIXME: Should we return true for references as well as pointers? */
1822 && TYPE_CODE (t
) == TYPE_CODE_PTR
1823 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1827 is_integral_type (struct type
*t
)
1832 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
1833 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
1834 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
1835 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
1836 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
1839 /* Check whether BASE is an ancestor or base class or DCLASS
1840 Return 1 if so, and 0 if not.
1841 Note: callers may want to check for identity of the types before
1842 calling this function -- identical types are considered to satisfy
1843 the ancestor relationship even if they're identical */
1846 is_ancestor (struct type
*base
, struct type
*dclass
)
1850 CHECK_TYPEDEF (base
);
1851 CHECK_TYPEDEF (dclass
);
1855 if (TYPE_NAME (base
) && TYPE_NAME (dclass
) &&
1856 !strcmp (TYPE_NAME (base
), TYPE_NAME (dclass
)))
1859 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1860 if (is_ancestor (base
, TYPE_BASECLASS (dclass
, i
)))
1868 /* See whether DCLASS has a virtual table. This routine is aimed at
1869 the HP/Taligent ANSI C++ runtime model, and may not work with other
1870 runtime models. Return 1 => Yes, 0 => No. */
1873 has_vtable (struct type
*dclass
)
1875 /* In the HP ANSI C++ runtime model, a class has a vtable only if it
1876 has virtual functions or virtual bases. */
1880 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1883 /* First check for the presence of virtual bases */
1884 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
1885 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1886 if (B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
))
1889 /* Next check for virtual functions */
1890 if (TYPE_FN_FIELDLISTS (dclass
))
1891 for (i
= 0; i
< TYPE_NFN_FIELDS (dclass
); i
++)
1892 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, i
), 0))
1895 /* Recurse on non-virtual bases to see if any of them needs a vtable */
1896 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
1897 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1898 if ((!B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
)) &&
1899 (has_vtable (TYPE_FIELD_TYPE (dclass
, i
))))
1902 /* Well, maybe we don't need a virtual table */
1906 /* Return a pointer to the "primary base class" of DCLASS.
1908 A NULL return indicates that DCLASS has no primary base, or that it
1909 couldn't be found (insufficient information).
1911 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
1912 and may not work with other runtime models. */
1915 primary_base_class (struct type
*dclass
)
1917 /* In HP ANSI C++'s runtime model, a "primary base class" of a class
1918 is the first directly inherited, non-virtual base class that
1919 requires a virtual table */
1923 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1926 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1927 if (!TYPE_FIELD_VIRTUAL (dclass
, i
) &&
1928 has_vtable (TYPE_FIELD_TYPE (dclass
, i
)))
1929 return TYPE_FIELD_TYPE (dclass
, i
);
1934 /* Global manipulated by virtual_base_list[_aux]() */
1936 static struct vbase
*current_vbase_list
= NULL
;
1938 /* Return a pointer to a null-terminated list of struct vbase
1939 items. The vbasetype pointer of each item in the list points to the
1940 type information for a virtual base of the argument DCLASS.
1942 Helper function for virtual_base_list().
1943 Note: the list goes backward, right-to-left. virtual_base_list()
1944 copies the items out in reverse order. */
1947 virtual_base_list_aux (struct type
*dclass
)
1949 struct vbase
*tmp_vbase
;
1952 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1955 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1957 /* Recurse on this ancestor, first */
1958 virtual_base_list_aux (TYPE_FIELD_TYPE (dclass
, i
));
1960 /* If this current base is itself virtual, add it to the list */
1961 if (BASETYPE_VIA_VIRTUAL (dclass
, i
))
1963 struct type
*basetype
= TYPE_FIELD_TYPE (dclass
, i
);
1965 /* Check if base already recorded */
1966 tmp_vbase
= current_vbase_list
;
1969 if (tmp_vbase
->vbasetype
== basetype
)
1970 break; /* found it */
1971 tmp_vbase
= tmp_vbase
->next
;
1974 if (!tmp_vbase
) /* normal exit from loop */
1976 /* Allocate new item for this virtual base */
1977 tmp_vbase
= (struct vbase
*) xmalloc (sizeof (struct vbase
));
1979 /* Stick it on at the end of the list */
1980 tmp_vbase
->vbasetype
= basetype
;
1981 tmp_vbase
->next
= current_vbase_list
;
1982 current_vbase_list
= tmp_vbase
;
1985 } /* for loop over bases */
1989 /* Compute the list of virtual bases in the right order. Virtual
1990 bases are laid out in the object's memory area in order of their
1991 occurrence in a depth-first, left-to-right search through the
1994 Argument DCLASS is the type whose virtual bases are required.
1995 Return value is the address of a null-terminated array of pointers
1996 to struct type items.
1998 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
1999 and may not work with other runtime models.
2001 This routine merely hands off the argument to virtual_base_list_aux()
2002 and then copies the result into an array to save space. */
2005 virtual_base_list (struct type
*dclass
)
2007 struct vbase
*tmp_vbase
;
2008 struct vbase
*tmp_vbase_2
;
2011 struct type
**vbase_array
;
2013 current_vbase_list
= NULL
;
2014 virtual_base_list_aux (dclass
);
2016 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
2021 vbase_array
= (struct type
**) xmalloc ((count
+ 1) * sizeof (struct type
*));
2023 for (i
= count
- 1, tmp_vbase
= current_vbase_list
; i
>= 0; i
--, tmp_vbase
= tmp_vbase
->next
)
2024 vbase_array
[i
] = tmp_vbase
->vbasetype
;
2026 /* Get rid of constructed chain */
2027 tmp_vbase_2
= tmp_vbase
= current_vbase_list
;
2030 tmp_vbase
= tmp_vbase
->next
;
2031 xfree (tmp_vbase_2
);
2032 tmp_vbase_2
= tmp_vbase
;
2035 vbase_array
[count
] = NULL
;
2039 /* Return the length of the virtual base list of the type DCLASS. */
2042 virtual_base_list_length (struct type
*dclass
)
2045 struct vbase
*tmp_vbase
;
2047 current_vbase_list
= NULL
;
2048 virtual_base_list_aux (dclass
);
2050 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
2055 /* Return the number of elements of the virtual base list of the type
2056 DCLASS, ignoring those appearing in the primary base (and its
2057 primary base, recursively). */
2060 virtual_base_list_length_skip_primaries (struct type
*dclass
)
2063 struct vbase
*tmp_vbase
;
2064 struct type
*primary
;
2066 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
2069 return virtual_base_list_length (dclass
);
2071 current_vbase_list
= NULL
;
2072 virtual_base_list_aux (dclass
);
2074 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; tmp_vbase
= tmp_vbase
->next
)
2076 if (virtual_base_index (tmp_vbase
->vbasetype
, primary
) >= 0)
2084 /* Return the index (position) of type BASE, which is a virtual base
2085 class of DCLASS, in the latter's virtual base list. A return of -1
2086 indicates "not found" or a problem. */
2089 virtual_base_index (struct type
*base
, struct type
*dclass
)
2094 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
2095 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
2099 vbase
= virtual_base_list (dclass
)[0];
2104 vbase
= virtual_base_list (dclass
)[++i
];
2107 return vbase
? i
: -1;
2112 /* Return the index (position) of type BASE, which is a virtual base
2113 class of DCLASS, in the latter's virtual base list. Skip over all
2114 bases that may appear in the virtual base list of the primary base
2115 class of DCLASS (recursively). A return of -1 indicates "not
2116 found" or a problem. */
2119 virtual_base_index_skip_primaries (struct type
*base
, struct type
*dclass
)
2123 struct type
*primary
;
2125 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
2126 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
2129 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
2133 vbase
= virtual_base_list (dclass
)[0];
2136 if (!primary
|| (virtual_base_index_skip_primaries (vbase
, primary
) < 0))
2140 vbase
= virtual_base_list (dclass
)[++i
];
2143 return vbase
? j
: -1;
2146 /* Return position of a derived class DCLASS in the list of
2147 * primary bases starting with the remotest ancestor.
2148 * Position returned is 0-based. */
2151 class_index_in_primary_list (struct type
*dclass
)
2153 struct type
*pbc
; /* primary base class */
2155 /* Simply recurse on primary base */
2156 pbc
= TYPE_PRIMARY_BASE (dclass
);
2158 return 1 + class_index_in_primary_list (pbc
);
2163 /* Return a count of the number of virtual functions a type has.
2164 * This includes all the virtual functions it inherits from its
2168 /* pai: FIXME This doesn't do the right thing: count redefined virtual
2169 * functions only once (latest redefinition)
2173 count_virtual_fns (struct type
*dclass
)
2175 int fn
, oi
; /* function and overloaded instance indices */
2176 int vfuncs
; /* count to return */
2178 /* recurse on bases that can share virtual table */
2179 struct type
*pbc
= primary_base_class (dclass
);
2181 vfuncs
= count_virtual_fns (pbc
);
2185 for (fn
= 0; fn
< TYPE_NFN_FIELDS (dclass
); fn
++)
2186 for (oi
= 0; oi
< TYPE_FN_FIELDLIST_LENGTH (dclass
, fn
); oi
++)
2187 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, fn
), oi
))
2195 /* Functions for overload resolution begin here */
2197 /* Compare two badness vectors A and B and return the result.
2198 * 0 => A and B are identical
2199 * 1 => A and B are incomparable
2200 * 2 => A is better than B
2201 * 3 => A is worse than B */
2204 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
2208 short found_pos
= 0; /* any positives in c? */
2209 short found_neg
= 0; /* any negatives in c? */
2211 /* differing lengths => incomparable */
2212 if (a
->length
!= b
->length
)
2215 /* Subtract b from a */
2216 for (i
= 0; i
< a
->length
; i
++)
2218 tmp
= a
->rank
[i
] - b
->rank
[i
];
2228 return 1; /* incomparable */
2230 return 3; /* A > B */
2236 return 2; /* A < B */
2238 return 0; /* A == B */
2242 /* Rank a function by comparing its parameter types (PARMS, length NPARMS),
2243 * to the types of an argument list (ARGS, length NARGS).
2244 * Return a pointer to a badness vector. This has NARGS + 1 entries. */
2246 struct badness_vector
*
2247 rank_function (struct type
**parms
, int nparms
, struct type
**args
, int nargs
)
2250 struct badness_vector
*bv
;
2251 int min_len
= nparms
< nargs
? nparms
: nargs
;
2253 bv
= xmalloc (sizeof (struct badness_vector
));
2254 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank */
2255 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
2257 /* First compare the lengths of the supplied lists.
2258 * If there is a mismatch, set it to a high value. */
2260 /* pai/1997-06-03 FIXME: when we have debug info about default
2261 * arguments and ellipsis parameter lists, we should consider those
2262 * and rank the length-match more finely. */
2264 LENGTH_MATCH (bv
) = (nargs
!= nparms
) ? LENGTH_MISMATCH_BADNESS
: 0;
2266 /* Now rank all the parameters of the candidate function */
2267 for (i
= 1; i
<= min_len
; i
++)
2268 bv
->rank
[i
] = rank_one_type (parms
[i
-1], args
[i
-1]);
2270 /* If more arguments than parameters, add dummy entries */
2271 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2272 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2277 /* Compare the names of two integer types, assuming that any sign
2278 qualifiers have been checked already. We do it this way because
2279 there may be an "int" in the name of one of the types. */
2282 integer_types_same_name_p (const char *first
, const char *second
)
2284 int first_p
, second_p
;
2286 /* If both are shorts, return 1; if neither is a short, keep checking. */
2287 first_p
= (strstr (first
, "short") != NULL
);
2288 second_p
= (strstr (second
, "short") != NULL
);
2289 if (first_p
&& second_p
)
2291 if (first_p
|| second_p
)
2294 /* Likewise for long. */
2295 first_p
= (strstr (first
, "long") != NULL
);
2296 second_p
= (strstr (second
, "long") != NULL
);
2297 if (first_p
&& second_p
)
2299 if (first_p
|| second_p
)
2302 /* Likewise for char. */
2303 first_p
= (strstr (first
, "char") != NULL
);
2304 second_p
= (strstr (second
, "char") != NULL
);
2305 if (first_p
&& second_p
)
2307 if (first_p
|| second_p
)
2310 /* They must both be ints. */
2314 /* Compare one type (PARM) for compatibility with another (ARG).
2315 * PARM is intended to be the parameter type of a function; and
2316 * ARG is the supplied argument's type. This function tests if
2317 * the latter can be converted to the former.
2319 * Return 0 if they are identical types;
2320 * Otherwise, return an integer which corresponds to how compatible
2321 * PARM is to ARG. The higher the return value, the worse the match.
2322 * Generally the "bad" conversions are all uniformly assigned a 100 */
2325 rank_one_type (struct type
*parm
, struct type
*arg
)
2327 /* Identical type pointers */
2328 /* However, this still doesn't catch all cases of same type for arg
2329 * and param. The reason is that builtin types are different from
2330 * the same ones constructed from the object. */
2334 /* Resolve typedefs */
2335 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2336 parm
= check_typedef (parm
);
2337 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2338 arg
= check_typedef (arg
);
2341 Well, damnit, if the names are exactly the same,
2342 i'll say they are exactly the same. This happens when we generate
2343 method stubs. The types won't point to the same address, but they
2344 really are the same.
2347 if (TYPE_NAME (parm
) && TYPE_NAME (arg
) &&
2348 !strcmp (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2351 /* Check if identical after resolving typedefs */
2355 /* See through references, since we can almost make non-references
2357 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2358 return (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
))
2359 + REFERENCE_CONVERSION_BADNESS
);
2360 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2361 return (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
)
2362 + REFERENCE_CONVERSION_BADNESS
);
2364 /* Debugging only. */
2365 fprintf_filtered (gdb_stderr
,"------ Arg is %s [%d], parm is %s [%d]\n",
2366 TYPE_NAME (arg
), TYPE_CODE (arg
), TYPE_NAME (parm
), TYPE_CODE (parm
));
2368 /* x -> y means arg of type x being supplied for parameter of type y */
2370 switch (TYPE_CODE (parm
))
2373 switch (TYPE_CODE (arg
))
2376 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2377 return VOID_PTR_CONVERSION_BADNESS
;
2379 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2380 case TYPE_CODE_ARRAY
:
2381 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2382 case TYPE_CODE_FUNC
:
2383 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
);
2385 case TYPE_CODE_ENUM
:
2386 case TYPE_CODE_CHAR
:
2387 case TYPE_CODE_RANGE
:
2388 case TYPE_CODE_BOOL
:
2389 return POINTER_CONVERSION_BADNESS
;
2391 return INCOMPATIBLE_TYPE_BADNESS
;
2393 case TYPE_CODE_ARRAY
:
2394 switch (TYPE_CODE (arg
))
2397 case TYPE_CODE_ARRAY
:
2398 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2400 return INCOMPATIBLE_TYPE_BADNESS
;
2402 case TYPE_CODE_FUNC
:
2403 switch (TYPE_CODE (arg
))
2405 case TYPE_CODE_PTR
: /* funcptr -> func */
2406 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
));
2408 return INCOMPATIBLE_TYPE_BADNESS
;
2411 switch (TYPE_CODE (arg
))
2414 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2416 /* Deal with signed, unsigned, and plain chars and
2417 signed and unsigned ints */
2418 if (TYPE_NOSIGN (parm
))
2420 /* This case only for character types */
2421 if (TYPE_NOSIGN (arg
)) /* plain char -> plain char */
2424 return INTEGER_CONVERSION_BADNESS
; /* signed/unsigned char -> plain char */
2426 else if (TYPE_UNSIGNED (parm
))
2428 if (TYPE_UNSIGNED (arg
))
2430 /* unsigned int -> unsigned int, or unsigned long -> unsigned long */
2431 if (integer_types_same_name_p (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2433 else if (integer_types_same_name_p (TYPE_NAME (arg
), "int")
2434 && integer_types_same_name_p (TYPE_NAME (parm
), "long"))
2435 return INTEGER_PROMOTION_BADNESS
; /* unsigned int -> unsigned long */
2437 return INTEGER_CONVERSION_BADNESS
; /* unsigned long -> unsigned int */
2441 if (integer_types_same_name_p (TYPE_NAME (arg
), "long")
2442 && integer_types_same_name_p (TYPE_NAME (parm
), "int"))
2443 return INTEGER_CONVERSION_BADNESS
; /* signed long -> unsigned int */
2445 return INTEGER_CONVERSION_BADNESS
; /* signed int/long -> unsigned int/long */
2448 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2450 if (integer_types_same_name_p (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2452 else if (integer_types_same_name_p (TYPE_NAME (arg
), "int")
2453 && integer_types_same_name_p (TYPE_NAME (parm
), "long"))
2454 return INTEGER_PROMOTION_BADNESS
;
2456 return INTEGER_CONVERSION_BADNESS
;
2459 return INTEGER_CONVERSION_BADNESS
;
2461 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2462 return INTEGER_PROMOTION_BADNESS
;
2464 return INTEGER_CONVERSION_BADNESS
;
2465 case TYPE_CODE_ENUM
:
2466 case TYPE_CODE_CHAR
:
2467 case TYPE_CODE_RANGE
:
2468 case TYPE_CODE_BOOL
:
2469 return INTEGER_PROMOTION_BADNESS
;
2471 return INT_FLOAT_CONVERSION_BADNESS
;
2473 return NS_POINTER_CONVERSION_BADNESS
;
2475 return INCOMPATIBLE_TYPE_BADNESS
;
2478 case TYPE_CODE_ENUM
:
2479 switch (TYPE_CODE (arg
))
2482 case TYPE_CODE_CHAR
:
2483 case TYPE_CODE_RANGE
:
2484 case TYPE_CODE_BOOL
:
2485 case TYPE_CODE_ENUM
:
2486 return INTEGER_CONVERSION_BADNESS
;
2488 return INT_FLOAT_CONVERSION_BADNESS
;
2490 return INCOMPATIBLE_TYPE_BADNESS
;
2493 case TYPE_CODE_CHAR
:
2494 switch (TYPE_CODE (arg
))
2496 case TYPE_CODE_RANGE
:
2497 case TYPE_CODE_BOOL
:
2498 case TYPE_CODE_ENUM
:
2499 return INTEGER_CONVERSION_BADNESS
;
2501 return INT_FLOAT_CONVERSION_BADNESS
;
2503 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2504 return INTEGER_CONVERSION_BADNESS
;
2505 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2506 return INTEGER_PROMOTION_BADNESS
;
2507 /* >>> !! else fall through !! <<< */
2508 case TYPE_CODE_CHAR
:
2509 /* Deal with signed, unsigned, and plain chars for C++
2510 and with int cases falling through from previous case */
2511 if (TYPE_NOSIGN (parm
))
2513 if (TYPE_NOSIGN (arg
))
2516 return INTEGER_CONVERSION_BADNESS
;
2518 else if (TYPE_UNSIGNED (parm
))
2520 if (TYPE_UNSIGNED (arg
))
2523 return INTEGER_PROMOTION_BADNESS
;
2525 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2528 return INTEGER_CONVERSION_BADNESS
;
2530 return INCOMPATIBLE_TYPE_BADNESS
;
2533 case TYPE_CODE_RANGE
:
2534 switch (TYPE_CODE (arg
))
2537 case TYPE_CODE_CHAR
:
2538 case TYPE_CODE_RANGE
:
2539 case TYPE_CODE_BOOL
:
2540 case TYPE_CODE_ENUM
:
2541 return INTEGER_CONVERSION_BADNESS
;
2543 return INT_FLOAT_CONVERSION_BADNESS
;
2545 return INCOMPATIBLE_TYPE_BADNESS
;
2548 case TYPE_CODE_BOOL
:
2549 switch (TYPE_CODE (arg
))
2552 case TYPE_CODE_CHAR
:
2553 case TYPE_CODE_RANGE
:
2554 case TYPE_CODE_ENUM
:
2557 return BOOLEAN_CONVERSION_BADNESS
;
2558 case TYPE_CODE_BOOL
:
2561 return INCOMPATIBLE_TYPE_BADNESS
;
2565 switch (TYPE_CODE (arg
))
2568 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2569 return FLOAT_PROMOTION_BADNESS
;
2570 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2573 return FLOAT_CONVERSION_BADNESS
;
2575 case TYPE_CODE_BOOL
:
2576 case TYPE_CODE_ENUM
:
2577 case TYPE_CODE_RANGE
:
2578 case TYPE_CODE_CHAR
:
2579 return INT_FLOAT_CONVERSION_BADNESS
;
2581 return INCOMPATIBLE_TYPE_BADNESS
;
2584 case TYPE_CODE_COMPLEX
:
2585 switch (TYPE_CODE (arg
))
2586 { /* Strictly not needed for C++, but... */
2588 return FLOAT_PROMOTION_BADNESS
;
2589 case TYPE_CODE_COMPLEX
:
2592 return INCOMPATIBLE_TYPE_BADNESS
;
2595 case TYPE_CODE_STRUCT
:
2596 /* currently same as TYPE_CODE_CLASS */
2597 switch (TYPE_CODE (arg
))
2599 case TYPE_CODE_STRUCT
:
2600 /* Check for derivation */
2601 if (is_ancestor (parm
, arg
))
2602 return BASE_CONVERSION_BADNESS
;
2603 /* else fall through */
2605 return INCOMPATIBLE_TYPE_BADNESS
;
2608 case TYPE_CODE_UNION
:
2609 switch (TYPE_CODE (arg
))
2611 case TYPE_CODE_UNION
:
2613 return INCOMPATIBLE_TYPE_BADNESS
;
2616 case TYPE_CODE_MEMBER
:
2617 switch (TYPE_CODE (arg
))
2620 return INCOMPATIBLE_TYPE_BADNESS
;
2623 case TYPE_CODE_METHOD
:
2624 switch (TYPE_CODE (arg
))
2628 return INCOMPATIBLE_TYPE_BADNESS
;
2632 switch (TYPE_CODE (arg
))
2636 return INCOMPATIBLE_TYPE_BADNESS
;
2641 switch (TYPE_CODE (arg
))
2645 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0), TYPE_FIELD_TYPE (arg
, 0));
2647 return INCOMPATIBLE_TYPE_BADNESS
;
2650 case TYPE_CODE_VOID
:
2652 return INCOMPATIBLE_TYPE_BADNESS
;
2653 } /* switch (TYPE_CODE (arg)) */
2657 /* End of functions for overload resolution */
2660 print_bit_vector (B_TYPE
*bits
, int nbits
)
2664 for (bitno
= 0; bitno
< nbits
; bitno
++)
2666 if ((bitno
% 8) == 0)
2668 puts_filtered (" ");
2670 if (B_TST (bits
, bitno
))
2672 printf_filtered ("1");
2676 printf_filtered ("0");
2681 /* Note the first arg should be the "this" pointer, we may not want to
2682 include it since we may get into a infinitely recursive situation. */
2685 print_arg_types (struct field
*args
, int nargs
, int spaces
)
2691 for (i
= 0; i
< nargs
; i
++)
2692 recursive_dump_type (args
[i
].type
, spaces
+ 2);
2697 dump_fn_fieldlists (struct type
*type
, int spaces
)
2703 printfi_filtered (spaces
, "fn_fieldlists ");
2704 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2705 printf_filtered ("\n");
2706 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2708 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2709 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2711 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2712 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2714 printf_filtered (") length %d\n",
2715 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2716 for (overload_idx
= 0;
2717 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2720 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2722 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2723 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2725 printf_filtered (")\n");
2726 printfi_filtered (spaces
+ 8, "type ");
2727 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
2728 printf_filtered ("\n");
2730 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2733 printfi_filtered (spaces
+ 8, "args ");
2734 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
2735 printf_filtered ("\n");
2737 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2738 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
, overload_idx
)),
2740 printfi_filtered (spaces
+ 8, "fcontext ");
2741 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2743 printf_filtered ("\n");
2745 printfi_filtered (spaces
+ 8, "is_const %d\n",
2746 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2747 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2748 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2749 printfi_filtered (spaces
+ 8, "is_private %d\n",
2750 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2751 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2752 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2753 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2754 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2755 printfi_filtered (spaces
+ 8, "voffset %u\n",
2756 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2762 print_cplus_stuff (struct type
*type
, int spaces
)
2764 printfi_filtered (spaces
, "n_baseclasses %d\n",
2765 TYPE_N_BASECLASSES (type
));
2766 printfi_filtered (spaces
, "nfn_fields %d\n",
2767 TYPE_NFN_FIELDS (type
));
2768 printfi_filtered (spaces
, "nfn_fields_total %d\n",
2769 TYPE_NFN_FIELDS_TOTAL (type
));
2770 if (TYPE_N_BASECLASSES (type
) > 0)
2772 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2773 TYPE_N_BASECLASSES (type
));
2774 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
2775 printf_filtered (")");
2777 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2778 TYPE_N_BASECLASSES (type
));
2779 puts_filtered ("\n");
2781 if (TYPE_NFIELDS (type
) > 0)
2783 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2785 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
2786 TYPE_NFIELDS (type
));
2787 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
2788 printf_filtered (")");
2789 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2790 TYPE_NFIELDS (type
));
2791 puts_filtered ("\n");
2793 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2795 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
2796 TYPE_NFIELDS (type
));
2797 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
2798 printf_filtered (")");
2799 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2800 TYPE_NFIELDS (type
));
2801 puts_filtered ("\n");
2804 if (TYPE_NFN_FIELDS (type
) > 0)
2806 dump_fn_fieldlists (type
, spaces
);
2811 print_bound_type (int bt
)
2815 case BOUND_CANNOT_BE_DETERMINED
:
2816 printf_filtered ("(BOUND_CANNOT_BE_DETERMINED)");
2818 case BOUND_BY_REF_ON_STACK
:
2819 printf_filtered ("(BOUND_BY_REF_ON_STACK)");
2821 case BOUND_BY_VALUE_ON_STACK
:
2822 printf_filtered ("(BOUND_BY_VALUE_ON_STACK)");
2824 case BOUND_BY_REF_IN_REG
:
2825 printf_filtered ("(BOUND_BY_REF_IN_REG)");
2827 case BOUND_BY_VALUE_IN_REG
:
2828 printf_filtered ("(BOUND_BY_VALUE_IN_REG)");
2831 printf_filtered ("(BOUND_SIMPLE)");
2834 printf_filtered ("(unknown bound type)");
2839 static struct obstack dont_print_type_obstack
;
2842 recursive_dump_type (struct type
*type
, int spaces
)
2847 obstack_begin (&dont_print_type_obstack
, 0);
2849 if (TYPE_NFIELDS (type
) > 0
2850 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
2852 struct type
**first_dont_print
2853 = (struct type
**) obstack_base (&dont_print_type_obstack
);
2855 int i
= (struct type
**) obstack_next_free (&dont_print_type_obstack
)
2860 if (type
== first_dont_print
[i
])
2862 printfi_filtered (spaces
, "type node ");
2863 gdb_print_host_address (type
, gdb_stdout
);
2864 printf_filtered (" <same as already seen type>\n");
2869 obstack_ptr_grow (&dont_print_type_obstack
, type
);
2872 printfi_filtered (spaces
, "type node ");
2873 gdb_print_host_address (type
, gdb_stdout
);
2874 printf_filtered ("\n");
2875 printfi_filtered (spaces
, "name '%s' (",
2876 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
2877 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
2878 printf_filtered (")\n");
2879 printfi_filtered (spaces
, "tagname '%s' (",
2880 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
2881 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
2882 printf_filtered (")\n");
2883 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
2884 switch (TYPE_CODE (type
))
2886 case TYPE_CODE_UNDEF
:
2887 printf_filtered ("(TYPE_CODE_UNDEF)");
2890 printf_filtered ("(TYPE_CODE_PTR)");
2892 case TYPE_CODE_ARRAY
:
2893 printf_filtered ("(TYPE_CODE_ARRAY)");
2895 case TYPE_CODE_STRUCT
:
2896 printf_filtered ("(TYPE_CODE_STRUCT)");
2898 case TYPE_CODE_UNION
:
2899 printf_filtered ("(TYPE_CODE_UNION)");
2901 case TYPE_CODE_ENUM
:
2902 printf_filtered ("(TYPE_CODE_ENUM)");
2904 case TYPE_CODE_FUNC
:
2905 printf_filtered ("(TYPE_CODE_FUNC)");
2908 printf_filtered ("(TYPE_CODE_INT)");
2911 printf_filtered ("(TYPE_CODE_FLT)");
2913 case TYPE_CODE_VOID
:
2914 printf_filtered ("(TYPE_CODE_VOID)");
2917 printf_filtered ("(TYPE_CODE_SET)");
2919 case TYPE_CODE_RANGE
:
2920 printf_filtered ("(TYPE_CODE_RANGE)");
2922 case TYPE_CODE_STRING
:
2923 printf_filtered ("(TYPE_CODE_STRING)");
2925 case TYPE_CODE_BITSTRING
:
2926 printf_filtered ("(TYPE_CODE_BITSTRING)");
2928 case TYPE_CODE_ERROR
:
2929 printf_filtered ("(TYPE_CODE_ERROR)");
2931 case TYPE_CODE_MEMBER
:
2932 printf_filtered ("(TYPE_CODE_MEMBER)");
2934 case TYPE_CODE_METHOD
:
2935 printf_filtered ("(TYPE_CODE_METHOD)");
2938 printf_filtered ("(TYPE_CODE_REF)");
2940 case TYPE_CODE_CHAR
:
2941 printf_filtered ("(TYPE_CODE_CHAR)");
2943 case TYPE_CODE_BOOL
:
2944 printf_filtered ("(TYPE_CODE_BOOL)");
2946 case TYPE_CODE_COMPLEX
:
2947 printf_filtered ("(TYPE_CODE_COMPLEX)");
2949 case TYPE_CODE_TYPEDEF
:
2950 printf_filtered ("(TYPE_CODE_TYPEDEF)");
2952 case TYPE_CODE_TEMPLATE
:
2953 printf_filtered ("(TYPE_CODE_TEMPLATE)");
2955 case TYPE_CODE_TEMPLATE_ARG
:
2956 printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)");
2958 case TYPE_CODE_NAMESPACE
:
2959 printf_filtered ("(TYPE_CODE_NAMESPACE)");
2962 printf_filtered ("(UNKNOWN TYPE CODE)");
2965 puts_filtered ("\n");
2966 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
2967 printfi_filtered (spaces
, "upper_bound_type 0x%x ",
2968 TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
2969 print_bound_type (TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
2970 puts_filtered ("\n");
2971 printfi_filtered (spaces
, "lower_bound_type 0x%x ",
2972 TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
2973 print_bound_type (TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
2974 puts_filtered ("\n");
2975 printfi_filtered (spaces
, "objfile ");
2976 gdb_print_host_address (TYPE_OBJFILE (type
), gdb_stdout
);
2977 printf_filtered ("\n");
2978 printfi_filtered (spaces
, "target_type ");
2979 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
2980 printf_filtered ("\n");
2981 if (TYPE_TARGET_TYPE (type
) != NULL
)
2983 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
2985 printfi_filtered (spaces
, "pointer_type ");
2986 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
2987 printf_filtered ("\n");
2988 printfi_filtered (spaces
, "reference_type ");
2989 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
2990 printf_filtered ("\n");
2991 printfi_filtered (spaces
, "type_chain ");
2992 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
2993 printf_filtered ("\n");
2994 printfi_filtered (spaces
, "instance_flags 0x%x", TYPE_INSTANCE_FLAGS (type
));
2995 if (TYPE_CONST (type
))
2997 puts_filtered (" TYPE_FLAG_CONST");
2999 if (TYPE_VOLATILE (type
))
3001 puts_filtered (" TYPE_FLAG_VOLATILE");
3003 if (TYPE_CODE_SPACE (type
))
3005 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3007 if (TYPE_DATA_SPACE (type
))
3009 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3011 if (TYPE_ADDRESS_CLASS_1 (type
))
3013 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3015 if (TYPE_ADDRESS_CLASS_2 (type
))
3017 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3019 puts_filtered ("\n");
3020 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
3021 if (TYPE_UNSIGNED (type
))
3023 puts_filtered (" TYPE_FLAG_UNSIGNED");
3025 if (TYPE_NOSIGN (type
))
3027 puts_filtered (" TYPE_FLAG_NOSIGN");
3029 if (TYPE_STUB (type
))
3031 puts_filtered (" TYPE_FLAG_STUB");
3033 if (TYPE_TARGET_STUB (type
))
3035 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3037 if (TYPE_STATIC (type
))
3039 puts_filtered (" TYPE_FLAG_STATIC");
3041 if (TYPE_PROTOTYPED (type
))
3043 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3045 if (TYPE_INCOMPLETE (type
))
3047 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3049 if (TYPE_VARARGS (type
))
3051 puts_filtered (" TYPE_FLAG_VARARGS");
3053 /* This is used for things like AltiVec registers on ppc. Gcc emits
3054 an attribute for the array type, which tells whether or not we
3055 have a vector, instead of a regular array. */
3056 if (TYPE_VECTOR (type
))
3058 puts_filtered (" TYPE_FLAG_VECTOR");
3060 puts_filtered ("\n");
3061 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
3062 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
3063 puts_filtered ("\n");
3064 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
3066 printfi_filtered (spaces
+ 2,
3067 "[%d] bitpos %d bitsize %d type ",
3068 idx
, TYPE_FIELD_BITPOS (type
, idx
),
3069 TYPE_FIELD_BITSIZE (type
, idx
));
3070 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
3071 printf_filtered (" name '%s' (",
3072 TYPE_FIELD_NAME (type
, idx
) != NULL
3073 ? TYPE_FIELD_NAME (type
, idx
)
3075 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
3076 printf_filtered (")\n");
3077 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
3079 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
3082 printfi_filtered (spaces
, "vptr_basetype ");
3083 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
3084 puts_filtered ("\n");
3085 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
3087 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
3089 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
3090 switch (TYPE_CODE (type
))
3092 case TYPE_CODE_STRUCT
:
3093 printfi_filtered (spaces
, "cplus_stuff ");
3094 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
3095 puts_filtered ("\n");
3096 print_cplus_stuff (type
, spaces
);
3100 printfi_filtered (spaces
, "floatformat ");
3101 if (TYPE_FLOATFORMAT (type
) == NULL
3102 || TYPE_FLOATFORMAT (type
)->name
== NULL
)
3103 puts_filtered ("(null)");
3105 puts_filtered (TYPE_FLOATFORMAT (type
)->name
);
3106 puts_filtered ("\n");
3110 /* We have to pick one of the union types to be able print and test
3111 the value. Pick cplus_struct_type, even though we know it isn't
3112 any particular one. */
3113 printfi_filtered (spaces
, "type_specific ");
3114 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
3115 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
3117 printf_filtered (" (unknown data form)");
3119 printf_filtered ("\n");
3124 obstack_free (&dont_print_type_obstack
, NULL
);
3127 static void build_gdbtypes (void);
3129 build_gdbtypes (void)
3132 init_type (TYPE_CODE_VOID
, 1,
3134 "void", (struct objfile
*) NULL
);
3136 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3138 | (TARGET_CHAR_SIGNED
? 0 : TYPE_FLAG_UNSIGNED
)),
3139 "char", (struct objfile
*) NULL
);
3140 builtin_type_true_char
=
3141 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3143 "true character", (struct objfile
*) NULL
);
3144 builtin_type_signed_char
=
3145 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3147 "signed char", (struct objfile
*) NULL
);
3148 builtin_type_unsigned_char
=
3149 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3151 "unsigned char", (struct objfile
*) NULL
);
3152 builtin_type_short
=
3153 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
3155 "short", (struct objfile
*) NULL
);
3156 builtin_type_unsigned_short
=
3157 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
3159 "unsigned short", (struct objfile
*) NULL
);
3161 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3163 "int", (struct objfile
*) NULL
);
3164 builtin_type_unsigned_int
=
3165 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3167 "unsigned int", (struct objfile
*) NULL
);
3169 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
3171 "long", (struct objfile
*) NULL
);
3172 builtin_type_unsigned_long
=
3173 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
3175 "unsigned long", (struct objfile
*) NULL
);
3176 builtin_type_long_long
=
3177 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
3179 "long long", (struct objfile
*) NULL
);
3180 builtin_type_unsigned_long_long
=
3181 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
3183 "unsigned long long", (struct objfile
*) NULL
);
3184 builtin_type_float
=
3185 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
3187 "float", (struct objfile
*) NULL
);
3188 /* vinschen@redhat.com 2002-02-08:
3189 The below lines are disabled since they are doing the wrong
3190 thing for non-multiarch targets. They are setting the correct
3191 type of floats for the target but while on multiarch targets
3192 this is done everytime the architecture changes, it's done on
3193 non-multiarch targets only on startup, leaving the wrong values
3194 in even if the architecture changes (eg. from big-endian to
3197 TYPE_FLOATFORMAT (builtin_type_float
) = TARGET_FLOAT_FORMAT
;
3199 builtin_type_double
=
3200 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3202 "double", (struct objfile
*) NULL
);
3204 TYPE_FLOATFORMAT (builtin_type_double
) = TARGET_DOUBLE_FORMAT
;
3206 builtin_type_long_double
=
3207 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3209 "long double", (struct objfile
*) NULL
);
3211 TYPE_FLOATFORMAT (builtin_type_long_double
) = TARGET_LONG_DOUBLE_FORMAT
;
3213 builtin_type_complex
=
3214 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
3216 "complex", (struct objfile
*) NULL
);
3217 TYPE_TARGET_TYPE (builtin_type_complex
) = builtin_type_float
;
3218 builtin_type_double_complex
=
3219 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3221 "double complex", (struct objfile
*) NULL
);
3222 TYPE_TARGET_TYPE (builtin_type_double_complex
) = builtin_type_double
;
3223 builtin_type_string
=
3224 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3226 "string", (struct objfile
*) NULL
);
3228 init_type (TYPE_CODE_INT
, 0 / 8,
3230 "int0_t", (struct objfile
*) NULL
);
3232 init_type (TYPE_CODE_INT
, 8 / 8,
3234 "int8_t", (struct objfile
*) NULL
);
3235 builtin_type_uint8
=
3236 init_type (TYPE_CODE_INT
, 8 / 8,
3238 "uint8_t", (struct objfile
*) NULL
);
3239 builtin_type_int16
=
3240 init_type (TYPE_CODE_INT
, 16 / 8,
3242 "int16_t", (struct objfile
*) NULL
);
3243 builtin_type_uint16
=
3244 init_type (TYPE_CODE_INT
, 16 / 8,
3246 "uint16_t", (struct objfile
*) NULL
);
3247 builtin_type_int32
=
3248 init_type (TYPE_CODE_INT
, 32 / 8,
3250 "int32_t", (struct objfile
*) NULL
);
3251 builtin_type_uint32
=
3252 init_type (TYPE_CODE_INT
, 32 / 8,
3254 "uint32_t", (struct objfile
*) NULL
);
3255 builtin_type_int64
=
3256 init_type (TYPE_CODE_INT
, 64 / 8,
3258 "int64_t", (struct objfile
*) NULL
);
3259 builtin_type_uint64
=
3260 init_type (TYPE_CODE_INT
, 64 / 8,
3262 "uint64_t", (struct objfile
*) NULL
);
3263 builtin_type_int128
=
3264 init_type (TYPE_CODE_INT
, 128 / 8,
3266 "int128_t", (struct objfile
*) NULL
);
3267 builtin_type_uint128
=
3268 init_type (TYPE_CODE_INT
, 128 / 8,
3270 "uint128_t", (struct objfile
*) NULL
);
3272 init_type (TYPE_CODE_BOOL
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3274 "bool", (struct objfile
*) NULL
);
3276 /* Add user knob for controlling resolution of opaque types */
3277 deprecated_add_show_from_set
3278 (add_set_cmd ("opaque-type-resolution", class_support
, var_boolean
, (char *) &opaque_type_resolution
,
3279 "Set resolution of opaque struct/class/union types (if set before loading symbols).",
3282 opaque_type_resolution
= 1;
3284 /* Build SIMD types. */
3286 = init_simd_type ("__builtin_v4sf", builtin_type_float
, "f", 4);
3288 = init_simd_type ("__builtin_v4si", builtin_type_int32
, "f", 4);
3290 = init_simd_type ("__builtin_v16qi", builtin_type_int8
, "f", 16);
3292 = init_simd_type ("__builtin_v8qi", builtin_type_int8
, "f", 8);
3294 = init_simd_type ("__builtin_v8hi", builtin_type_int16
, "f", 8);
3296 = init_simd_type ("__builtin_v4hi", builtin_type_int16
, "f", 4);
3298 = init_simd_type ("__builtin_v2si", builtin_type_int32
, "f", 2);
3300 /* 128 bit vectors. */
3301 builtin_type_v2_double
= init_vector_type (builtin_type_double
, 2);
3302 builtin_type_v4_float
= init_vector_type (builtin_type_float
, 4);
3303 builtin_type_v2_int64
= init_vector_type (builtin_type_int64
, 2);
3304 builtin_type_v4_int32
= init_vector_type (builtin_type_int32
, 4);
3305 builtin_type_v8_int16
= init_vector_type (builtin_type_int16
, 8);
3306 builtin_type_v16_int8
= init_vector_type (builtin_type_int8
, 16);
3307 /* 64 bit vectors. */
3308 builtin_type_v2_float
= init_vector_type (builtin_type_float
, 2);
3309 builtin_type_v2_int32
= init_vector_type (builtin_type_int32
, 2);
3310 builtin_type_v4_int16
= init_vector_type (builtin_type_int16
, 4);
3311 builtin_type_v8_int8
= init_vector_type (builtin_type_int8
, 8);
3314 builtin_type_vec64
= build_builtin_type_vec64 ();
3315 builtin_type_vec64i
= build_builtin_type_vec64i ();
3316 builtin_type_vec128
= build_builtin_type_vec128 ();
3317 builtin_type_vec128i
= build_builtin_type_vec128i ();
3319 /* Pointer/Address types. */
3321 /* NOTE: on some targets, addresses and pointers are not necessarily
3322 the same --- for example, on the D10V, pointers are 16 bits long,
3323 but addresses are 32 bits long. See doc/gdbint.texinfo,
3324 ``Pointers Are Not Always Addresses''.
3327 - gdb's `struct type' always describes the target's
3329 - gdb's `struct value' objects should always hold values in
3331 - gdb's CORE_ADDR values are addresses in the unified virtual
3332 address space that the assembler and linker work with. Thus,
3333 since target_read_memory takes a CORE_ADDR as an argument, it
3334 can access any memory on the target, even if the processor has
3335 separate code and data address spaces.
3338 - If v is a value holding a D10V code pointer, its contents are
3339 in target form: a big-endian address left-shifted two bits.
3340 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3341 sizeof (void *) == 2 on the target.
3343 In this context, builtin_type_CORE_ADDR is a bit odd: it's a
3344 target type for a value the target will never see. It's only
3345 used to hold the values of (typeless) linker symbols, which are
3346 indeed in the unified virtual address space. */
3347 builtin_type_void_data_ptr
= make_pointer_type (builtin_type_void
, NULL
);
3348 builtin_type_void_func_ptr
3349 = lookup_pointer_type (lookup_function_type (builtin_type_void
));
3350 builtin_type_CORE_ADDR
=
3351 init_type (TYPE_CODE_INT
, TARGET_ADDR_BIT
/ 8,
3353 "__CORE_ADDR", (struct objfile
*) NULL
);
3354 builtin_type_bfd_vma
=
3355 init_type (TYPE_CODE_INT
, TARGET_BFD_VMA_BIT
/ 8,
3357 "__bfd_vma", (struct objfile
*) NULL
);
3360 static struct gdbarch_data
*gdbtypes_data
;
3362 const struct builtin_type
*
3363 builtin_type (struct gdbarch
*gdbarch
)
3365 return gdbarch_data (gdbarch
, gdbtypes_data
);
3369 gdbtypes_post_init (struct gdbarch
*gdbarch
)
3371 struct builtin_type
*builtin_type
3372 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
3374 builtin_type
->builtin_void
=
3375 init_type (TYPE_CODE_VOID
, 1,
3377 "void", (struct objfile
*) NULL
);
3378 builtin_type
->builtin_char
=
3379 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3381 | (TARGET_CHAR_SIGNED
? 0 : TYPE_FLAG_UNSIGNED
)),
3382 "char", (struct objfile
*) NULL
);
3383 builtin_type
->true_char
=
3384 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3386 "true character", (struct objfile
*) NULL
);
3387 builtin_type
->builtin_signed_char
=
3388 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3390 "signed char", (struct objfile
*) NULL
);
3391 builtin_type
->builtin_unsigned_char
=
3392 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3394 "unsigned char", (struct objfile
*) NULL
);
3395 builtin_type
->builtin_short
=
3396 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
3398 "short", (struct objfile
*) NULL
);
3399 builtin_type
->builtin_unsigned_short
=
3400 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
3402 "unsigned short", (struct objfile
*) NULL
);
3403 builtin_type
->builtin_int
=
3404 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3406 "int", (struct objfile
*) NULL
);
3407 builtin_type
->builtin_unsigned_int
=
3408 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3410 "unsigned int", (struct objfile
*) NULL
);
3411 builtin_type
->builtin_long
=
3412 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
3414 "long", (struct objfile
*) NULL
);
3415 builtin_type
->builtin_unsigned_long
=
3416 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
3418 "unsigned long", (struct objfile
*) NULL
);
3419 builtin_type
->builtin_long_long
=
3420 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
3422 "long long", (struct objfile
*) NULL
);
3423 builtin_type
->builtin_unsigned_long_long
=
3424 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
3426 "unsigned long long", (struct objfile
*) NULL
);
3427 builtin_type
->builtin_float
=
3428 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
3430 "float", (struct objfile
*) NULL
);
3431 TYPE_FLOATFORMAT (builtin_type
->builtin_float
) = TARGET_FLOAT_FORMAT
;
3432 builtin_type
->builtin_double
=
3433 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3435 "double", (struct objfile
*) NULL
);
3436 TYPE_FLOATFORMAT (builtin_type
->builtin_double
) = TARGET_DOUBLE_FORMAT
;
3437 builtin_type
->builtin_long_double
=
3438 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3440 "long double", (struct objfile
*) NULL
);
3441 TYPE_FLOATFORMAT (builtin_type
->builtin_long_double
) = TARGET_LONG_DOUBLE_FORMAT
;
3442 builtin_type
->builtin_complex
=
3443 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
3445 "complex", (struct objfile
*) NULL
);
3446 TYPE_TARGET_TYPE (builtin_type
->builtin_complex
) = builtin_type
->builtin_float
;
3447 builtin_type
->builtin_double_complex
=
3448 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3450 "double complex", (struct objfile
*) NULL
);
3451 TYPE_TARGET_TYPE (builtin_type
->builtin_double_complex
) = builtin_type
->builtin_double
;
3452 builtin_type
->builtin_string
=
3453 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3455 "string", (struct objfile
*) NULL
);
3456 builtin_type
->builtin_int0
=
3457 init_type (TYPE_CODE_INT
, 0 / 8,
3459 "int0_t", (struct objfile
*) NULL
);
3460 builtin_type
->builtin_int8
=
3461 init_type (TYPE_CODE_INT
, 8 / 8,
3463 "int8_t", (struct objfile
*) NULL
);
3464 builtin_type
->builtin_uint8
=
3465 init_type (TYPE_CODE_INT
, 8 / 8,
3467 "uint8_t", (struct objfile
*) NULL
);
3468 builtin_type
->builtin_int16
=
3469 init_type (TYPE_CODE_INT
, 16 / 8,
3471 "int16_t", (struct objfile
*) NULL
);
3472 builtin_type
->builtin_uint16
=
3473 init_type (TYPE_CODE_INT
, 16 / 8,
3475 "uint16_t", (struct objfile
*) NULL
);
3476 builtin_type
->builtin_int32
=
3477 init_type (TYPE_CODE_INT
, 32 / 8,
3479 "int32_t", (struct objfile
*) NULL
);
3480 builtin_type
->builtin_uint32
=
3481 init_type (TYPE_CODE_INT
, 32 / 8,
3483 "uint32_t", (struct objfile
*) NULL
);
3484 builtin_type
->builtin_int64
=
3485 init_type (TYPE_CODE_INT
, 64 / 8,
3487 "int64_t", (struct objfile
*) NULL
);
3488 builtin_type
->builtin_uint64
=
3489 init_type (TYPE_CODE_INT
, 64 / 8,
3491 "uint64_t", (struct objfile
*) NULL
);
3492 builtin_type
->builtin_int128
=
3493 init_type (TYPE_CODE_INT
, 128 / 8,
3495 "int128_t", (struct objfile
*) NULL
);
3496 builtin_type
->builtin_uint128
=
3497 init_type (TYPE_CODE_INT
, 128 / 8,
3499 "uint128_t", (struct objfile
*) NULL
);
3500 builtin_type
->builtin_bool
=
3501 init_type (TYPE_CODE_BOOL
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3503 "bool", (struct objfile
*) NULL
);
3505 /* Pointer/Address types. */
3507 /* NOTE: on some targets, addresses and pointers are not necessarily
3508 the same --- for example, on the D10V, pointers are 16 bits long,
3509 but addresses are 32 bits long. See doc/gdbint.texinfo,
3510 ``Pointers Are Not Always Addresses''.
3513 - gdb's `struct type' always describes the target's
3515 - gdb's `struct value' objects should always hold values in
3517 - gdb's CORE_ADDR values are addresses in the unified virtual
3518 address space that the assembler and linker work with. Thus,
3519 since target_read_memory takes a CORE_ADDR as an argument, it
3520 can access any memory on the target, even if the processor has
3521 separate code and data address spaces.
3524 - If v is a value holding a D10V code pointer, its contents are
3525 in target form: a big-endian address left-shifted two bits.
3526 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3527 sizeof (void *) == 2 on the target.
3529 In this context, builtin_type->CORE_ADDR is a bit odd: it's a
3530 target type for a value the target will never see. It's only
3531 used to hold the values of (typeless) linker symbols, which are
3532 indeed in the unified virtual address space. */
3533 builtin_type
->builtin_data_ptr
3534 = make_pointer_type (builtin_type
->builtin_void
, NULL
);
3535 builtin_type
->builtin_func_ptr
3536 = lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
3537 builtin_type
->builtin_core_addr
=
3538 init_type (TYPE_CODE_INT
, TARGET_ADDR_BIT
/ 8,
3540 "__CORE_ADDR", (struct objfile
*) NULL
);
3542 return builtin_type
;
3545 extern void _initialize_gdbtypes (void);
3547 _initialize_gdbtypes (void)
3549 struct cmd_list_element
*c
;
3552 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
3554 /* FIXME - For the moment, handle types by swapping them in and out.
3555 Should be using the per-architecture data-pointer and a large
3557 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void
);
3558 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_char
);
3559 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_short
);
3560 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int
);
3561 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long
);
3562 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long_long
);
3563 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_signed_char
);
3564 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_char
);
3565 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_short
);
3566 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_int
);
3567 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_long
);
3568 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_long_long
);
3569 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_float
);
3570 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_double
);
3571 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long_double
);
3572 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_complex
);
3573 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_double_complex
);
3574 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_string
);
3575 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int8
);
3576 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_uint8
);
3577 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int16
);
3578 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_uint16
);
3579 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int32
);
3580 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_uint32
);
3581 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int64
);
3582 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_uint64
);
3583 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int128
);
3584 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_uint128
);
3585 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4sf
);
3586 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4si
);
3587 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v16qi
);
3588 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8qi
);
3589 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8hi
);
3590 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4hi
);
3591 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2si
);
3592 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_double
);
3593 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_float
);
3594 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_int64
);
3595 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_int32
);
3596 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8_int16
);
3597 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v16_int8
);
3598 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_float
);
3599 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_int32
);
3600 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8_int8
);
3601 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_int16
);
3602 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_vec128
);
3603 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_vec128i
);
3604 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void_data_ptr
);
3605 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void_func_ptr
);
3606 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR
);
3607 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma
);
3608 deprecated_register_gdbarch_swap (NULL
, 0, build_gdbtypes
);
3610 /* Note: These types do not need to be swapped - they are target
3612 builtin_type_ieee_single_big
=
3613 init_type (TYPE_CODE_FLT
, floatformat_ieee_single_big
.totalsize
/ 8,
3614 0, "builtin_type_ieee_single_big", NULL
);
3615 TYPE_FLOATFORMAT (builtin_type_ieee_single_big
) = &floatformat_ieee_single_big
;
3616 builtin_type_ieee_single_little
=
3617 init_type (TYPE_CODE_FLT
, floatformat_ieee_single_little
.totalsize
/ 8,
3618 0, "builtin_type_ieee_single_little", NULL
);
3619 TYPE_FLOATFORMAT (builtin_type_ieee_single_little
) = &floatformat_ieee_single_little
;
3620 builtin_type_ieee_double_big
=
3621 init_type (TYPE_CODE_FLT
, floatformat_ieee_double_big
.totalsize
/ 8,
3622 0, "builtin_type_ieee_double_big", NULL
);
3623 TYPE_FLOATFORMAT (builtin_type_ieee_double_big
) = &floatformat_ieee_double_big
;
3624 builtin_type_ieee_double_little
=
3625 init_type (TYPE_CODE_FLT
, floatformat_ieee_double_little
.totalsize
/ 8,
3626 0, "builtin_type_ieee_double_little", NULL
);
3627 TYPE_FLOATFORMAT (builtin_type_ieee_double_little
) = &floatformat_ieee_double_little
;
3628 builtin_type_ieee_double_littlebyte_bigword
=
3629 init_type (TYPE_CODE_FLT
, floatformat_ieee_double_littlebyte_bigword
.totalsize
/ 8,
3630 0, "builtin_type_ieee_double_littlebyte_bigword", NULL
);
3631 TYPE_FLOATFORMAT (builtin_type_ieee_double_littlebyte_bigword
) = &floatformat_ieee_double_littlebyte_bigword
;
3632 builtin_type_i387_ext
=
3633 init_type (TYPE_CODE_FLT
, floatformat_i387_ext
.totalsize
/ 8,
3634 0, "builtin_type_i387_ext", NULL
);
3635 TYPE_FLOATFORMAT (builtin_type_i387_ext
) = &floatformat_i387_ext
;
3636 builtin_type_m68881_ext
=
3637 init_type (TYPE_CODE_FLT
, floatformat_m68881_ext
.totalsize
/ 8,
3638 0, "builtin_type_m68881_ext", NULL
);
3639 TYPE_FLOATFORMAT (builtin_type_m68881_ext
) = &floatformat_m68881_ext
;
3640 builtin_type_i960_ext
=
3641 init_type (TYPE_CODE_FLT
, floatformat_i960_ext
.totalsize
/ 8,
3642 0, "builtin_type_i960_ext", NULL
);
3643 TYPE_FLOATFORMAT (builtin_type_i960_ext
) = &floatformat_i960_ext
;
3644 builtin_type_m88110_ext
=
3645 init_type (TYPE_CODE_FLT
, floatformat_m88110_ext
.totalsize
/ 8,
3646 0, "builtin_type_m88110_ext", NULL
);
3647 TYPE_FLOATFORMAT (builtin_type_m88110_ext
) = &floatformat_m88110_ext
;
3648 builtin_type_m88110_harris_ext
=
3649 init_type (TYPE_CODE_FLT
, floatformat_m88110_harris_ext
.totalsize
/ 8,
3650 0, "builtin_type_m88110_harris_ext", NULL
);
3651 TYPE_FLOATFORMAT (builtin_type_m88110_harris_ext
) = &floatformat_m88110_harris_ext
;
3652 builtin_type_arm_ext_big
=
3653 init_type (TYPE_CODE_FLT
, floatformat_arm_ext_big
.totalsize
/ 8,
3654 0, "builtin_type_arm_ext_big", NULL
);
3655 TYPE_FLOATFORMAT (builtin_type_arm_ext_big
) = &floatformat_arm_ext_big
;
3656 builtin_type_arm_ext_littlebyte_bigword
=
3657 init_type (TYPE_CODE_FLT
, floatformat_arm_ext_littlebyte_bigword
.totalsize
/ 8,
3658 0, "builtin_type_arm_ext_littlebyte_bigword", NULL
);
3659 TYPE_FLOATFORMAT (builtin_type_arm_ext_littlebyte_bigword
) = &floatformat_arm_ext_littlebyte_bigword
;
3660 builtin_type_ia64_spill_big
=
3661 init_type (TYPE_CODE_FLT
, floatformat_ia64_spill_big
.totalsize
/ 8,
3662 0, "builtin_type_ia64_spill_big", NULL
);
3663 TYPE_FLOATFORMAT (builtin_type_ia64_spill_big
) = &floatformat_ia64_spill_big
;
3664 builtin_type_ia64_spill_little
=
3665 init_type (TYPE_CODE_FLT
, floatformat_ia64_spill_little
.totalsize
/ 8,
3666 0, "builtin_type_ia64_spill_little", NULL
);
3667 TYPE_FLOATFORMAT (builtin_type_ia64_spill_little
) = &floatformat_ia64_spill_little
;
3668 builtin_type_ia64_quad_big
=
3669 init_type (TYPE_CODE_FLT
, floatformat_ia64_quad_big
.totalsize
/ 8,
3670 0, "builtin_type_ia64_quad_big", NULL
);
3671 TYPE_FLOATFORMAT (builtin_type_ia64_quad_big
) = &floatformat_ia64_quad_big
;
3672 builtin_type_ia64_quad_little
=
3673 init_type (TYPE_CODE_FLT
, floatformat_ia64_quad_little
.totalsize
/ 8,
3674 0, "builtin_type_ia64_quad_little", NULL
);
3675 TYPE_FLOATFORMAT (builtin_type_ia64_quad_little
) = &floatformat_ia64_quad_little
;
3677 deprecated_add_show_from_set
3678 (add_set_cmd ("overload", no_class
, var_zinteger
, (char *) &overload_debug
,
3679 "Set debugging of C++ overloading.\n\
3680 When enabled, ranking of the functions is displayed.", &setdebuglist
),