1 /* Support routines for manipulating internal types for GDB.
2 Copyright (C) 1992, 93, 94, 95, 96, 1998 Free Software Foundation, Inc.
3 Contributed by Cygnus Support, using pieces from other GDB modules.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 #include "gdb_string.h"
29 #include "expression.h"
34 #include "complaints.h"
38 /* These variables point to the objects
39 representing the predefined C data types. */
41 struct type
*builtin_type_void
;
42 struct type
*builtin_type_char
;
43 struct type
*builtin_type_true_char
;
44 struct type
*builtin_type_short
;
45 struct type
*builtin_type_int
;
46 struct type
*builtin_type_long
;
47 struct type
*builtin_type_long_long
;
48 struct type
*builtin_type_signed_char
;
49 struct type
*builtin_type_unsigned_char
;
50 struct type
*builtin_type_unsigned_short
;
51 struct type
*builtin_type_unsigned_int
;
52 struct type
*builtin_type_unsigned_long
;
53 struct type
*builtin_type_unsigned_long_long
;
54 struct type
*builtin_type_float
;
55 struct type
*builtin_type_double
;
56 struct type
*builtin_type_long_double
;
57 struct type
*builtin_type_complex
;
58 struct type
*builtin_type_double_complex
;
59 struct type
*builtin_type_string
;
60 struct type
*builtin_type_int8
;
61 struct type
*builtin_type_uint8
;
62 struct type
*builtin_type_int16
;
63 struct type
*builtin_type_uint16
;
64 struct type
*builtin_type_int32
;
65 struct type
*builtin_type_uint32
;
66 struct type
*builtin_type_int64
;
67 struct type
*builtin_type_uint64
;
68 struct type
*builtin_type_bool
;
69 struct type
*builtin_type_v4sf
;
70 struct type
*builtin_type_v4si
;
71 struct type
*builtin_type_v8qi
;
72 struct type
*builtin_type_v4hi
;
73 struct type
*builtin_type_v2si
;
74 struct type
*builtin_type_ptr
;
75 struct type
*builtin_type_CORE_ADDR
;
76 struct type
*builtin_type_bfd_vma
;
78 int opaque_type_resolution
= 1;
79 int overload_debug
= 0;
85 }; /* maximum extention is 128! FIXME */
87 static void add_name (struct extra
*, char *);
88 static void add_mangled_type (struct extra
*, struct type
*);
90 static void cfront_mangle_name (struct type
*, int, int);
92 static void print_bit_vector (B_TYPE
*, int);
93 static void print_arg_types (struct type
**, int);
94 static void dump_fn_fieldlists (struct type
*, int);
95 static void print_cplus_stuff (struct type
*, int);
96 static void virtual_base_list_aux (struct type
*dclass
);
99 /* Alloc a new type structure and fill it with some defaults. If
100 OBJFILE is non-NULL, then allocate the space for the type structure
101 in that objfile's type_obstack. */
105 struct objfile
*objfile
;
107 register struct type
*type
;
109 /* Alloc the structure and start off with all fields zeroed. */
113 type
= (struct type
*) xmalloc (sizeof (struct type
));
117 type
= (struct type
*) obstack_alloc (&objfile
->type_obstack
,
118 sizeof (struct type
));
119 OBJSTAT (objfile
, n_types
++);
121 memset ((char *) type
, 0, sizeof (struct type
));
123 /* Initialize the fields that might not be zero. */
125 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
126 TYPE_OBJFILE (type
) = objfile
;
127 TYPE_VPTR_FIELDNO (type
) = -1;
128 TYPE_CV_TYPE (type
) = type
; /* chain back to itself */
133 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
134 to a pointer to memory where the pointer type should be stored.
135 If *TYPEPTR is zero, update it to point to the pointer type we return.
136 We allocate new memory if needed. */
139 make_pointer_type (type
, typeptr
)
141 struct type
**typeptr
;
143 register struct type
*ntype
; /* New type */
144 struct objfile
*objfile
;
146 ntype
= TYPE_POINTER_TYPE (type
);
151 return ntype
; /* Don't care about alloc, and have new type. */
152 else if (*typeptr
== 0)
154 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
159 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
161 ntype
= alloc_type (TYPE_OBJFILE (type
));
166 /* We have storage, but need to reset it. */
169 objfile
= TYPE_OBJFILE (ntype
);
170 memset ((char *) ntype
, 0, sizeof (struct type
));
171 TYPE_OBJFILE (ntype
) = objfile
;
174 TYPE_TARGET_TYPE (ntype
) = type
;
175 TYPE_POINTER_TYPE (type
) = ntype
;
177 /* FIXME! Assume the machine has only one representation for pointers! */
179 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
180 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
182 /* Mark pointers as unsigned. The target converts between pointers
183 and addresses (CORE_ADDRs) using POINTER_TO_ADDRESS() and
184 ADDRESS_TO_POINTER(). */
185 TYPE_FLAGS (ntype
) |= TYPE_FLAG_UNSIGNED
;
187 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
188 TYPE_POINTER_TYPE (type
) = ntype
;
193 /* Given a type TYPE, return a type of pointers to that type.
194 May need to construct such a type if this is the first use. */
197 lookup_pointer_type (type
)
200 return make_pointer_type (type
, (struct type
**) 0);
203 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero, points
204 to a pointer to memory where the reference type should be stored.
205 If *TYPEPTR is zero, update it to point to the reference type we return.
206 We allocate new memory if needed. */
209 make_reference_type (type
, typeptr
)
211 struct type
**typeptr
;
213 register struct type
*ntype
; /* New type */
214 struct objfile
*objfile
;
216 ntype
= TYPE_REFERENCE_TYPE (type
);
221 return ntype
; /* Don't care about alloc, and have new type. */
222 else if (*typeptr
== 0)
224 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
229 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
231 ntype
= alloc_type (TYPE_OBJFILE (type
));
236 /* We have storage, but need to reset it. */
239 objfile
= TYPE_OBJFILE (ntype
);
240 memset ((char *) ntype
, 0, sizeof (struct type
));
241 TYPE_OBJFILE (ntype
) = objfile
;
244 TYPE_TARGET_TYPE (ntype
) = type
;
245 TYPE_REFERENCE_TYPE (type
) = ntype
;
247 /* FIXME! Assume the machine has only one representation for references,
248 and that it matches the (only) representation for pointers! */
250 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
251 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
253 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
254 TYPE_REFERENCE_TYPE (type
) = ntype
;
259 /* Same as above, but caller doesn't care about memory allocation details. */
262 lookup_reference_type (type
)
265 return make_reference_type (type
, (struct type
**) 0);
268 /* Lookup a function type that returns type TYPE. TYPEPTR, if nonzero, points
269 to a pointer to memory where the function type should be stored.
270 If *TYPEPTR is zero, update it to point to the function type we return.
271 We allocate new memory if needed. */
274 make_function_type (type
, typeptr
)
276 struct type
**typeptr
;
278 register struct type
*ntype
; /* New type */
279 struct objfile
*objfile
;
281 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
283 ntype
= alloc_type (TYPE_OBJFILE (type
));
288 /* We have storage, but need to reset it. */
291 objfile
= TYPE_OBJFILE (ntype
);
292 memset ((char *) ntype
, 0, sizeof (struct type
));
293 TYPE_OBJFILE (ntype
) = objfile
;
296 TYPE_TARGET_TYPE (ntype
) = type
;
298 TYPE_LENGTH (ntype
) = 1;
299 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
305 /* Given a type TYPE, return a type of functions that return that type.
306 May need to construct such a type if this is the first use. */
309 lookup_function_type (type
)
312 return make_function_type (type
, (struct type
**) 0);
316 /* Make a "c-v" variant of a type -- a type that is identical to the
317 one supplied except that it may have const or volatile attributes
318 CNST is a flag for setting the const attribute
319 VOLTL is a flag for setting the volatile attribute
320 TYPE is the base type whose variant we are creating.
321 TYPEPTR, if nonzero, points
322 to a pointer to memory where the reference type should be stored.
323 If *TYPEPTR is zero, update it to point to the reference type we return.
324 We allocate new memory if needed. */
327 make_cv_type (cnst
, voltl
, type
, typeptr
)
331 struct type
**typeptr
;
333 register struct type
*ntype
; /* New type */
334 register struct type
*tmp_type
= type
; /* tmp type */
335 struct objfile
*objfile
;
337 ntype
= TYPE_CV_TYPE (type
);
339 while (ntype
!= type
)
341 if ((TYPE_CONST (ntype
) == cnst
) &&
342 (TYPE_VOLATILE (ntype
) == voltl
))
346 else if (*typeptr
== 0)
348 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
353 ntype
= TYPE_CV_TYPE (ntype
);
356 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
358 ntype
= alloc_type (TYPE_OBJFILE (type
));
363 /* We have storage, but need to reset it. */
366 objfile
= TYPE_OBJFILE (ntype
);
367 /* memset ((char *) ntype, 0, sizeof (struct type)); */
368 TYPE_OBJFILE (ntype
) = objfile
;
371 /* Copy original type */
372 memcpy ((char *) ntype
, (char *) type
, sizeof (struct type
));
373 /* But zero out fields that shouldn't be copied */
374 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0; /* Need new pointer kind */
375 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0; /* Need new referene kind */
376 /* Note: TYPE_TARGET_TYPE can be left as is */
378 /* Set flags appropriately */
380 TYPE_FLAGS (ntype
) |= TYPE_FLAG_CONST
;
382 TYPE_FLAGS (ntype
) &= ~TYPE_FLAG_CONST
;
385 TYPE_FLAGS (ntype
) |= TYPE_FLAG_VOLATILE
;
387 TYPE_FLAGS (ntype
) &= ~TYPE_FLAG_VOLATILE
;
389 /* Fix the chain of cv variants */
390 TYPE_CV_TYPE (ntype
) = type
;
391 TYPE_CV_TYPE (tmp_type
) = ntype
;
399 /* Implement direct support for MEMBER_TYPE in GNU C++.
400 May need to construct such a type if this is the first use.
401 The TYPE is the type of the member. The DOMAIN is the type
402 of the aggregate that the member belongs to. */
405 lookup_member_type (type
, domain
)
409 register struct type
*mtype
;
411 mtype
= alloc_type (TYPE_OBJFILE (type
));
412 smash_to_member_type (mtype
, domain
, type
);
416 /* Allocate a stub method whose return type is TYPE.
417 This apparently happens for speed of symbol reading, since parsing
418 out the arguments to the method is cpu-intensive, the way we are doing
419 it. So, we will fill in arguments later.
420 This always returns a fresh type. */
423 allocate_stub_method (type
)
428 mtype
= alloc_type (TYPE_OBJFILE (type
));
429 TYPE_TARGET_TYPE (mtype
) = type
;
430 /* _DOMAIN_TYPE (mtype) = unknown yet */
431 /* _ARG_TYPES (mtype) = unknown yet */
432 TYPE_FLAGS (mtype
) = TYPE_FLAG_STUB
;
433 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
434 TYPE_LENGTH (mtype
) = 1;
438 /* Create a range type using either a blank type supplied in RESULT_TYPE,
439 or creating a new type, inheriting the objfile from INDEX_TYPE.
441 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
442 HIGH_BOUND, inclusive.
444 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
445 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
448 create_range_type (result_type
, index_type
, low_bound
, high_bound
)
449 struct type
*result_type
;
450 struct type
*index_type
;
454 if (result_type
== NULL
)
456 result_type
= alloc_type (TYPE_OBJFILE (index_type
));
458 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
459 TYPE_TARGET_TYPE (result_type
) = index_type
;
460 if (TYPE_FLAGS (index_type
) & TYPE_FLAG_STUB
)
461 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
463 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
464 TYPE_NFIELDS (result_type
) = 2;
465 TYPE_FIELDS (result_type
) = (struct field
*)
466 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
467 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
468 TYPE_FIELD_BITPOS (result_type
, 0) = low_bound
;
469 TYPE_FIELD_BITPOS (result_type
, 1) = high_bound
;
470 TYPE_FIELD_TYPE (result_type
, 0) = builtin_type_int
; /* FIXME */
471 TYPE_FIELD_TYPE (result_type
, 1) = builtin_type_int
; /* FIXME */
474 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
476 return (result_type
);
479 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE.
480 Return 1 of type is a range type, 0 if it is discrete (and bounds
481 will fit in LONGEST), or -1 otherwise. */
484 get_discrete_bounds (type
, lowp
, highp
)
486 LONGEST
*lowp
, *highp
;
488 CHECK_TYPEDEF (type
);
489 switch (TYPE_CODE (type
))
491 case TYPE_CODE_RANGE
:
492 *lowp
= TYPE_LOW_BOUND (type
);
493 *highp
= TYPE_HIGH_BOUND (type
);
496 if (TYPE_NFIELDS (type
) > 0)
498 /* The enums may not be sorted by value, so search all
502 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
503 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
505 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
506 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
507 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
508 *highp
= TYPE_FIELD_BITPOS (type
, i
);
511 /* Set unsigned indicator if warranted. */
514 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
528 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
530 if (!TYPE_UNSIGNED (type
))
532 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
536 /* ... fall through for unsigned ints ... */
539 /* This round-about calculation is to avoid shifting by
540 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
541 if TYPE_LENGTH (type) == sizeof (LONGEST). */
542 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
543 *highp
= (*highp
- 1) | *highp
;
550 /* Create an array type using either a blank type supplied in RESULT_TYPE,
551 or creating a new type, inheriting the objfile from RANGE_TYPE.
553 Elements will be of type ELEMENT_TYPE, the indices will be of type
556 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
557 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
560 create_array_type (result_type
, element_type
, range_type
)
561 struct type
*result_type
;
562 struct type
*element_type
;
563 struct type
*range_type
;
565 LONGEST low_bound
, high_bound
;
567 if (result_type
== NULL
)
569 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
571 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
572 TYPE_TARGET_TYPE (result_type
) = element_type
;
573 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
574 low_bound
= high_bound
= 0;
575 CHECK_TYPEDEF (element_type
);
576 TYPE_LENGTH (result_type
) =
577 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
578 TYPE_NFIELDS (result_type
) = 1;
579 TYPE_FIELDS (result_type
) =
580 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
581 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
582 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
583 TYPE_VPTR_FIELDNO (result_type
) = -1;
585 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
586 if (TYPE_LENGTH (result_type
) == 0)
587 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
589 return (result_type
);
592 /* Create a string type using either a blank type supplied in RESULT_TYPE,
593 or creating a new type. String types are similar enough to array of
594 char types that we can use create_array_type to build the basic type
595 and then bash it into a string type.
597 For fixed length strings, the range type contains 0 as the lower
598 bound and the length of the string minus one as the upper bound.
600 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
601 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
604 create_string_type (result_type
, range_type
)
605 struct type
*result_type
;
606 struct type
*range_type
;
608 result_type
= create_array_type (result_type
,
609 *current_language
->string_char_type
,
611 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
612 return (result_type
);
616 create_set_type (result_type
, domain_type
)
617 struct type
*result_type
;
618 struct type
*domain_type
;
620 LONGEST low_bound
, high_bound
, bit_length
;
621 if (result_type
== NULL
)
623 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
625 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
626 TYPE_NFIELDS (result_type
) = 1;
627 TYPE_FIELDS (result_type
) = (struct field
*)
628 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
629 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
631 if (!(TYPE_FLAGS (domain_type
) & TYPE_FLAG_STUB
))
633 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
634 low_bound
= high_bound
= 0;
635 bit_length
= high_bound
- low_bound
+ 1;
636 TYPE_LENGTH (result_type
)
637 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
639 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
642 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
644 return (result_type
);
648 /* Construct and return a type of the form:
649 struct NAME { ELT_TYPE ELT_NAME[N]; }
650 We use these types for SIMD registers. For example, the type of
651 the SSE registers on the late x86-family processors is:
652 struct __builtin_v4sf { float f[4]; }
653 built by the function call:
654 init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4)
655 The type returned is a permanent type, allocated using malloc; it
656 doesn't live in any objfile's obstack. */
658 init_simd_type (char *name
,
659 struct type
*elt_type
,
666 /* Build the field structure. */
667 f
= xmalloc (sizeof (*f
));
668 memset (f
, 0, sizeof (*f
));
670 f
->type
= create_array_type (0, elt_type
,
671 create_range_type (0, builtin_type_int
,
675 /* Build a struct type with that field. */
676 t
= init_type (TYPE_CODE_STRUCT
, n
* TYPE_LENGTH (elt_type
), 0, 0, 0);
685 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
686 A MEMBER is a wierd thing -- it amounts to a typed offset into
687 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
688 include the offset (that's the value of the MEMBER itself), but does
689 include the structure type into which it points (for some reason).
691 When "smashing" the type, we preserve the objfile that the
692 old type pointed to, since we aren't changing where the type is actually
696 smash_to_member_type (type
, domain
, to_type
)
699 struct type
*to_type
;
701 struct objfile
*objfile
;
703 objfile
= TYPE_OBJFILE (type
);
705 memset ((char *) type
, 0, sizeof (struct type
));
706 TYPE_OBJFILE (type
) = objfile
;
707 TYPE_TARGET_TYPE (type
) = to_type
;
708 TYPE_DOMAIN_TYPE (type
) = domain
;
709 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
710 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
713 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
714 METHOD just means `function that gets an extra "this" argument'.
716 When "smashing" the type, we preserve the objfile that the
717 old type pointed to, since we aren't changing where the type is actually
721 smash_to_method_type (type
, domain
, to_type
, args
)
724 struct type
*to_type
;
727 struct objfile
*objfile
;
729 objfile
= TYPE_OBJFILE (type
);
731 memset ((char *) type
, 0, sizeof (struct type
));
732 TYPE_OBJFILE (type
) = objfile
;
733 TYPE_TARGET_TYPE (type
) = to_type
;
734 TYPE_DOMAIN_TYPE (type
) = domain
;
735 TYPE_ARG_TYPES (type
) = args
;
736 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
737 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
740 /* Return a typename for a struct/union/enum type without "struct ",
741 "union ", or "enum ". If the type has a NULL name, return NULL. */
744 type_name_no_tag (type
)
745 register const struct type
*type
;
747 if (TYPE_TAG_NAME (type
) != NULL
)
748 return TYPE_TAG_NAME (type
);
750 /* Is there code which expects this to return the name if there is no
751 tag name? My guess is that this is mainly used for C++ in cases where
752 the two will always be the same. */
753 return TYPE_NAME (type
);
756 /* Lookup a primitive type named NAME.
757 Return zero if NAME is not a primitive type. */
760 lookup_primitive_typename (name
)
763 struct type
**const *p
;
765 for (p
= current_language
->la_builtin_type_vector
; *p
!= NULL
; p
++)
767 if (STREQ ((**p
)->name
, name
))
775 /* Lookup a typedef or primitive type named NAME,
776 visible in lexical block BLOCK.
777 If NOERR is nonzero, return zero if NAME is not suitably defined. */
780 lookup_typename (name
, block
, noerr
)
785 register struct symbol
*sym
;
786 register struct type
*tmp
;
788 sym
= lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
789 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
791 tmp
= lookup_primitive_typename (name
);
796 else if (!tmp
&& noerr
)
802 error ("No type named %s.", name
);
805 return (SYMBOL_TYPE (sym
));
809 lookup_unsigned_typename (name
)
812 char *uns
= alloca (strlen (name
) + 10);
814 strcpy (uns
, "unsigned ");
815 strcpy (uns
+ 9, name
);
816 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
820 lookup_signed_typename (name
)
824 char *uns
= alloca (strlen (name
) + 8);
826 strcpy (uns
, "signed ");
827 strcpy (uns
+ 7, name
);
828 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
829 /* If we don't find "signed FOO" just try again with plain "FOO". */
832 return lookup_typename (name
, (struct block
*) NULL
, 0);
835 /* Lookup a structure type named "struct NAME",
836 visible in lexical block BLOCK. */
839 lookup_struct (name
, block
)
843 register struct symbol
*sym
;
845 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
846 (struct symtab
**) NULL
);
850 error ("No struct type named %s.", name
);
852 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
854 error ("This context has class, union or enum %s, not a struct.", name
);
856 return (SYMBOL_TYPE (sym
));
859 /* Lookup a union type named "union NAME",
860 visible in lexical block BLOCK. */
863 lookup_union (name
, block
)
867 register struct symbol
*sym
;
870 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
871 (struct symtab
**) NULL
);
874 error ("No union type named %s.", name
);
876 t
= SYMBOL_TYPE (sym
);
878 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
881 /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
882 * a further "declared_type" field to discover it is really a union.
884 if (HAVE_CPLUS_STRUCT (t
))
885 if (TYPE_DECLARED_TYPE (t
) == DECLARED_TYPE_UNION
)
888 /* If we get here, it's not a union */
889 error ("This context has class, struct or enum %s, not a union.", name
);
893 /* Lookup an enum type named "enum NAME",
894 visible in lexical block BLOCK. */
897 lookup_enum (name
, block
)
901 register struct symbol
*sym
;
903 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
904 (struct symtab
**) NULL
);
907 error ("No enum type named %s.", name
);
909 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
911 error ("This context has class, struct or union %s, not an enum.", name
);
913 return (SYMBOL_TYPE (sym
));
916 /* Lookup a template type named "template NAME<TYPE>",
917 visible in lexical block BLOCK. */
920 lookup_template_type (name
, type
, block
)
926 char *nam
= (char *) alloca (strlen (name
) + strlen (type
->name
) + 4);
929 strcat (nam
, type
->name
);
930 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
932 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
936 error ("No template type named %s.", name
);
938 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
940 error ("This context has class, union or enum %s, not a struct.", name
);
942 return (SYMBOL_TYPE (sym
));
945 /* Given a type TYPE, lookup the type of the component of type named NAME.
947 TYPE can be either a struct or union, or a pointer or reference to a struct or
948 union. If it is a pointer or reference, its target type is automatically used.
949 Thus '.' and '->' are interchangable, as specified for the definitions of the
950 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
952 If NOERR is nonzero, return zero if NAME is not suitably defined.
953 If NAME is the name of a baseclass type, return that type. */
956 lookup_struct_elt_type (type
, name
, noerr
)
965 CHECK_TYPEDEF (type
);
966 if (TYPE_CODE (type
) != TYPE_CODE_PTR
967 && TYPE_CODE (type
) != TYPE_CODE_REF
)
969 type
= TYPE_TARGET_TYPE (type
);
972 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
973 TYPE_CODE (type
) != TYPE_CODE_UNION
)
975 target_terminal_ours ();
976 gdb_flush (gdb_stdout
);
977 fprintf_unfiltered (gdb_stderr
, "Type ");
978 type_print (type
, "", gdb_stderr
, -1);
979 error (" is not a structure or union type.");
983 /* FIXME: This change put in by Michael seems incorrect for the case where
984 the structure tag name is the same as the member name. I.E. when doing
985 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
990 typename
= type_name_no_tag (type
);
991 if (typename
!= NULL
&& STREQ (typename
, name
))
996 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
998 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1000 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1002 return TYPE_FIELD_TYPE (type
, i
);
1006 /* OK, it's not in this class. Recursively check the baseclasses. */
1007 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1011 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, noerr
);
1023 target_terminal_ours ();
1024 gdb_flush (gdb_stdout
);
1025 fprintf_unfiltered (gdb_stderr
, "Type ");
1026 type_print (type
, "", gdb_stderr
, -1);
1027 fprintf_unfiltered (gdb_stderr
, " has no component named ");
1028 fputs_filtered (name
, gdb_stderr
);
1030 return (struct type
*) -1; /* For lint */
1033 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
1034 valid. Callers should be aware that in some cases (for example,
1035 the type or one of its baseclasses is a stub type and we are
1036 debugging a .o file), this function will not be able to find the virtual
1037 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
1038 will remain NULL. */
1041 fill_in_vptr_fieldno (type
)
1044 CHECK_TYPEDEF (type
);
1046 if (TYPE_VPTR_FIELDNO (type
) < 0)
1050 /* We must start at zero in case the first (and only) baseclass is
1051 virtual (and hence we cannot share the table pointer). */
1052 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1054 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, i
));
1055 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
)) >= 0)
1057 TYPE_VPTR_FIELDNO (type
)
1058 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
));
1059 TYPE_VPTR_BASETYPE (type
)
1060 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type
, i
));
1067 /* Find the method and field indices for the destructor in class type T.
1068 Return 1 if the destructor was found, otherwise, return 0. */
1071 get_destructor_fn_field (t
, method_indexp
, field_indexp
)
1078 for (i
= 0; i
< TYPE_NFN_FIELDS (t
); i
++)
1081 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1083 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (t
, i
); j
++)
1085 if (DESTRUCTOR_PREFIX_P (TYPE_FN_FIELD_PHYSNAME (f
, j
)))
1096 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1098 If this is a stubbed struct (i.e. declared as struct foo *), see if
1099 we can find a full definition in some other file. If so, copy this
1100 definition, so we can use it in future. There used to be a comment (but
1101 not any code) that if we don't find a full definition, we'd set a flag
1102 so we don't spend time in the future checking the same type. That would
1103 be a mistake, though--we might load in more symbols which contain a
1104 full definition for the type.
1106 This used to be coded as a macro, but I don't think it is called
1107 often enough to merit such treatment. */
1109 struct complaint stub_noname_complaint
=
1110 {"stub type has NULL name", 0, 0};
1113 check_typedef (type
)
1114 register struct type
*type
;
1116 struct type
*orig_type
= type
;
1117 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1119 if (!TYPE_TARGET_TYPE (type
))
1124 /* It is dangerous to call lookup_symbol if we are currently
1125 reading a symtab. Infinite recursion is one danger. */
1126 if (currently_reading_symtab
)
1129 name
= type_name_no_tag (type
);
1130 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1131 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
1132 as appropriate? (this code was written before TYPE_NAME and
1133 TYPE_TAG_NAME were separate). */
1136 complain (&stub_noname_complaint
);
1139 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
1140 (struct symtab
**) NULL
);
1142 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1144 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
); /* TYPE_CODE_UNDEF */
1146 type
= TYPE_TARGET_TYPE (type
);
1149 /* If this is a struct/class/union with no fields, then check whether a
1150 full definition exists somewhere else. This is for systems where a
1151 type definition with no fields is issued for such types, instead of
1152 identifying them as stub types in the first place */
1154 if (TYPE_IS_OPAQUE (type
) && opaque_type_resolution
&& !currently_reading_symtab
)
1156 char *name
= type_name_no_tag (type
);
1157 struct type
*newtype
;
1160 complain (&stub_noname_complaint
);
1163 newtype
= lookup_transparent_type (name
);
1166 memcpy ((char *) type
, (char *) newtype
, sizeof (struct type
));
1169 /* Otherwise, rely on the stub flag being set for opaque/stubbed types */
1170 else if ((TYPE_FLAGS (type
) & TYPE_FLAG_STUB
) && !currently_reading_symtab
)
1172 char *name
= type_name_no_tag (type
);
1173 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1174 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
1175 as appropriate? (this code was written before TYPE_NAME and
1176 TYPE_TAG_NAME were separate). */
1180 complain (&stub_noname_complaint
);
1183 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0, (struct symtab
**) NULL
);
1186 memcpy ((char *) type
, (char *) SYMBOL_TYPE (sym
), sizeof (struct type
));
1190 if (TYPE_FLAGS (type
) & TYPE_FLAG_TARGET_STUB
)
1192 struct type
*range_type
;
1193 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1195 if (TYPE_FLAGS (target_type
) & (TYPE_FLAG_STUB
| TYPE_FLAG_TARGET_STUB
))
1198 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1199 && TYPE_NFIELDS (type
) == 1
1200 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
1201 == TYPE_CODE_RANGE
))
1203 /* Now recompute the length of the array type, based on its
1204 number of elements and the target type's length. */
1205 TYPE_LENGTH (type
) =
1206 ((TYPE_FIELD_BITPOS (range_type
, 1)
1207 - TYPE_FIELD_BITPOS (range_type
, 0)
1209 * TYPE_LENGTH (target_type
));
1210 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1212 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1214 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1215 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1218 /* Cache TYPE_LENGTH for future use. */
1219 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1223 /* New code added to support parsing of Cfront stabs strings */
1225 #define INIT_EXTRA { pextras->len=0; pextras->str[0]='\0'; }
1226 #define ADD_EXTRA(c) { pextras->str[pextras->len++]=c; }
1229 add_name (pextras
, n
)
1230 struct extra
*pextras
;
1235 if ((nlen
= (n
? strlen (n
) : 0)) == 0)
1237 sprintf (pextras
->str
+ pextras
->len
, "%d%s", nlen
, n
);
1238 pextras
->len
= strlen (pextras
->str
);
1242 add_mangled_type (pextras
, t
)
1243 struct extra
*pextras
;
1246 enum type_code tcode
;
1250 tcode
= TYPE_CODE (t
);
1251 tlen
= TYPE_LENGTH (t
);
1252 tflags
= TYPE_FLAGS (t
);
1253 tname
= TYPE_NAME (t
);
1254 /* args of "..." seem to get mangled as "e" */
1272 if ((pname
= strrchr (tname
, 'l'), pname
) && !strcmp (pname
, "long"))
1285 static struct complaint msg
=
1286 {"Bad int type code length x%x\n", 0, 0};
1288 complain (&msg
, tlen
);
1307 static struct complaint msg
=
1308 {"Bad float type code length x%x\n", 0, 0};
1309 complain (&msg
, tlen
);
1315 /* followed by what it's a ref to */
1319 /* followed by what it's a ptr to */
1321 case TYPE_CODE_TYPEDEF
:
1323 static struct complaint msg
=
1324 {"Typedefs in overloaded functions not yet supported\n", 0, 0};
1327 /* followed by type bytes & name */
1329 case TYPE_CODE_FUNC
:
1331 /* followed by func's arg '_' & ret types */
1333 case TYPE_CODE_VOID
:
1336 case TYPE_CODE_METHOD
:
1338 /* followed by name of class and func's arg '_' & ret types */
1339 add_name (pextras
, tname
);
1340 ADD_EXTRA ('F'); /* then mangle function */
1342 case TYPE_CODE_STRUCT
: /* C struct */
1343 case TYPE_CODE_UNION
: /* C union */
1344 case TYPE_CODE_ENUM
: /* Enumeration type */
1345 /* followed by name of type */
1346 add_name (pextras
, tname
);
1349 /* errors possible types/not supported */
1350 case TYPE_CODE_CHAR
:
1351 case TYPE_CODE_ARRAY
: /* Array type */
1352 case TYPE_CODE_MEMBER
: /* Member type */
1353 case TYPE_CODE_BOOL
:
1354 case TYPE_CODE_COMPLEX
: /* Complex float */
1355 case TYPE_CODE_UNDEF
:
1356 case TYPE_CODE_SET
: /* Pascal sets */
1357 case TYPE_CODE_RANGE
:
1358 case TYPE_CODE_STRING
:
1359 case TYPE_CODE_BITSTRING
:
1360 case TYPE_CODE_ERROR
:
1363 static struct complaint msg
=
1364 {"Unknown type code x%x\n", 0, 0};
1365 complain (&msg
, tcode
);
1369 add_mangled_type (pextras
, t
->target_type
);
1374 cfront_mangle_name (type
, i
, j
)
1380 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
1382 f
= TYPE_FN_FIELDLIST1 (type
, i
); /* moved from below */
1384 /* kludge to support cfront methods - gdb expects to find "F" for
1385 ARM_mangled names, so when we mangle, we have to add it here */
1389 char *arm_mangled_name
;
1390 struct fn_field
*method
= &f
[j
];
1391 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1392 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1393 char *newname
= type_name_no_tag (type
);
1395 struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
1396 int nargs
= TYPE_NFIELDS (ftype
); /* number of args */
1397 struct extra extras
, *pextras
= &extras
;
1400 if (TYPE_FN_FIELD_STATIC_P (f
, j
)) /* j for sublist within this list */
1403 /* add args here! */
1404 if (nargs
<= 1) /* no args besides this */
1408 for (k
= 1; k
< nargs
; k
++)
1411 t
= TYPE_FIELD_TYPE (ftype
, k
);
1412 add_mangled_type (pextras
, t
);
1416 printf ("add_mangled_type: %s\n", extras
.str
); /* FIXME */
1417 arm_mangled_name
= malloc (strlen (mangled_name
) + extras
.len
);
1418 sprintf (arm_mangled_name
, "%s%s", mangled_name
, extras
.str
);
1419 free (mangled_name
);
1420 mangled_name
= arm_mangled_name
;
1426 /* End of new code added to support parsing of Cfront stabs strings */
1428 /* Parse a type expression in the string [P..P+LENGTH). If an error occurs,
1429 silently return builtin_type_void. */
1432 safe_parse_type (char *p
, int length
)
1434 struct ui_file
*saved_gdb_stderr
;
1437 /* Suppress error messages. */
1438 saved_gdb_stderr
= gdb_stderr
;
1439 gdb_stderr
= ui_file_new ();
1441 /* Call parse_and_eval_type() without fear of longjmp()s. */
1442 if (!gdb_parse_and_eval_type (p
, length
, &type
))
1443 type
= builtin_type_void
;
1445 /* Stop suppressing error messages. */
1446 ui_file_delete (gdb_stderr
);
1447 gdb_stderr
= saved_gdb_stderr
;
1452 /* Ugly hack to convert method stubs into method types.
1454 He ain't kiddin'. This demangles the name of the method into a string
1455 including argument types, parses out each argument type, generates
1456 a string casting a zero to that type, evaluates the string, and stuffs
1457 the resulting type into an argtype vector!!! Then it knows the type
1458 of the whole function (including argument types for overloading),
1459 which info used to be in the stab's but was removed to hack back
1460 the space required for them. */
1463 check_stub_method (type
, method_id
, signature_id
)
1469 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1470 char *demangled_name
= cplus_demangle (mangled_name
,
1471 DMGL_PARAMS
| DMGL_ANSI
);
1472 char *argtypetext
, *p
;
1473 int depth
= 0, argcount
= 1;
1474 struct type
**argtypes
;
1477 /* Make sure we got back a function string that we can use. */
1479 p
= strchr (demangled_name
, '(');
1481 if (demangled_name
== NULL
|| p
== NULL
)
1482 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
1484 /* Now, read in the parameters that define this type. */
1489 if (*p
== '(' || *p
== '<')
1493 else if (*p
== ')' || *p
== '>')
1497 else if (*p
== ',' && depth
== 0)
1505 /* We need two more slots: one for the THIS pointer, and one for the
1506 NULL [...] or void [end of arglist]. */
1508 argtypes
= (struct type
**)
1509 TYPE_ALLOC (type
, (argcount
+ 2) * sizeof (struct type
*));
1511 /* FIXME: This is wrong for static member functions. */
1512 argtypes
[0] = lookup_pointer_type (type
);
1515 if (*p
!= ')') /* () means no args, skip while */
1520 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1522 /* Avoid parsing of ellipsis, they will be handled below. */
1523 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0)
1525 argtypes
[argcount
] =
1526 safe_parse_type (argtypetext
, p
- argtypetext
);
1529 argtypetext
= p
+ 1;
1532 if (*p
== '(' || *p
== '<')
1536 else if (*p
== ')' || *p
== '>')
1545 if (p
[-2] != '.') /* Not '...' */
1547 argtypes
[argcount
] = builtin_type_void
; /* List terminator */
1551 argtypes
[argcount
] = NULL
; /* Ellist terminator */
1554 free (demangled_name
);
1556 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1558 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1560 /* Now update the old "stub" type into a real type. */
1561 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1562 TYPE_DOMAIN_TYPE (mtype
) = type
;
1563 TYPE_ARG_TYPES (mtype
) = argtypes
;
1564 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1565 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1568 const struct cplus_struct_type cplus_struct_default
;
1571 allocate_cplus_struct_type (type
)
1574 if (!HAVE_CPLUS_STRUCT (type
))
1576 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1577 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1578 *(TYPE_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1582 /* Helper function to initialize the standard scalar types.
1584 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1585 of the string pointed to by name in the type_obstack for that objfile,
1586 and initialize the type name to that copy. There are places (mipsread.c
1587 in particular, where init_type is called with a NULL value for NAME). */
1590 init_type (code
, length
, flags
, name
, objfile
)
1591 enum type_code code
;
1595 struct objfile
*objfile
;
1597 register struct type
*type
;
1599 type
= alloc_type (objfile
);
1600 TYPE_CODE (type
) = code
;
1601 TYPE_LENGTH (type
) = length
;
1602 TYPE_FLAGS (type
) |= flags
;
1603 if ((name
!= NULL
) && (objfile
!= NULL
))
1606 obsavestring (name
, strlen (name
), &objfile
->type_obstack
);
1610 TYPE_NAME (type
) = name
;
1615 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
1617 INIT_CPLUS_SPECIFIC (type
);
1622 /* Look up a fundamental type for the specified objfile.
1623 May need to construct such a type if this is the first use.
1625 Some object file formats (ELF, COFF, etc) do not define fundamental
1626 types such as "int" or "double". Others (stabs for example), do
1627 define fundamental types.
1629 For the formats which don't provide fundamental types, gdb can create
1630 such types, using defaults reasonable for the current language and
1631 the current target machine.
1633 NOTE: This routine is obsolescent. Each debugging format reader
1634 should manage it's own fundamental types, either creating them from
1635 suitable defaults or reading them from the debugging information,
1636 whichever is appropriate. The DWARF reader has already been
1637 fixed to do this. Once the other readers are fixed, this routine
1638 will go away. Also note that fundamental types should be managed
1639 on a compilation unit basis in a multi-language environment, not
1640 on a linkage unit basis as is done here. */
1644 lookup_fundamental_type (objfile
, typeid)
1645 struct objfile
*objfile
;
1648 register struct type
**typep
;
1649 register int nbytes
;
1651 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1653 error ("internal error - invalid fundamental type id %d", typeid);
1656 /* If this is the first time we need a fundamental type for this objfile
1657 then we need to initialize the vector of type pointers. */
1659 if (objfile
->fundamental_types
== NULL
)
1661 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1662 objfile
->fundamental_types
= (struct type
**)
1663 obstack_alloc (&objfile
->type_obstack
, nbytes
);
1664 memset ((char *) objfile
->fundamental_types
, 0, nbytes
);
1665 OBJSTAT (objfile
, n_types
+= FT_NUM_MEMBERS
);
1668 /* Look for this particular type in the fundamental type vector. If one is
1669 not found, create and install one appropriate for the current language. */
1671 typep
= objfile
->fundamental_types
+ typeid;
1674 *typep
= create_fundamental_type (objfile
, typeid);
1684 /* FIXME: Should we return true for references as well as pointers? */
1688 && TYPE_CODE (t
) == TYPE_CODE_PTR
1689 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1693 is_integral_type (t
)
1699 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
1700 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
1701 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
1702 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
1703 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
1706 /* Chill varying string and arrays are represented as follows:
1708 struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
1710 Return true if TYPE is such a Chill varying type. */
1713 chill_varying_type (type
)
1716 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1717 || TYPE_NFIELDS (type
) != 2
1718 || strcmp (TYPE_FIELD_NAME (type
, 0), "__var_length") != 0)
1723 /* Check whether BASE is an ancestor or base class or DCLASS
1724 Return 1 if so, and 0 if not.
1725 Note: callers may want to check for identity of the types before
1726 calling this function -- identical types are considered to satisfy
1727 the ancestor relationship even if they're identical */
1730 is_ancestor (base
, dclass
)
1732 struct type
*dclass
;
1736 CHECK_TYPEDEF (base
);
1737 CHECK_TYPEDEF (dclass
);
1741 if (TYPE_NAME (base
) && TYPE_NAME (dclass
) &&
1742 !strcmp (TYPE_NAME (base
), TYPE_NAME (dclass
)))
1745 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1746 if (is_ancestor (base
, TYPE_BASECLASS (dclass
, i
)))
1754 /* See whether DCLASS has a virtual table. This routine is aimed at
1755 the HP/Taligent ANSI C++ runtime model, and may not work with other
1756 runtime models. Return 1 => Yes, 0 => No. */
1760 struct type
*dclass
;
1762 /* In the HP ANSI C++ runtime model, a class has a vtable only if it
1763 has virtual functions or virtual bases. */
1767 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1770 /* First check for the presence of virtual bases */
1771 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
1772 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1773 if (B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
))
1776 /* Next check for virtual functions */
1777 if (TYPE_FN_FIELDLISTS (dclass
))
1778 for (i
= 0; i
< TYPE_NFN_FIELDS (dclass
); i
++)
1779 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, i
), 0))
1782 /* Recurse on non-virtual bases to see if any of them needs a vtable */
1783 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
1784 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1785 if ((!B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
)) &&
1786 (has_vtable (TYPE_FIELD_TYPE (dclass
, i
))))
1789 /* Well, maybe we don't need a virtual table */
1793 /* Return a pointer to the "primary base class" of DCLASS.
1795 A NULL return indicates that DCLASS has no primary base, or that it
1796 couldn't be found (insufficient information).
1798 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
1799 and may not work with other runtime models. */
1802 primary_base_class (dclass
)
1803 struct type
*dclass
;
1805 /* In HP ANSI C++'s runtime model, a "primary base class" of a class
1806 is the first directly inherited, non-virtual base class that
1807 requires a virtual table */
1811 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1814 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1815 if (!TYPE_FIELD_VIRTUAL (dclass
, i
) &&
1816 has_vtable (TYPE_FIELD_TYPE (dclass
, i
)))
1817 return TYPE_FIELD_TYPE (dclass
, i
);
1822 /* Global manipulated by virtual_base_list[_aux]() */
1824 static struct vbase
*current_vbase_list
= NULL
;
1826 /* Return a pointer to a null-terminated list of struct vbase
1827 items. The vbasetype pointer of each item in the list points to the
1828 type information for a virtual base of the argument DCLASS.
1830 Helper function for virtual_base_list().
1831 Note: the list goes backward, right-to-left. virtual_base_list()
1832 copies the items out in reverse order. */
1835 virtual_base_list_aux (dclass
)
1836 struct type
*dclass
;
1838 struct vbase
*tmp_vbase
;
1841 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1844 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1846 /* Recurse on this ancestor, first */
1847 virtual_base_list_aux (TYPE_FIELD_TYPE (dclass
, i
));
1849 /* If this current base is itself virtual, add it to the list */
1850 if (BASETYPE_VIA_VIRTUAL (dclass
, i
))
1852 struct type
*basetype
= TYPE_FIELD_TYPE (dclass
, i
);
1854 /* Check if base already recorded */
1855 tmp_vbase
= current_vbase_list
;
1858 if (tmp_vbase
->vbasetype
== basetype
)
1859 break; /* found it */
1860 tmp_vbase
= tmp_vbase
->next
;
1863 if (!tmp_vbase
) /* normal exit from loop */
1865 /* Allocate new item for this virtual base */
1866 tmp_vbase
= (struct vbase
*) xmalloc (sizeof (struct vbase
));
1868 /* Stick it on at the end of the list */
1869 tmp_vbase
->vbasetype
= basetype
;
1870 tmp_vbase
->next
= current_vbase_list
;
1871 current_vbase_list
= tmp_vbase
;
1874 } /* for loop over bases */
1878 /* Compute the list of virtual bases in the right order. Virtual
1879 bases are laid out in the object's memory area in order of their
1880 occurrence in a depth-first, left-to-right search through the
1883 Argument DCLASS is the type whose virtual bases are required.
1884 Return value is the address of a null-terminated array of pointers
1885 to struct type items.
1887 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
1888 and may not work with other runtime models.
1890 This routine merely hands off the argument to virtual_base_list_aux()
1891 and then copies the result into an array to save space. */
1894 virtual_base_list (dclass
)
1895 struct type
*dclass
;
1897 register struct vbase
*tmp_vbase
;
1898 register struct vbase
*tmp_vbase_2
;
1901 struct type
**vbase_array
;
1903 current_vbase_list
= NULL
;
1904 virtual_base_list_aux (dclass
);
1906 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
1911 vbase_array
= (struct type
**) xmalloc ((count
+ 1) * sizeof (struct type
*));
1913 for (i
= count
- 1, tmp_vbase
= current_vbase_list
; i
>= 0; i
--, tmp_vbase
= tmp_vbase
->next
)
1914 vbase_array
[i
] = tmp_vbase
->vbasetype
;
1916 /* Get rid of constructed chain */
1917 tmp_vbase_2
= tmp_vbase
= current_vbase_list
;
1920 tmp_vbase
= tmp_vbase
->next
;
1922 tmp_vbase_2
= tmp_vbase
;
1925 vbase_array
[count
] = NULL
;
1929 /* Return the length of the virtual base list of the type DCLASS. */
1932 virtual_base_list_length (dclass
)
1933 struct type
*dclass
;
1936 register struct vbase
*tmp_vbase
;
1938 current_vbase_list
= NULL
;
1939 virtual_base_list_aux (dclass
);
1941 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
1946 /* Return the number of elements of the virtual base list of the type
1947 DCLASS, ignoring those appearing in the primary base (and its
1948 primary base, recursively). */
1951 virtual_base_list_length_skip_primaries (dclass
)
1952 struct type
*dclass
;
1955 register struct vbase
*tmp_vbase
;
1956 struct type
*primary
;
1958 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
1961 return virtual_base_list_length (dclass
);
1963 current_vbase_list
= NULL
;
1964 virtual_base_list_aux (dclass
);
1966 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; tmp_vbase
= tmp_vbase
->next
)
1968 if (virtual_base_index (tmp_vbase
->vbasetype
, primary
) >= 0)
1976 /* Return the index (position) of type BASE, which is a virtual base
1977 class of DCLASS, in the latter's virtual base list. A return of -1
1978 indicates "not found" or a problem. */
1981 virtual_base_index (base
, dclass
)
1983 struct type
*dclass
;
1985 register struct type
*vbase
;
1988 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
1989 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
1993 vbase
= TYPE_VIRTUAL_BASE_LIST (dclass
)[0];
1998 vbase
= TYPE_VIRTUAL_BASE_LIST (dclass
)[++i
];
2001 return vbase
? i
: -1;
2006 /* Return the index (position) of type BASE, which is a virtual base
2007 class of DCLASS, in the latter's virtual base list. Skip over all
2008 bases that may appear in the virtual base list of the primary base
2009 class of DCLASS (recursively). A return of -1 indicates "not
2010 found" or a problem. */
2013 virtual_base_index_skip_primaries (base
, dclass
)
2015 struct type
*dclass
;
2017 register struct type
*vbase
;
2019 struct type
*primary
;
2021 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
2022 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
2025 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
2029 vbase
= TYPE_VIRTUAL_BASE_LIST (dclass
)[0];
2032 if (!primary
|| (virtual_base_index_skip_primaries (vbase
, primary
) < 0))
2036 vbase
= TYPE_VIRTUAL_BASE_LIST (dclass
)[++i
];
2039 return vbase
? j
: -1;
2042 /* Return position of a derived class DCLASS in the list of
2043 * primary bases starting with the remotest ancestor.
2044 * Position returned is 0-based. */
2047 class_index_in_primary_list (dclass
)
2048 struct type
*dclass
;
2050 struct type
*pbc
; /* primary base class */
2052 /* Simply recurse on primary base */
2053 pbc
= TYPE_PRIMARY_BASE (dclass
);
2055 return 1 + class_index_in_primary_list (pbc
);
2060 /* Return a count of the number of virtual functions a type has.
2061 * This includes all the virtual functions it inherits from its
2065 /* pai: FIXME This doesn't do the right thing: count redefined virtual
2066 * functions only once (latest redefinition)
2070 count_virtual_fns (dclass
)
2071 struct type
*dclass
;
2073 int fn
, oi
; /* function and overloaded instance indices */
2074 int vfuncs
; /* count to return */
2076 /* recurse on bases that can share virtual table */
2077 struct type
*pbc
= primary_base_class (dclass
);
2079 vfuncs
= count_virtual_fns (pbc
);
2081 for (fn
= 0; fn
< TYPE_NFN_FIELDS (dclass
); fn
++)
2082 for (oi
= 0; oi
< TYPE_FN_FIELDLIST_LENGTH (dclass
, fn
); oi
++)
2083 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, fn
), oi
))
2091 /* Functions for overload resolution begin here */
2093 /* Compare two badness vectors A and B and return the result.
2094 * 0 => A and B are identical
2095 * 1 => A and B are incomparable
2096 * 2 => A is better than B
2097 * 3 => A is worse than B */
2100 compare_badness (a
, b
)
2101 struct badness_vector
*a
;
2102 struct badness_vector
*b
;
2106 short found_pos
= 0; /* any positives in c? */
2107 short found_neg
= 0; /* any negatives in c? */
2109 /* differing lengths => incomparable */
2110 if (a
->length
!= b
->length
)
2113 /* Subtract b from a */
2114 for (i
= 0; i
< a
->length
; i
++)
2116 tmp
= a
->rank
[i
] - b
->rank
[i
];
2126 return 1; /* incomparable */
2128 return 3; /* A > B */
2134 return 2; /* A < B */
2136 return 0; /* A == B */
2140 /* Rank a function by comparing its parameter types (PARMS, length NPARMS),
2141 * to the types of an argument list (ARGS, length NARGS).
2142 * Return a pointer to a badness vector. This has NARGS + 1 entries. */
2144 struct badness_vector
*
2145 rank_function (parms
, nparms
, args
, nargs
)
2146 struct type
**parms
;
2152 struct badness_vector
*bv
;
2153 int min_len
= nparms
< nargs
? nparms
: nargs
;
2155 bv
= xmalloc (sizeof (struct badness_vector
));
2156 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank */
2157 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
2159 /* First compare the lengths of the supplied lists.
2160 * If there is a mismatch, set it to a high value. */
2162 /* pai/1997-06-03 FIXME: when we have debug info about default
2163 * arguments and ellipsis parameter lists, we should consider those
2164 * and rank the length-match more finely. */
2166 LENGTH_MATCH (bv
) = (nargs
!= nparms
) ? LENGTH_MISMATCH_BADNESS
: 0;
2168 /* Now rank all the parameters of the candidate function */
2169 for (i
= 1; i
<= min_len
; i
++)
2170 bv
->rank
[i
] = rank_one_type (parms
[i
-1], args
[i
-1]);
2172 /* If more arguments than parameters, add dummy entries */
2173 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2174 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2179 /* Compare one type (PARM) for compatibility with another (ARG).
2180 * PARM is intended to be the parameter type of a function; and
2181 * ARG is the supplied argument's type. This function tests if
2182 * the latter can be converted to the former.
2184 * Return 0 if they are identical types;
2185 * Otherwise, return an integer which corresponds to how compatible
2186 * PARM is to ARG. The higher the return value, the worse the match.
2187 * Generally the "bad" conversions are all uniformly assigned a 100 */
2190 rank_one_type (parm
, arg
)
2194 /* Identical type pointers */
2195 /* However, this still doesn't catch all cases of same type for arg
2196 * and param. The reason is that builtin types are different from
2197 * the same ones constructed from the object. */
2201 /* Resolve typedefs */
2202 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2203 parm
= check_typedef (parm
);
2204 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2205 arg
= check_typedef (arg
);
2208 Well, damnit, if the names are exactly the same,
2209 i'll say they are exactly the same. This happens when we generate
2210 method stubs. The types won't point to the same address, but they
2211 really are the same.
2214 if (TYPE_NAME (parm
) && TYPE_NAME (arg
) &&
2215 !strcmp (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2218 /* Check if identical after resolving typedefs */
2222 /* See through references, since we can almost make non-references
2224 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2225 return (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
))
2226 + REFERENCE_CONVERSION_BADNESS
);
2227 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2228 return (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
)
2229 + REFERENCE_CONVERSION_BADNESS
);
2231 /* Debugging only. */
2232 fprintf_filtered (gdb_stderr
,"------ Arg is %s [%d], parm is %s [%d]\n",
2233 TYPE_NAME (arg
), TYPE_CODE (arg
), TYPE_NAME (parm
), TYPE_CODE (parm
));
2235 /* x -> y means arg of type x being supplied for parameter of type y */
2237 switch (TYPE_CODE (parm
))
2240 switch (TYPE_CODE (arg
))
2243 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2244 return VOID_PTR_CONVERSION_BADNESS
;
2246 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2247 case TYPE_CODE_ARRAY
:
2248 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2249 case TYPE_CODE_FUNC
:
2250 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
);
2252 case TYPE_CODE_ENUM
:
2253 case TYPE_CODE_CHAR
:
2254 case TYPE_CODE_RANGE
:
2255 case TYPE_CODE_BOOL
:
2256 return POINTER_CONVERSION_BADNESS
;
2258 return INCOMPATIBLE_TYPE_BADNESS
;
2260 case TYPE_CODE_ARRAY
:
2261 switch (TYPE_CODE (arg
))
2264 case TYPE_CODE_ARRAY
:
2265 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2267 return INCOMPATIBLE_TYPE_BADNESS
;
2269 case TYPE_CODE_FUNC
:
2270 switch (TYPE_CODE (arg
))
2272 case TYPE_CODE_PTR
: /* funcptr -> func */
2273 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
));
2275 return INCOMPATIBLE_TYPE_BADNESS
;
2278 switch (TYPE_CODE (arg
))
2281 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2283 /* Deal with signed, unsigned, and plain chars and
2284 signed and unsigned ints */
2285 if (TYPE_NOSIGN (parm
))
2287 /* This case only for character types */
2288 if (TYPE_NOSIGN (arg
)) /* plain char -> plain char */
2291 return INTEGER_COERCION_BADNESS
; /* signed/unsigned char -> plain char */
2293 else if (TYPE_UNSIGNED (parm
))
2295 if (TYPE_UNSIGNED (arg
))
2297 if (!strcmp_iw (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2298 return 0; /* unsigned int -> unsigned int, or unsigned long -> unsigned long */
2299 else if (!strcmp_iw (TYPE_NAME (arg
), "int") && !strcmp_iw (TYPE_NAME (parm
), "long"))
2300 return INTEGER_PROMOTION_BADNESS
; /* unsigned int -> unsigned long */
2302 return INTEGER_COERCION_BADNESS
; /* unsigned long -> unsigned int */
2306 if (!strcmp_iw (TYPE_NAME (arg
), "long") && !strcmp_iw (TYPE_NAME (parm
), "int"))
2307 return INTEGER_COERCION_BADNESS
; /* signed long -> unsigned int */
2309 return INTEGER_CONVERSION_BADNESS
; /* signed int/long -> unsigned int/long */
2312 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2314 if (!strcmp_iw (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2316 else if (!strcmp_iw (TYPE_NAME (arg
), "int") && !strcmp_iw (TYPE_NAME (parm
), "long"))
2317 return INTEGER_PROMOTION_BADNESS
;
2319 return INTEGER_COERCION_BADNESS
;
2322 return INTEGER_COERCION_BADNESS
;
2324 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2325 return INTEGER_PROMOTION_BADNESS
;
2327 return INTEGER_COERCION_BADNESS
;
2328 case TYPE_CODE_ENUM
:
2329 case TYPE_CODE_CHAR
:
2330 case TYPE_CODE_RANGE
:
2331 case TYPE_CODE_BOOL
:
2332 return INTEGER_PROMOTION_BADNESS
;
2334 return INT_FLOAT_CONVERSION_BADNESS
;
2336 return NS_POINTER_CONVERSION_BADNESS
;
2338 return INCOMPATIBLE_TYPE_BADNESS
;
2341 case TYPE_CODE_ENUM
:
2342 switch (TYPE_CODE (arg
))
2345 case TYPE_CODE_CHAR
:
2346 case TYPE_CODE_RANGE
:
2347 case TYPE_CODE_BOOL
:
2348 case TYPE_CODE_ENUM
:
2349 return INTEGER_COERCION_BADNESS
;
2351 return INT_FLOAT_CONVERSION_BADNESS
;
2353 return INCOMPATIBLE_TYPE_BADNESS
;
2356 case TYPE_CODE_CHAR
:
2357 switch (TYPE_CODE (arg
))
2359 case TYPE_CODE_RANGE
:
2360 case TYPE_CODE_BOOL
:
2361 case TYPE_CODE_ENUM
:
2362 return INTEGER_COERCION_BADNESS
;
2364 return INT_FLOAT_CONVERSION_BADNESS
;
2366 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2367 return INTEGER_COERCION_BADNESS
;
2368 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2369 return INTEGER_PROMOTION_BADNESS
;
2370 /* >>> !! else fall through !! <<< */
2371 case TYPE_CODE_CHAR
:
2372 /* Deal with signed, unsigned, and plain chars for C++
2373 and with int cases falling through from previous case */
2374 if (TYPE_NOSIGN (parm
))
2376 if (TYPE_NOSIGN (arg
))
2379 return INTEGER_COERCION_BADNESS
;
2381 else if (TYPE_UNSIGNED (parm
))
2383 if (TYPE_UNSIGNED (arg
))
2386 return INTEGER_PROMOTION_BADNESS
;
2388 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2391 return INTEGER_COERCION_BADNESS
;
2393 return INCOMPATIBLE_TYPE_BADNESS
;
2396 case TYPE_CODE_RANGE
:
2397 switch (TYPE_CODE (arg
))
2400 case TYPE_CODE_CHAR
:
2401 case TYPE_CODE_RANGE
:
2402 case TYPE_CODE_BOOL
:
2403 case TYPE_CODE_ENUM
:
2404 return INTEGER_COERCION_BADNESS
;
2406 return INT_FLOAT_CONVERSION_BADNESS
;
2408 return INCOMPATIBLE_TYPE_BADNESS
;
2411 case TYPE_CODE_BOOL
:
2412 switch (TYPE_CODE (arg
))
2415 case TYPE_CODE_CHAR
:
2416 case TYPE_CODE_RANGE
:
2417 case TYPE_CODE_ENUM
:
2420 return BOOLEAN_CONVERSION_BADNESS
;
2421 case TYPE_CODE_BOOL
:
2424 return INCOMPATIBLE_TYPE_BADNESS
;
2428 switch (TYPE_CODE (arg
))
2431 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2432 return FLOAT_PROMOTION_BADNESS
;
2433 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2436 return FLOAT_CONVERSION_BADNESS
;
2438 case TYPE_CODE_BOOL
:
2439 case TYPE_CODE_ENUM
:
2440 case TYPE_CODE_RANGE
:
2441 case TYPE_CODE_CHAR
:
2442 return INT_FLOAT_CONVERSION_BADNESS
;
2444 return INCOMPATIBLE_TYPE_BADNESS
;
2447 case TYPE_CODE_COMPLEX
:
2448 switch (TYPE_CODE (arg
))
2449 { /* Strictly not needed for C++, but... */
2451 return FLOAT_PROMOTION_BADNESS
;
2452 case TYPE_CODE_COMPLEX
:
2455 return INCOMPATIBLE_TYPE_BADNESS
;
2458 case TYPE_CODE_STRUCT
:
2459 /* currently same as TYPE_CODE_CLASS */
2460 switch (TYPE_CODE (arg
))
2462 case TYPE_CODE_STRUCT
:
2463 /* Check for derivation */
2464 if (is_ancestor (parm
, arg
))
2465 return BASE_CONVERSION_BADNESS
;
2466 /* else fall through */
2468 return INCOMPATIBLE_TYPE_BADNESS
;
2471 case TYPE_CODE_UNION
:
2472 switch (TYPE_CODE (arg
))
2474 case TYPE_CODE_UNION
:
2476 return INCOMPATIBLE_TYPE_BADNESS
;
2479 case TYPE_CODE_MEMBER
:
2480 switch (TYPE_CODE (arg
))
2483 return INCOMPATIBLE_TYPE_BADNESS
;
2486 case TYPE_CODE_METHOD
:
2487 switch (TYPE_CODE (arg
))
2491 return INCOMPATIBLE_TYPE_BADNESS
;
2495 switch (TYPE_CODE (arg
))
2499 return INCOMPATIBLE_TYPE_BADNESS
;
2504 switch (TYPE_CODE (arg
))
2508 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0), TYPE_FIELD_TYPE (arg
, 0));
2510 return INCOMPATIBLE_TYPE_BADNESS
;
2513 case TYPE_CODE_VOID
:
2515 return INCOMPATIBLE_TYPE_BADNESS
;
2516 } /* switch (TYPE_CODE (arg)) */
2520 /* End of functions for overload resolution */
2523 print_bit_vector (bits
, nbits
)
2529 for (bitno
= 0; bitno
< nbits
; bitno
++)
2531 if ((bitno
% 8) == 0)
2533 puts_filtered (" ");
2535 if (B_TST (bits
, bitno
))
2537 printf_filtered ("1");
2541 printf_filtered ("0");
2546 /* The args list is a strange beast. It is either terminated by a NULL
2547 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
2548 type for normal fixed argcount functions. (FIXME someday)
2549 Also note the first arg should be the "this" pointer, we may not want to
2550 include it since we may get into a infinitely recursive situation. */
2553 print_arg_types (args
, spaces
)
2559 while (*args
!= NULL
)
2561 recursive_dump_type (*args
, spaces
+ 2);
2562 if ((*args
++)->code
== TYPE_CODE_VOID
)
2571 dump_fn_fieldlists (type
, spaces
)
2579 printfi_filtered (spaces
, "fn_fieldlists ");
2580 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2581 printf_filtered ("\n");
2582 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2584 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2585 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2587 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2588 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2590 printf_filtered (") length %d\n",
2591 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2592 for (overload_idx
= 0;
2593 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2596 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2598 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2599 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2601 printf_filtered (")\n");
2602 printfi_filtered (spaces
+ 8, "type ");
2603 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
2604 printf_filtered ("\n");
2606 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2609 printfi_filtered (spaces
+ 8, "args ");
2610 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
2611 printf_filtered ("\n");
2613 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
), spaces
);
2614 printfi_filtered (spaces
+ 8, "fcontext ");
2615 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2617 printf_filtered ("\n");
2619 printfi_filtered (spaces
+ 8, "is_const %d\n",
2620 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2621 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2622 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2623 printfi_filtered (spaces
+ 8, "is_private %d\n",
2624 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2625 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2626 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2627 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2628 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2629 printfi_filtered (spaces
+ 8, "voffset %u\n",
2630 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2636 print_cplus_stuff (type
, spaces
)
2640 printfi_filtered (spaces
, "n_baseclasses %d\n",
2641 TYPE_N_BASECLASSES (type
));
2642 printfi_filtered (spaces
, "nfn_fields %d\n",
2643 TYPE_NFN_FIELDS (type
));
2644 printfi_filtered (spaces
, "nfn_fields_total %d\n",
2645 TYPE_NFN_FIELDS_TOTAL (type
));
2646 if (TYPE_N_BASECLASSES (type
) > 0)
2648 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2649 TYPE_N_BASECLASSES (type
));
2650 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
2651 printf_filtered (")");
2653 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2654 TYPE_N_BASECLASSES (type
));
2655 puts_filtered ("\n");
2657 if (TYPE_NFIELDS (type
) > 0)
2659 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2661 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
2662 TYPE_NFIELDS (type
));
2663 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
2664 printf_filtered (")");
2665 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2666 TYPE_NFIELDS (type
));
2667 puts_filtered ("\n");
2669 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2671 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
2672 TYPE_NFIELDS (type
));
2673 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
2674 printf_filtered (")");
2675 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2676 TYPE_NFIELDS (type
));
2677 puts_filtered ("\n");
2680 if (TYPE_NFN_FIELDS (type
) > 0)
2682 dump_fn_fieldlists (type
, spaces
);
2686 static struct obstack dont_print_type_obstack
;
2689 recursive_dump_type (type
, spaces
)
2696 obstack_begin (&dont_print_type_obstack
, 0);
2698 if (TYPE_NFIELDS (type
) > 0
2699 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
2701 struct type
**first_dont_print
2702 = (struct type
**) obstack_base (&dont_print_type_obstack
);
2704 int i
= (struct type
**) obstack_next_free (&dont_print_type_obstack
)
2709 if (type
== first_dont_print
[i
])
2711 printfi_filtered (spaces
, "type node ");
2712 gdb_print_host_address (type
, gdb_stdout
);
2713 printf_filtered (" <same as already seen type>\n");
2718 obstack_ptr_grow (&dont_print_type_obstack
, type
);
2721 printfi_filtered (spaces
, "type node ");
2722 gdb_print_host_address (type
, gdb_stdout
);
2723 printf_filtered ("\n");
2724 printfi_filtered (spaces
, "name '%s' (",
2725 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
2726 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
2727 printf_filtered (")\n");
2728 if (TYPE_TAG_NAME (type
) != NULL
)
2730 printfi_filtered (spaces
, "tagname '%s' (",
2731 TYPE_TAG_NAME (type
));
2732 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
2733 printf_filtered (")\n");
2735 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
2736 switch (TYPE_CODE (type
))
2738 case TYPE_CODE_UNDEF
:
2739 printf_filtered ("(TYPE_CODE_UNDEF)");
2742 printf_filtered ("(TYPE_CODE_PTR)");
2744 case TYPE_CODE_ARRAY
:
2745 printf_filtered ("(TYPE_CODE_ARRAY)");
2747 case TYPE_CODE_STRUCT
:
2748 printf_filtered ("(TYPE_CODE_STRUCT)");
2750 case TYPE_CODE_UNION
:
2751 printf_filtered ("(TYPE_CODE_UNION)");
2753 case TYPE_CODE_ENUM
:
2754 printf_filtered ("(TYPE_CODE_ENUM)");
2756 case TYPE_CODE_FUNC
:
2757 printf_filtered ("(TYPE_CODE_FUNC)");
2760 printf_filtered ("(TYPE_CODE_INT)");
2763 printf_filtered ("(TYPE_CODE_FLT)");
2765 case TYPE_CODE_VOID
:
2766 printf_filtered ("(TYPE_CODE_VOID)");
2769 printf_filtered ("(TYPE_CODE_SET)");
2771 case TYPE_CODE_RANGE
:
2772 printf_filtered ("(TYPE_CODE_RANGE)");
2774 case TYPE_CODE_STRING
:
2775 printf_filtered ("(TYPE_CODE_STRING)");
2777 case TYPE_CODE_ERROR
:
2778 printf_filtered ("(TYPE_CODE_ERROR)");
2780 case TYPE_CODE_MEMBER
:
2781 printf_filtered ("(TYPE_CODE_MEMBER)");
2783 case TYPE_CODE_METHOD
:
2784 printf_filtered ("(TYPE_CODE_METHOD)");
2787 printf_filtered ("(TYPE_CODE_REF)");
2789 case TYPE_CODE_CHAR
:
2790 printf_filtered ("(TYPE_CODE_CHAR)");
2792 case TYPE_CODE_BOOL
:
2793 printf_filtered ("(TYPE_CODE_BOOL)");
2795 case TYPE_CODE_TYPEDEF
:
2796 printf_filtered ("(TYPE_CODE_TYPEDEF)");
2799 printf_filtered ("(UNKNOWN TYPE CODE)");
2802 puts_filtered ("\n");
2803 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
2804 printfi_filtered (spaces
, "objfile ");
2805 gdb_print_host_address (TYPE_OBJFILE (type
), gdb_stdout
);
2806 printf_filtered ("\n");
2807 printfi_filtered (spaces
, "target_type ");
2808 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
2809 printf_filtered ("\n");
2810 if (TYPE_TARGET_TYPE (type
) != NULL
)
2812 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
2814 printfi_filtered (spaces
, "pointer_type ");
2815 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
2816 printf_filtered ("\n");
2817 printfi_filtered (spaces
, "reference_type ");
2818 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
2819 printf_filtered ("\n");
2820 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
2821 if (TYPE_FLAGS (type
) & TYPE_FLAG_UNSIGNED
)
2823 puts_filtered (" TYPE_FLAG_UNSIGNED");
2825 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
2827 puts_filtered (" TYPE_FLAG_STUB");
2829 puts_filtered ("\n");
2830 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
2831 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
2832 puts_filtered ("\n");
2833 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
2835 printfi_filtered (spaces
+ 2,
2836 "[%d] bitpos %d bitsize %d type ",
2837 idx
, TYPE_FIELD_BITPOS (type
, idx
),
2838 TYPE_FIELD_BITSIZE (type
, idx
));
2839 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
2840 printf_filtered (" name '%s' (",
2841 TYPE_FIELD_NAME (type
, idx
) != NULL
2842 ? TYPE_FIELD_NAME (type
, idx
)
2844 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
2845 printf_filtered (")\n");
2846 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
2848 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
2851 printfi_filtered (spaces
, "vptr_basetype ");
2852 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
2853 puts_filtered ("\n");
2854 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
2856 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
2858 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
2859 switch (TYPE_CODE (type
))
2861 case TYPE_CODE_METHOD
:
2862 case TYPE_CODE_FUNC
:
2863 printfi_filtered (spaces
, "arg_types ");
2864 gdb_print_host_address (TYPE_ARG_TYPES (type
), gdb_stdout
);
2865 puts_filtered ("\n");
2866 print_arg_types (TYPE_ARG_TYPES (type
), spaces
);
2869 case TYPE_CODE_STRUCT
:
2870 printfi_filtered (spaces
, "cplus_stuff ");
2871 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
2872 puts_filtered ("\n");
2873 print_cplus_stuff (type
, spaces
);
2877 /* We have to pick one of the union types to be able print and test
2878 the value. Pick cplus_struct_type, even though we know it isn't
2879 any particular one. */
2880 printfi_filtered (spaces
, "type_specific ");
2881 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
2882 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
2884 printf_filtered (" (unknown data form)");
2886 printf_filtered ("\n");
2891 obstack_free (&dont_print_type_obstack
, NULL
);
2894 static void build_gdbtypes (void);
2899 init_type (TYPE_CODE_VOID
, 1,
2901 "void", (struct objfile
*) NULL
);
2903 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
2905 "char", (struct objfile
*) NULL
);
2906 TYPE_FLAGS (builtin_type_char
) |= TYPE_FLAG_NOSIGN
;
2907 builtin_type_true_char
=
2908 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
2910 "true character", (struct objfile
*) NULL
);
2911 builtin_type_signed_char
=
2912 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
2914 "signed char", (struct objfile
*) NULL
);
2915 builtin_type_unsigned_char
=
2916 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
2918 "unsigned char", (struct objfile
*) NULL
);
2919 builtin_type_short
=
2920 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
2922 "short", (struct objfile
*) NULL
);
2923 builtin_type_unsigned_short
=
2924 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
2926 "unsigned short", (struct objfile
*) NULL
);
2928 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
2930 "int", (struct objfile
*) NULL
);
2931 builtin_type_unsigned_int
=
2932 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
2934 "unsigned int", (struct objfile
*) NULL
);
2936 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
2938 "long", (struct objfile
*) NULL
);
2939 builtin_type_unsigned_long
=
2940 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
2942 "unsigned long", (struct objfile
*) NULL
);
2943 builtin_type_long_long
=
2944 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
2946 "long long", (struct objfile
*) NULL
);
2947 builtin_type_unsigned_long_long
=
2948 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
2950 "unsigned long long", (struct objfile
*) NULL
);
2951 builtin_type_float
=
2952 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
2954 "float", (struct objfile
*) NULL
);
2955 builtin_type_double
=
2956 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
2958 "double", (struct objfile
*) NULL
);
2959 builtin_type_long_double
=
2960 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
2962 "long double", (struct objfile
*) NULL
);
2963 builtin_type_complex
=
2964 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
2966 "complex", (struct objfile
*) NULL
);
2967 TYPE_TARGET_TYPE (builtin_type_complex
) = builtin_type_float
;
2968 builtin_type_double_complex
=
2969 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
2971 "double complex", (struct objfile
*) NULL
);
2972 TYPE_TARGET_TYPE (builtin_type_double_complex
) = builtin_type_double
;
2973 builtin_type_string
=
2974 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
2976 "string", (struct objfile
*) NULL
);
2978 init_type (TYPE_CODE_INT
, 8 / 8,
2980 "int8_t", (struct objfile
*) NULL
);
2981 builtin_type_uint8
=
2982 init_type (TYPE_CODE_INT
, 8 / 8,
2984 "uint8_t", (struct objfile
*) NULL
);
2985 builtin_type_int16
=
2986 init_type (TYPE_CODE_INT
, 16 / 8,
2988 "int16_t", (struct objfile
*) NULL
);
2989 builtin_type_uint16
=
2990 init_type (TYPE_CODE_INT
, 16 / 8,
2992 "uint16_t", (struct objfile
*) NULL
);
2993 builtin_type_int32
=
2994 init_type (TYPE_CODE_INT
, 32 / 8,
2996 "int32_t", (struct objfile
*) NULL
);
2997 builtin_type_uint32
=
2998 init_type (TYPE_CODE_INT
, 32 / 8,
3000 "uint32_t", (struct objfile
*) NULL
);
3001 builtin_type_int64
=
3002 init_type (TYPE_CODE_INT
, 64 / 8,
3004 "int64_t", (struct objfile
*) NULL
);
3005 builtin_type_uint64
=
3006 init_type (TYPE_CODE_INT
, 64 / 8,
3008 "uint64_t", (struct objfile
*) NULL
);
3010 init_type (TYPE_CODE_BOOL
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3012 "bool", (struct objfile
*) NULL
);
3014 /* Add user knob for controlling resolution of opaque types */
3016 (add_set_cmd ("opaque-type-resolution", class_support
, var_boolean
, (char *) &opaque_type_resolution
,
3017 "Set resolution of opaque struct/class/union types (if set before loading symbols).",
3020 opaque_type_resolution
= 1;
3023 /* Build SIMD types. */
3025 = init_simd_type ("__builtin_v4sf", builtin_type_float
, "f", 4);
3027 = init_simd_type ("__builtin_v4si", builtin_type_int32
, "f", 4);
3029 = init_simd_type ("__builtin_v8qi", builtin_type_int8
, "f", 8);
3031 = init_simd_type ("__builtin_v4hi", builtin_type_int16
, "f", 4);
3033 = init_simd_type ("__builtin_v2si", builtin_type_int32
, "f", 2);
3035 /* Pointer/Address types. */
3036 /* NOTE: At present there is no way of differentiating between at
3037 target address and the target C language pointer type type even
3038 though the two can be different (cf d10v) */
3039 builtin_type_ptr
= make_pointer_type (builtin_type_void
, NULL
);
3040 builtin_type_CORE_ADDR
=
3041 init_type (TYPE_CODE_INT
, TARGET_PTR_BIT
/ 8,
3043 "__CORE_ADDR", (struct objfile
*) NULL
);
3044 builtin_type_bfd_vma
=
3045 init_type (TYPE_CODE_INT
, TARGET_BFD_VMA_BIT
/ 8,
3047 "__bfd_vma", (struct objfile
*) NULL
);
3051 extern void _initialize_gdbtypes (void);
3053 _initialize_gdbtypes ()
3055 struct cmd_list_element
*c
;
3058 /* FIXME - For the moment, handle types by swapping them in and out.
3059 Should be using the per-architecture data-pointer and a large
3061 register_gdbarch_swap (&builtin_type_void
, sizeof (struct type
*), NULL
);
3062 register_gdbarch_swap (&builtin_type_char
, sizeof (struct type
*), NULL
);
3063 register_gdbarch_swap (&builtin_type_short
, sizeof (struct type
*), NULL
);
3064 register_gdbarch_swap (&builtin_type_int
, sizeof (struct type
*), NULL
);
3065 register_gdbarch_swap (&builtin_type_long
, sizeof (struct type
*), NULL
);
3066 register_gdbarch_swap (&builtin_type_long_long
, sizeof (struct type
*), NULL
);
3067 register_gdbarch_swap (&builtin_type_signed_char
, sizeof (struct type
*), NULL
);
3068 register_gdbarch_swap (&builtin_type_unsigned_char
, sizeof (struct type
*), NULL
);
3069 register_gdbarch_swap (&builtin_type_unsigned_short
, sizeof (struct type
*), NULL
);
3070 register_gdbarch_swap (&builtin_type_unsigned_int
, sizeof (struct type
*), NULL
);
3071 register_gdbarch_swap (&builtin_type_unsigned_long
, sizeof (struct type
*), NULL
);
3072 register_gdbarch_swap (&builtin_type_unsigned_long_long
, sizeof (struct type
*), NULL
);
3073 register_gdbarch_swap (&builtin_type_float
, sizeof (struct type
*), NULL
);
3074 register_gdbarch_swap (&builtin_type_double
, sizeof (struct type
*), NULL
);
3075 register_gdbarch_swap (&builtin_type_long_double
, sizeof (struct type
*), NULL
);
3076 register_gdbarch_swap (&builtin_type_complex
, sizeof (struct type
*), NULL
);
3077 register_gdbarch_swap (&builtin_type_double_complex
, sizeof (struct type
*), NULL
);
3078 register_gdbarch_swap (&builtin_type_string
, sizeof (struct type
*), NULL
);
3079 register_gdbarch_swap (&builtin_type_int8
, sizeof (struct type
*), NULL
);
3080 register_gdbarch_swap (&builtin_type_uint8
, sizeof (struct type
*), NULL
);
3081 register_gdbarch_swap (&builtin_type_int16
, sizeof (struct type
*), NULL
);
3082 register_gdbarch_swap (&builtin_type_uint16
, sizeof (struct type
*), NULL
);
3083 register_gdbarch_swap (&builtin_type_int32
, sizeof (struct type
*), NULL
);
3084 register_gdbarch_swap (&builtin_type_uint32
, sizeof (struct type
*), NULL
);
3085 register_gdbarch_swap (&builtin_type_int64
, sizeof (struct type
*), NULL
);
3086 register_gdbarch_swap (&builtin_type_uint64
, sizeof (struct type
*), NULL
);
3087 register_gdbarch_swap (&builtin_type_v4sf
, sizeof (struct type
*), NULL
);
3088 register_gdbarch_swap (&builtin_type_v4si
, sizeof (struct type
*), NULL
);
3089 register_gdbarch_swap (&builtin_type_v8qi
, sizeof (struct type
*), NULL
);
3090 register_gdbarch_swap (&builtin_type_v4hi
, sizeof (struct type
*), NULL
);
3091 register_gdbarch_swap (&builtin_type_v2si
, sizeof (struct type
*), NULL
);
3092 REGISTER_GDBARCH_SWAP (builtin_type_ptr
);
3093 REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR
);
3094 REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma
);
3095 register_gdbarch_swap (NULL
, 0, build_gdbtypes
);
3098 add_set_cmd ("overload", no_class
, var_zinteger
, (char *) &overload_debug
,
3099 "Set debugging of C++ overloading.\n\
3100 When enabled, ranking of the functions\n\
3101 is displayed.", &setdebuglist
),