1 /* Support routines for manipulating internal types for GDB.
2 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000
3 Free Software Foundation, Inc.
4 Contributed by Cygnus Support, using pieces from other GDB modules.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 #include "gdb_string.h"
30 #include "expression.h"
35 #include "complaints.h"
39 #include "gdb_assert.h"
41 /* These variables point to the objects
42 representing the predefined C data types. */
44 struct type
*builtin_type_void
;
45 struct type
*builtin_type_char
;
46 struct type
*builtin_type_true_char
;
47 struct type
*builtin_type_short
;
48 struct type
*builtin_type_int
;
49 struct type
*builtin_type_long
;
50 struct type
*builtin_type_long_long
;
51 struct type
*builtin_type_signed_char
;
52 struct type
*builtin_type_unsigned_char
;
53 struct type
*builtin_type_unsigned_short
;
54 struct type
*builtin_type_unsigned_int
;
55 struct type
*builtin_type_unsigned_long
;
56 struct type
*builtin_type_unsigned_long_long
;
57 struct type
*builtin_type_float
;
58 struct type
*builtin_type_double
;
59 struct type
*builtin_type_long_double
;
60 struct type
*builtin_type_complex
;
61 struct type
*builtin_type_double_complex
;
62 struct type
*builtin_type_string
;
63 struct type
*builtin_type_int8
;
64 struct type
*builtin_type_uint8
;
65 struct type
*builtin_type_int16
;
66 struct type
*builtin_type_uint16
;
67 struct type
*builtin_type_int32
;
68 struct type
*builtin_type_uint32
;
69 struct type
*builtin_type_int64
;
70 struct type
*builtin_type_uint64
;
71 struct type
*builtin_type_int128
;
72 struct type
*builtin_type_uint128
;
73 struct type
*builtin_type_bool
;
74 struct type
*builtin_type_v4sf
;
75 struct type
*builtin_type_v4si
;
76 struct type
*builtin_type_v16qi
;
77 struct type
*builtin_type_v8qi
;
78 struct type
*builtin_type_v8hi
;
79 struct type
*builtin_type_v4hi
;
80 struct type
*builtin_type_v2si
;
81 struct type
*builtin_type_vec128
;
82 struct type
*builtin_type_ieee_single_big
;
83 struct type
*builtin_type_ieee_single_little
;
84 struct type
*builtin_type_ieee_double_big
;
85 struct type
*builtin_type_ieee_double_little
;
86 struct type
*builtin_type_ieee_double_littlebyte_bigword
;
87 struct type
*builtin_type_i387_ext
;
88 struct type
*builtin_type_m68881_ext
;
89 struct type
*builtin_type_i960_ext
;
90 struct type
*builtin_type_m88110_ext
;
91 struct type
*builtin_type_m88110_harris_ext
;
92 struct type
*builtin_type_arm_ext_big
;
93 struct type
*builtin_type_arm_ext_littlebyte_bigword
;
94 struct type
*builtin_type_ia64_spill_big
;
95 struct type
*builtin_type_ia64_spill_little
;
96 struct type
*builtin_type_ia64_quad_big
;
97 struct type
*builtin_type_ia64_quad_little
;
98 struct type
*builtin_type_void_data_ptr
;
99 struct type
*builtin_type_void_func_ptr
;
100 struct type
*builtin_type_CORE_ADDR
;
101 struct type
*builtin_type_bfd_vma
;
103 int opaque_type_resolution
= 1;
104 int overload_debug
= 0;
110 }; /* maximum extension is 128! FIXME */
112 static void add_name (struct extra
*, char *);
113 static void add_mangled_type (struct extra
*, struct type
*);
115 static void cfront_mangle_name (struct type
*, int, int);
117 static void print_bit_vector (B_TYPE
*, int);
118 static void print_arg_types (struct type
**, int);
119 static void dump_fn_fieldlists (struct type
*, int);
120 static void print_cplus_stuff (struct type
*, int);
121 static void virtual_base_list_aux (struct type
*dclass
);
124 /* Alloc a new type structure and fill it with some defaults. If
125 OBJFILE is non-NULL, then allocate the space for the type structure
126 in that objfile's type_obstack. */
129 alloc_type (struct objfile
*objfile
)
131 register struct type
*type
;
133 /* Alloc the structure and start off with all fields zeroed. */
137 type
= (struct type
*) xmalloc (sizeof (struct type
));
141 type
= (struct type
*) obstack_alloc (&objfile
->type_obstack
,
142 sizeof (struct type
));
143 OBJSTAT (objfile
, n_types
++);
145 memset ((char *) type
, 0, sizeof (struct type
));
147 /* Initialize the fields that might not be zero. */
149 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
150 TYPE_OBJFILE (type
) = objfile
;
151 TYPE_VPTR_FIELDNO (type
) = -1;
152 TYPE_CV_TYPE (type
) = type
; /* chain back to itself */
153 TYPE_AS_TYPE (type
) = type
; /* ditto */
158 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
159 to a pointer to memory where the pointer type should be stored.
160 If *TYPEPTR is zero, update it to point to the pointer type we return.
161 We allocate new memory if needed. */
164 make_pointer_type (struct type
*type
, struct type
**typeptr
)
166 register struct type
*ntype
; /* New type */
167 struct objfile
*objfile
;
169 ntype
= TYPE_POINTER_TYPE (type
);
174 return ntype
; /* Don't care about alloc, and have new type. */
175 else if (*typeptr
== 0)
177 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
182 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
184 ntype
= alloc_type (TYPE_OBJFILE (type
));
189 /* We have storage, but need to reset it. */
192 objfile
= TYPE_OBJFILE (ntype
);
193 memset ((char *) ntype
, 0, sizeof (struct type
));
194 TYPE_OBJFILE (ntype
) = objfile
;
197 TYPE_TARGET_TYPE (ntype
) = type
;
198 TYPE_POINTER_TYPE (type
) = ntype
;
200 /* FIXME! Assume the machine has only one representation for pointers! */
202 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
203 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
205 /* Mark pointers as unsigned. The target converts between pointers
206 and addresses (CORE_ADDRs) using POINTER_TO_ADDRESS() and
207 ADDRESS_TO_POINTER(). */
208 TYPE_FLAGS (ntype
) |= TYPE_FLAG_UNSIGNED
;
210 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
211 TYPE_POINTER_TYPE (type
) = ntype
;
216 /* Given a type TYPE, return a type of pointers to that type.
217 May need to construct such a type if this is the first use. */
220 lookup_pointer_type (struct type
*type
)
222 return make_pointer_type (type
, (struct type
**) 0);
225 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero, points
226 to a pointer to memory where the reference type should be stored.
227 If *TYPEPTR is zero, update it to point to the reference type we return.
228 We allocate new memory if needed. */
231 make_reference_type (struct type
*type
, struct type
**typeptr
)
233 register struct type
*ntype
; /* New type */
234 struct objfile
*objfile
;
236 ntype
= TYPE_REFERENCE_TYPE (type
);
241 return ntype
; /* Don't care about alloc, and have new type. */
242 else if (*typeptr
== 0)
244 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
249 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
251 ntype
= alloc_type (TYPE_OBJFILE (type
));
256 /* We have storage, but need to reset it. */
259 objfile
= TYPE_OBJFILE (ntype
);
260 memset ((char *) ntype
, 0, sizeof (struct type
));
261 TYPE_OBJFILE (ntype
) = objfile
;
264 TYPE_TARGET_TYPE (ntype
) = type
;
265 TYPE_REFERENCE_TYPE (type
) = ntype
;
267 /* FIXME! Assume the machine has only one representation for references,
268 and that it matches the (only) representation for pointers! */
270 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
271 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
273 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
274 TYPE_REFERENCE_TYPE (type
) = ntype
;
279 /* Same as above, but caller doesn't care about memory allocation details. */
282 lookup_reference_type (struct type
*type
)
284 return make_reference_type (type
, (struct type
**) 0);
287 /* Lookup a function type that returns type TYPE. TYPEPTR, if nonzero, points
288 to a pointer to memory where the function type should be stored.
289 If *TYPEPTR is zero, update it to point to the function type we return.
290 We allocate new memory if needed. */
293 make_function_type (struct type
*type
, struct type
**typeptr
)
295 register struct type
*ntype
; /* New type */
296 struct objfile
*objfile
;
298 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
300 ntype
= alloc_type (TYPE_OBJFILE (type
));
305 /* We have storage, but need to reset it. */
308 objfile
= TYPE_OBJFILE (ntype
);
309 memset ((char *) ntype
, 0, sizeof (struct type
));
310 TYPE_OBJFILE (ntype
) = objfile
;
313 TYPE_TARGET_TYPE (ntype
) = type
;
315 TYPE_LENGTH (ntype
) = 1;
316 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
322 /* Given a type TYPE, return a type of functions that return that type.
323 May need to construct such a type if this is the first use. */
326 lookup_function_type (struct type
*type
)
328 return make_function_type (type
, (struct type
**) 0);
331 /* Identify address space identifier by name --
332 return the integer flag defined in gdbtypes.h. */
334 address_space_name_to_int (char *space_identifier
)
336 /* Check for known address space delimiters. */
337 if (!strcmp (space_identifier
, "code"))
338 return TYPE_FLAG_CODE_SPACE
;
339 else if (!strcmp (space_identifier
, "data"))
340 return TYPE_FLAG_DATA_SPACE
;
342 error ("Unknown address space specifier: \"%s\"", space_identifier
);
345 /* Identify address space identifier by integer flag as defined in
346 gdbtypes.h -- return the string version of the adress space name. */
349 address_space_int_to_name (int space_flag
)
351 if (space_flag
& TYPE_FLAG_CODE_SPACE
)
353 else if (space_flag
& TYPE_FLAG_DATA_SPACE
)
359 /* Make an address-space-delimited variant of a type -- a type that
360 is identical to the one supplied except that it has an address
361 space attribute attached to it (such as "code" or "data").
363 This is for Harvard architectures. */
366 make_type_with_address_space (struct type
*type
, int space_flag
)
372 if ((ntype
->flags
& space_flag
) != 0)
374 ntype
= TYPE_AS_TYPE (ntype
);
375 } while (ntype
!= type
);
377 /* Create a new, duplicate type. */
378 ntype
= alloc_type (TYPE_OBJFILE (type
));
379 /* Copy original type. */
380 memcpy ((char *) ntype
, (char *) type
, sizeof (struct type
));
382 /* Pointers or references to the original type are not relevant to
383 the new type; but if the original type is a pointer, the new type
384 points to the same thing (so TYPE_TARGET_TYPE remains unchanged). */
385 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
386 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
387 TYPE_CV_TYPE (ntype
) = ntype
;
389 /* Chain the new address-space-specific type to the old type. */
390 ntype
->as_type
= type
->as_type
;
391 type
->as_type
= ntype
;
393 /* Now set the address-space flag, and return the new type. */
394 ntype
->flags
|= space_flag
;
399 /* Make a "c-v" variant of a type -- a type that is identical to the
400 one supplied except that it may have const or volatile attributes
401 CNST is a flag for setting the const attribute
402 VOLTL is a flag for setting the volatile attribute
403 TYPE is the base type whose variant we are creating.
404 TYPEPTR, if nonzero, points
405 to a pointer to memory where the reference type should be stored.
406 If *TYPEPTR is zero, update it to point to the reference type we return.
407 We allocate new memory if needed. */
410 make_cv_type (int cnst
, int voltl
, struct type
*type
, struct type
**typeptr
)
412 register struct type
*ntype
; /* New type */
413 register struct type
*tmp_type
= type
; /* tmp type */
414 struct objfile
*objfile
;
416 ntype
= TYPE_CV_TYPE (type
);
418 while (ntype
!= type
)
420 if ((TYPE_CONST (ntype
) == cnst
) &&
421 (TYPE_VOLATILE (ntype
) == voltl
))
425 else if (*typeptr
== 0)
427 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
432 ntype
= TYPE_CV_TYPE (ntype
);
435 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
437 ntype
= alloc_type (TYPE_OBJFILE (type
));
442 /* We have storage, but need to reset it. */
445 objfile
= TYPE_OBJFILE (ntype
);
446 /* memset ((char *) ntype, 0, sizeof (struct type)); */
447 TYPE_OBJFILE (ntype
) = objfile
;
450 /* Copy original type */
451 memcpy ((char *) ntype
, (char *) type
, sizeof (struct type
));
452 /* But zero out fields that shouldn't be copied */
453 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0; /* Need new pointer kind */
454 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0; /* Need new referene kind */
455 TYPE_AS_TYPE (ntype
) = ntype
; /* Need new address-space kind. */
456 /* Note: TYPE_TARGET_TYPE can be left as is */
458 /* Set flags appropriately */
460 TYPE_FLAGS (ntype
) |= TYPE_FLAG_CONST
;
462 TYPE_FLAGS (ntype
) &= ~TYPE_FLAG_CONST
;
465 TYPE_FLAGS (ntype
) |= TYPE_FLAG_VOLATILE
;
467 TYPE_FLAGS (ntype
) &= ~TYPE_FLAG_VOLATILE
;
469 /* Fix the chain of cv variants */
470 TYPE_CV_TYPE (ntype
) = type
;
471 TYPE_CV_TYPE (tmp_type
) = ntype
;
476 /* When reading in a class type, we may have created references to
477 cv-qualified versions of the type (in method arguments, for
478 instance). Update everything on the cv ring from the primary
481 The only reason we do not need to do the same thing for address
482 spaces is that type readers do not create address space qualified
485 finish_cv_type (struct type
*type
)
487 struct type
*ntype
, *cv_type
, *ptr_type
, *ref_type
;
490 gdb_assert (!TYPE_CONST (type
) && !TYPE_VOLATILE (type
));
493 while ((ntype
= TYPE_CV_TYPE (ntype
)) != type
)
496 cv_flags
= TYPE_FLAGS (ntype
) & (TYPE_FLAG_VOLATILE
| TYPE_FLAG_CONST
);
498 /* If any reference or pointer types were created, save them too. */
499 ptr_type
= TYPE_POINTER_TYPE (ntype
);
500 ref_type
= TYPE_REFERENCE_TYPE (ntype
);
502 /* Don't disturb the CV chain. */
503 cv_type
= TYPE_CV_TYPE (ntype
);
505 /* Verify that we haven't added any address-space qualified types,
507 gdb_assert (ntype
== TYPE_AS_TYPE (ntype
));
509 /* Copy original type */
510 memcpy ((char *) ntype
, (char *) type
, sizeof (struct type
));
512 /* Restore everything. */
513 TYPE_POINTER_TYPE (ntype
) = ptr_type
;
514 TYPE_REFERENCE_TYPE (ntype
) = ref_type
;
515 TYPE_CV_TYPE (ntype
) = cv_type
;
516 TYPE_FLAGS (ntype
) = TYPE_FLAGS (ntype
) | cv_flags
;
518 TYPE_AS_TYPE (ntype
) = ntype
;
522 /* Implement direct support for MEMBER_TYPE in GNU C++.
523 May need to construct such a type if this is the first use.
524 The TYPE is the type of the member. The DOMAIN is the type
525 of the aggregate that the member belongs to. */
528 lookup_member_type (struct type
*type
, struct type
*domain
)
530 register struct type
*mtype
;
532 mtype
= alloc_type (TYPE_OBJFILE (type
));
533 smash_to_member_type (mtype
, domain
, type
);
537 /* Allocate a stub method whose return type is TYPE.
538 This apparently happens for speed of symbol reading, since parsing
539 out the arguments to the method is cpu-intensive, the way we are doing
540 it. So, we will fill in arguments later.
541 This always returns a fresh type. */
544 allocate_stub_method (struct type
*type
)
548 mtype
= init_type (TYPE_CODE_METHOD
, 1, TYPE_FLAG_STUB
, NULL
,
549 TYPE_OBJFILE (type
));
550 TYPE_TARGET_TYPE (mtype
) = type
;
551 /* _DOMAIN_TYPE (mtype) = unknown yet */
552 /* _ARG_TYPES (mtype) = unknown yet */
556 /* Create a range type using either a blank type supplied in RESULT_TYPE,
557 or creating a new type, inheriting the objfile from INDEX_TYPE.
559 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
560 HIGH_BOUND, inclusive.
562 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
563 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
566 create_range_type (struct type
*result_type
, struct type
*index_type
,
567 int low_bound
, int high_bound
)
569 if (result_type
== NULL
)
571 result_type
= alloc_type (TYPE_OBJFILE (index_type
));
573 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
574 TYPE_TARGET_TYPE (result_type
) = index_type
;
575 if (TYPE_STUB (index_type
))
576 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
578 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
579 TYPE_NFIELDS (result_type
) = 2;
580 TYPE_FIELDS (result_type
) = (struct field
*)
581 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
582 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
583 TYPE_FIELD_BITPOS (result_type
, 0) = low_bound
;
584 TYPE_FIELD_BITPOS (result_type
, 1) = high_bound
;
585 TYPE_FIELD_TYPE (result_type
, 0) = builtin_type_int
; /* FIXME */
586 TYPE_FIELD_TYPE (result_type
, 1) = builtin_type_int
; /* FIXME */
589 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
591 return (result_type
);
594 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE.
595 Return 1 of type is a range type, 0 if it is discrete (and bounds
596 will fit in LONGEST), or -1 otherwise. */
599 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
601 CHECK_TYPEDEF (type
);
602 switch (TYPE_CODE (type
))
604 case TYPE_CODE_RANGE
:
605 *lowp
= TYPE_LOW_BOUND (type
);
606 *highp
= TYPE_HIGH_BOUND (type
);
609 if (TYPE_NFIELDS (type
) > 0)
611 /* The enums may not be sorted by value, so search all
615 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
616 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
618 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
619 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
620 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
621 *highp
= TYPE_FIELD_BITPOS (type
, i
);
624 /* Set unsigned indicator if warranted. */
627 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
641 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
643 if (!TYPE_UNSIGNED (type
))
645 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
649 /* ... fall through for unsigned ints ... */
652 /* This round-about calculation is to avoid shifting by
653 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
654 if TYPE_LENGTH (type) == sizeof (LONGEST). */
655 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
656 *highp
= (*highp
- 1) | *highp
;
663 /* Create an array type using either a blank type supplied in RESULT_TYPE,
664 or creating a new type, inheriting the objfile from RANGE_TYPE.
666 Elements will be of type ELEMENT_TYPE, the indices will be of type
669 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
670 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
673 create_array_type (struct type
*result_type
, struct type
*element_type
,
674 struct type
*range_type
)
676 LONGEST low_bound
, high_bound
;
678 if (result_type
== NULL
)
680 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
682 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
683 TYPE_TARGET_TYPE (result_type
) = element_type
;
684 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
685 low_bound
= high_bound
= 0;
686 CHECK_TYPEDEF (element_type
);
687 TYPE_LENGTH (result_type
) =
688 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
689 TYPE_NFIELDS (result_type
) = 1;
690 TYPE_FIELDS (result_type
) =
691 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
692 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
693 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
694 TYPE_VPTR_FIELDNO (result_type
) = -1;
696 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
697 if (TYPE_LENGTH (result_type
) == 0)
698 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
700 return (result_type
);
703 /* Create a string type using either a blank type supplied in RESULT_TYPE,
704 or creating a new type. String types are similar enough to array of
705 char types that we can use create_array_type to build the basic type
706 and then bash it into a string type.
708 For fixed length strings, the range type contains 0 as the lower
709 bound and the length of the string minus one as the upper bound.
711 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
712 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
715 create_string_type (struct type
*result_type
, struct type
*range_type
)
717 result_type
= create_array_type (result_type
,
718 *current_language
->string_char_type
,
720 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
721 return (result_type
);
725 create_set_type (struct type
*result_type
, struct type
*domain_type
)
727 LONGEST low_bound
, high_bound
, bit_length
;
728 if (result_type
== NULL
)
730 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
732 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
733 TYPE_NFIELDS (result_type
) = 1;
734 TYPE_FIELDS (result_type
) = (struct field
*)
735 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
736 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
738 if (!TYPE_STUB (domain_type
))
740 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
741 low_bound
= high_bound
= 0;
742 bit_length
= high_bound
- low_bound
+ 1;
743 TYPE_LENGTH (result_type
)
744 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
746 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
749 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
751 return (result_type
);
755 /* Construct and return a type of the form:
756 struct NAME { ELT_TYPE ELT_NAME[N]; }
757 We use these types for SIMD registers. For example, the type of
758 the SSE registers on the late x86-family processors is:
759 struct __builtin_v4sf { float f[4]; }
760 built by the function call:
761 init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4)
762 The type returned is a permanent type, allocated using malloc; it
763 doesn't live in any objfile's obstack. */
765 init_simd_type (char *name
,
766 struct type
*elt_type
,
773 /* Build the field structure. */
774 f
= xmalloc (sizeof (*f
));
775 memset (f
, 0, sizeof (*f
));
777 f
->type
= create_array_type (0, elt_type
,
778 create_range_type (0, builtin_type_int
,
782 /* Build a struct type with that field. */
783 t
= init_type (TYPE_CODE_STRUCT
, n
* TYPE_LENGTH (elt_type
), 0, 0, 0);
792 build_builtin_type_vec128 (void)
794 /* Construct a type for the 128 bit registers. The type we're
797 union __gdb_builtin_type_vec128
799 struct __builtin_v16qi v16qi
;
800 struct __builtin_v8hi v8hi
;
801 struct __builtin_v4si v4si
;
802 struct __builtin_v4sf v4sf
;
810 f
= (struct field
*) xcalloc (5, sizeof (*f
));
812 FIELD_TYPE (f
[0]) = builtin_type_int128
;
813 FIELD_NAME (f
[0]) = "uint128";
815 FIELD_TYPE (f
[1]) = builtin_type_v4sf
;
816 FIELD_NAME (f
[1]) = "v4sf";
818 FIELD_TYPE (f
[2]) = builtin_type_v4si
;
819 FIELD_NAME (f
[2]) = "v4si";
821 FIELD_TYPE (f
[3]) = builtin_type_v8hi
;
822 FIELD_NAME (f
[3]) = "v8hi";
824 FIELD_TYPE (f
[4]) = builtin_type_v16qi
;
825 FIELD_NAME (f
[4]) = "v16qi";
827 /* Build a union type with those fields. */
828 t
= init_type (TYPE_CODE_UNION
, 16, 0, 0, 0);
829 TYPE_NFIELDS (t
) = 5;
831 TYPE_TAG_NAME (t
) = "__gdb_builtin_type_vec128";
836 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
837 A MEMBER is a wierd thing -- it amounts to a typed offset into
838 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
839 include the offset (that's the value of the MEMBER itself), but does
840 include the structure type into which it points (for some reason).
842 When "smashing" the type, we preserve the objfile that the
843 old type pointed to, since we aren't changing where the type is actually
847 smash_to_member_type (struct type
*type
, struct type
*domain
,
848 struct type
*to_type
)
850 struct objfile
*objfile
;
852 objfile
= TYPE_OBJFILE (type
);
854 memset ((char *) type
, 0, sizeof (struct type
));
855 TYPE_OBJFILE (type
) = objfile
;
856 TYPE_TARGET_TYPE (type
) = to_type
;
857 TYPE_DOMAIN_TYPE (type
) = domain
;
858 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
859 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
862 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
863 METHOD just means `function that gets an extra "this" argument'.
865 When "smashing" the type, we preserve the objfile that the
866 old type pointed to, since we aren't changing where the type is actually
870 smash_to_method_type (struct type
*type
, struct type
*domain
,
871 struct type
*to_type
, struct type
**args
)
873 struct objfile
*objfile
;
875 objfile
= TYPE_OBJFILE (type
);
877 memset ((char *) type
, 0, sizeof (struct type
));
878 TYPE_OBJFILE (type
) = objfile
;
879 TYPE_TARGET_TYPE (type
) = to_type
;
880 TYPE_DOMAIN_TYPE (type
) = domain
;
881 TYPE_ARG_TYPES (type
) = args
;
882 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
883 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
886 /* Return a typename for a struct/union/enum type without "struct ",
887 "union ", or "enum ". If the type has a NULL name, return NULL. */
890 type_name_no_tag (register const struct type
*type
)
892 if (TYPE_TAG_NAME (type
) != NULL
)
893 return TYPE_TAG_NAME (type
);
895 /* Is there code which expects this to return the name if there is no
896 tag name? My guess is that this is mainly used for C++ in cases where
897 the two will always be the same. */
898 return TYPE_NAME (type
);
901 /* Lookup a primitive type named NAME.
902 Return zero if NAME is not a primitive type. */
905 lookup_primitive_typename (char *name
)
907 struct type
**const *p
;
909 for (p
= current_language
->la_builtin_type_vector
; *p
!= NULL
; p
++)
911 if (STREQ ((**p
)->name
, name
))
919 /* Lookup a typedef or primitive type named NAME,
920 visible in lexical block BLOCK.
921 If NOERR is nonzero, return zero if NAME is not suitably defined. */
924 lookup_typename (char *name
, struct block
*block
, int noerr
)
926 register struct symbol
*sym
;
927 register struct type
*tmp
;
929 sym
= lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
930 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
932 tmp
= lookup_primitive_typename (name
);
937 else if (!tmp
&& noerr
)
943 error ("No type named %s.", name
);
946 return (SYMBOL_TYPE (sym
));
950 lookup_unsigned_typename (char *name
)
952 char *uns
= alloca (strlen (name
) + 10);
954 strcpy (uns
, "unsigned ");
955 strcpy (uns
+ 9, name
);
956 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
960 lookup_signed_typename (char *name
)
963 char *uns
= alloca (strlen (name
) + 8);
965 strcpy (uns
, "signed ");
966 strcpy (uns
+ 7, name
);
967 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
968 /* If we don't find "signed FOO" just try again with plain "FOO". */
971 return lookup_typename (name
, (struct block
*) NULL
, 0);
974 /* Lookup a structure type named "struct NAME",
975 visible in lexical block BLOCK. */
978 lookup_struct (char *name
, struct block
*block
)
980 register struct symbol
*sym
;
982 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
983 (struct symtab
**) NULL
);
987 error ("No struct type named %s.", name
);
989 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
991 error ("This context has class, union or enum %s, not a struct.", name
);
993 return (SYMBOL_TYPE (sym
));
996 /* Lookup a union type named "union NAME",
997 visible in lexical block BLOCK. */
1000 lookup_union (char *name
, struct block
*block
)
1002 register struct symbol
*sym
;
1005 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
1006 (struct symtab
**) NULL
);
1009 error ("No union type named %s.", name
);
1011 t
= SYMBOL_TYPE (sym
);
1013 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1016 /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
1017 * a further "declared_type" field to discover it is really a union.
1019 if (HAVE_CPLUS_STRUCT (t
))
1020 if (TYPE_DECLARED_TYPE (t
) == DECLARED_TYPE_UNION
)
1023 /* If we get here, it's not a union */
1024 error ("This context has class, struct or enum %s, not a union.", name
);
1028 /* Lookup an enum type named "enum NAME",
1029 visible in lexical block BLOCK. */
1032 lookup_enum (char *name
, struct block
*block
)
1034 register struct symbol
*sym
;
1036 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
1037 (struct symtab
**) NULL
);
1040 error ("No enum type named %s.", name
);
1042 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1044 error ("This context has class, struct or union %s, not an enum.", name
);
1046 return (SYMBOL_TYPE (sym
));
1049 /* Lookup a template type named "template NAME<TYPE>",
1050 visible in lexical block BLOCK. */
1053 lookup_template_type (char *name
, struct type
*type
, struct block
*block
)
1056 char *nam
= (char *) alloca (strlen (name
) + strlen (type
->name
) + 4);
1059 strcat (nam
, type
->name
);
1060 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1062 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
1066 error ("No template type named %s.", name
);
1068 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1070 error ("This context has class, union or enum %s, not a struct.", name
);
1072 return (SYMBOL_TYPE (sym
));
1075 /* Given a type TYPE, lookup the type of the component of type named NAME.
1077 TYPE can be either a struct or union, or a pointer or reference to a struct or
1078 union. If it is a pointer or reference, its target type is automatically used.
1079 Thus '.' and '->' are interchangable, as specified for the definitions of the
1080 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
1082 If NOERR is nonzero, return zero if NAME is not suitably defined.
1083 If NAME is the name of a baseclass type, return that type. */
1086 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
1092 CHECK_TYPEDEF (type
);
1093 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1094 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1096 type
= TYPE_TARGET_TYPE (type
);
1099 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
1100 TYPE_CODE (type
) != TYPE_CODE_UNION
)
1102 target_terminal_ours ();
1103 gdb_flush (gdb_stdout
);
1104 fprintf_unfiltered (gdb_stderr
, "Type ");
1105 type_print (type
, "", gdb_stderr
, -1);
1106 error (" is not a structure or union type.");
1110 /* FIXME: This change put in by Michael seems incorrect for the case where
1111 the structure tag name is the same as the member name. I.E. when doing
1112 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
1117 typename
= type_name_no_tag (type
);
1118 if (typename
!= NULL
&& STREQ (typename
, name
))
1123 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1125 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1127 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1129 return TYPE_FIELD_TYPE (type
, i
);
1133 /* OK, it's not in this class. Recursively check the baseclasses. */
1134 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1138 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, noerr
);
1150 target_terminal_ours ();
1151 gdb_flush (gdb_stdout
);
1152 fprintf_unfiltered (gdb_stderr
, "Type ");
1153 type_print (type
, "", gdb_stderr
, -1);
1154 fprintf_unfiltered (gdb_stderr
, " has no component named ");
1155 fputs_filtered (name
, gdb_stderr
);
1157 return (struct type
*) -1; /* For lint */
1160 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
1161 valid. Callers should be aware that in some cases (for example,
1162 the type or one of its baseclasses is a stub type and we are
1163 debugging a .o file), this function will not be able to find the virtual
1164 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
1165 will remain NULL. */
1168 fill_in_vptr_fieldno (struct type
*type
)
1170 CHECK_TYPEDEF (type
);
1172 if (TYPE_VPTR_FIELDNO (type
) < 0)
1176 /* We must start at zero in case the first (and only) baseclass is
1177 virtual (and hence we cannot share the table pointer). */
1178 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1180 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, i
));
1181 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
)) >= 0)
1183 TYPE_VPTR_FIELDNO (type
)
1184 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
));
1185 TYPE_VPTR_BASETYPE (type
)
1186 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type
, i
));
1193 /* Find the method and field indices for the destructor in class type T.
1194 Return 1 if the destructor was found, otherwise, return 0. */
1197 get_destructor_fn_field (struct type
*t
, int *method_indexp
, int *field_indexp
)
1201 for (i
= 0; i
< TYPE_NFN_FIELDS (t
); i
++)
1204 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1206 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (t
, i
); j
++)
1208 if (is_destructor_name (TYPE_FN_FIELD_PHYSNAME (f
, j
)) != 0)
1219 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1221 If this is a stubbed struct (i.e. declared as struct foo *), see if
1222 we can find a full definition in some other file. If so, copy this
1223 definition, so we can use it in future. There used to be a comment (but
1224 not any code) that if we don't find a full definition, we'd set a flag
1225 so we don't spend time in the future checking the same type. That would
1226 be a mistake, though--we might load in more symbols which contain a
1227 full definition for the type.
1229 This used to be coded as a macro, but I don't think it is called
1230 often enough to merit such treatment. */
1232 struct complaint stub_noname_complaint
=
1233 {"stub type has NULL name", 0, 0};
1236 check_typedef (struct type
*type
)
1238 struct type
*orig_type
= type
;
1239 int is_const
, is_volatile
;
1241 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1243 if (!TYPE_TARGET_TYPE (type
))
1248 /* It is dangerous to call lookup_symbol if we are currently
1249 reading a symtab. Infinite recursion is one danger. */
1250 if (currently_reading_symtab
)
1253 name
= type_name_no_tag (type
);
1254 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1255 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
1256 as appropriate? (this code was written before TYPE_NAME and
1257 TYPE_TAG_NAME were separate). */
1260 complain (&stub_noname_complaint
);
1263 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
1264 (struct symtab
**) NULL
);
1266 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1268 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
); /* TYPE_CODE_UNDEF */
1270 type
= TYPE_TARGET_TYPE (type
);
1273 is_const
= TYPE_CONST (type
);
1274 is_volatile
= TYPE_VOLATILE (type
);
1276 /* If this is a struct/class/union with no fields, then check whether a
1277 full definition exists somewhere else. This is for systems where a
1278 type definition with no fields is issued for such types, instead of
1279 identifying them as stub types in the first place */
1281 if (TYPE_IS_OPAQUE (type
) && opaque_type_resolution
&& !currently_reading_symtab
)
1283 char *name
= type_name_no_tag (type
);
1284 struct type
*newtype
;
1287 complain (&stub_noname_complaint
);
1290 newtype
= lookup_transparent_type (name
);
1292 make_cv_type (is_const
, is_volatile
, newtype
, &type
);
1294 /* Otherwise, rely on the stub flag being set for opaque/stubbed types */
1295 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1297 char *name
= type_name_no_tag (type
);
1298 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1299 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
1300 as appropriate? (this code was written before TYPE_NAME and
1301 TYPE_TAG_NAME were separate). */
1305 complain (&stub_noname_complaint
);
1308 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0, (struct symtab
**) NULL
);
1310 make_cv_type (is_const
, is_volatile
, SYMBOL_TYPE (sym
), &type
);
1313 if (TYPE_TARGET_STUB (type
))
1315 struct type
*range_type
;
1316 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1318 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1321 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1322 && TYPE_NFIELDS (type
) == 1
1323 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
1324 == TYPE_CODE_RANGE
))
1326 /* Now recompute the length of the array type, based on its
1327 number of elements and the target type's length. */
1328 TYPE_LENGTH (type
) =
1329 ((TYPE_FIELD_BITPOS (range_type
, 1)
1330 - TYPE_FIELD_BITPOS (range_type
, 0)
1332 * TYPE_LENGTH (target_type
));
1333 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1335 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1337 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1338 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1341 /* Cache TYPE_LENGTH for future use. */
1342 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1346 /* New code added to support parsing of Cfront stabs strings */
1347 #define INIT_EXTRA { pextras->len=0; pextras->str[0]='\0'; }
1348 #define ADD_EXTRA(c) { pextras->str[pextras->len++]=c; }
1351 add_name (struct extra
*pextras
, char *n
)
1355 if ((nlen
= (n
? strlen (n
) : 0)) == 0)
1357 sprintf (pextras
->str
+ pextras
->len
, "%d%s", nlen
, n
);
1358 pextras
->len
= strlen (pextras
->str
);
1362 add_mangled_type (struct extra
*pextras
, struct type
*t
)
1364 enum type_code tcode
;
1368 tcode
= TYPE_CODE (t
);
1369 tlen
= TYPE_LENGTH (t
);
1370 tflags
= TYPE_FLAGS (t
);
1371 tname
= TYPE_NAME (t
);
1372 /* args of "..." seem to get mangled as "e" */
1390 if ((pname
= strrchr (tname
, 'l'), pname
) && !strcmp (pname
, "long"))
1403 static struct complaint msg
=
1404 {"Bad int type code length x%x\n", 0, 0};
1406 complain (&msg
, tlen
);
1425 static struct complaint msg
=
1426 {"Bad float type code length x%x\n", 0, 0};
1427 complain (&msg
, tlen
);
1433 /* followed by what it's a ref to */
1437 /* followed by what it's a ptr to */
1439 case TYPE_CODE_TYPEDEF
:
1441 static struct complaint msg
=
1442 {"Typedefs in overloaded functions not yet supported\n", 0, 0};
1445 /* followed by type bytes & name */
1447 case TYPE_CODE_FUNC
:
1449 /* followed by func's arg '_' & ret types */
1451 case TYPE_CODE_VOID
:
1454 case TYPE_CODE_METHOD
:
1456 /* followed by name of class and func's arg '_' & ret types */
1457 add_name (pextras
, tname
);
1458 ADD_EXTRA ('F'); /* then mangle function */
1460 case TYPE_CODE_STRUCT
: /* C struct */
1461 case TYPE_CODE_UNION
: /* C union */
1462 case TYPE_CODE_ENUM
: /* Enumeration type */
1463 /* followed by name of type */
1464 add_name (pextras
, tname
);
1467 /* errors possible types/not supported */
1468 case TYPE_CODE_CHAR
:
1469 case TYPE_CODE_ARRAY
: /* Array type */
1470 case TYPE_CODE_MEMBER
: /* Member type */
1471 case TYPE_CODE_BOOL
:
1472 case TYPE_CODE_COMPLEX
: /* Complex float */
1473 case TYPE_CODE_UNDEF
:
1474 case TYPE_CODE_SET
: /* Pascal sets */
1475 case TYPE_CODE_RANGE
:
1476 case TYPE_CODE_STRING
:
1477 case TYPE_CODE_BITSTRING
:
1478 case TYPE_CODE_ERROR
:
1481 static struct complaint msg
=
1482 {"Unknown type code x%x\n", 0, 0};
1483 complain (&msg
, tcode
);
1487 add_mangled_type (pextras
, t
->target_type
);
1492 cfront_mangle_name (struct type
*type
, int i
, int j
)
1495 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
1497 f
= TYPE_FN_FIELDLIST1 (type
, i
); /* moved from below */
1499 /* kludge to support cfront methods - gdb expects to find "F" for
1500 ARM_mangled names, so when we mangle, we have to add it here */
1504 char *arm_mangled_name
;
1505 struct fn_field
*method
= &f
[j
];
1506 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1507 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1508 char *newname
= type_name_no_tag (type
);
1510 struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
1511 int nargs
= TYPE_NFIELDS (ftype
); /* number of args */
1512 struct extra extras
, *pextras
= &extras
;
1515 if (TYPE_FN_FIELD_STATIC_P (f
, j
)) /* j for sublist within this list */
1518 /* add args here! */
1519 if (nargs
<= 1) /* no args besides this */
1523 for (k
= 1; k
< nargs
; k
++)
1526 t
= TYPE_FIELD_TYPE (ftype
, k
);
1527 add_mangled_type (pextras
, t
);
1531 printf ("add_mangled_type: %s\n", extras
.str
); /* FIXME */
1532 xasprintf (&arm_mangled_name
, "%s%s", mangled_name
, extras
.str
);
1533 xfree (mangled_name
);
1534 mangled_name
= arm_mangled_name
;
1540 /* End of new code added to support parsing of Cfront stabs strings */
1542 /* Parse a type expression in the string [P..P+LENGTH). If an error occurs,
1543 silently return builtin_type_void. */
1546 safe_parse_type (char *p
, int length
)
1548 struct ui_file
*saved_gdb_stderr
;
1551 /* Suppress error messages. */
1552 saved_gdb_stderr
= gdb_stderr
;
1553 gdb_stderr
= ui_file_new ();
1555 /* Call parse_and_eval_type() without fear of longjmp()s. */
1556 if (!gdb_parse_and_eval_type (p
, length
, &type
))
1557 type
= builtin_type_void
;
1559 /* Stop suppressing error messages. */
1560 ui_file_delete (gdb_stderr
);
1561 gdb_stderr
= saved_gdb_stderr
;
1566 /* Ugly hack to convert method stubs into method types.
1568 He ain't kiddin'. This demangles the name of the method into a string
1569 including argument types, parses out each argument type, generates
1570 a string casting a zero to that type, evaluates the string, and stuffs
1571 the resulting type into an argtype vector!!! Then it knows the type
1572 of the whole function (including argument types for overloading),
1573 which info used to be in the stab's but was removed to hack back
1574 the space required for them. */
1577 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1580 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1581 char *demangled_name
= cplus_demangle (mangled_name
,
1582 DMGL_PARAMS
| DMGL_ANSI
);
1583 char *argtypetext
, *p
;
1584 int depth
= 0, argcount
= 1;
1585 struct type
**argtypes
;
1588 /* Make sure we got back a function string that we can use. */
1590 p
= strchr (demangled_name
, '(');
1594 if (demangled_name
== NULL
|| p
== NULL
)
1595 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
1597 /* Now, read in the parameters that define this type. */
1602 if (*p
== '(' || *p
== '<')
1606 else if (*p
== ')' || *p
== '>')
1610 else if (*p
== ',' && depth
== 0)
1618 /* We need two more slots: one for the THIS pointer, and one for the
1619 NULL [...] or void [end of arglist]. */
1621 argtypes
= (struct type
**)
1622 TYPE_ALLOC (type
, (argcount
+ 2) * sizeof (struct type
*));
1624 /* FIXME: This is wrong for static member functions. */
1625 argtypes
[0] = lookup_pointer_type (type
);
1628 if (*p
!= ')') /* () means no args, skip while */
1633 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1635 /* Avoid parsing of ellipsis, they will be handled below. */
1636 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0)
1638 argtypes
[argcount
] =
1639 safe_parse_type (argtypetext
, p
- argtypetext
);
1642 argtypetext
= p
+ 1;
1645 if (*p
== '(' || *p
== '<')
1649 else if (*p
== ')' || *p
== '>')
1658 if (p
[-2] != '.') /* Not '...' */
1660 argtypes
[argcount
] = builtin_type_void
; /* List terminator */
1664 argtypes
[argcount
] = NULL
; /* Ellist terminator */
1667 xfree (demangled_name
);
1669 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1671 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1673 /* Now update the old "stub" type into a real type. */
1674 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1675 TYPE_DOMAIN_TYPE (mtype
) = type
;
1676 TYPE_ARG_TYPES (mtype
) = argtypes
;
1677 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1678 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1681 const struct cplus_struct_type cplus_struct_default
;
1684 allocate_cplus_struct_type (struct type
*type
)
1686 if (!HAVE_CPLUS_STRUCT (type
))
1688 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1689 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1690 *(TYPE_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1694 /* Helper function to initialize the standard scalar types.
1696 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1697 of the string pointed to by name in the type_obstack for that objfile,
1698 and initialize the type name to that copy. There are places (mipsread.c
1699 in particular, where init_type is called with a NULL value for NAME). */
1702 init_type (enum type_code code
, int length
, int flags
, char *name
,
1703 struct objfile
*objfile
)
1705 register struct type
*type
;
1707 type
= alloc_type (objfile
);
1708 TYPE_CODE (type
) = code
;
1709 TYPE_LENGTH (type
) = length
;
1710 TYPE_FLAGS (type
) |= flags
;
1711 if ((name
!= NULL
) && (objfile
!= NULL
))
1714 obsavestring (name
, strlen (name
), &objfile
->type_obstack
);
1718 TYPE_NAME (type
) = name
;
1723 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
1725 INIT_CPLUS_SPECIFIC (type
);
1730 /* Look up a fundamental type for the specified objfile.
1731 May need to construct such a type if this is the first use.
1733 Some object file formats (ELF, COFF, etc) do not define fundamental
1734 types such as "int" or "double". Others (stabs for example), do
1735 define fundamental types.
1737 For the formats which don't provide fundamental types, gdb can create
1738 such types, using defaults reasonable for the current language and
1739 the current target machine.
1741 NOTE: This routine is obsolescent. Each debugging format reader
1742 should manage it's own fundamental types, either creating them from
1743 suitable defaults or reading them from the debugging information,
1744 whichever is appropriate. The DWARF reader has already been
1745 fixed to do this. Once the other readers are fixed, this routine
1746 will go away. Also note that fundamental types should be managed
1747 on a compilation unit basis in a multi-language environment, not
1748 on a linkage unit basis as is done here. */
1752 lookup_fundamental_type (struct objfile
*objfile
, int typeid)
1754 register struct type
**typep
;
1755 register int nbytes
;
1757 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1759 error ("internal error - invalid fundamental type id %d", typeid);
1762 /* If this is the first time we need a fundamental type for this objfile
1763 then we need to initialize the vector of type pointers. */
1765 if (objfile
->fundamental_types
== NULL
)
1767 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1768 objfile
->fundamental_types
= (struct type
**)
1769 obstack_alloc (&objfile
->type_obstack
, nbytes
);
1770 memset ((char *) objfile
->fundamental_types
, 0, nbytes
);
1771 OBJSTAT (objfile
, n_types
+= FT_NUM_MEMBERS
);
1774 /* Look for this particular type in the fundamental type vector. If one is
1775 not found, create and install one appropriate for the current language. */
1777 typep
= objfile
->fundamental_types
+ typeid;
1780 *typep
= create_fundamental_type (objfile
, typeid);
1787 can_dereference (struct type
*t
)
1789 /* FIXME: Should we return true for references as well as pointers? */
1793 && TYPE_CODE (t
) == TYPE_CODE_PTR
1794 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1798 is_integral_type (struct type
*t
)
1803 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
1804 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
1805 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
1806 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
1807 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
1810 /* Chill varying string and arrays are represented as follows:
1812 struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
1814 Return true if TYPE is such a Chill varying type. */
1817 chill_varying_type (struct type
*type
)
1819 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1820 || TYPE_NFIELDS (type
) != 2
1821 || strcmp (TYPE_FIELD_NAME (type
, 0), "__var_length") != 0)
1826 /* Check whether BASE is an ancestor or base class or DCLASS
1827 Return 1 if so, and 0 if not.
1828 Note: callers may want to check for identity of the types before
1829 calling this function -- identical types are considered to satisfy
1830 the ancestor relationship even if they're identical */
1833 is_ancestor (struct type
*base
, struct type
*dclass
)
1837 CHECK_TYPEDEF (base
);
1838 CHECK_TYPEDEF (dclass
);
1842 if (TYPE_NAME (base
) && TYPE_NAME (dclass
) &&
1843 !strcmp (TYPE_NAME (base
), TYPE_NAME (dclass
)))
1846 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1847 if (is_ancestor (base
, TYPE_BASECLASS (dclass
, i
)))
1855 /* See whether DCLASS has a virtual table. This routine is aimed at
1856 the HP/Taligent ANSI C++ runtime model, and may not work with other
1857 runtime models. Return 1 => Yes, 0 => No. */
1860 has_vtable (struct type
*dclass
)
1862 /* In the HP ANSI C++ runtime model, a class has a vtable only if it
1863 has virtual functions or virtual bases. */
1867 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1870 /* First check for the presence of virtual bases */
1871 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
1872 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1873 if (B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
))
1876 /* Next check for virtual functions */
1877 if (TYPE_FN_FIELDLISTS (dclass
))
1878 for (i
= 0; i
< TYPE_NFN_FIELDS (dclass
); i
++)
1879 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, i
), 0))
1882 /* Recurse on non-virtual bases to see if any of them needs a vtable */
1883 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
1884 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1885 if ((!B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
)) &&
1886 (has_vtable (TYPE_FIELD_TYPE (dclass
, i
))))
1889 /* Well, maybe we don't need a virtual table */
1893 /* Return a pointer to the "primary base class" of DCLASS.
1895 A NULL return indicates that DCLASS has no primary base, or that it
1896 couldn't be found (insufficient information).
1898 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
1899 and may not work with other runtime models. */
1902 primary_base_class (struct type
*dclass
)
1904 /* In HP ANSI C++'s runtime model, a "primary base class" of a class
1905 is the first directly inherited, non-virtual base class that
1906 requires a virtual table */
1910 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1913 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1914 if (!TYPE_FIELD_VIRTUAL (dclass
, i
) &&
1915 has_vtable (TYPE_FIELD_TYPE (dclass
, i
)))
1916 return TYPE_FIELD_TYPE (dclass
, i
);
1921 /* Global manipulated by virtual_base_list[_aux]() */
1923 static struct vbase
*current_vbase_list
= NULL
;
1925 /* Return a pointer to a null-terminated list of struct vbase
1926 items. The vbasetype pointer of each item in the list points to the
1927 type information for a virtual base of the argument DCLASS.
1929 Helper function for virtual_base_list().
1930 Note: the list goes backward, right-to-left. virtual_base_list()
1931 copies the items out in reverse order. */
1934 virtual_base_list_aux (struct type
*dclass
)
1936 struct vbase
*tmp_vbase
;
1939 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1942 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1944 /* Recurse on this ancestor, first */
1945 virtual_base_list_aux (TYPE_FIELD_TYPE (dclass
, i
));
1947 /* If this current base is itself virtual, add it to the list */
1948 if (BASETYPE_VIA_VIRTUAL (dclass
, i
))
1950 struct type
*basetype
= TYPE_FIELD_TYPE (dclass
, i
);
1952 /* Check if base already recorded */
1953 tmp_vbase
= current_vbase_list
;
1956 if (tmp_vbase
->vbasetype
== basetype
)
1957 break; /* found it */
1958 tmp_vbase
= tmp_vbase
->next
;
1961 if (!tmp_vbase
) /* normal exit from loop */
1963 /* Allocate new item for this virtual base */
1964 tmp_vbase
= (struct vbase
*) xmalloc (sizeof (struct vbase
));
1966 /* Stick it on at the end of the list */
1967 tmp_vbase
->vbasetype
= basetype
;
1968 tmp_vbase
->next
= current_vbase_list
;
1969 current_vbase_list
= tmp_vbase
;
1972 } /* for loop over bases */
1976 /* Compute the list of virtual bases in the right order. Virtual
1977 bases are laid out in the object's memory area in order of their
1978 occurrence in a depth-first, left-to-right search through the
1981 Argument DCLASS is the type whose virtual bases are required.
1982 Return value is the address of a null-terminated array of pointers
1983 to struct type items.
1985 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
1986 and may not work with other runtime models.
1988 This routine merely hands off the argument to virtual_base_list_aux()
1989 and then copies the result into an array to save space. */
1992 virtual_base_list (struct type
*dclass
)
1994 register struct vbase
*tmp_vbase
;
1995 register struct vbase
*tmp_vbase_2
;
1998 struct type
**vbase_array
;
2000 current_vbase_list
= NULL
;
2001 virtual_base_list_aux (dclass
);
2003 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
2008 vbase_array
= (struct type
**) xmalloc ((count
+ 1) * sizeof (struct type
*));
2010 for (i
= count
- 1, tmp_vbase
= current_vbase_list
; i
>= 0; i
--, tmp_vbase
= tmp_vbase
->next
)
2011 vbase_array
[i
] = tmp_vbase
->vbasetype
;
2013 /* Get rid of constructed chain */
2014 tmp_vbase_2
= tmp_vbase
= current_vbase_list
;
2017 tmp_vbase
= tmp_vbase
->next
;
2018 xfree (tmp_vbase_2
);
2019 tmp_vbase_2
= tmp_vbase
;
2022 vbase_array
[count
] = NULL
;
2026 /* Return the length of the virtual base list of the type DCLASS. */
2029 virtual_base_list_length (struct type
*dclass
)
2032 register struct vbase
*tmp_vbase
;
2034 current_vbase_list
= NULL
;
2035 virtual_base_list_aux (dclass
);
2037 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
2042 /* Return the number of elements of the virtual base list of the type
2043 DCLASS, ignoring those appearing in the primary base (and its
2044 primary base, recursively). */
2047 virtual_base_list_length_skip_primaries (struct type
*dclass
)
2050 register struct vbase
*tmp_vbase
;
2051 struct type
*primary
;
2053 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
2056 return virtual_base_list_length (dclass
);
2058 current_vbase_list
= NULL
;
2059 virtual_base_list_aux (dclass
);
2061 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; tmp_vbase
= tmp_vbase
->next
)
2063 if (virtual_base_index (tmp_vbase
->vbasetype
, primary
) >= 0)
2071 /* Return the index (position) of type BASE, which is a virtual base
2072 class of DCLASS, in the latter's virtual base list. A return of -1
2073 indicates "not found" or a problem. */
2076 virtual_base_index (struct type
*base
, struct type
*dclass
)
2078 register struct type
*vbase
;
2081 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
2082 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
2086 vbase
= virtual_base_list (dclass
)[0];
2091 vbase
= virtual_base_list (dclass
)[++i
];
2094 return vbase
? i
: -1;
2099 /* Return the index (position) of type BASE, which is a virtual base
2100 class of DCLASS, in the latter's virtual base list. Skip over all
2101 bases that may appear in the virtual base list of the primary base
2102 class of DCLASS (recursively). A return of -1 indicates "not
2103 found" or a problem. */
2106 virtual_base_index_skip_primaries (struct type
*base
, struct type
*dclass
)
2108 register struct type
*vbase
;
2110 struct type
*primary
;
2112 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
2113 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
2116 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
2120 vbase
= virtual_base_list (dclass
)[0];
2123 if (!primary
|| (virtual_base_index_skip_primaries (vbase
, primary
) < 0))
2127 vbase
= virtual_base_list (dclass
)[++i
];
2130 return vbase
? j
: -1;
2133 /* Return position of a derived class DCLASS in the list of
2134 * primary bases starting with the remotest ancestor.
2135 * Position returned is 0-based. */
2138 class_index_in_primary_list (struct type
*dclass
)
2140 struct type
*pbc
; /* primary base class */
2142 /* Simply recurse on primary base */
2143 pbc
= TYPE_PRIMARY_BASE (dclass
);
2145 return 1 + class_index_in_primary_list (pbc
);
2150 /* Return a count of the number of virtual functions a type has.
2151 * This includes all the virtual functions it inherits from its
2155 /* pai: FIXME This doesn't do the right thing: count redefined virtual
2156 * functions only once (latest redefinition)
2160 count_virtual_fns (struct type
*dclass
)
2162 int fn
, oi
; /* function and overloaded instance indices */
2163 int vfuncs
; /* count to return */
2165 /* recurse on bases that can share virtual table */
2166 struct type
*pbc
= primary_base_class (dclass
);
2168 vfuncs
= count_virtual_fns (pbc
);
2172 for (fn
= 0; fn
< TYPE_NFN_FIELDS (dclass
); fn
++)
2173 for (oi
= 0; oi
< TYPE_FN_FIELDLIST_LENGTH (dclass
, fn
); oi
++)
2174 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, fn
), oi
))
2182 /* Functions for overload resolution begin here */
2184 /* Compare two badness vectors A and B and return the result.
2185 * 0 => A and B are identical
2186 * 1 => A and B are incomparable
2187 * 2 => A is better than B
2188 * 3 => A is worse than B */
2191 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
2195 short found_pos
= 0; /* any positives in c? */
2196 short found_neg
= 0; /* any negatives in c? */
2198 /* differing lengths => incomparable */
2199 if (a
->length
!= b
->length
)
2202 /* Subtract b from a */
2203 for (i
= 0; i
< a
->length
; i
++)
2205 tmp
= a
->rank
[i
] - b
->rank
[i
];
2215 return 1; /* incomparable */
2217 return 3; /* A > B */
2223 return 2; /* A < B */
2225 return 0; /* A == B */
2229 /* Rank a function by comparing its parameter types (PARMS, length NPARMS),
2230 * to the types of an argument list (ARGS, length NARGS).
2231 * Return a pointer to a badness vector. This has NARGS + 1 entries. */
2233 struct badness_vector
*
2234 rank_function (struct type
**parms
, int nparms
, struct type
**args
, int nargs
)
2237 struct badness_vector
*bv
;
2238 int min_len
= nparms
< nargs
? nparms
: nargs
;
2240 bv
= xmalloc (sizeof (struct badness_vector
));
2241 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank */
2242 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
2244 /* First compare the lengths of the supplied lists.
2245 * If there is a mismatch, set it to a high value. */
2247 /* pai/1997-06-03 FIXME: when we have debug info about default
2248 * arguments and ellipsis parameter lists, we should consider those
2249 * and rank the length-match more finely. */
2251 LENGTH_MATCH (bv
) = (nargs
!= nparms
) ? LENGTH_MISMATCH_BADNESS
: 0;
2253 /* Now rank all the parameters of the candidate function */
2254 for (i
= 1; i
<= min_len
; i
++)
2255 bv
->rank
[i
] = rank_one_type (parms
[i
-1], args
[i
-1]);
2257 /* If more arguments than parameters, add dummy entries */
2258 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2259 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2264 /* Compare one type (PARM) for compatibility with another (ARG).
2265 * PARM is intended to be the parameter type of a function; and
2266 * ARG is the supplied argument's type. This function tests if
2267 * the latter can be converted to the former.
2269 * Return 0 if they are identical types;
2270 * Otherwise, return an integer which corresponds to how compatible
2271 * PARM is to ARG. The higher the return value, the worse the match.
2272 * Generally the "bad" conversions are all uniformly assigned a 100 */
2275 rank_one_type (struct type
*parm
, struct type
*arg
)
2277 /* Identical type pointers */
2278 /* However, this still doesn't catch all cases of same type for arg
2279 * and param. The reason is that builtin types are different from
2280 * the same ones constructed from the object. */
2284 /* Resolve typedefs */
2285 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2286 parm
= check_typedef (parm
);
2287 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2288 arg
= check_typedef (arg
);
2291 Well, damnit, if the names are exactly the same,
2292 i'll say they are exactly the same. This happens when we generate
2293 method stubs. The types won't point to the same address, but they
2294 really are the same.
2297 if (TYPE_NAME (parm
) && TYPE_NAME (arg
) &&
2298 !strcmp (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2301 /* Check if identical after resolving typedefs */
2305 /* See through references, since we can almost make non-references
2307 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2308 return (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
))
2309 + REFERENCE_CONVERSION_BADNESS
);
2310 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2311 return (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
)
2312 + REFERENCE_CONVERSION_BADNESS
);
2314 /* Debugging only. */
2315 fprintf_filtered (gdb_stderr
,"------ Arg is %s [%d], parm is %s [%d]\n",
2316 TYPE_NAME (arg
), TYPE_CODE (arg
), TYPE_NAME (parm
), TYPE_CODE (parm
));
2318 /* x -> y means arg of type x being supplied for parameter of type y */
2320 switch (TYPE_CODE (parm
))
2323 switch (TYPE_CODE (arg
))
2326 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2327 return VOID_PTR_CONVERSION_BADNESS
;
2329 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2330 case TYPE_CODE_ARRAY
:
2331 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2332 case TYPE_CODE_FUNC
:
2333 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
);
2335 case TYPE_CODE_ENUM
:
2336 case TYPE_CODE_CHAR
:
2337 case TYPE_CODE_RANGE
:
2338 case TYPE_CODE_BOOL
:
2339 return POINTER_CONVERSION_BADNESS
;
2341 return INCOMPATIBLE_TYPE_BADNESS
;
2343 case TYPE_CODE_ARRAY
:
2344 switch (TYPE_CODE (arg
))
2347 case TYPE_CODE_ARRAY
:
2348 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2350 return INCOMPATIBLE_TYPE_BADNESS
;
2352 case TYPE_CODE_FUNC
:
2353 switch (TYPE_CODE (arg
))
2355 case TYPE_CODE_PTR
: /* funcptr -> func */
2356 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
));
2358 return INCOMPATIBLE_TYPE_BADNESS
;
2361 switch (TYPE_CODE (arg
))
2364 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2366 /* Deal with signed, unsigned, and plain chars and
2367 signed and unsigned ints */
2368 if (TYPE_NOSIGN (parm
))
2370 /* This case only for character types */
2371 if (TYPE_NOSIGN (arg
)) /* plain char -> plain char */
2374 return INTEGER_COERCION_BADNESS
; /* signed/unsigned char -> plain char */
2376 else if (TYPE_UNSIGNED (parm
))
2378 if (TYPE_UNSIGNED (arg
))
2380 if (!strcmp_iw (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2381 return 0; /* unsigned int -> unsigned int, or unsigned long -> unsigned long */
2382 else if (!strcmp_iw (TYPE_NAME (arg
), "int") && !strcmp_iw (TYPE_NAME (parm
), "long"))
2383 return INTEGER_PROMOTION_BADNESS
; /* unsigned int -> unsigned long */
2385 return INTEGER_COERCION_BADNESS
; /* unsigned long -> unsigned int */
2389 if (!strcmp_iw (TYPE_NAME (arg
), "long") && !strcmp_iw (TYPE_NAME (parm
), "int"))
2390 return INTEGER_COERCION_BADNESS
; /* signed long -> unsigned int */
2392 return INTEGER_CONVERSION_BADNESS
; /* signed int/long -> unsigned int/long */
2395 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2397 if (!strcmp_iw (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2399 else if (!strcmp_iw (TYPE_NAME (arg
), "int") && !strcmp_iw (TYPE_NAME (parm
), "long"))
2400 return INTEGER_PROMOTION_BADNESS
;
2402 return INTEGER_COERCION_BADNESS
;
2405 return INTEGER_COERCION_BADNESS
;
2407 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2408 return INTEGER_PROMOTION_BADNESS
;
2410 return INTEGER_COERCION_BADNESS
;
2411 case TYPE_CODE_ENUM
:
2412 case TYPE_CODE_CHAR
:
2413 case TYPE_CODE_RANGE
:
2414 case TYPE_CODE_BOOL
:
2415 return INTEGER_PROMOTION_BADNESS
;
2417 return INT_FLOAT_CONVERSION_BADNESS
;
2419 return NS_POINTER_CONVERSION_BADNESS
;
2421 return INCOMPATIBLE_TYPE_BADNESS
;
2424 case TYPE_CODE_ENUM
:
2425 switch (TYPE_CODE (arg
))
2428 case TYPE_CODE_CHAR
:
2429 case TYPE_CODE_RANGE
:
2430 case TYPE_CODE_BOOL
:
2431 case TYPE_CODE_ENUM
:
2432 return INTEGER_COERCION_BADNESS
;
2434 return INT_FLOAT_CONVERSION_BADNESS
;
2436 return INCOMPATIBLE_TYPE_BADNESS
;
2439 case TYPE_CODE_CHAR
:
2440 switch (TYPE_CODE (arg
))
2442 case TYPE_CODE_RANGE
:
2443 case TYPE_CODE_BOOL
:
2444 case TYPE_CODE_ENUM
:
2445 return INTEGER_COERCION_BADNESS
;
2447 return INT_FLOAT_CONVERSION_BADNESS
;
2449 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2450 return INTEGER_COERCION_BADNESS
;
2451 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2452 return INTEGER_PROMOTION_BADNESS
;
2453 /* >>> !! else fall through !! <<< */
2454 case TYPE_CODE_CHAR
:
2455 /* Deal with signed, unsigned, and plain chars for C++
2456 and with int cases falling through from previous case */
2457 if (TYPE_NOSIGN (parm
))
2459 if (TYPE_NOSIGN (arg
))
2462 return INTEGER_COERCION_BADNESS
;
2464 else if (TYPE_UNSIGNED (parm
))
2466 if (TYPE_UNSIGNED (arg
))
2469 return INTEGER_PROMOTION_BADNESS
;
2471 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2474 return INTEGER_COERCION_BADNESS
;
2476 return INCOMPATIBLE_TYPE_BADNESS
;
2479 case TYPE_CODE_RANGE
:
2480 switch (TYPE_CODE (arg
))
2483 case TYPE_CODE_CHAR
:
2484 case TYPE_CODE_RANGE
:
2485 case TYPE_CODE_BOOL
:
2486 case TYPE_CODE_ENUM
:
2487 return INTEGER_COERCION_BADNESS
;
2489 return INT_FLOAT_CONVERSION_BADNESS
;
2491 return INCOMPATIBLE_TYPE_BADNESS
;
2494 case TYPE_CODE_BOOL
:
2495 switch (TYPE_CODE (arg
))
2498 case TYPE_CODE_CHAR
:
2499 case TYPE_CODE_RANGE
:
2500 case TYPE_CODE_ENUM
:
2503 return BOOLEAN_CONVERSION_BADNESS
;
2504 case TYPE_CODE_BOOL
:
2507 return INCOMPATIBLE_TYPE_BADNESS
;
2511 switch (TYPE_CODE (arg
))
2514 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2515 return FLOAT_PROMOTION_BADNESS
;
2516 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2519 return FLOAT_CONVERSION_BADNESS
;
2521 case TYPE_CODE_BOOL
:
2522 case TYPE_CODE_ENUM
:
2523 case TYPE_CODE_RANGE
:
2524 case TYPE_CODE_CHAR
:
2525 return INT_FLOAT_CONVERSION_BADNESS
;
2527 return INCOMPATIBLE_TYPE_BADNESS
;
2530 case TYPE_CODE_COMPLEX
:
2531 switch (TYPE_CODE (arg
))
2532 { /* Strictly not needed for C++, but... */
2534 return FLOAT_PROMOTION_BADNESS
;
2535 case TYPE_CODE_COMPLEX
:
2538 return INCOMPATIBLE_TYPE_BADNESS
;
2541 case TYPE_CODE_STRUCT
:
2542 /* currently same as TYPE_CODE_CLASS */
2543 switch (TYPE_CODE (arg
))
2545 case TYPE_CODE_STRUCT
:
2546 /* Check for derivation */
2547 if (is_ancestor (parm
, arg
))
2548 return BASE_CONVERSION_BADNESS
;
2549 /* else fall through */
2551 return INCOMPATIBLE_TYPE_BADNESS
;
2554 case TYPE_CODE_UNION
:
2555 switch (TYPE_CODE (arg
))
2557 case TYPE_CODE_UNION
:
2559 return INCOMPATIBLE_TYPE_BADNESS
;
2562 case TYPE_CODE_MEMBER
:
2563 switch (TYPE_CODE (arg
))
2566 return INCOMPATIBLE_TYPE_BADNESS
;
2569 case TYPE_CODE_METHOD
:
2570 switch (TYPE_CODE (arg
))
2574 return INCOMPATIBLE_TYPE_BADNESS
;
2578 switch (TYPE_CODE (arg
))
2582 return INCOMPATIBLE_TYPE_BADNESS
;
2587 switch (TYPE_CODE (arg
))
2591 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0), TYPE_FIELD_TYPE (arg
, 0));
2593 return INCOMPATIBLE_TYPE_BADNESS
;
2596 case TYPE_CODE_VOID
:
2598 return INCOMPATIBLE_TYPE_BADNESS
;
2599 } /* switch (TYPE_CODE (arg)) */
2603 /* End of functions for overload resolution */
2606 print_bit_vector (B_TYPE
*bits
, int nbits
)
2610 for (bitno
= 0; bitno
< nbits
; bitno
++)
2612 if ((bitno
% 8) == 0)
2614 puts_filtered (" ");
2616 if (B_TST (bits
, bitno
))
2618 printf_filtered ("1");
2622 printf_filtered ("0");
2627 /* The args list is a strange beast. It is either terminated by a NULL
2628 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
2629 type for normal fixed argcount functions. (FIXME someday)
2630 Also note the first arg should be the "this" pointer, we may not want to
2631 include it since we may get into a infinitely recursive situation. */
2634 print_arg_types (struct type
**args
, int spaces
)
2638 while (*args
!= NULL
)
2640 recursive_dump_type (*args
, spaces
+ 2);
2641 if ((*args
++)->code
== TYPE_CODE_VOID
)
2650 dump_fn_fieldlists (struct type
*type
, int spaces
)
2656 printfi_filtered (spaces
, "fn_fieldlists ");
2657 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2658 printf_filtered ("\n");
2659 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2661 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2662 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2664 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2665 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2667 printf_filtered (") length %d\n",
2668 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2669 for (overload_idx
= 0;
2670 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2673 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2675 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2676 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2678 printf_filtered (")\n");
2679 printfi_filtered (spaces
+ 8, "type ");
2680 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
2681 printf_filtered ("\n");
2683 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2686 printfi_filtered (spaces
+ 8, "args ");
2687 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
2688 printf_filtered ("\n");
2690 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
), spaces
);
2691 printfi_filtered (spaces
+ 8, "fcontext ");
2692 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2694 printf_filtered ("\n");
2696 printfi_filtered (spaces
+ 8, "is_const %d\n",
2697 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2698 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2699 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2700 printfi_filtered (spaces
+ 8, "is_private %d\n",
2701 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2702 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2703 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2704 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2705 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2706 printfi_filtered (spaces
+ 8, "voffset %u\n",
2707 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2713 print_cplus_stuff (struct type
*type
, int spaces
)
2715 printfi_filtered (spaces
, "n_baseclasses %d\n",
2716 TYPE_N_BASECLASSES (type
));
2717 printfi_filtered (spaces
, "nfn_fields %d\n",
2718 TYPE_NFN_FIELDS (type
));
2719 printfi_filtered (spaces
, "nfn_fields_total %d\n",
2720 TYPE_NFN_FIELDS_TOTAL (type
));
2721 if (TYPE_N_BASECLASSES (type
) > 0)
2723 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2724 TYPE_N_BASECLASSES (type
));
2725 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
2726 printf_filtered (")");
2728 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2729 TYPE_N_BASECLASSES (type
));
2730 puts_filtered ("\n");
2732 if (TYPE_NFIELDS (type
) > 0)
2734 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2736 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
2737 TYPE_NFIELDS (type
));
2738 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
2739 printf_filtered (")");
2740 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2741 TYPE_NFIELDS (type
));
2742 puts_filtered ("\n");
2744 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2746 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
2747 TYPE_NFIELDS (type
));
2748 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
2749 printf_filtered (")");
2750 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2751 TYPE_NFIELDS (type
));
2752 puts_filtered ("\n");
2755 if (TYPE_NFN_FIELDS (type
) > 0)
2757 dump_fn_fieldlists (type
, spaces
);
2762 print_bound_type (int bt
)
2766 case BOUND_CANNOT_BE_DETERMINED
:
2767 printf_filtered ("(BOUND_CANNOT_BE_DETERMINED)");
2769 case BOUND_BY_REF_ON_STACK
:
2770 printf_filtered ("(BOUND_BY_REF_ON_STACK)");
2772 case BOUND_BY_VALUE_ON_STACK
:
2773 printf_filtered ("(BOUND_BY_VALUE_ON_STACK)");
2775 case BOUND_BY_REF_IN_REG
:
2776 printf_filtered ("(BOUND_BY_REF_IN_REG)");
2778 case BOUND_BY_VALUE_IN_REG
:
2779 printf_filtered ("(BOUND_BY_VALUE_IN_REG)");
2782 printf_filtered ("(BOUND_SIMPLE)");
2785 printf_filtered ("(unknown bound type)");
2790 static struct obstack dont_print_type_obstack
;
2793 recursive_dump_type (struct type
*type
, int spaces
)
2798 obstack_begin (&dont_print_type_obstack
, 0);
2800 if (TYPE_NFIELDS (type
) > 0
2801 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
2803 struct type
**first_dont_print
2804 = (struct type
**) obstack_base (&dont_print_type_obstack
);
2806 int i
= (struct type
**) obstack_next_free (&dont_print_type_obstack
)
2811 if (type
== first_dont_print
[i
])
2813 printfi_filtered (spaces
, "type node ");
2814 gdb_print_host_address (type
, gdb_stdout
);
2815 printf_filtered (" <same as already seen type>\n");
2820 obstack_ptr_grow (&dont_print_type_obstack
, type
);
2823 printfi_filtered (spaces
, "type node ");
2824 gdb_print_host_address (type
, gdb_stdout
);
2825 printf_filtered ("\n");
2826 printfi_filtered (spaces
, "name '%s' (",
2827 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
2828 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
2829 printf_filtered (")\n");
2830 printfi_filtered (spaces
, "tagname '%s' (",
2831 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
2832 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
2833 printf_filtered (")\n");
2834 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
2835 switch (TYPE_CODE (type
))
2837 case TYPE_CODE_UNDEF
:
2838 printf_filtered ("(TYPE_CODE_UNDEF)");
2841 printf_filtered ("(TYPE_CODE_PTR)");
2843 case TYPE_CODE_ARRAY
:
2844 printf_filtered ("(TYPE_CODE_ARRAY)");
2846 case TYPE_CODE_STRUCT
:
2847 printf_filtered ("(TYPE_CODE_STRUCT)");
2849 case TYPE_CODE_UNION
:
2850 printf_filtered ("(TYPE_CODE_UNION)");
2852 case TYPE_CODE_ENUM
:
2853 printf_filtered ("(TYPE_CODE_ENUM)");
2855 case TYPE_CODE_FUNC
:
2856 printf_filtered ("(TYPE_CODE_FUNC)");
2859 printf_filtered ("(TYPE_CODE_INT)");
2862 printf_filtered ("(TYPE_CODE_FLT)");
2864 case TYPE_CODE_VOID
:
2865 printf_filtered ("(TYPE_CODE_VOID)");
2868 printf_filtered ("(TYPE_CODE_SET)");
2870 case TYPE_CODE_RANGE
:
2871 printf_filtered ("(TYPE_CODE_RANGE)");
2873 case TYPE_CODE_STRING
:
2874 printf_filtered ("(TYPE_CODE_STRING)");
2876 case TYPE_CODE_BITSTRING
:
2877 printf_filtered ("(TYPE_CODE_BITSTRING)");
2879 case TYPE_CODE_ERROR
:
2880 printf_filtered ("(TYPE_CODE_ERROR)");
2882 case TYPE_CODE_MEMBER
:
2883 printf_filtered ("(TYPE_CODE_MEMBER)");
2885 case TYPE_CODE_METHOD
:
2886 printf_filtered ("(TYPE_CODE_METHOD)");
2889 printf_filtered ("(TYPE_CODE_REF)");
2891 case TYPE_CODE_CHAR
:
2892 printf_filtered ("(TYPE_CODE_CHAR)");
2894 case TYPE_CODE_BOOL
:
2895 printf_filtered ("(TYPE_CODE_BOOL)");
2897 case TYPE_CODE_COMPLEX
:
2898 printf_filtered ("(TYPE_CODE_COMPLEX)");
2900 case TYPE_CODE_TYPEDEF
:
2901 printf_filtered ("(TYPE_CODE_TYPEDEF)");
2903 case TYPE_CODE_TEMPLATE
:
2904 printf_filtered ("(TYPE_CODE_TEMPLATE)");
2906 case TYPE_CODE_TEMPLATE_ARG
:
2907 printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)");
2910 printf_filtered ("(UNKNOWN TYPE CODE)");
2913 puts_filtered ("\n");
2914 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
2915 printfi_filtered (spaces
, "upper_bound_type 0x%x ",
2916 TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
2917 print_bound_type (TYPE_ARRAY_UPPER_BOUND_TYPE (type
));
2918 puts_filtered ("\n");
2919 printfi_filtered (spaces
, "lower_bound_type 0x%x ",
2920 TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
2921 print_bound_type (TYPE_ARRAY_LOWER_BOUND_TYPE (type
));
2922 puts_filtered ("\n");
2923 printfi_filtered (spaces
, "objfile ");
2924 gdb_print_host_address (TYPE_OBJFILE (type
), gdb_stdout
);
2925 printf_filtered ("\n");
2926 printfi_filtered (spaces
, "target_type ");
2927 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
2928 printf_filtered ("\n");
2929 if (TYPE_TARGET_TYPE (type
) != NULL
)
2931 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
2933 printfi_filtered (spaces
, "pointer_type ");
2934 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
2935 printf_filtered ("\n");
2936 printfi_filtered (spaces
, "reference_type ");
2937 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
2938 printf_filtered ("\n");
2939 printfi_filtered (spaces
, "cv_type ");
2940 gdb_print_host_address (TYPE_CV_TYPE (type
), gdb_stdout
);
2941 printf_filtered ("\n");
2942 printfi_filtered (spaces
, "as_type ");
2943 gdb_print_host_address (TYPE_AS_TYPE (type
), gdb_stdout
);
2944 printf_filtered ("\n");
2945 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
2946 if (TYPE_UNSIGNED (type
))
2948 puts_filtered (" TYPE_FLAG_UNSIGNED");
2950 if (TYPE_NOSIGN (type
))
2952 puts_filtered (" TYPE_FLAG_NOSIGN");
2954 if (TYPE_STUB (type
))
2956 puts_filtered (" TYPE_FLAG_STUB");
2958 if (TYPE_TARGET_STUB (type
))
2960 puts_filtered (" TYPE_FLAG_TARGET_STUB");
2962 if (TYPE_STATIC (type
))
2964 puts_filtered (" TYPE_FLAG_STATIC");
2966 if (TYPE_CONST (type
))
2968 puts_filtered (" TYPE_FLAG_CONST");
2970 if (TYPE_VOLATILE (type
))
2972 puts_filtered (" TYPE_FLAG_VOLATILE");
2974 if (TYPE_PROTOTYPED (type
))
2976 puts_filtered (" TYPE_FLAG_PROTOTYPED");
2978 if (TYPE_INCOMPLETE (type
))
2980 puts_filtered (" TYPE_FLAG_INCOMPLETE");
2982 if (TYPE_CODE_SPACE (type
))
2984 puts_filtered (" TYPE_FLAG_CODE_SPACE");
2986 if (TYPE_DATA_SPACE (type
))
2988 puts_filtered (" TYPE_FLAG_DATA_SPACE");
2990 if (TYPE_VARARGS (type
))
2992 puts_filtered (" TYPE_FLAG_VARARGS");
2994 puts_filtered ("\n");
2995 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
2996 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
2997 puts_filtered ("\n");
2998 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
3000 printfi_filtered (spaces
+ 2,
3001 "[%d] bitpos %d bitsize %d type ",
3002 idx
, TYPE_FIELD_BITPOS (type
, idx
),
3003 TYPE_FIELD_BITSIZE (type
, idx
));
3004 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
3005 printf_filtered (" name '%s' (",
3006 TYPE_FIELD_NAME (type
, idx
) != NULL
3007 ? TYPE_FIELD_NAME (type
, idx
)
3009 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
3010 printf_filtered (")\n");
3011 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
3013 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
3016 printfi_filtered (spaces
, "vptr_basetype ");
3017 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
3018 puts_filtered ("\n");
3019 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
3021 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
3023 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
3024 switch (TYPE_CODE (type
))
3026 case TYPE_CODE_METHOD
:
3027 case TYPE_CODE_FUNC
:
3028 printfi_filtered (spaces
, "arg_types ");
3029 gdb_print_host_address (TYPE_ARG_TYPES (type
), gdb_stdout
);
3030 puts_filtered ("\n");
3031 print_arg_types (TYPE_ARG_TYPES (type
), spaces
);
3034 case TYPE_CODE_STRUCT
:
3035 printfi_filtered (spaces
, "cplus_stuff ");
3036 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
3037 puts_filtered ("\n");
3038 print_cplus_stuff (type
, spaces
);
3042 printfi_filtered (spaces
, "floatformat ");
3043 if (TYPE_FLOATFORMAT (type
) == NULL
3044 || TYPE_FLOATFORMAT (type
)->name
== NULL
)
3045 puts_filtered ("(null)");
3047 puts_filtered (TYPE_FLOATFORMAT (type
)->name
);
3048 puts_filtered ("\n");
3052 /* We have to pick one of the union types to be able print and test
3053 the value. Pick cplus_struct_type, even though we know it isn't
3054 any particular one. */
3055 printfi_filtered (spaces
, "type_specific ");
3056 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
3057 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
3059 printf_filtered (" (unknown data form)");
3061 printf_filtered ("\n");
3066 obstack_free (&dont_print_type_obstack
, NULL
);
3069 static void build_gdbtypes (void);
3071 build_gdbtypes (void)
3074 init_type (TYPE_CODE_VOID
, 1,
3076 "void", (struct objfile
*) NULL
);
3078 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3080 | (TARGET_CHAR_SIGNED
? 0 : TYPE_FLAG_UNSIGNED
)),
3081 "char", (struct objfile
*) NULL
);
3082 builtin_type_true_char
=
3083 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3085 "true character", (struct objfile
*) NULL
);
3086 builtin_type_signed_char
=
3087 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3089 "signed char", (struct objfile
*) NULL
);
3090 builtin_type_unsigned_char
=
3091 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3093 "unsigned char", (struct objfile
*) NULL
);
3094 builtin_type_short
=
3095 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
3097 "short", (struct objfile
*) NULL
);
3098 builtin_type_unsigned_short
=
3099 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
3101 "unsigned short", (struct objfile
*) NULL
);
3103 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3105 "int", (struct objfile
*) NULL
);
3106 builtin_type_unsigned_int
=
3107 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3109 "unsigned int", (struct objfile
*) NULL
);
3111 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
3113 "long", (struct objfile
*) NULL
);
3114 builtin_type_unsigned_long
=
3115 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
3117 "unsigned long", (struct objfile
*) NULL
);
3118 builtin_type_long_long
=
3119 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
3121 "long long", (struct objfile
*) NULL
);
3122 builtin_type_unsigned_long_long
=
3123 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
3125 "unsigned long long", (struct objfile
*) NULL
);
3126 builtin_type_float
=
3127 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
3129 "float", (struct objfile
*) NULL
);
3130 TYPE_FLOATFORMAT (builtin_type_float
) = TARGET_FLOAT_FORMAT
;
3131 builtin_type_double
=
3132 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3134 "double", (struct objfile
*) NULL
);
3135 TYPE_FLOATFORMAT (builtin_type_double
) = TARGET_DOUBLE_FORMAT
;
3136 builtin_type_long_double
=
3137 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3139 "long double", (struct objfile
*) NULL
);
3140 TYPE_FLOATFORMAT (builtin_type_long_double
) = TARGET_LONG_DOUBLE_FORMAT
;
3141 builtin_type_complex
=
3142 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
3144 "complex", (struct objfile
*) NULL
);
3145 TYPE_TARGET_TYPE (builtin_type_complex
) = builtin_type_float
;
3146 builtin_type_double_complex
=
3147 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3149 "double complex", (struct objfile
*) NULL
);
3150 TYPE_TARGET_TYPE (builtin_type_double_complex
) = builtin_type_double
;
3151 builtin_type_string
=
3152 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3154 "string", (struct objfile
*) NULL
);
3156 init_type (TYPE_CODE_INT
, 8 / 8,
3158 "int8_t", (struct objfile
*) NULL
);
3159 builtin_type_uint8
=
3160 init_type (TYPE_CODE_INT
, 8 / 8,
3162 "uint8_t", (struct objfile
*) NULL
);
3163 builtin_type_int16
=
3164 init_type (TYPE_CODE_INT
, 16 / 8,
3166 "int16_t", (struct objfile
*) NULL
);
3167 builtin_type_uint16
=
3168 init_type (TYPE_CODE_INT
, 16 / 8,
3170 "uint16_t", (struct objfile
*) NULL
);
3171 builtin_type_int32
=
3172 init_type (TYPE_CODE_INT
, 32 / 8,
3174 "int32_t", (struct objfile
*) NULL
);
3175 builtin_type_uint32
=
3176 init_type (TYPE_CODE_INT
, 32 / 8,
3178 "uint32_t", (struct objfile
*) NULL
);
3179 builtin_type_int64
=
3180 init_type (TYPE_CODE_INT
, 64 / 8,
3182 "int64_t", (struct objfile
*) NULL
);
3183 builtin_type_uint64
=
3184 init_type (TYPE_CODE_INT
, 64 / 8,
3186 "uint64_t", (struct objfile
*) NULL
);
3187 builtin_type_int128
=
3188 init_type (TYPE_CODE_INT
, 128 / 8,
3190 "int128_t", (struct objfile
*) NULL
);
3191 builtin_type_uint128
=
3192 init_type (TYPE_CODE_INT
, 128 / 8,
3194 "uint128_t", (struct objfile
*) NULL
);
3196 init_type (TYPE_CODE_BOOL
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3198 "bool", (struct objfile
*) NULL
);
3200 /* Add user knob for controlling resolution of opaque types */
3202 (add_set_cmd ("opaque-type-resolution", class_support
, var_boolean
, (char *) &opaque_type_resolution
,
3203 "Set resolution of opaque struct/class/union types (if set before loading symbols).",
3206 opaque_type_resolution
= 1;
3208 /* Build SIMD types. */
3210 = init_simd_type ("__builtin_v4sf", builtin_type_float
, "f", 4);
3212 = init_simd_type ("__builtin_v4si", builtin_type_int32
, "f", 4);
3214 = init_simd_type ("__builtin_v16qi", builtin_type_int8
, "f", 16);
3216 = init_simd_type ("__builtin_v8qi", builtin_type_int8
, "f", 8);
3218 = init_simd_type ("__builtin_v8hi", builtin_type_int16
, "f", 8);
3220 = init_simd_type ("__builtin_v4hi", builtin_type_int16
, "f", 4);
3222 = init_simd_type ("__builtin_v2si", builtin_type_int32
, "f", 2);
3226 = build_builtin_type_vec128 ();
3228 /* Pointer/Address types. */
3230 /* NOTE: on some targets, addresses and pointers are not necessarily
3231 the same --- for example, on the D10V, pointers are 16 bits long,
3232 but addresses are 32 bits long. See doc/gdbint.texinfo,
3233 ``Pointers Are Not Always Addresses''.
3236 - gdb's `struct type' always describes the target's
3238 - gdb's `struct value' objects should always hold values in
3240 - gdb's CORE_ADDR values are addresses in the unified virtual
3241 address space that the assembler and linker work with. Thus,
3242 since target_read_memory takes a CORE_ADDR as an argument, it
3243 can access any memory on the target, even if the processor has
3244 separate code and data address spaces.
3247 - If v is a value holding a D10V code pointer, its contents are
3248 in target form: a big-endian address left-shifted two bits.
3249 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3250 sizeof (void *) == 2 on the target.
3252 In this context, builtin_type_CORE_ADDR is a bit odd: it's a
3253 target type for a value the target will never see. It's only
3254 used to hold the values of (typeless) linker symbols, which are
3255 indeed in the unified virtual address space. */
3256 builtin_type_void_data_ptr
= make_pointer_type (builtin_type_void
, NULL
);
3257 builtin_type_void_func_ptr
3258 = lookup_pointer_type (lookup_function_type (builtin_type_void
));
3259 builtin_type_CORE_ADDR
=
3260 init_type (TYPE_CODE_INT
, TARGET_ADDR_BIT
/ 8,
3262 "__CORE_ADDR", (struct objfile
*) NULL
);
3263 builtin_type_bfd_vma
=
3264 init_type (TYPE_CODE_INT
, TARGET_BFD_VMA_BIT
/ 8,
3266 "__bfd_vma", (struct objfile
*) NULL
);
3270 extern void _initialize_gdbtypes (void);
3272 _initialize_gdbtypes (void)
3274 struct cmd_list_element
*c
;
3277 /* FIXME - For the moment, handle types by swapping them in and out.
3278 Should be using the per-architecture data-pointer and a large
3280 register_gdbarch_swap (&builtin_type_void
, sizeof (struct type
*), NULL
);
3281 register_gdbarch_swap (&builtin_type_char
, sizeof (struct type
*), NULL
);
3282 register_gdbarch_swap (&builtin_type_short
, sizeof (struct type
*), NULL
);
3283 register_gdbarch_swap (&builtin_type_int
, sizeof (struct type
*), NULL
);
3284 register_gdbarch_swap (&builtin_type_long
, sizeof (struct type
*), NULL
);
3285 register_gdbarch_swap (&builtin_type_long_long
, sizeof (struct type
*), NULL
);
3286 register_gdbarch_swap (&builtin_type_signed_char
, sizeof (struct type
*), NULL
);
3287 register_gdbarch_swap (&builtin_type_unsigned_char
, sizeof (struct type
*), NULL
);
3288 register_gdbarch_swap (&builtin_type_unsigned_short
, sizeof (struct type
*), NULL
);
3289 register_gdbarch_swap (&builtin_type_unsigned_int
, sizeof (struct type
*), NULL
);
3290 register_gdbarch_swap (&builtin_type_unsigned_long
, sizeof (struct type
*), NULL
);
3291 register_gdbarch_swap (&builtin_type_unsigned_long_long
, sizeof (struct type
*), NULL
);
3292 register_gdbarch_swap (&builtin_type_float
, sizeof (struct type
*), NULL
);
3293 register_gdbarch_swap (&builtin_type_double
, sizeof (struct type
*), NULL
);
3294 register_gdbarch_swap (&builtin_type_long_double
, sizeof (struct type
*), NULL
);
3295 register_gdbarch_swap (&builtin_type_complex
, sizeof (struct type
*), NULL
);
3296 register_gdbarch_swap (&builtin_type_double_complex
, sizeof (struct type
*), NULL
);
3297 register_gdbarch_swap (&builtin_type_string
, sizeof (struct type
*), NULL
);
3298 register_gdbarch_swap (&builtin_type_int8
, sizeof (struct type
*), NULL
);
3299 register_gdbarch_swap (&builtin_type_uint8
, sizeof (struct type
*), NULL
);
3300 register_gdbarch_swap (&builtin_type_int16
, sizeof (struct type
*), NULL
);
3301 register_gdbarch_swap (&builtin_type_uint16
, sizeof (struct type
*), NULL
);
3302 register_gdbarch_swap (&builtin_type_int32
, sizeof (struct type
*), NULL
);
3303 register_gdbarch_swap (&builtin_type_uint32
, sizeof (struct type
*), NULL
);
3304 register_gdbarch_swap (&builtin_type_int64
, sizeof (struct type
*), NULL
);
3305 register_gdbarch_swap (&builtin_type_uint64
, sizeof (struct type
*), NULL
);
3306 register_gdbarch_swap (&builtin_type_int128
, sizeof (struct type
*), NULL
);
3307 register_gdbarch_swap (&builtin_type_uint128
, sizeof (struct type
*), NULL
);
3308 register_gdbarch_swap (&builtin_type_v4sf
, sizeof (struct type
*), NULL
);
3309 register_gdbarch_swap (&builtin_type_v4si
, sizeof (struct type
*), NULL
);
3310 register_gdbarch_swap (&builtin_type_v16qi
, sizeof (struct type
*), NULL
);
3311 register_gdbarch_swap (&builtin_type_v8qi
, sizeof (struct type
*), NULL
);
3312 register_gdbarch_swap (&builtin_type_v8hi
, sizeof (struct type
*), NULL
);
3313 register_gdbarch_swap (&builtin_type_v4hi
, sizeof (struct type
*), NULL
);
3314 register_gdbarch_swap (&builtin_type_v2si
, sizeof (struct type
*), NULL
);
3315 register_gdbarch_swap (&builtin_type_vec128
, sizeof (struct type
*), NULL
);
3316 REGISTER_GDBARCH_SWAP (builtin_type_void_data_ptr
);
3317 REGISTER_GDBARCH_SWAP (builtin_type_void_func_ptr
);
3318 REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR
);
3319 REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma
);
3320 register_gdbarch_swap (NULL
, 0, build_gdbtypes
);
3322 /* Note: These types do not need to be swapped - they are target
3324 builtin_type_ieee_single_big
=
3325 init_type (TYPE_CODE_FLT
, floatformat_ieee_single_big
.totalsize
/ 8,
3326 0, "builtin_type_ieee_single_big", NULL
);
3327 TYPE_FLOATFORMAT (builtin_type_ieee_single_big
) = &floatformat_ieee_single_big
;
3328 builtin_type_ieee_single_little
=
3329 init_type (TYPE_CODE_FLT
, floatformat_ieee_single_little
.totalsize
/ 8,
3330 0, "builtin_type_ieee_single_little", NULL
);
3331 builtin_type_ieee_double_big
=
3332 init_type (TYPE_CODE_FLT
, floatformat_ieee_double_big
.totalsize
/ 8,
3333 0, "builtin_type_ieee_double_big", NULL
);
3334 builtin_type_ieee_double_little
=
3335 init_type (TYPE_CODE_FLT
, floatformat_ieee_double_little
.totalsize
/ 8,
3336 0, "builtin_type_ieee_double_little", NULL
);
3337 builtin_type_ieee_double_littlebyte_bigword
=
3338 init_type (TYPE_CODE_FLT
, floatformat_ieee_double_littlebyte_bigword
.totalsize
/ 8,
3339 0, "builtin_type_ieee_double_littlebyte_bigword", NULL
);
3340 builtin_type_i387_ext
=
3341 init_type (TYPE_CODE_FLT
, floatformat_i387_ext
.totalsize
/ 8,
3342 0, "builtin_type_i387_ext", NULL
);
3343 TYPE_FLOATFORMAT (builtin_type_i387_ext
) = &floatformat_i387_ext
;
3344 builtin_type_m68881_ext
=
3345 init_type (TYPE_CODE_FLT
, floatformat_m68881_ext
.totalsize
/ 8,
3346 0, "builtin_type_m68881_ext", NULL
);
3347 builtin_type_i960_ext
=
3348 init_type (TYPE_CODE_FLT
, floatformat_i960_ext
.totalsize
/ 8,
3349 0, "builtin_type_i960_ext", NULL
);
3350 builtin_type_m88110_ext
=
3351 init_type (TYPE_CODE_FLT
, floatformat_m88110_ext
.totalsize
/ 8,
3352 0, "builtin_type_m88110_ext", NULL
);
3353 builtin_type_m88110_harris_ext
=
3354 init_type (TYPE_CODE_FLT
, floatformat_m88110_harris_ext
.totalsize
/ 8,
3355 0, "builtin_type_m88110_harris_ext", NULL
);
3356 builtin_type_arm_ext_big
=
3357 init_type (TYPE_CODE_FLT
, floatformat_arm_ext_big
.totalsize
/ 8,
3358 0, "builtin_type_arm_ext_big", NULL
);
3359 builtin_type_arm_ext_littlebyte_bigword
=
3360 init_type (TYPE_CODE_FLT
, floatformat_arm_ext_littlebyte_bigword
.totalsize
/ 8,
3361 0, "builtin_type_arm_ext_littlebyte_bigword", NULL
);
3362 builtin_type_ia64_spill_big
=
3363 init_type (TYPE_CODE_FLT
, floatformat_ia64_spill_big
.totalsize
/ 8,
3364 0, "builtin_type_ia64_spill_big", NULL
);
3365 builtin_type_ia64_spill_little
=
3366 init_type (TYPE_CODE_FLT
, floatformat_ia64_spill_little
.totalsize
/ 8,
3367 0, "builtin_type_ia64_spill_little", NULL
);
3368 builtin_type_ia64_quad_big
=
3369 init_type (TYPE_CODE_FLT
, floatformat_ia64_quad_big
.totalsize
/ 8,
3370 0, "builtin_type_ia64_quad_big", NULL
);
3371 builtin_type_ia64_quad_little
=
3372 init_type (TYPE_CODE_FLT
, floatformat_ia64_quad_little
.totalsize
/ 8,
3373 0, "builtin_type_ia64_quad_little", NULL
);
3376 add_set_cmd ("overload", no_class
, var_zinteger
, (char *) &overload_debug
,
3377 "Set debugging of C++ overloading.\n\
3378 When enabled, ranking of the functions\n\
3379 is displayed.", &setdebuglist
),