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_vec128
;
98 struct type
*builtin_type_ieee_single
[BFD_ENDIAN_UNKNOWN
];
99 struct type
*builtin_type_ieee_single_big
;
100 struct type
*builtin_type_ieee_single_little
;
101 struct type
*builtin_type_ieee_double
[BFD_ENDIAN_UNKNOWN
];
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
[BFD_ENDIAN_UNKNOWN
];
111 struct type
*builtin_type_arm_ext_big
;
112 struct type
*builtin_type_arm_ext_littlebyte_bigword
;
113 struct type
*builtin_type_ia64_spill
[BFD_ENDIAN_UNKNOWN
];
114 struct type
*builtin_type_ia64_spill_big
;
115 struct type
*builtin_type_ia64_spill_little
;
116 struct type
*builtin_type_ia64_quad
[BFD_ENDIAN_UNKNOWN
];
117 struct type
*builtin_type_ia64_quad_big
;
118 struct type
*builtin_type_ia64_quad_little
;
119 struct type
*builtin_type_void_data_ptr
;
120 struct type
*builtin_type_void_func_ptr
;
121 struct type
*builtin_type_CORE_ADDR
;
122 struct type
*builtin_type_bfd_vma
;
124 int opaque_type_resolution
= 1;
126 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
127 struct cmd_list_element
*c
, const char *value
)
129 fprintf_filtered (file
, _("\
130 Resolution of opaque struct/class/union types (if set before loading symbols) is %s.\n"),
134 int overload_debug
= 0;
136 show_overload_debug (struct ui_file
*file
, int from_tty
,
137 struct cmd_list_element
*c
, const char *value
)
139 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"), value
);
146 }; /* maximum extension is 128! FIXME */
148 static void print_bit_vector (B_TYPE
*, int);
149 static void print_arg_types (struct field
*, int, int);
150 static void dump_fn_fieldlists (struct type
*, int);
151 static void print_cplus_stuff (struct type
*, int);
152 static void virtual_base_list_aux (struct type
*dclass
);
155 /* Alloc a new type structure and fill it with some defaults. If
156 OBJFILE is non-NULL, then allocate the space for the type structure
157 in that objfile's objfile_obstack. Otherwise allocate the new type structure
158 by xmalloc () (for permanent types). */
161 alloc_type (struct objfile
*objfile
)
165 /* Alloc the structure and start off with all fields zeroed. */
169 type
= xmalloc (sizeof (struct type
));
170 memset (type
, 0, sizeof (struct type
));
171 TYPE_MAIN_TYPE (type
) = xmalloc (sizeof (struct main_type
));
175 type
= obstack_alloc (&objfile
->objfile_obstack
,
176 sizeof (struct type
));
177 memset (type
, 0, sizeof (struct type
));
178 TYPE_MAIN_TYPE (type
) = obstack_alloc (&objfile
->objfile_obstack
,
179 sizeof (struct main_type
));
180 OBJSTAT (objfile
, n_types
++);
182 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
184 /* Initialize the fields that might not be zero. */
186 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
187 TYPE_OBJFILE (type
) = objfile
;
188 TYPE_VPTR_FIELDNO (type
) = -1;
189 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
194 /* Alloc a new type instance structure, fill it with some defaults,
195 and point it at OLDTYPE. Allocate the new type instance from the
196 same place as OLDTYPE. */
199 alloc_type_instance (struct type
*oldtype
)
203 /* Allocate the structure. */
205 if (TYPE_OBJFILE (oldtype
) == NULL
)
207 type
= xmalloc (sizeof (struct type
));
208 memset (type
, 0, sizeof (struct type
));
212 type
= obstack_alloc (&TYPE_OBJFILE (oldtype
)->objfile_obstack
,
213 sizeof (struct type
));
214 memset (type
, 0, sizeof (struct type
));
216 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
218 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
223 /* Clear all remnants of the previous type at TYPE, in preparation for
224 replacing it with something else. */
226 smash_type (struct type
*type
)
228 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
230 /* For now, delete the rings. */
231 TYPE_CHAIN (type
) = type
;
233 /* For now, leave the pointer/reference types alone. */
236 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
237 to a pointer to memory where the pointer type should be stored.
238 If *TYPEPTR is zero, update it to point to the pointer type we return.
239 We allocate new memory if needed. */
242 make_pointer_type (struct type
*type
, struct type
**typeptr
)
244 struct type
*ntype
; /* New type */
245 struct objfile
*objfile
;
247 ntype
= TYPE_POINTER_TYPE (type
);
252 return ntype
; /* Don't care about alloc, and have new type. */
253 else if (*typeptr
== 0)
255 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
260 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
262 ntype
= alloc_type (TYPE_OBJFILE (type
));
267 /* We have storage, but need to reset it. */
270 objfile
= TYPE_OBJFILE (ntype
);
272 TYPE_OBJFILE (ntype
) = objfile
;
275 TYPE_TARGET_TYPE (ntype
) = type
;
276 TYPE_POINTER_TYPE (type
) = ntype
;
278 /* FIXME! Assume the machine has only one representation for pointers! */
280 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
281 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
283 /* Mark pointers as unsigned. The target converts between pointers
284 and addresses (CORE_ADDRs) using POINTER_TO_ADDRESS() and
285 ADDRESS_TO_POINTER(). */
286 TYPE_FLAGS (ntype
) |= TYPE_FLAG_UNSIGNED
;
288 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
289 TYPE_POINTER_TYPE (type
) = ntype
;
294 /* Given a type TYPE, return a type of pointers to that type.
295 May need to construct such a type if this is the first use. */
298 lookup_pointer_type (struct type
*type
)
300 return make_pointer_type (type
, (struct type
**) 0);
303 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero, points
304 to a pointer to memory where the reference type should be stored.
305 If *TYPEPTR is zero, update it to point to the reference type we return.
306 We allocate new memory if needed. */
309 make_reference_type (struct type
*type
, struct type
**typeptr
)
311 struct type
*ntype
; /* New type */
312 struct objfile
*objfile
;
314 ntype
= TYPE_REFERENCE_TYPE (type
);
319 return ntype
; /* Don't care about alloc, and have new type. */
320 else if (*typeptr
== 0)
322 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
327 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
329 ntype
= alloc_type (TYPE_OBJFILE (type
));
334 /* We have storage, but need to reset it. */
337 objfile
= TYPE_OBJFILE (ntype
);
339 TYPE_OBJFILE (ntype
) = objfile
;
342 TYPE_TARGET_TYPE (ntype
) = type
;
343 TYPE_REFERENCE_TYPE (type
) = ntype
;
345 /* FIXME! Assume the machine has only one representation for references,
346 and that it matches the (only) representation for pointers! */
348 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
349 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
351 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
352 TYPE_REFERENCE_TYPE (type
) = ntype
;
357 /* Same as above, but caller doesn't care about memory allocation details. */
360 lookup_reference_type (struct type
*type
)
362 return make_reference_type (type
, (struct type
**) 0);
365 /* Lookup a function type that returns type TYPE. TYPEPTR, if nonzero, points
366 to a pointer to memory where the function type should be stored.
367 If *TYPEPTR is zero, update it to point to the function type we return.
368 We allocate new memory if needed. */
371 make_function_type (struct type
*type
, struct type
**typeptr
)
373 struct type
*ntype
; /* New type */
374 struct objfile
*objfile
;
376 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
378 ntype
= alloc_type (TYPE_OBJFILE (type
));
383 /* We have storage, but need to reset it. */
386 objfile
= TYPE_OBJFILE (ntype
);
388 TYPE_OBJFILE (ntype
) = objfile
;
391 TYPE_TARGET_TYPE (ntype
) = type
;
393 TYPE_LENGTH (ntype
) = 1;
394 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
400 /* Given a type TYPE, return a type of functions that return that type.
401 May need to construct such a type if this is the first use. */
404 lookup_function_type (struct type
*type
)
406 return make_function_type (type
, (struct type
**) 0);
409 /* Identify address space identifier by name --
410 return the integer flag defined in gdbtypes.h. */
412 address_space_name_to_int (char *space_identifier
)
414 struct gdbarch
*gdbarch
= current_gdbarch
;
416 /* Check for known address space delimiters. */
417 if (!strcmp (space_identifier
, "code"))
418 return TYPE_FLAG_CODE_SPACE
;
419 else if (!strcmp (space_identifier
, "data"))
420 return TYPE_FLAG_DATA_SPACE
;
421 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
422 && gdbarch_address_class_name_to_type_flags (gdbarch
,
427 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
430 /* Identify address space identifier by integer flag as defined in
431 gdbtypes.h -- return the string version of the adress space name. */
434 address_space_int_to_name (int space_flag
)
436 struct gdbarch
*gdbarch
= current_gdbarch
;
437 if (space_flag
& TYPE_FLAG_CODE_SPACE
)
439 else if (space_flag
& TYPE_FLAG_DATA_SPACE
)
441 else if ((space_flag
& TYPE_FLAG_ADDRESS_CLASS_ALL
)
442 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
443 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
448 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
450 If STORAGE is non-NULL, create the new type instance there.
451 STORAGE must be in the same obstack as TYPE. */
454 make_qualified_type (struct type
*type
, int new_flags
,
455 struct type
*storage
)
461 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
463 ntype
= TYPE_CHAIN (ntype
);
464 } while (ntype
!= type
);
466 /* Create a new type instance. */
468 ntype
= alloc_type_instance (type
);
471 /* If STORAGE was provided, it had better be in the same objfile as
472 TYPE. Otherwise, we can't link it into TYPE's cv chain: if one
473 objfile is freed and the other kept, we'd have dangling
475 gdb_assert (TYPE_OBJFILE (type
) == TYPE_OBJFILE (storage
));
478 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
479 TYPE_CHAIN (ntype
) = ntype
;
482 /* Pointers or references to the original type are not relevant to
484 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
485 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
487 /* Chain the new qualified type to the old type. */
488 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
489 TYPE_CHAIN (type
) = ntype
;
491 /* Now set the instance flags and return the new type. */
492 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
494 /* Set length of new type to that of the original type. */
495 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
500 /* Make an address-space-delimited variant of a type -- a type that
501 is identical to the one supplied except that it has an address
502 space attribute attached to it (such as "code" or "data").
504 The space attributes "code" and "data" are for Harvard architectures.
505 The address space attributes are for architectures which have
506 alternately sized pointers or pointers with alternate representations. */
509 make_type_with_address_space (struct type
*type
, int space_flag
)
512 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
513 & ~(TYPE_FLAG_CODE_SPACE
| TYPE_FLAG_DATA_SPACE
514 | TYPE_FLAG_ADDRESS_CLASS_ALL
))
517 return make_qualified_type (type
, new_flags
, NULL
);
520 /* Make a "c-v" variant of a type -- a type that is identical to the
521 one supplied except that it may have const or volatile attributes
522 CNST is a flag for setting the const attribute
523 VOLTL is a flag for setting the volatile attribute
524 TYPE is the base type whose variant we are creating.
526 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
527 storage to hold the new qualified type; *TYPEPTR and TYPE must be
528 in the same objfile. Otherwise, allocate fresh memory for the new
529 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
530 new type we construct. */
532 make_cv_type (int cnst
, int voltl
, struct type
*type
, struct type
**typeptr
)
534 struct type
*ntype
; /* New type */
535 struct type
*tmp_type
= type
; /* tmp type */
536 struct objfile
*objfile
;
538 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
539 & ~(TYPE_FLAG_CONST
| TYPE_FLAG_VOLATILE
));
542 new_flags
|= TYPE_FLAG_CONST
;
545 new_flags
|= TYPE_FLAG_VOLATILE
;
547 if (typeptr
&& *typeptr
!= NULL
)
549 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
550 a C-V variant chain that threads across objfiles: if one
551 objfile gets freed, then the other has a broken C-V chain.
553 This code used to try to copy over the main type from TYPE to
554 *TYPEPTR if they were in different objfiles, but that's
555 wrong, too: TYPE may have a field list or member function
556 lists, which refer to types of their own, etc. etc. The
557 whole shebang would need to be copied over recursively; you
558 can't have inter-objfile pointers. The only thing to do is
559 to leave stub types as stub types, and look them up afresh by
560 name each time you encounter them. */
561 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
));
564 ntype
= make_qualified_type (type
, new_flags
, typeptr
? *typeptr
: NULL
);
572 /* Replace the contents of ntype with the type *type. This changes the
573 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
574 the changes are propogated to all types in the TYPE_CHAIN.
576 In order to build recursive types, it's inevitable that we'll need
577 to update types in place --- but this sort of indiscriminate
578 smashing is ugly, and needs to be replaced with something more
579 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
580 clear if more steps are needed. */
582 replace_type (struct type
*ntype
, struct type
*type
)
586 /* These two types had better be in the same objfile. Otherwise,
587 the assignment of one type's main type structure to the other
588 will produce a type with references to objects (names; field
589 lists; etc.) allocated on an objfile other than its own. */
590 gdb_assert (TYPE_OBJFILE (ntype
) == TYPE_OBJFILE (ntype
));
592 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
594 /* The type length is not a part of the main type. Update it for each
595 type on the variant chain. */
598 /* Assert that this element of the chain has no address-class bits
599 set in its flags. Such type variants might have type lengths
600 which are supposed to be different from the non-address-class
601 variants. This assertion shouldn't ever be triggered because
602 symbol readers which do construct address-class variants don't
603 call replace_type(). */
604 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
606 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
607 chain
= TYPE_CHAIN (chain
);
608 } while (ntype
!= chain
);
610 /* Assert that the two types have equivalent instance qualifiers.
611 This should be true for at least all of our debug readers. */
612 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
615 /* Implement direct support for MEMBER_TYPE in GNU C++.
616 May need to construct such a type if this is the first use.
617 The TYPE is the type of the member. The DOMAIN is the type
618 of the aggregate that the member belongs to. */
621 lookup_member_type (struct type
*type
, struct type
*domain
)
625 mtype
= alloc_type (TYPE_OBJFILE (type
));
626 smash_to_member_type (mtype
, domain
, type
);
630 /* Allocate a stub method whose return type is TYPE.
631 This apparently happens for speed of symbol reading, since parsing
632 out the arguments to the method is cpu-intensive, the way we are doing
633 it. So, we will fill in arguments later.
634 This always returns a fresh type. */
637 allocate_stub_method (struct type
*type
)
641 mtype
= init_type (TYPE_CODE_METHOD
, 1, TYPE_FLAG_STUB
, NULL
,
642 TYPE_OBJFILE (type
));
643 TYPE_TARGET_TYPE (mtype
) = type
;
644 /* _DOMAIN_TYPE (mtype) = unknown yet */
648 /* Create a range type using either a blank type supplied in RESULT_TYPE,
649 or creating a new type, inheriting the objfile from INDEX_TYPE.
651 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
652 HIGH_BOUND, inclusive.
654 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
655 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
658 create_range_type (struct type
*result_type
, struct type
*index_type
,
659 int low_bound
, int high_bound
)
661 if (result_type
== NULL
)
663 result_type
= alloc_type (TYPE_OBJFILE (index_type
));
665 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
666 TYPE_TARGET_TYPE (result_type
) = index_type
;
667 if (TYPE_STUB (index_type
))
668 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
670 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
671 TYPE_NFIELDS (result_type
) = 2;
672 TYPE_FIELDS (result_type
) = (struct field
*)
673 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
674 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
675 TYPE_FIELD_BITPOS (result_type
, 0) = low_bound
;
676 TYPE_FIELD_BITPOS (result_type
, 1) = high_bound
;
677 TYPE_FIELD_TYPE (result_type
, 0) = builtin_type_int
; /* FIXME */
678 TYPE_FIELD_TYPE (result_type
, 1) = builtin_type_int
; /* FIXME */
681 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
683 return (result_type
);
686 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE.
687 Return 1 of type is a range type, 0 if it is discrete (and bounds
688 will fit in LONGEST), or -1 otherwise. */
691 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
693 CHECK_TYPEDEF (type
);
694 switch (TYPE_CODE (type
))
696 case TYPE_CODE_RANGE
:
697 *lowp
= TYPE_LOW_BOUND (type
);
698 *highp
= TYPE_HIGH_BOUND (type
);
701 if (TYPE_NFIELDS (type
) > 0)
703 /* The enums may not be sorted by value, so search all
707 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
708 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
710 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
711 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
712 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
713 *highp
= TYPE_FIELD_BITPOS (type
, i
);
716 /* Set unsigned indicator if warranted. */
719 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
733 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
735 if (!TYPE_UNSIGNED (type
))
737 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
741 /* ... fall through for unsigned ints ... */
744 /* This round-about calculation is to avoid shifting by
745 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
746 if TYPE_LENGTH (type) == sizeof (LONGEST). */
747 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
748 *highp
= (*highp
- 1) | *highp
;
755 /* Create an array type using either a blank type supplied in RESULT_TYPE,
756 or creating a new type, inheriting the objfile from RANGE_TYPE.
758 Elements will be of type ELEMENT_TYPE, the indices will be of type
761 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
762 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
765 create_array_type (struct type
*result_type
, struct type
*element_type
,
766 struct type
*range_type
)
768 LONGEST low_bound
, high_bound
;
770 if (result_type
== NULL
)
772 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
774 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
775 TYPE_TARGET_TYPE (result_type
) = element_type
;
776 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
777 low_bound
= high_bound
= 0;
778 CHECK_TYPEDEF (element_type
);
779 TYPE_LENGTH (result_type
) =
780 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
781 TYPE_NFIELDS (result_type
) = 1;
782 TYPE_FIELDS (result_type
) =
783 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
784 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
785 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
786 TYPE_VPTR_FIELDNO (result_type
) = -1;
788 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
789 if (TYPE_LENGTH (result_type
) == 0)
790 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
792 return (result_type
);
795 /* Create a string type using either a blank type supplied in RESULT_TYPE,
796 or creating a new type. String types are similar enough to array of
797 char types that we can use create_array_type to build the basic type
798 and then bash it into a string type.
800 For fixed length strings, the range type contains 0 as the lower
801 bound and the length of the string minus one as the upper bound.
803 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
804 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
807 create_string_type (struct type
*result_type
, struct type
*range_type
)
809 struct type
*string_char_type
;
811 string_char_type
= language_string_char_type (current_language
,
813 result_type
= create_array_type (result_type
,
816 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
817 return (result_type
);
821 create_set_type (struct type
*result_type
, struct type
*domain_type
)
823 LONGEST low_bound
, high_bound
, bit_length
;
824 if (result_type
== NULL
)
826 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
828 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
829 TYPE_NFIELDS (result_type
) = 1;
830 TYPE_FIELDS (result_type
) = (struct field
*)
831 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
832 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
834 if (!TYPE_STUB (domain_type
))
836 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
837 low_bound
= high_bound
= 0;
838 bit_length
= high_bound
- low_bound
+ 1;
839 TYPE_LENGTH (result_type
)
840 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
842 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
845 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
847 return (result_type
);
850 /* Construct and return a type of the form:
851 struct NAME { ELT_TYPE ELT_NAME[N]; }
852 We use these types for SIMD registers. For example, the type of
853 the SSE registers on the late x86-family processors is:
854 struct __builtin_v4sf { float f[4]; }
855 built by the function call:
856 init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4)
857 The type returned is a permanent type, allocated using malloc; it
858 doesn't live in any objfile's obstack. */
860 init_simd_type (char *name
,
861 struct type
*elt_type
,
865 struct type
*simd_type
;
866 struct type
*array_type
;
868 simd_type
= init_composite_type (name
, TYPE_CODE_STRUCT
);
869 array_type
= create_array_type (0, elt_type
,
870 create_range_type (0, builtin_type_int
,
872 append_composite_type_field (simd_type
, elt_name
, array_type
);
877 init_vector_type (struct type
*elt_type
, int n
)
879 struct type
*array_type
;
881 array_type
= create_array_type (0, elt_type
,
882 create_range_type (0, builtin_type_int
,
884 TYPE_FLAGS (array_type
) |= TYPE_FLAG_VECTOR
;
889 build_builtin_type_vec64 (void)
891 /* Construct a type for the 64 bit registers. The type we're
894 union __gdb_builtin_type_vec64
906 t
= init_composite_type ("__gdb_builtin_type_vec64", TYPE_CODE_UNION
);
907 append_composite_type_field (t
, "uint64", builtin_type_int64
);
908 append_composite_type_field (t
, "v2_float", builtin_type_v2_float
);
909 append_composite_type_field (t
, "v2_int32", builtin_type_v2_int32
);
910 append_composite_type_field (t
, "v4_int16", builtin_type_v4_int16
);
911 append_composite_type_field (t
, "v8_int8", builtin_type_v8_int8
);
913 TYPE_FLAGS (t
) |= TYPE_FLAG_VECTOR
;
914 TYPE_NAME (t
) = "builtin_type_vec64";
919 build_builtin_type_vec128 (void)
921 /* Construct a type for the 128 bit registers. The type we're
924 union __gdb_builtin_type_vec128
936 t
= init_composite_type ("__gdb_builtin_type_vec128", TYPE_CODE_UNION
);
937 append_composite_type_field (t
, "uint128", builtin_type_int128
);
938 append_composite_type_field (t
, "v4_float", builtin_type_v4_float
);
939 append_composite_type_field (t
, "v4_int32", builtin_type_v4_int32
);
940 append_composite_type_field (t
, "v8_int16", builtin_type_v8_int16
);
941 append_composite_type_field (t
, "v16_int8", builtin_type_v16_int8
);
943 TYPE_FLAGS (t
) |= TYPE_FLAG_VECTOR
;
944 TYPE_NAME (t
) = "builtin_type_vec128";
948 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
949 A MEMBER is a wierd thing -- it amounts to a typed offset into
950 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
951 include the offset (that's the value of the MEMBER itself), but does
952 include the structure type into which it points (for some reason).
954 When "smashing" the type, we preserve the objfile that the
955 old type pointed to, since we aren't changing where the type is actually
959 smash_to_member_type (struct type
*type
, struct type
*domain
,
960 struct type
*to_type
)
962 struct objfile
*objfile
;
964 objfile
= TYPE_OBJFILE (type
);
967 TYPE_OBJFILE (type
) = objfile
;
968 TYPE_TARGET_TYPE (type
) = to_type
;
969 TYPE_DOMAIN_TYPE (type
) = domain
;
970 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
971 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
974 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
975 METHOD just means `function that gets an extra "this" argument'.
977 When "smashing" the type, we preserve the objfile that the
978 old type pointed to, since we aren't changing where the type is actually
982 smash_to_method_type (struct type
*type
, struct type
*domain
,
983 struct type
*to_type
, struct field
*args
,
984 int nargs
, int varargs
)
986 struct objfile
*objfile
;
988 objfile
= TYPE_OBJFILE (type
);
991 TYPE_OBJFILE (type
) = objfile
;
992 TYPE_TARGET_TYPE (type
) = to_type
;
993 TYPE_DOMAIN_TYPE (type
) = domain
;
994 TYPE_FIELDS (type
) = args
;
995 TYPE_NFIELDS (type
) = nargs
;
997 TYPE_FLAGS (type
) |= TYPE_FLAG_VARARGS
;
998 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
999 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
1002 /* Return a typename for a struct/union/enum type without "struct ",
1003 "union ", or "enum ". If the type has a NULL name, return NULL. */
1006 type_name_no_tag (const struct type
*type
)
1008 if (TYPE_TAG_NAME (type
) != NULL
)
1009 return TYPE_TAG_NAME (type
);
1011 /* Is there code which expects this to return the name if there is no
1012 tag name? My guess is that this is mainly used for C++ in cases where
1013 the two will always be the same. */
1014 return TYPE_NAME (type
);
1017 /* Lookup a typedef or primitive type named NAME,
1018 visible in lexical block BLOCK.
1019 If NOERR is nonzero, return zero if NAME is not suitably defined. */
1022 lookup_typename (char *name
, struct block
*block
, int noerr
)
1027 sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, 0, (struct symtab
**) NULL
);
1028 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1030 tmp
= language_lookup_primitive_type_by_name (current_language
,
1037 else if (!tmp
&& noerr
)
1043 error (_("No type named %s."), name
);
1046 return (SYMBOL_TYPE (sym
));
1050 lookup_unsigned_typename (char *name
)
1052 char *uns
= alloca (strlen (name
) + 10);
1054 strcpy (uns
, "unsigned ");
1055 strcpy (uns
+ 9, name
);
1056 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
1060 lookup_signed_typename (char *name
)
1063 char *uns
= alloca (strlen (name
) + 8);
1065 strcpy (uns
, "signed ");
1066 strcpy (uns
+ 7, name
);
1067 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
1068 /* If we don't find "signed FOO" just try again with plain "FOO". */
1071 return lookup_typename (name
, (struct block
*) NULL
, 0);
1074 /* Lookup a structure type named "struct NAME",
1075 visible in lexical block BLOCK. */
1078 lookup_struct (char *name
, struct block
*block
)
1082 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
1083 (struct symtab
**) NULL
);
1087 error (_("No struct type named %s."), name
);
1089 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1091 error (_("This context has class, union or enum %s, not a struct."), name
);
1093 return (SYMBOL_TYPE (sym
));
1096 /* Lookup a union type named "union NAME",
1097 visible in lexical block BLOCK. */
1100 lookup_union (char *name
, struct block
*block
)
1105 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
1106 (struct symtab
**) NULL
);
1109 error (_("No union type named %s."), name
);
1111 t
= SYMBOL_TYPE (sym
);
1113 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1116 /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
1117 * a further "declared_type" field to discover it is really a union.
1119 if (HAVE_CPLUS_STRUCT (t
))
1120 if (TYPE_DECLARED_TYPE (t
) == DECLARED_TYPE_UNION
)
1123 /* If we get here, it's not a union */
1124 error (_("This context has class, struct or enum %s, not a union."), name
);
1128 /* Lookup an enum type named "enum NAME",
1129 visible in lexical block BLOCK. */
1132 lookup_enum (char *name
, struct block
*block
)
1136 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
1137 (struct symtab
**) NULL
);
1140 error (_("No enum type named %s."), name
);
1142 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1144 error (_("This context has class, struct or union %s, not an enum."), name
);
1146 return (SYMBOL_TYPE (sym
));
1149 /* Lookup a template type named "template NAME<TYPE>",
1150 visible in lexical block BLOCK. */
1153 lookup_template_type (char *name
, struct type
*type
, struct block
*block
)
1156 char *nam
= (char *) alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1159 strcat (nam
, TYPE_NAME (type
));
1160 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1162 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0, (struct symtab
**) NULL
);
1166 error (_("No template type named %s."), name
);
1168 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1170 error (_("This context has class, union or enum %s, not a struct."), name
);
1172 return (SYMBOL_TYPE (sym
));
1175 /* Given a type TYPE, lookup the type of the component of type named NAME.
1177 TYPE can be either a struct or union, or a pointer or reference to a struct or
1178 union. If it is a pointer or reference, its target type is automatically used.
1179 Thus '.' and '->' are interchangable, as specified for the definitions of the
1180 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
1182 If NOERR is nonzero, return zero if NAME is not suitably defined.
1183 If NAME is the name of a baseclass type, return that type. */
1186 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
1192 CHECK_TYPEDEF (type
);
1193 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1194 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1196 type
= TYPE_TARGET_TYPE (type
);
1199 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
1200 TYPE_CODE (type
) != TYPE_CODE_UNION
)
1202 target_terminal_ours ();
1203 gdb_flush (gdb_stdout
);
1204 fprintf_unfiltered (gdb_stderr
, "Type ");
1205 type_print (type
, "", gdb_stderr
, -1);
1206 error (_(" is not a structure or union type."));
1210 /* FIXME: This change put in by Michael seems incorrect for the case where
1211 the structure tag name is the same as the member name. I.E. when doing
1212 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
1217 typename
= type_name_no_tag (type
);
1218 if (typename
!= NULL
&& strcmp (typename
, name
) == 0)
1223 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1225 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1227 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1229 return TYPE_FIELD_TYPE (type
, i
);
1233 /* OK, it's not in this class. Recursively check the baseclasses. */
1234 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1238 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, noerr
);
1250 target_terminal_ours ();
1251 gdb_flush (gdb_stdout
);
1252 fprintf_unfiltered (gdb_stderr
, "Type ");
1253 type_print (type
, "", gdb_stderr
, -1);
1254 fprintf_unfiltered (gdb_stderr
, " has no component named ");
1255 fputs_filtered (name
, gdb_stderr
);
1257 return (struct type
*) -1; /* For lint */
1260 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
1261 valid. Callers should be aware that in some cases (for example,
1262 the type or one of its baseclasses is a stub type and we are
1263 debugging a .o file), this function will not be able to find the virtual
1264 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
1265 will remain NULL. */
1268 fill_in_vptr_fieldno (struct type
*type
)
1270 CHECK_TYPEDEF (type
);
1272 if (TYPE_VPTR_FIELDNO (type
) < 0)
1276 /* We must start at zero in case the first (and only) baseclass is
1277 virtual (and hence we cannot share the table pointer). */
1278 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1280 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1281 fill_in_vptr_fieldno (baseclass
);
1282 if (TYPE_VPTR_FIELDNO (baseclass
) >= 0)
1284 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (baseclass
);
1285 TYPE_VPTR_BASETYPE (type
) = TYPE_VPTR_BASETYPE (baseclass
);
1292 /* Find the method and field indices for the destructor in class type T.
1293 Return 1 if the destructor was found, otherwise, return 0. */
1296 get_destructor_fn_field (struct type
*t
, int *method_indexp
, int *field_indexp
)
1300 for (i
= 0; i
< TYPE_NFN_FIELDS (t
); i
++)
1303 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1305 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (t
, i
); j
++)
1307 if (is_destructor_name (TYPE_FN_FIELD_PHYSNAME (f
, j
)) != 0)
1319 stub_noname_complaint (void)
1321 complaint (&symfile_complaints
, _("stub type has NULL name"));
1324 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1326 If this is a stubbed struct (i.e. declared as struct foo *), see if
1327 we can find a full definition in some other file. If so, copy this
1328 definition, so we can use it in future. There used to be a comment (but
1329 not any code) that if we don't find a full definition, we'd set a flag
1330 so we don't spend time in the future checking the same type. That would
1331 be a mistake, though--we might load in more symbols which contain a
1332 full definition for the type.
1334 This used to be coded as a macro, but I don't think it is called
1335 often enough to merit such treatment. */
1337 /* Find the real type of TYPE. This function returns the real type, after
1338 removing all layers of typedefs and completing opaque or stub types.
1339 Completion changes the TYPE argument, but stripping of typedefs does
1343 check_typedef (struct type
*type
)
1345 struct type
*orig_type
= type
;
1346 int is_const
, is_volatile
;
1348 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1350 if (!TYPE_TARGET_TYPE (type
))
1355 /* It is dangerous to call lookup_symbol if we are currently
1356 reading a symtab. Infinite recursion is one danger. */
1357 if (currently_reading_symtab
)
1360 name
= type_name_no_tag (type
);
1361 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1362 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1363 as appropriate? (this code was written before TYPE_NAME and
1364 TYPE_TAG_NAME were separate). */
1367 stub_noname_complaint ();
1370 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0,
1371 (struct symtab
**) NULL
);
1373 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1375 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
); /* TYPE_CODE_UNDEF */
1377 type
= TYPE_TARGET_TYPE (type
);
1380 is_const
= TYPE_CONST (type
);
1381 is_volatile
= TYPE_VOLATILE (type
);
1383 /* If this is a struct/class/union with no fields, then check whether a
1384 full definition exists somewhere else. This is for systems where a
1385 type definition with no fields is issued for such types, instead of
1386 identifying them as stub types in the first place */
1388 if (TYPE_IS_OPAQUE (type
) && opaque_type_resolution
&& !currently_reading_symtab
)
1390 char *name
= type_name_no_tag (type
);
1391 struct type
*newtype
;
1394 stub_noname_complaint ();
1397 newtype
= lookup_transparent_type (name
);
1401 /* If the resolved type and the stub are in the same objfile,
1402 then replace the stub type with the real deal. But if
1403 they're in separate objfiles, leave the stub alone; we'll
1404 just look up the transparent type every time we call
1405 check_typedef. We can't create pointers between types
1406 allocated to different objfiles, since they may have
1407 different lifetimes. Trying to copy NEWTYPE over to TYPE's
1408 objfile is pointless, too, since you'll have to move over any
1409 other types NEWTYPE refers to, which could be an unbounded
1411 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
1412 make_cv_type (is_const
, is_volatile
, newtype
, &type
);
1417 /* Otherwise, rely on the stub flag being set for opaque/stubbed types */
1418 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1420 char *name
= type_name_no_tag (type
);
1421 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1422 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1423 as appropriate? (this code was written before TYPE_NAME and
1424 TYPE_TAG_NAME were separate). */
1428 stub_noname_complaint ();
1431 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0, (struct symtab
**) NULL
);
1433 make_cv_type (is_const
, is_volatile
, SYMBOL_TYPE (sym
), &type
);
1436 if (TYPE_TARGET_STUB (type
))
1438 struct type
*range_type
;
1439 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1441 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1444 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1445 && TYPE_NFIELDS (type
) == 1
1446 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
1447 == TYPE_CODE_RANGE
))
1449 /* Now recompute the length of the array type, based on its
1450 number of elements and the target type's length. */
1451 TYPE_LENGTH (type
) =
1452 ((TYPE_FIELD_BITPOS (range_type
, 1)
1453 - TYPE_FIELD_BITPOS (range_type
, 0)
1455 * TYPE_LENGTH (target_type
));
1456 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1458 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1460 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1461 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1464 /* Cache TYPE_LENGTH for future use. */
1465 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1469 /* Parse a type expression in the string [P..P+LENGTH). If an error occurs,
1470 silently return builtin_type_void. */
1472 static struct type
*
1473 safe_parse_type (char *p
, int length
)
1475 struct ui_file
*saved_gdb_stderr
;
1478 /* Suppress error messages. */
1479 saved_gdb_stderr
= gdb_stderr
;
1480 gdb_stderr
= ui_file_new ();
1482 /* Call parse_and_eval_type() without fear of longjmp()s. */
1483 if (!gdb_parse_and_eval_type (p
, length
, &type
))
1484 type
= builtin_type_void
;
1486 /* Stop suppressing error messages. */
1487 ui_file_delete (gdb_stderr
);
1488 gdb_stderr
= saved_gdb_stderr
;
1493 /* Ugly hack to convert method stubs into method types.
1495 He ain't kiddin'. This demangles the name of the method into a string
1496 including argument types, parses out each argument type, generates
1497 a string casting a zero to that type, evaluates the string, and stuffs
1498 the resulting type into an argtype vector!!! Then it knows the type
1499 of the whole function (including argument types for overloading),
1500 which info used to be in the stab's but was removed to hack back
1501 the space required for them. */
1504 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1507 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1508 char *demangled_name
= cplus_demangle (mangled_name
,
1509 DMGL_PARAMS
| DMGL_ANSI
);
1510 char *argtypetext
, *p
;
1511 int depth
= 0, argcount
= 1;
1512 struct field
*argtypes
;
1515 /* Make sure we got back a function string that we can use. */
1517 p
= strchr (demangled_name
, '(');
1521 if (demangled_name
== NULL
|| p
== NULL
)
1522 error (_("Internal: Cannot demangle mangled name `%s'."), mangled_name
);
1524 /* Now, read in the parameters that define this type. */
1529 if (*p
== '(' || *p
== '<')
1533 else if (*p
== ')' || *p
== '>')
1537 else if (*p
== ',' && depth
== 0)
1545 /* If we read one argument and it was ``void'', don't count it. */
1546 if (strncmp (argtypetext
, "(void)", 6) == 0)
1549 /* We need one extra slot, for the THIS pointer. */
1551 argtypes
= (struct field
*)
1552 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
1555 /* Add THIS pointer for non-static methods. */
1556 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1557 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
1561 argtypes
[0].type
= lookup_pointer_type (type
);
1565 if (*p
!= ')') /* () means no args, skip while */
1570 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1572 /* Avoid parsing of ellipsis, they will be handled below.
1573 Also avoid ``void'' as above. */
1574 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
1575 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
1577 argtypes
[argcount
].type
=
1578 safe_parse_type (argtypetext
, p
- argtypetext
);
1581 argtypetext
= p
+ 1;
1584 if (*p
== '(' || *p
== '<')
1588 else if (*p
== ')' || *p
== '>')
1597 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1599 /* Now update the old "stub" type into a real type. */
1600 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1601 TYPE_DOMAIN_TYPE (mtype
) = type
;
1602 TYPE_FIELDS (mtype
) = argtypes
;
1603 TYPE_NFIELDS (mtype
) = argcount
;
1604 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1605 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1607 TYPE_FLAGS (mtype
) |= TYPE_FLAG_VARARGS
;
1609 xfree (demangled_name
);
1612 /* This is the external interface to check_stub_method, above. This function
1613 unstubs all of the signatures for TYPE's METHOD_ID method name. After
1614 calling this function TYPE_FN_FIELD_STUB will be cleared for each signature
1615 and TYPE_FN_FIELDLIST_NAME will be correct.
1617 This function unfortunately can not die until stabs do. */
1620 check_stub_method_group (struct type
*type
, int method_id
)
1622 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
1623 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1624 int j
, found_stub
= 0;
1626 for (j
= 0; j
< len
; j
++)
1627 if (TYPE_FN_FIELD_STUB (f
, j
))
1630 check_stub_method (type
, method_id
, j
);
1633 /* GNU v3 methods with incorrect names were corrected when we read in
1634 type information, because it was cheaper to do it then. The only GNU v2
1635 methods with incorrect method names are operators and destructors;
1636 destructors were also corrected when we read in type information.
1638 Therefore the only thing we need to handle here are v2 operator
1640 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
1643 char dem_opname
[256];
1645 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
, method_id
),
1646 dem_opname
, DMGL_ANSI
);
1648 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
, method_id
),
1651 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
1655 const struct cplus_struct_type cplus_struct_default
;
1658 allocate_cplus_struct_type (struct type
*type
)
1660 if (!HAVE_CPLUS_STRUCT (type
))
1662 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1663 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1664 *(TYPE_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1668 /* Helper function to initialize the standard scalar types.
1670 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1671 of the string pointed to by name in the objfile_obstack for that objfile,
1672 and initialize the type name to that copy. There are places (mipsread.c
1673 in particular, where init_type is called with a NULL value for NAME). */
1676 init_type (enum type_code code
, int length
, int flags
, char *name
,
1677 struct objfile
*objfile
)
1681 type
= alloc_type (objfile
);
1682 TYPE_CODE (type
) = code
;
1683 TYPE_LENGTH (type
) = length
;
1684 TYPE_FLAGS (type
) |= flags
;
1685 if ((name
!= NULL
) && (objfile
!= NULL
))
1688 obsavestring (name
, strlen (name
), &objfile
->objfile_obstack
);
1692 TYPE_NAME (type
) = name
;
1697 if (name
&& strcmp (name
, "char") == 0)
1698 TYPE_FLAGS (type
) |= TYPE_FLAG_NOSIGN
;
1700 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
1701 || code
== TYPE_CODE_NAMESPACE
)
1703 INIT_CPLUS_SPECIFIC (type
);
1708 /* Helper function. Create an empty composite type. */
1711 init_composite_type (char *name
, enum type_code code
)
1714 gdb_assert (code
== TYPE_CODE_STRUCT
1715 || code
== TYPE_CODE_UNION
);
1716 t
= init_type (code
, 0, 0, NULL
, NULL
);
1717 TYPE_TAG_NAME (t
) = name
;
1721 /* Helper function. Append a field to a composite type. */
1724 append_composite_type_field (struct type
*t
, char *name
, struct type
*field
)
1727 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
1728 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
1729 sizeof (struct field
) * TYPE_NFIELDS (t
));
1730 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
1731 memset (f
, 0, sizeof f
[0]);
1732 FIELD_TYPE (f
[0]) = field
;
1733 FIELD_NAME (f
[0]) = name
;
1734 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1736 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
1737 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
1739 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
1741 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
1742 if (TYPE_NFIELDS (t
) > 1)
1744 FIELD_BITPOS (f
[0]) = (FIELD_BITPOS (f
[-1])
1745 + TYPE_LENGTH (field
) * TARGET_CHAR_BIT
);
1750 /* Look up a fundamental type for the specified objfile.
1751 May need to construct such a type if this is the first use.
1753 Some object file formats (ELF, COFF, etc) do not define fundamental
1754 types such as "int" or "double". Others (stabs for example), do
1755 define fundamental types.
1757 For the formats which don't provide fundamental types, gdb can create
1758 such types, using defaults reasonable for the current language and
1759 the current target machine.
1761 NOTE: This routine is obsolescent. Each debugging format reader
1762 should manage it's own fundamental types, either creating them from
1763 suitable defaults or reading them from the debugging information,
1764 whichever is appropriate. The DWARF reader has already been
1765 fixed to do this. Once the other readers are fixed, this routine
1766 will go away. Also note that fundamental types should be managed
1767 on a compilation unit basis in a multi-language environment, not
1768 on a linkage unit basis as is done here. */
1772 lookup_fundamental_type (struct objfile
*objfile
, int typeid)
1774 struct type
**typep
;
1777 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1779 error (_("internal error - invalid fundamental type id %d"), typeid);
1782 /* If this is the first time we need a fundamental type for this objfile
1783 then we need to initialize the vector of type pointers. */
1785 if (objfile
->fundamental_types
== NULL
)
1787 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1788 objfile
->fundamental_types
= (struct type
**)
1789 obstack_alloc (&objfile
->objfile_obstack
, nbytes
);
1790 memset ((char *) objfile
->fundamental_types
, 0, nbytes
);
1791 OBJSTAT (objfile
, n_types
+= FT_NUM_MEMBERS
);
1794 /* Look for this particular type in the fundamental type vector. If one is
1795 not found, create and install one appropriate for the current language. */
1797 typep
= objfile
->fundamental_types
+ typeid;
1800 *typep
= create_fundamental_type (objfile
, typeid);
1807 can_dereference (struct type
*t
)
1809 /* FIXME: Should we return true for references as well as pointers? */
1813 && TYPE_CODE (t
) == TYPE_CODE_PTR
1814 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1818 is_integral_type (struct type
*t
)
1823 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
1824 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
1825 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
1826 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
1827 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
1830 /* Check whether BASE is an ancestor or base class or DCLASS
1831 Return 1 if so, and 0 if not.
1832 Note: callers may want to check for identity of the types before
1833 calling this function -- identical types are considered to satisfy
1834 the ancestor relationship even if they're identical */
1837 is_ancestor (struct type
*base
, struct type
*dclass
)
1841 CHECK_TYPEDEF (base
);
1842 CHECK_TYPEDEF (dclass
);
1846 if (TYPE_NAME (base
) && TYPE_NAME (dclass
) &&
1847 !strcmp (TYPE_NAME (base
), TYPE_NAME (dclass
)))
1850 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1851 if (is_ancestor (base
, TYPE_BASECLASS (dclass
, i
)))
1859 /* See whether DCLASS has a virtual table. This routine is aimed at
1860 the HP/Taligent ANSI C++ runtime model, and may not work with other
1861 runtime models. Return 1 => Yes, 0 => No. */
1864 has_vtable (struct type
*dclass
)
1866 /* In the HP ANSI C++ runtime model, a class has a vtable only if it
1867 has virtual functions or virtual bases. */
1871 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1874 /* First check for the presence of virtual bases */
1875 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
1876 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1877 if (B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
))
1880 /* Next check for virtual functions */
1881 if (TYPE_FN_FIELDLISTS (dclass
))
1882 for (i
= 0; i
< TYPE_NFN_FIELDS (dclass
); i
++)
1883 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, i
), 0))
1886 /* Recurse on non-virtual bases to see if any of them needs a vtable */
1887 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
1888 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1889 if ((!B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
)) &&
1890 (has_vtable (TYPE_FIELD_TYPE (dclass
, i
))))
1893 /* Well, maybe we don't need a virtual table */
1897 /* Return a pointer to the "primary base class" of DCLASS.
1899 A NULL return indicates that DCLASS has no primary base, or that it
1900 couldn't be found (insufficient information).
1902 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
1903 and may not work with other runtime models. */
1906 primary_base_class (struct type
*dclass
)
1908 /* In HP ANSI C++'s runtime model, a "primary base class" of a class
1909 is the first directly inherited, non-virtual base class that
1910 requires a virtual table */
1914 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1917 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1918 if (!TYPE_FIELD_VIRTUAL (dclass
, i
) &&
1919 has_vtable (TYPE_FIELD_TYPE (dclass
, i
)))
1920 return TYPE_FIELD_TYPE (dclass
, i
);
1925 /* Global manipulated by virtual_base_list[_aux]() */
1927 static struct vbase
*current_vbase_list
= NULL
;
1929 /* Return a pointer to a null-terminated list of struct vbase
1930 items. The vbasetype pointer of each item in the list points to the
1931 type information for a virtual base of the argument DCLASS.
1933 Helper function for virtual_base_list().
1934 Note: the list goes backward, right-to-left. virtual_base_list()
1935 copies the items out in reverse order. */
1938 virtual_base_list_aux (struct type
*dclass
)
1940 struct vbase
*tmp_vbase
;
1943 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1946 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1948 /* Recurse on this ancestor, first */
1949 virtual_base_list_aux (TYPE_FIELD_TYPE (dclass
, i
));
1951 /* If this current base is itself virtual, add it to the list */
1952 if (BASETYPE_VIA_VIRTUAL (dclass
, i
))
1954 struct type
*basetype
= TYPE_FIELD_TYPE (dclass
, i
);
1956 /* Check if base already recorded */
1957 tmp_vbase
= current_vbase_list
;
1960 if (tmp_vbase
->vbasetype
== basetype
)
1961 break; /* found it */
1962 tmp_vbase
= tmp_vbase
->next
;
1965 if (!tmp_vbase
) /* normal exit from loop */
1967 /* Allocate new item for this virtual base */
1968 tmp_vbase
= (struct vbase
*) xmalloc (sizeof (struct vbase
));
1970 /* Stick it on at the end of the list */
1971 tmp_vbase
->vbasetype
= basetype
;
1972 tmp_vbase
->next
= current_vbase_list
;
1973 current_vbase_list
= tmp_vbase
;
1976 } /* for loop over bases */
1980 /* Compute the list of virtual bases in the right order. Virtual
1981 bases are laid out in the object's memory area in order of their
1982 occurrence in a depth-first, left-to-right search through the
1985 Argument DCLASS is the type whose virtual bases are required.
1986 Return value is the address of a null-terminated array of pointers
1987 to struct type items.
1989 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
1990 and may not work with other runtime models.
1992 This routine merely hands off the argument to virtual_base_list_aux()
1993 and then copies the result into an array to save space. */
1996 virtual_base_list (struct type
*dclass
)
1998 struct vbase
*tmp_vbase
;
1999 struct vbase
*tmp_vbase_2
;
2002 struct type
**vbase_array
;
2004 current_vbase_list
= NULL
;
2005 virtual_base_list_aux (dclass
);
2007 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
2012 vbase_array
= (struct type
**) xmalloc ((count
+ 1) * sizeof (struct type
*));
2014 for (i
= count
- 1, tmp_vbase
= current_vbase_list
; i
>= 0; i
--, tmp_vbase
= tmp_vbase
->next
)
2015 vbase_array
[i
] = tmp_vbase
->vbasetype
;
2017 /* Get rid of constructed chain */
2018 tmp_vbase_2
= tmp_vbase
= current_vbase_list
;
2021 tmp_vbase
= tmp_vbase
->next
;
2022 xfree (tmp_vbase_2
);
2023 tmp_vbase_2
= tmp_vbase
;
2026 vbase_array
[count
] = NULL
;
2030 /* Return the length of the virtual base list of the type DCLASS. */
2033 virtual_base_list_length (struct type
*dclass
)
2036 struct vbase
*tmp_vbase
;
2038 current_vbase_list
= NULL
;
2039 virtual_base_list_aux (dclass
);
2041 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
2046 /* Return the number of elements of the virtual base list of the type
2047 DCLASS, ignoring those appearing in the primary base (and its
2048 primary base, recursively). */
2051 virtual_base_list_length_skip_primaries (struct type
*dclass
)
2054 struct vbase
*tmp_vbase
;
2055 struct type
*primary
;
2057 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
2060 return virtual_base_list_length (dclass
);
2062 current_vbase_list
= NULL
;
2063 virtual_base_list_aux (dclass
);
2065 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; tmp_vbase
= tmp_vbase
->next
)
2067 if (virtual_base_index (tmp_vbase
->vbasetype
, primary
) >= 0)
2075 /* Return the index (position) of type BASE, which is a virtual base
2076 class of DCLASS, in the latter's virtual base list. A return of -1
2077 indicates "not found" or a problem. */
2080 virtual_base_index (struct type
*base
, struct type
*dclass
)
2085 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
2086 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
2090 vbase
= virtual_base_list (dclass
)[0];
2095 vbase
= virtual_base_list (dclass
)[++i
];
2098 return vbase
? i
: -1;
2103 /* Return the index (position) of type BASE, which is a virtual base
2104 class of DCLASS, in the latter's virtual base list. Skip over all
2105 bases that may appear in the virtual base list of the primary base
2106 class of DCLASS (recursively). A return of -1 indicates "not
2107 found" or a problem. */
2110 virtual_base_index_skip_primaries (struct type
*base
, struct type
*dclass
)
2114 struct type
*primary
;
2116 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
2117 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
2120 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
2124 vbase
= virtual_base_list (dclass
)[0];
2127 if (!primary
|| (virtual_base_index_skip_primaries (vbase
, primary
) < 0))
2131 vbase
= virtual_base_list (dclass
)[++i
];
2134 return vbase
? j
: -1;
2137 /* Return position of a derived class DCLASS in the list of
2138 * primary bases starting with the remotest ancestor.
2139 * Position returned is 0-based. */
2142 class_index_in_primary_list (struct type
*dclass
)
2144 struct type
*pbc
; /* primary base class */
2146 /* Simply recurse on primary base */
2147 pbc
= TYPE_PRIMARY_BASE (dclass
);
2149 return 1 + class_index_in_primary_list (pbc
);
2154 /* Return a count of the number of virtual functions a type has.
2155 * This includes all the virtual functions it inherits from its
2159 /* pai: FIXME This doesn't do the right thing: count redefined virtual
2160 * functions only once (latest redefinition)
2164 count_virtual_fns (struct type
*dclass
)
2166 int fn
, oi
; /* function and overloaded instance indices */
2167 int vfuncs
; /* count to return */
2169 /* recurse on bases that can share virtual table */
2170 struct type
*pbc
= primary_base_class (dclass
);
2172 vfuncs
= count_virtual_fns (pbc
);
2176 for (fn
= 0; fn
< TYPE_NFN_FIELDS (dclass
); fn
++)
2177 for (oi
= 0; oi
< TYPE_FN_FIELDLIST_LENGTH (dclass
, fn
); oi
++)
2178 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, fn
), oi
))
2186 /* Functions for overload resolution begin here */
2188 /* Compare two badness vectors A and B and return the result.
2189 * 0 => A and B are identical
2190 * 1 => A and B are incomparable
2191 * 2 => A is better than B
2192 * 3 => A is worse than B */
2195 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
2199 short found_pos
= 0; /* any positives in c? */
2200 short found_neg
= 0; /* any negatives in c? */
2202 /* differing lengths => incomparable */
2203 if (a
->length
!= b
->length
)
2206 /* Subtract b from a */
2207 for (i
= 0; i
< a
->length
; i
++)
2209 tmp
= a
->rank
[i
] - b
->rank
[i
];
2219 return 1; /* incomparable */
2221 return 3; /* A > B */
2227 return 2; /* A < B */
2229 return 0; /* A == B */
2233 /* Rank a function by comparing its parameter types (PARMS, length NPARMS),
2234 * to the types of an argument list (ARGS, length NARGS).
2235 * Return a pointer to a badness vector. This has NARGS + 1 entries. */
2237 struct badness_vector
*
2238 rank_function (struct type
**parms
, int nparms
, struct type
**args
, int nargs
)
2241 struct badness_vector
*bv
;
2242 int min_len
= nparms
< nargs
? nparms
: nargs
;
2244 bv
= xmalloc (sizeof (struct badness_vector
));
2245 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank */
2246 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
2248 /* First compare the lengths of the supplied lists.
2249 * If there is a mismatch, set it to a high value. */
2251 /* pai/1997-06-03 FIXME: when we have debug info about default
2252 * arguments and ellipsis parameter lists, we should consider those
2253 * and rank the length-match more finely. */
2255 LENGTH_MATCH (bv
) = (nargs
!= nparms
) ? LENGTH_MISMATCH_BADNESS
: 0;
2257 /* Now rank all the parameters of the candidate function */
2258 for (i
= 1; i
<= min_len
; i
++)
2259 bv
->rank
[i
] = rank_one_type (parms
[i
-1], args
[i
-1]);
2261 /* If more arguments than parameters, add dummy entries */
2262 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2263 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2268 /* Compare the names of two integer types, assuming that any sign
2269 qualifiers have been checked already. We do it this way because
2270 there may be an "int" in the name of one of the types. */
2273 integer_types_same_name_p (const char *first
, const char *second
)
2275 int first_p
, second_p
;
2277 /* If both are shorts, return 1; if neither is a short, keep checking. */
2278 first_p
= (strstr (first
, "short") != NULL
);
2279 second_p
= (strstr (second
, "short") != NULL
);
2280 if (first_p
&& second_p
)
2282 if (first_p
|| second_p
)
2285 /* Likewise for long. */
2286 first_p
= (strstr (first
, "long") != NULL
);
2287 second_p
= (strstr (second
, "long") != NULL
);
2288 if (first_p
&& second_p
)
2290 if (first_p
|| second_p
)
2293 /* Likewise for char. */
2294 first_p
= (strstr (first
, "char") != NULL
);
2295 second_p
= (strstr (second
, "char") != NULL
);
2296 if (first_p
&& second_p
)
2298 if (first_p
|| second_p
)
2301 /* They must both be ints. */
2305 /* Compare one type (PARM) for compatibility with another (ARG).
2306 * PARM is intended to be the parameter type of a function; and
2307 * ARG is the supplied argument's type. This function tests if
2308 * the latter can be converted to the former.
2310 * Return 0 if they are identical types;
2311 * Otherwise, return an integer which corresponds to how compatible
2312 * PARM is to ARG. The higher the return value, the worse the match.
2313 * Generally the "bad" conversions are all uniformly assigned a 100 */
2316 rank_one_type (struct type
*parm
, struct type
*arg
)
2318 /* Identical type pointers */
2319 /* However, this still doesn't catch all cases of same type for arg
2320 * and param. The reason is that builtin types are different from
2321 * the same ones constructed from the object. */
2325 /* Resolve typedefs */
2326 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2327 parm
= check_typedef (parm
);
2328 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2329 arg
= check_typedef (arg
);
2332 Well, damnit, if the names are exactly the same,
2333 i'll say they are exactly the same. This happens when we generate
2334 method stubs. The types won't point to the same address, but they
2335 really are the same.
2338 if (TYPE_NAME (parm
) && TYPE_NAME (arg
) &&
2339 !strcmp (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2342 /* Check if identical after resolving typedefs */
2346 /* See through references, since we can almost make non-references
2348 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2349 return (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
))
2350 + REFERENCE_CONVERSION_BADNESS
);
2351 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2352 return (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
)
2353 + REFERENCE_CONVERSION_BADNESS
);
2355 /* Debugging only. */
2356 fprintf_filtered (gdb_stderr
,"------ Arg is %s [%d], parm is %s [%d]\n",
2357 TYPE_NAME (arg
), TYPE_CODE (arg
), TYPE_NAME (parm
), TYPE_CODE (parm
));
2359 /* x -> y means arg of type x being supplied for parameter of type y */
2361 switch (TYPE_CODE (parm
))
2364 switch (TYPE_CODE (arg
))
2367 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2368 return VOID_PTR_CONVERSION_BADNESS
;
2370 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2371 case TYPE_CODE_ARRAY
:
2372 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2373 case TYPE_CODE_FUNC
:
2374 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
);
2376 case TYPE_CODE_ENUM
:
2377 case TYPE_CODE_CHAR
:
2378 case TYPE_CODE_RANGE
:
2379 case TYPE_CODE_BOOL
:
2380 return POINTER_CONVERSION_BADNESS
;
2382 return INCOMPATIBLE_TYPE_BADNESS
;
2384 case TYPE_CODE_ARRAY
:
2385 switch (TYPE_CODE (arg
))
2388 case TYPE_CODE_ARRAY
:
2389 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2391 return INCOMPATIBLE_TYPE_BADNESS
;
2393 case TYPE_CODE_FUNC
:
2394 switch (TYPE_CODE (arg
))
2396 case TYPE_CODE_PTR
: /* funcptr -> func */
2397 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
));
2399 return INCOMPATIBLE_TYPE_BADNESS
;
2402 switch (TYPE_CODE (arg
))
2405 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2407 /* Deal with signed, unsigned, and plain chars and
2408 signed and unsigned ints */
2409 if (TYPE_NOSIGN (parm
))
2411 /* This case only for character types */
2412 if (TYPE_NOSIGN (arg
)) /* plain char -> plain char */
2415 return INTEGER_CONVERSION_BADNESS
; /* signed/unsigned char -> plain char */
2417 else if (TYPE_UNSIGNED (parm
))
2419 if (TYPE_UNSIGNED (arg
))
2421 /* unsigned int -> unsigned int, or unsigned long -> unsigned long */
2422 if (integer_types_same_name_p (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2424 else if (integer_types_same_name_p (TYPE_NAME (arg
), "int")
2425 && integer_types_same_name_p (TYPE_NAME (parm
), "long"))
2426 return INTEGER_PROMOTION_BADNESS
; /* unsigned int -> unsigned long */
2428 return INTEGER_CONVERSION_BADNESS
; /* unsigned long -> unsigned int */
2432 if (integer_types_same_name_p (TYPE_NAME (arg
), "long")
2433 && integer_types_same_name_p (TYPE_NAME (parm
), "int"))
2434 return INTEGER_CONVERSION_BADNESS
; /* signed long -> unsigned int */
2436 return INTEGER_CONVERSION_BADNESS
; /* signed int/long -> unsigned int/long */
2439 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2441 if (integer_types_same_name_p (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2443 else if (integer_types_same_name_p (TYPE_NAME (arg
), "int")
2444 && integer_types_same_name_p (TYPE_NAME (parm
), "long"))
2445 return INTEGER_PROMOTION_BADNESS
;
2447 return INTEGER_CONVERSION_BADNESS
;
2450 return INTEGER_CONVERSION_BADNESS
;
2452 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2453 return INTEGER_PROMOTION_BADNESS
;
2455 return INTEGER_CONVERSION_BADNESS
;
2456 case TYPE_CODE_ENUM
:
2457 case TYPE_CODE_CHAR
:
2458 case TYPE_CODE_RANGE
:
2459 case TYPE_CODE_BOOL
:
2460 return INTEGER_PROMOTION_BADNESS
;
2462 return INT_FLOAT_CONVERSION_BADNESS
;
2464 return NS_POINTER_CONVERSION_BADNESS
;
2466 return INCOMPATIBLE_TYPE_BADNESS
;
2469 case TYPE_CODE_ENUM
:
2470 switch (TYPE_CODE (arg
))
2473 case TYPE_CODE_CHAR
:
2474 case TYPE_CODE_RANGE
:
2475 case TYPE_CODE_BOOL
:
2476 case TYPE_CODE_ENUM
:
2477 return INTEGER_CONVERSION_BADNESS
;
2479 return INT_FLOAT_CONVERSION_BADNESS
;
2481 return INCOMPATIBLE_TYPE_BADNESS
;
2484 case TYPE_CODE_CHAR
:
2485 switch (TYPE_CODE (arg
))
2487 case TYPE_CODE_RANGE
:
2488 case TYPE_CODE_BOOL
:
2489 case TYPE_CODE_ENUM
:
2490 return INTEGER_CONVERSION_BADNESS
;
2492 return INT_FLOAT_CONVERSION_BADNESS
;
2494 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2495 return INTEGER_CONVERSION_BADNESS
;
2496 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2497 return INTEGER_PROMOTION_BADNESS
;
2498 /* >>> !! else fall through !! <<< */
2499 case TYPE_CODE_CHAR
:
2500 /* Deal with signed, unsigned, and plain chars for C++
2501 and with int cases falling through from previous case */
2502 if (TYPE_NOSIGN (parm
))
2504 if (TYPE_NOSIGN (arg
))
2507 return INTEGER_CONVERSION_BADNESS
;
2509 else if (TYPE_UNSIGNED (parm
))
2511 if (TYPE_UNSIGNED (arg
))
2514 return INTEGER_PROMOTION_BADNESS
;
2516 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2519 return INTEGER_CONVERSION_BADNESS
;
2521 return INCOMPATIBLE_TYPE_BADNESS
;
2524 case TYPE_CODE_RANGE
:
2525 switch (TYPE_CODE (arg
))
2528 case TYPE_CODE_CHAR
:
2529 case TYPE_CODE_RANGE
:
2530 case TYPE_CODE_BOOL
:
2531 case TYPE_CODE_ENUM
:
2532 return INTEGER_CONVERSION_BADNESS
;
2534 return INT_FLOAT_CONVERSION_BADNESS
;
2536 return INCOMPATIBLE_TYPE_BADNESS
;
2539 case TYPE_CODE_BOOL
:
2540 switch (TYPE_CODE (arg
))
2543 case TYPE_CODE_CHAR
:
2544 case TYPE_CODE_RANGE
:
2545 case TYPE_CODE_ENUM
:
2548 return BOOLEAN_CONVERSION_BADNESS
;
2549 case TYPE_CODE_BOOL
:
2552 return INCOMPATIBLE_TYPE_BADNESS
;
2556 switch (TYPE_CODE (arg
))
2559 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2560 return FLOAT_PROMOTION_BADNESS
;
2561 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2564 return FLOAT_CONVERSION_BADNESS
;
2566 case TYPE_CODE_BOOL
:
2567 case TYPE_CODE_ENUM
:
2568 case TYPE_CODE_RANGE
:
2569 case TYPE_CODE_CHAR
:
2570 return INT_FLOAT_CONVERSION_BADNESS
;
2572 return INCOMPATIBLE_TYPE_BADNESS
;
2575 case TYPE_CODE_COMPLEX
:
2576 switch (TYPE_CODE (arg
))
2577 { /* Strictly not needed for C++, but... */
2579 return FLOAT_PROMOTION_BADNESS
;
2580 case TYPE_CODE_COMPLEX
:
2583 return INCOMPATIBLE_TYPE_BADNESS
;
2586 case TYPE_CODE_STRUCT
:
2587 /* currently same as TYPE_CODE_CLASS */
2588 switch (TYPE_CODE (arg
))
2590 case TYPE_CODE_STRUCT
:
2591 /* Check for derivation */
2592 if (is_ancestor (parm
, arg
))
2593 return BASE_CONVERSION_BADNESS
;
2594 /* else fall through */
2596 return INCOMPATIBLE_TYPE_BADNESS
;
2599 case TYPE_CODE_UNION
:
2600 switch (TYPE_CODE (arg
))
2602 case TYPE_CODE_UNION
:
2604 return INCOMPATIBLE_TYPE_BADNESS
;
2607 case TYPE_CODE_MEMBER
:
2608 switch (TYPE_CODE (arg
))
2611 return INCOMPATIBLE_TYPE_BADNESS
;
2614 case TYPE_CODE_METHOD
:
2615 switch (TYPE_CODE (arg
))
2619 return INCOMPATIBLE_TYPE_BADNESS
;
2623 switch (TYPE_CODE (arg
))
2627 return INCOMPATIBLE_TYPE_BADNESS
;
2632 switch (TYPE_CODE (arg
))
2636 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0), TYPE_FIELD_TYPE (arg
, 0));
2638 return INCOMPATIBLE_TYPE_BADNESS
;
2641 case TYPE_CODE_VOID
:
2643 return INCOMPATIBLE_TYPE_BADNESS
;
2644 } /* switch (TYPE_CODE (arg)) */
2648 /* End of functions for overload resolution */
2651 print_bit_vector (B_TYPE
*bits
, int nbits
)
2655 for (bitno
= 0; bitno
< nbits
; bitno
++)
2657 if ((bitno
% 8) == 0)
2659 puts_filtered (" ");
2661 if (B_TST (bits
, bitno
))
2662 printf_filtered (("1"));
2664 printf_filtered (("0"));
2668 /* Note the first arg should be the "this" pointer, we may not want to
2669 include it since we may get into a infinitely recursive situation. */
2672 print_arg_types (struct field
*args
, int nargs
, int spaces
)
2678 for (i
= 0; i
< nargs
; i
++)
2679 recursive_dump_type (args
[i
].type
, spaces
+ 2);
2684 dump_fn_fieldlists (struct type
*type
, int spaces
)
2690 printfi_filtered (spaces
, "fn_fieldlists ");
2691 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2692 printf_filtered ("\n");
2693 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2695 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2696 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2698 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2699 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2701 printf_filtered (_(") length %d\n"),
2702 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2703 for (overload_idx
= 0;
2704 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2707 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2709 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2710 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2712 printf_filtered (")\n");
2713 printfi_filtered (spaces
+ 8, "type ");
2714 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
2715 printf_filtered ("\n");
2717 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2720 printfi_filtered (spaces
+ 8, "args ");
2721 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
2722 printf_filtered ("\n");
2724 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2725 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
, overload_idx
)),
2727 printfi_filtered (spaces
+ 8, "fcontext ");
2728 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2730 printf_filtered ("\n");
2732 printfi_filtered (spaces
+ 8, "is_const %d\n",
2733 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2734 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2735 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2736 printfi_filtered (spaces
+ 8, "is_private %d\n",
2737 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2738 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2739 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2740 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2741 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2742 printfi_filtered (spaces
+ 8, "voffset %u\n",
2743 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2749 print_cplus_stuff (struct type
*type
, int spaces
)
2751 printfi_filtered (spaces
, "n_baseclasses %d\n",
2752 TYPE_N_BASECLASSES (type
));
2753 printfi_filtered (spaces
, "nfn_fields %d\n",
2754 TYPE_NFN_FIELDS (type
));
2755 printfi_filtered (spaces
, "nfn_fields_total %d\n",
2756 TYPE_NFN_FIELDS_TOTAL (type
));
2757 if (TYPE_N_BASECLASSES (type
) > 0)
2759 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2760 TYPE_N_BASECLASSES (type
));
2761 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
2762 printf_filtered (")");
2764 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2765 TYPE_N_BASECLASSES (type
));
2766 puts_filtered ("\n");
2768 if (TYPE_NFIELDS (type
) > 0)
2770 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2772 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
2773 TYPE_NFIELDS (type
));
2774 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
2775 printf_filtered (")");
2776 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2777 TYPE_NFIELDS (type
));
2778 puts_filtered ("\n");
2780 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2782 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
2783 TYPE_NFIELDS (type
));
2784 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
2785 printf_filtered (")");
2786 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2787 TYPE_NFIELDS (type
));
2788 puts_filtered ("\n");
2791 if (TYPE_NFN_FIELDS (type
) > 0)
2793 dump_fn_fieldlists (type
, spaces
);
2798 print_bound_type (int bt
)
2802 case BOUND_CANNOT_BE_DETERMINED
:
2803 printf_filtered ("(BOUND_CANNOT_BE_DETERMINED)");
2805 case BOUND_BY_REF_ON_STACK
:
2806 printf_filtered ("(BOUND_BY_REF_ON_STACK)");
2808 case BOUND_BY_VALUE_ON_STACK
:
2809 printf_filtered ("(BOUND_BY_VALUE_ON_STACK)");
2811 case BOUND_BY_REF_IN_REG
:
2812 printf_filtered ("(BOUND_BY_REF_IN_REG)");
2814 case BOUND_BY_VALUE_IN_REG
:
2815 printf_filtered ("(BOUND_BY_VALUE_IN_REG)");
2818 printf_filtered ("(BOUND_SIMPLE)");
2821 printf_filtered (_("(unknown bound type)"));
2826 static struct obstack dont_print_type_obstack
;
2829 recursive_dump_type (struct type
*type
, int spaces
)
2834 obstack_begin (&dont_print_type_obstack
, 0);
2836 if (TYPE_NFIELDS (type
) > 0
2837 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
2839 struct type
**first_dont_print
2840 = (struct type
**) obstack_base (&dont_print_type_obstack
);
2842 int i
= (struct type
**) obstack_next_free (&dont_print_type_obstack
)
2847 if (type
== first_dont_print
[i
])
2849 printfi_filtered (spaces
, "type node ");
2850 gdb_print_host_address (type
, gdb_stdout
);
2851 printf_filtered (_(" <same as already seen type>\n"));
2856 obstack_ptr_grow (&dont_print_type_obstack
, type
);
2859 printfi_filtered (spaces
, "type node ");
2860 gdb_print_host_address (type
, gdb_stdout
);
2861 printf_filtered ("\n");
2862 printfi_filtered (spaces
, "name '%s' (",
2863 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
2864 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
2865 printf_filtered (")\n");
2866 printfi_filtered (spaces
, "tagname '%s' (",
2867 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
2868 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
2869 printf_filtered (")\n");
2870 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
2871 switch (TYPE_CODE (type
))
2873 case TYPE_CODE_UNDEF
:
2874 printf_filtered ("(TYPE_CODE_UNDEF)");
2877 printf_filtered ("(TYPE_CODE_PTR)");
2879 case TYPE_CODE_ARRAY
:
2880 printf_filtered ("(TYPE_CODE_ARRAY)");
2882 case TYPE_CODE_STRUCT
:
2883 printf_filtered ("(TYPE_CODE_STRUCT)");
2885 case TYPE_CODE_UNION
:
2886 printf_filtered ("(TYPE_CODE_UNION)");
2888 case TYPE_CODE_ENUM
:
2889 printf_filtered ("(TYPE_CODE_ENUM)");
2891 case TYPE_CODE_FUNC
:
2892 printf_filtered ("(TYPE_CODE_FUNC)");
2895 printf_filtered ("(TYPE_CODE_INT)");
2898 printf_filtered ("(TYPE_CODE_FLT)");
2900 case TYPE_CODE_VOID
:
2901 printf_filtered ("(TYPE_CODE_VOID)");
2904 printf_filtered ("(TYPE_CODE_SET)");
2906 case TYPE_CODE_RANGE
:
2907 printf_filtered ("(TYPE_CODE_RANGE)");
2909 case TYPE_CODE_STRING
:
2910 printf_filtered ("(TYPE_CODE_STRING)");
2912 case TYPE_CODE_BITSTRING
:
2913 printf_filtered ("(TYPE_CODE_BITSTRING)");
2915 case TYPE_CODE_ERROR
:
2916 printf_filtered ("(TYPE_CODE_ERROR)");
2918 case TYPE_CODE_MEMBER
:
2919 printf_filtered ("(TYPE_CODE_MEMBER)");
2921 case TYPE_CODE_METHOD
:
2922 printf_filtered ("(TYPE_CODE_METHOD)");
2925 printf_filtered ("(TYPE_CODE_REF)");
2927 case TYPE_CODE_CHAR
:
2928 printf_filtered ("(TYPE_CODE_CHAR)");
2930 case TYPE_CODE_BOOL
:
2931 printf_filtered ("(TYPE_CODE_BOOL)");
2933 case TYPE_CODE_COMPLEX
:
2934 printf_filtered ("(TYPE_CODE_COMPLEX)");
2936 case TYPE_CODE_TYPEDEF
:
2937 printf_filtered ("(TYPE_CODE_TYPEDEF)");
2939 case TYPE_CODE_TEMPLATE
:
2940 printf_filtered ("(TYPE_CODE_TEMPLATE)");
2942 case TYPE_CODE_TEMPLATE_ARG
:
2943 printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)");
2945 case TYPE_CODE_NAMESPACE
:
2946 printf_filtered ("(TYPE_CODE_NAMESPACE)");
2949 printf_filtered ("(UNKNOWN TYPE CODE)");
2952 puts_filtered ("\n");
2953 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
2954 printfi_filtered (spaces
, "upper_bound_type 0x%x ",
2955 TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
2956 print_bound_type (TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
2957 puts_filtered ("\n");
2958 printfi_filtered (spaces
, "lower_bound_type 0x%x ",
2959 TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
2960 print_bound_type (TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
2961 puts_filtered ("\n");
2962 printfi_filtered (spaces
, "objfile ");
2963 gdb_print_host_address (TYPE_OBJFILE (type
), gdb_stdout
);
2964 printf_filtered ("\n");
2965 printfi_filtered (spaces
, "target_type ");
2966 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
2967 printf_filtered ("\n");
2968 if (TYPE_TARGET_TYPE (type
) != NULL
)
2970 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
2972 printfi_filtered (spaces
, "pointer_type ");
2973 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
2974 printf_filtered ("\n");
2975 printfi_filtered (spaces
, "reference_type ");
2976 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
2977 printf_filtered ("\n");
2978 printfi_filtered (spaces
, "type_chain ");
2979 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
2980 printf_filtered ("\n");
2981 printfi_filtered (spaces
, "instance_flags 0x%x", TYPE_INSTANCE_FLAGS (type
));
2982 if (TYPE_CONST (type
))
2984 puts_filtered (" TYPE_FLAG_CONST");
2986 if (TYPE_VOLATILE (type
))
2988 puts_filtered (" TYPE_FLAG_VOLATILE");
2990 if (TYPE_CODE_SPACE (type
))
2992 puts_filtered (" TYPE_FLAG_CODE_SPACE");
2994 if (TYPE_DATA_SPACE (type
))
2996 puts_filtered (" TYPE_FLAG_DATA_SPACE");
2998 if (TYPE_ADDRESS_CLASS_1 (type
))
3000 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3002 if (TYPE_ADDRESS_CLASS_2 (type
))
3004 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3006 puts_filtered ("\n");
3007 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
3008 if (TYPE_UNSIGNED (type
))
3010 puts_filtered (" TYPE_FLAG_UNSIGNED");
3012 if (TYPE_NOSIGN (type
))
3014 puts_filtered (" TYPE_FLAG_NOSIGN");
3016 if (TYPE_STUB (type
))
3018 puts_filtered (" TYPE_FLAG_STUB");
3020 if (TYPE_TARGET_STUB (type
))
3022 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3024 if (TYPE_STATIC (type
))
3026 puts_filtered (" TYPE_FLAG_STATIC");
3028 if (TYPE_PROTOTYPED (type
))
3030 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3032 if (TYPE_INCOMPLETE (type
))
3034 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3036 if (TYPE_VARARGS (type
))
3038 puts_filtered (" TYPE_FLAG_VARARGS");
3040 /* This is used for things like AltiVec registers on ppc. Gcc emits
3041 an attribute for the array type, which tells whether or not we
3042 have a vector, instead of a regular array. */
3043 if (TYPE_VECTOR (type
))
3045 puts_filtered (" TYPE_FLAG_VECTOR");
3047 puts_filtered ("\n");
3048 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
3049 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
3050 puts_filtered ("\n");
3051 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
3053 printfi_filtered (spaces
+ 2,
3054 "[%d] bitpos %d bitsize %d type ",
3055 idx
, TYPE_FIELD_BITPOS (type
, idx
),
3056 TYPE_FIELD_BITSIZE (type
, idx
));
3057 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
3058 printf_filtered (" name '%s' (",
3059 TYPE_FIELD_NAME (type
, idx
) != NULL
3060 ? TYPE_FIELD_NAME (type
, idx
)
3062 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
3063 printf_filtered (")\n");
3064 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
3066 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
3069 printfi_filtered (spaces
, "vptr_basetype ");
3070 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
3071 puts_filtered ("\n");
3072 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
3074 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
3076 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
3077 switch (TYPE_CODE (type
))
3079 case TYPE_CODE_STRUCT
:
3080 printfi_filtered (spaces
, "cplus_stuff ");
3081 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
3082 puts_filtered ("\n");
3083 print_cplus_stuff (type
, spaces
);
3087 printfi_filtered (spaces
, "floatformat ");
3088 if (TYPE_FLOATFORMAT (type
) == NULL
3089 || TYPE_FLOATFORMAT (type
)->name
== NULL
)
3090 puts_filtered ("(null)");
3092 puts_filtered (TYPE_FLOATFORMAT (type
)->name
);
3093 puts_filtered ("\n");
3097 /* We have to pick one of the union types to be able print and test
3098 the value. Pick cplus_struct_type, even though we know it isn't
3099 any particular one. */
3100 printfi_filtered (spaces
, "type_specific ");
3101 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
3102 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
3104 printf_filtered (_(" (unknown data form)"));
3106 printf_filtered ("\n");
3111 obstack_free (&dont_print_type_obstack
, NULL
);
3114 static void build_gdbtypes (void);
3116 build_gdbtypes (void)
3119 init_type (TYPE_CODE_VOID
, 1,
3121 "void", (struct objfile
*) NULL
);
3123 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3125 | (TARGET_CHAR_SIGNED
? 0 : TYPE_FLAG_UNSIGNED
)),
3126 "char", (struct objfile
*) NULL
);
3127 builtin_type_true_char
=
3128 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3130 "true character", (struct objfile
*) NULL
);
3131 builtin_type_signed_char
=
3132 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3134 "signed char", (struct objfile
*) NULL
);
3135 builtin_type_unsigned_char
=
3136 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3138 "unsigned char", (struct objfile
*) NULL
);
3139 builtin_type_short
=
3140 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
3142 "short", (struct objfile
*) NULL
);
3143 builtin_type_unsigned_short
=
3144 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
3146 "unsigned short", (struct objfile
*) NULL
);
3148 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3150 "int", (struct objfile
*) NULL
);
3151 builtin_type_unsigned_int
=
3152 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3154 "unsigned int", (struct objfile
*) NULL
);
3156 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
3158 "long", (struct objfile
*) NULL
);
3159 builtin_type_unsigned_long
=
3160 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
3162 "unsigned long", (struct objfile
*) NULL
);
3163 builtin_type_long_long
=
3164 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
3166 "long long", (struct objfile
*) NULL
);
3167 builtin_type_unsigned_long_long
=
3168 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
3170 "unsigned long long", (struct objfile
*) NULL
);
3171 builtin_type_float
=
3172 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
3174 "float", (struct objfile
*) NULL
);
3175 /* vinschen@redhat.com 2002-02-08:
3176 The below lines are disabled since they are doing the wrong
3177 thing for non-multiarch targets. They are setting the correct
3178 type of floats for the target but while on multiarch targets
3179 this is done everytime the architecture changes, it's done on
3180 non-multiarch targets only on startup, leaving the wrong values
3181 in even if the architecture changes (eg. from big-endian to
3184 TYPE_FLOATFORMAT (builtin_type_float
) = TARGET_FLOAT_FORMAT
;
3186 builtin_type_double
=
3187 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3189 "double", (struct objfile
*) NULL
);
3191 TYPE_FLOATFORMAT (builtin_type_double
) = TARGET_DOUBLE_FORMAT
;
3193 builtin_type_long_double
=
3194 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3196 "long double", (struct objfile
*) NULL
);
3198 TYPE_FLOATFORMAT (builtin_type_long_double
) = TARGET_LONG_DOUBLE_FORMAT
;
3200 builtin_type_complex
=
3201 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
3203 "complex", (struct objfile
*) NULL
);
3204 TYPE_TARGET_TYPE (builtin_type_complex
) = builtin_type_float
;
3205 builtin_type_double_complex
=
3206 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3208 "double complex", (struct objfile
*) NULL
);
3209 TYPE_TARGET_TYPE (builtin_type_double_complex
) = builtin_type_double
;
3210 builtin_type_string
=
3211 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3213 "string", (struct objfile
*) NULL
);
3215 init_type (TYPE_CODE_BOOL
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3217 "bool", (struct objfile
*) NULL
);
3219 /* Add user knob for controlling resolution of opaque types */
3220 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
3221 &opaque_type_resolution
, _("\
3222 Set resolution of opaque struct/class/union types (if set before loading symbols)."), _("\
3223 Show resolution of opaque struct/class/union types (if set before loading symbols)."), NULL
,
3225 show_opaque_type_resolution
,
3226 &setlist
, &showlist
);
3227 opaque_type_resolution
= 1;
3229 /* Build SIMD types. */
3231 = init_simd_type ("__builtin_v4sf", builtin_type_float
, "f", 4);
3233 = init_simd_type ("__builtin_v4si", builtin_type_int32
, "f", 4);
3235 = init_simd_type ("__builtin_v16qi", builtin_type_int8
, "f", 16);
3237 = init_simd_type ("__builtin_v8qi", builtin_type_int8
, "f", 8);
3239 = init_simd_type ("__builtin_v8hi", builtin_type_int16
, "f", 8);
3241 = init_simd_type ("__builtin_v4hi", builtin_type_int16
, "f", 4);
3243 = init_simd_type ("__builtin_v2si", builtin_type_int32
, "f", 2);
3245 /* 128 bit vectors. */
3246 builtin_type_v2_double
= init_vector_type (builtin_type_double
, 2);
3247 builtin_type_v4_float
= init_vector_type (builtin_type_float
, 4);
3248 builtin_type_v2_int64
= init_vector_type (builtin_type_int64
, 2);
3249 builtin_type_v4_int32
= init_vector_type (builtin_type_int32
, 4);
3250 builtin_type_v8_int16
= init_vector_type (builtin_type_int16
, 8);
3251 builtin_type_v16_int8
= init_vector_type (builtin_type_int8
, 16);
3252 /* 64 bit vectors. */
3253 builtin_type_v2_float
= init_vector_type (builtin_type_float
, 2);
3254 builtin_type_v2_int32
= init_vector_type (builtin_type_int32
, 2);
3255 builtin_type_v4_int16
= init_vector_type (builtin_type_int16
, 4);
3256 builtin_type_v8_int8
= init_vector_type (builtin_type_int8
, 8);
3259 builtin_type_vec64
= build_builtin_type_vec64 ();
3260 builtin_type_vec128
= build_builtin_type_vec128 ();
3262 /* Pointer/Address types. */
3264 /* NOTE: on some targets, addresses and pointers are not necessarily
3265 the same --- for example, on the D10V, pointers are 16 bits long,
3266 but addresses are 32 bits long. See doc/gdbint.texinfo,
3267 ``Pointers Are Not Always Addresses''.
3270 - gdb's `struct type' always describes the target's
3272 - gdb's `struct value' objects should always hold values in
3274 - gdb's CORE_ADDR values are addresses in the unified virtual
3275 address space that the assembler and linker work with. Thus,
3276 since target_read_memory takes a CORE_ADDR as an argument, it
3277 can access any memory on the target, even if the processor has
3278 separate code and data address spaces.
3281 - If v is a value holding a D10V code pointer, its contents are
3282 in target form: a big-endian address left-shifted two bits.
3283 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3284 sizeof (void *) == 2 on the target.
3286 In this context, builtin_type_CORE_ADDR is a bit odd: it's a
3287 target type for a value the target will never see. It's only
3288 used to hold the values of (typeless) linker symbols, which are
3289 indeed in the unified virtual address space. */
3290 builtin_type_void_data_ptr
= make_pointer_type (builtin_type_void
, NULL
);
3291 builtin_type_void_func_ptr
3292 = lookup_pointer_type (lookup_function_type (builtin_type_void
));
3293 builtin_type_CORE_ADDR
=
3294 init_type (TYPE_CODE_INT
, TARGET_ADDR_BIT
/ 8,
3296 "__CORE_ADDR", (struct objfile
*) NULL
);
3297 builtin_type_bfd_vma
=
3298 init_type (TYPE_CODE_INT
, TARGET_BFD_VMA_BIT
/ 8,
3300 "__bfd_vma", (struct objfile
*) NULL
);
3303 static struct gdbarch_data
*gdbtypes_data
;
3305 const struct builtin_type
*
3306 builtin_type (struct gdbarch
*gdbarch
)
3308 return gdbarch_data (gdbarch
, gdbtypes_data
);
3312 static struct type
*
3313 build_flt (int bit
, char *name
, const struct floatformat
*floatformat
)
3316 if (bit
<= 0 || floatformat
== NULL
)
3318 gdb_assert (builtin_type_error
!= NULL
);
3319 return builtin_type_error
;
3321 t
= init_type (TYPE_CODE_FLT
, bit
/ TARGET_CHAR_BIT
,
3322 0, name
, (struct objfile
*) NULL
);
3323 TYPE_FLOATFORMAT (t
) = floatformat
;
3327 static struct type
*
3328 build_complex (int bit
, char *name
, struct type
*target_type
)
3331 if (bit
<= 0 || target_type
== builtin_type_error
)
3333 gdb_assert (builtin_type_error
!= NULL
);
3334 return builtin_type_error
;
3336 t
= init_type (TYPE_CODE_COMPLEX
, 2 * bit
/ TARGET_CHAR_BIT
,
3337 0, name
, (struct objfile
*) NULL
);
3338 TYPE_TARGET_TYPE (t
) = target_type
;
3343 gdbtypes_post_init (struct gdbarch
*gdbarch
)
3345 struct builtin_type
*builtin_type
3346 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
3348 builtin_type
->builtin_void
=
3349 init_type (TYPE_CODE_VOID
, 1,
3351 "void", (struct objfile
*) NULL
);
3352 builtin_type
->builtin_char
=
3353 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3355 | (TARGET_CHAR_SIGNED
? 0 : TYPE_FLAG_UNSIGNED
)),
3356 "char", (struct objfile
*) NULL
);
3357 builtin_type
->builtin_true_char
=
3358 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3360 "true character", (struct objfile
*) NULL
);
3361 builtin_type
->builtin_signed_char
=
3362 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3364 "signed char", (struct objfile
*) NULL
);
3365 builtin_type
->builtin_unsigned_char
=
3366 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3368 "unsigned char", (struct objfile
*) NULL
);
3369 builtin_type
->builtin_short
=
3370 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
3372 "short", (struct objfile
*) NULL
);
3373 builtin_type
->builtin_unsigned_short
=
3374 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
3376 "unsigned short", (struct objfile
*) NULL
);
3377 builtin_type
->builtin_int
=
3378 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3380 "int", (struct objfile
*) NULL
);
3381 builtin_type
->builtin_unsigned_int
=
3382 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3384 "unsigned int", (struct objfile
*) NULL
);
3385 builtin_type
->builtin_long
=
3386 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
3388 "long", (struct objfile
*) NULL
);
3389 builtin_type
->builtin_unsigned_long
=
3390 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
3392 "unsigned long", (struct objfile
*) NULL
);
3393 builtin_type
->builtin_long_long
=
3394 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
3396 "long long", (struct objfile
*) NULL
);
3397 builtin_type
->builtin_unsigned_long_long
=
3398 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
3400 "unsigned long long", (struct objfile
*) NULL
);
3401 builtin_type
->builtin_float
3402 = build_flt (gdbarch_float_bit (gdbarch
), "float",
3403 gdbarch_float_format (gdbarch
));
3404 builtin_type
->builtin_double
3405 = build_flt (gdbarch_double_bit (gdbarch
), "double",
3406 gdbarch_double_format (gdbarch
));
3407 builtin_type
->builtin_long_double
3408 = build_flt (gdbarch_long_double_bit (gdbarch
), "long double",
3409 gdbarch_long_double_format (gdbarch
));
3410 builtin_type
->builtin_complex
3411 = build_complex (gdbarch_float_bit (gdbarch
), "complex",
3412 builtin_type
->builtin_float
);
3413 builtin_type
->builtin_double_complex
3414 = build_complex (gdbarch_double_bit (gdbarch
), "double complex",
3415 builtin_type
->builtin_double
);
3416 builtin_type
->builtin_string
=
3417 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3419 "string", (struct objfile
*) NULL
);
3420 builtin_type
->builtin_bool
=
3421 init_type (TYPE_CODE_BOOL
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3423 "bool", (struct objfile
*) NULL
);
3425 /* Pointer/Address types. */
3427 /* NOTE: on some targets, addresses and pointers are not necessarily
3428 the same --- for example, on the D10V, pointers are 16 bits long,
3429 but addresses are 32 bits long. See doc/gdbint.texinfo,
3430 ``Pointers Are Not Always Addresses''.
3433 - gdb's `struct type' always describes the target's
3435 - gdb's `struct value' objects should always hold values in
3437 - gdb's CORE_ADDR values are addresses in the unified virtual
3438 address space that the assembler and linker work with. Thus,
3439 since target_read_memory takes a CORE_ADDR as an argument, it
3440 can access any memory on the target, even if the processor has
3441 separate code and data address spaces.
3444 - If v is a value holding a D10V code pointer, its contents are
3445 in target form: a big-endian address left-shifted two bits.
3446 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3447 sizeof (void *) == 2 on the target.
3449 In this context, builtin_type->CORE_ADDR is a bit odd: it's a
3450 target type for a value the target will never see. It's only
3451 used to hold the values of (typeless) linker symbols, which are
3452 indeed in the unified virtual address space. */
3453 builtin_type
->builtin_data_ptr
3454 = make_pointer_type (builtin_type
->builtin_void
, NULL
);
3455 builtin_type
->builtin_func_ptr
3456 = lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
3457 builtin_type
->builtin_core_addr
=
3458 init_type (TYPE_CODE_INT
, TARGET_ADDR_BIT
/ 8,
3460 "__CORE_ADDR", (struct objfile
*) NULL
);
3462 return builtin_type
;
3465 extern void _initialize_gdbtypes (void);
3467 _initialize_gdbtypes (void)
3469 struct cmd_list_element
*c
;
3472 init_type (TYPE_CODE_INT
, 0 / 8,
3474 "int0_t", (struct objfile
*) NULL
);
3476 init_type (TYPE_CODE_INT
, 8 / 8,
3478 "int8_t", (struct objfile
*) NULL
);
3479 builtin_type_uint8
=
3480 init_type (TYPE_CODE_INT
, 8 / 8,
3482 "uint8_t", (struct objfile
*) NULL
);
3483 builtin_type_int16
=
3484 init_type (TYPE_CODE_INT
, 16 / 8,
3486 "int16_t", (struct objfile
*) NULL
);
3487 builtin_type_uint16
=
3488 init_type (TYPE_CODE_INT
, 16 / 8,
3490 "uint16_t", (struct objfile
*) NULL
);
3491 builtin_type_int32
=
3492 init_type (TYPE_CODE_INT
, 32 / 8,
3494 "int32_t", (struct objfile
*) NULL
);
3495 builtin_type_uint32
=
3496 init_type (TYPE_CODE_INT
, 32 / 8,
3498 "uint32_t", (struct objfile
*) NULL
);
3499 builtin_type_int64
=
3500 init_type (TYPE_CODE_INT
, 64 / 8,
3502 "int64_t", (struct objfile
*) NULL
);
3503 builtin_type_uint64
=
3504 init_type (TYPE_CODE_INT
, 64 / 8,
3506 "uint64_t", (struct objfile
*) NULL
);
3507 builtin_type_int128
=
3508 init_type (TYPE_CODE_INT
, 128 / 8,
3510 "int128_t", (struct objfile
*) NULL
);
3511 builtin_type_uint128
=
3512 init_type (TYPE_CODE_INT
, 128 / 8,
3514 "uint128_t", (struct objfile
*) NULL
);
3518 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
3520 /* FIXME - For the moment, handle types by swapping them in and out.
3521 Should be using the per-architecture data-pointer and a large
3523 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void
);
3524 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_char
);
3525 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_short
);
3526 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int
);
3527 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long
);
3528 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long_long
);
3529 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_signed_char
);
3530 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_char
);
3531 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_short
);
3532 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_int
);
3533 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_long
);
3534 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_long_long
);
3535 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_float
);
3536 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_double
);
3537 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long_double
);
3538 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_complex
);
3539 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_double_complex
);
3540 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_string
);
3541 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4sf
);
3542 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4si
);
3543 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v16qi
);
3544 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8qi
);
3545 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8hi
);
3546 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4hi
);
3547 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2si
);
3548 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_double
);
3549 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_float
);
3550 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_int64
);
3551 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_int32
);
3552 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8_int16
);
3553 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v16_int8
);
3554 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_float
);
3555 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_int32
);
3556 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8_int8
);
3557 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_int16
);
3558 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_vec128
);
3559 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void_data_ptr
);
3560 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void_func_ptr
);
3561 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR
);
3562 DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma
);
3563 deprecated_register_gdbarch_swap (NULL
, 0, build_gdbtypes
);
3565 /* Note: These types do not need to be swapped - they are target
3567 builtin_type_ieee_single_big
=
3568 init_type (TYPE_CODE_FLT
, floatformat_ieee_single_big
.totalsize
/ 8,
3569 0, "builtin_type_ieee_single_big", NULL
);
3570 TYPE_FLOATFORMAT (builtin_type_ieee_single_big
) = &floatformat_ieee_single_big
;
3571 builtin_type_ieee_single_little
=
3572 init_type (TYPE_CODE_FLT
, floatformat_ieee_single_little
.totalsize
/ 8,
3573 0, "builtin_type_ieee_single_little", NULL
);
3574 TYPE_FLOATFORMAT (builtin_type_ieee_single_little
) = &floatformat_ieee_single_little
;
3575 builtin_type_ieee_single
[BFD_ENDIAN_BIG
]
3576 = build_flt (floatformat_ieee_single_big
.totalsize
,
3577 "builtin_type_ieee_single_big",
3578 &floatformat_ieee_single_big
);
3579 builtin_type_ieee_single
[BFD_ENDIAN_LITTLE
]
3580 = build_flt (floatformat_ieee_single_little
.totalsize
,
3581 "builtin_type_ieee_single_little",
3582 &floatformat_ieee_single_little
);
3583 builtin_type_ieee_double_big
=
3584 init_type (TYPE_CODE_FLT
, floatformat_ieee_double_big
.totalsize
/ 8,
3585 0, "builtin_type_ieee_double_big", NULL
);
3586 TYPE_FLOATFORMAT (builtin_type_ieee_double_big
) = &floatformat_ieee_double_big
;
3587 builtin_type_ieee_double_little
=
3588 init_type (TYPE_CODE_FLT
, floatformat_ieee_double_little
.totalsize
/ 8,
3589 0, "builtin_type_ieee_double_little", NULL
);
3590 TYPE_FLOATFORMAT (builtin_type_ieee_double_little
) = &floatformat_ieee_double_little
;
3591 builtin_type_ieee_double
[BFD_ENDIAN_BIG
]
3592 = build_flt (floatformat_ieee_double_big
.totalsize
,
3593 "builtin_type_ieee_double_big",
3594 &floatformat_ieee_double_big
);
3595 builtin_type_ieee_double
[BFD_ENDIAN_LITTLE
]
3596 = build_flt (floatformat_ieee_double_little
.totalsize
,
3597 "builtin_type_ieee_double_little",
3598 &floatformat_ieee_double_little
);
3599 builtin_type_ieee_double_littlebyte_bigword
=
3600 init_type (TYPE_CODE_FLT
, floatformat_ieee_double_littlebyte_bigword
.totalsize
/ 8,
3601 0, "builtin_type_ieee_double_littlebyte_bigword", NULL
);
3602 TYPE_FLOATFORMAT (builtin_type_ieee_double_littlebyte_bigword
) = &floatformat_ieee_double_littlebyte_bigword
;
3603 builtin_type_i387_ext
=
3604 init_type (TYPE_CODE_FLT
, floatformat_i387_ext
.totalsize
/ 8,
3605 0, "builtin_type_i387_ext", NULL
);
3606 TYPE_FLOATFORMAT (builtin_type_i387_ext
) = &floatformat_i387_ext
;
3607 builtin_type_m68881_ext
=
3608 init_type (TYPE_CODE_FLT
, floatformat_m68881_ext
.totalsize
/ 8,
3609 0, "builtin_type_m68881_ext", NULL
);
3610 TYPE_FLOATFORMAT (builtin_type_m68881_ext
) = &floatformat_m68881_ext
;
3611 builtin_type_i960_ext
=
3612 init_type (TYPE_CODE_FLT
, floatformat_i960_ext
.totalsize
/ 8,
3613 0, "builtin_type_i960_ext", NULL
);
3614 TYPE_FLOATFORMAT (builtin_type_i960_ext
) = &floatformat_i960_ext
;
3615 builtin_type_m88110_ext
=
3616 init_type (TYPE_CODE_FLT
, floatformat_m88110_ext
.totalsize
/ 8,
3617 0, "builtin_type_m88110_ext", NULL
);
3618 TYPE_FLOATFORMAT (builtin_type_m88110_ext
) = &floatformat_m88110_ext
;
3619 builtin_type_m88110_harris_ext
=
3620 init_type (TYPE_CODE_FLT
, floatformat_m88110_harris_ext
.totalsize
/ 8,
3621 0, "builtin_type_m88110_harris_ext", NULL
);
3622 TYPE_FLOATFORMAT (builtin_type_m88110_harris_ext
) = &floatformat_m88110_harris_ext
;
3623 builtin_type_arm_ext_big
=
3624 init_type (TYPE_CODE_FLT
, floatformat_arm_ext_big
.totalsize
/ 8,
3625 0, "builtin_type_arm_ext_big", NULL
);
3626 TYPE_FLOATFORMAT (builtin_type_arm_ext_big
) = &floatformat_arm_ext_big
;
3627 builtin_type_arm_ext_littlebyte_bigword
=
3628 init_type (TYPE_CODE_FLT
, floatformat_arm_ext_littlebyte_bigword
.totalsize
/ 8,
3629 0, "builtin_type_arm_ext_littlebyte_bigword", NULL
);
3630 TYPE_FLOATFORMAT (builtin_type_arm_ext_littlebyte_bigword
) = &floatformat_arm_ext_littlebyte_bigword
;
3631 builtin_type_arm_ext
[BFD_ENDIAN_BIG
]
3632 = build_flt (floatformat_arm_ext_big
.totalsize
,
3633 "builtin_type_arm_ext_big",
3634 &floatformat_arm_ext_big
);
3635 builtin_type_arm_ext
[BFD_ENDIAN_LITTLE
]
3636 = build_flt (floatformat_arm_ext_littlebyte_bigword
.totalsize
,
3637 "builtin_type_arm_ext_littlebyte_bigword",
3638 &floatformat_arm_ext_littlebyte_bigword
);
3639 builtin_type_ia64_spill_big
=
3640 init_type (TYPE_CODE_FLT
, floatformat_ia64_spill_big
.totalsize
/ 8,
3641 0, "builtin_type_ia64_spill_big", NULL
);
3642 TYPE_FLOATFORMAT (builtin_type_ia64_spill_big
) = &floatformat_ia64_spill_big
;
3643 builtin_type_ia64_spill_little
=
3644 init_type (TYPE_CODE_FLT
, floatformat_ia64_spill_little
.totalsize
/ 8,
3645 0, "builtin_type_ia64_spill_little", NULL
);
3646 TYPE_FLOATFORMAT (builtin_type_ia64_spill_little
) = &floatformat_ia64_spill_little
;
3647 builtin_type_ia64_spill
[BFD_ENDIAN_BIG
]
3648 = build_flt (floatformat_ia64_spill_big
.totalsize
,
3649 "builtin_type_ia64_spill_big",
3650 &floatformat_ia64_spill_big
);
3651 builtin_type_ia64_spill
[BFD_ENDIAN_LITTLE
]
3652 = build_flt (floatformat_ia64_spill_little
.totalsize
,
3653 "builtin_type_ia64_spill_little",
3654 &floatformat_ia64_spill_little
);
3655 builtin_type_ia64_quad_big
=
3656 init_type (TYPE_CODE_FLT
, floatformat_ia64_quad_big
.totalsize
/ 8,
3657 0, "builtin_type_ia64_quad_big", NULL
);
3658 TYPE_FLOATFORMAT (builtin_type_ia64_quad_big
) = &floatformat_ia64_quad_big
;
3659 builtin_type_ia64_quad_little
=
3660 init_type (TYPE_CODE_FLT
, floatformat_ia64_quad_little
.totalsize
/ 8,
3661 0, "builtin_type_ia64_quad_little", NULL
);
3662 TYPE_FLOATFORMAT (builtin_type_ia64_quad_little
) = &floatformat_ia64_quad_little
;
3663 builtin_type_ia64_quad
[BFD_ENDIAN_BIG
]
3664 = build_flt (floatformat_ia64_quad_big
.totalsize
,
3665 "builtin_type_ia64_quad_big",
3666 &floatformat_ia64_quad_big
);
3667 builtin_type_ia64_quad
[BFD_ENDIAN_LITTLE
]
3668 = build_flt (floatformat_ia64_quad_little
.totalsize
,
3669 "builtin_type_ia64_quad_little",
3670 &floatformat_ia64_quad_little
);
3672 add_setshow_zinteger_cmd ("overload", no_class
, &overload_debug
, _("\
3673 Set debugging of C++ overloading."), _("\
3674 Show debugging of C++ overloading."), _("\
3675 When enabled, ranking of the functions is displayed."),
3677 show_overload_debug
,
3678 &setdebuglist
, &showdebuglist
);