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 /* These variables point to the objects
40 representing the predefined C data types. */
42 struct type
*builtin_type_void
;
43 struct type
*builtin_type_char
;
44 struct type
*builtin_type_true_char
;
45 struct type
*builtin_type_short
;
46 struct type
*builtin_type_int
;
47 struct type
*builtin_type_long
;
48 struct type
*builtin_type_long_long
;
49 struct type
*builtin_type_signed_char
;
50 struct type
*builtin_type_unsigned_char
;
51 struct type
*builtin_type_unsigned_short
;
52 struct type
*builtin_type_unsigned_int
;
53 struct type
*builtin_type_unsigned_long
;
54 struct type
*builtin_type_unsigned_long_long
;
55 struct type
*builtin_type_float
;
56 struct type
*builtin_type_double
;
57 struct type
*builtin_type_long_double
;
58 struct type
*builtin_type_complex
;
59 struct type
*builtin_type_double_complex
;
60 struct type
*builtin_type_string
;
61 struct type
*builtin_type_int8
;
62 struct type
*builtin_type_uint8
;
63 struct type
*builtin_type_int16
;
64 struct type
*builtin_type_uint16
;
65 struct type
*builtin_type_int32
;
66 struct type
*builtin_type_uint32
;
67 struct type
*builtin_type_int64
;
68 struct type
*builtin_type_uint64
;
69 struct type
*builtin_type_bool
;
70 struct type
*builtin_type_v4sf
;
71 struct type
*builtin_type_v4si
;
72 struct type
*builtin_type_v8qi
;
73 struct type
*builtin_type_v4hi
;
74 struct type
*builtin_type_v2si
;
75 struct type
*builtin_type_ptr
;
76 struct type
*builtin_type_CORE_ADDR
;
77 struct type
*builtin_type_bfd_vma
;
79 int opaque_type_resolution
= 1;
80 int overload_debug
= 0;
86 }; /* maximum extension is 128! FIXME */
88 static void add_name (struct extra
*, char *);
89 static void add_mangled_type (struct extra
*, struct type
*);
91 static void cfront_mangle_name (struct type
*, int, int);
93 static void print_bit_vector (B_TYPE
*, int);
94 static void print_arg_types (struct type
**, int);
95 static void dump_fn_fieldlists (struct type
*, int);
96 static void print_cplus_stuff (struct type
*, int);
97 static void virtual_base_list_aux (struct type
*dclass
);
100 /* Alloc a new type structure and fill it with some defaults. If
101 OBJFILE is non-NULL, then allocate the space for the type structure
102 in that objfile's type_obstack. */
105 alloc_type (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 (struct type
*type
, struct type
**typeptr
)
141 register struct type
*ntype
; /* New type */
142 struct objfile
*objfile
;
144 ntype
= TYPE_POINTER_TYPE (type
);
149 return ntype
; /* Don't care about alloc, and have new type. */
150 else if (*typeptr
== 0)
152 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
157 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
159 ntype
= alloc_type (TYPE_OBJFILE (type
));
164 /* We have storage, but need to reset it. */
167 objfile
= TYPE_OBJFILE (ntype
);
168 memset ((char *) ntype
, 0, sizeof (struct type
));
169 TYPE_OBJFILE (ntype
) = objfile
;
172 TYPE_TARGET_TYPE (ntype
) = type
;
173 TYPE_POINTER_TYPE (type
) = ntype
;
175 /* FIXME! Assume the machine has only one representation for pointers! */
177 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
178 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
180 /* Mark pointers as unsigned. The target converts between pointers
181 and addresses (CORE_ADDRs) using POINTER_TO_ADDRESS() and
182 ADDRESS_TO_POINTER(). */
183 TYPE_FLAGS (ntype
) |= TYPE_FLAG_UNSIGNED
;
185 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
186 TYPE_POINTER_TYPE (type
) = ntype
;
191 /* Given a type TYPE, return a type of pointers to that type.
192 May need to construct such a type if this is the first use. */
195 lookup_pointer_type (struct type
*type
)
197 return make_pointer_type (type
, (struct type
**) 0);
200 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero, points
201 to a pointer to memory where the reference type should be stored.
202 If *TYPEPTR is zero, update it to point to the reference type we return.
203 We allocate new memory if needed. */
206 make_reference_type (struct type
*type
, struct type
**typeptr
)
208 register struct type
*ntype
; /* New type */
209 struct objfile
*objfile
;
211 ntype
= TYPE_REFERENCE_TYPE (type
);
216 return ntype
; /* Don't care about alloc, and have new type. */
217 else if (*typeptr
== 0)
219 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
224 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
226 ntype
= alloc_type (TYPE_OBJFILE (type
));
231 /* We have storage, but need to reset it. */
234 objfile
= TYPE_OBJFILE (ntype
);
235 memset ((char *) ntype
, 0, sizeof (struct type
));
236 TYPE_OBJFILE (ntype
) = objfile
;
239 TYPE_TARGET_TYPE (ntype
) = type
;
240 TYPE_REFERENCE_TYPE (type
) = ntype
;
242 /* FIXME! Assume the machine has only one representation for references,
243 and that it matches the (only) representation for pointers! */
245 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
246 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
248 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
249 TYPE_REFERENCE_TYPE (type
) = ntype
;
254 /* Same as above, but caller doesn't care about memory allocation details. */
257 lookup_reference_type (struct type
*type
)
259 return make_reference_type (type
, (struct type
**) 0);
262 /* Lookup a function type that returns type TYPE. TYPEPTR, if nonzero, points
263 to a pointer to memory where the function type should be stored.
264 If *TYPEPTR is zero, update it to point to the function type we return.
265 We allocate new memory if needed. */
268 make_function_type (struct type
*type
, struct type
**typeptr
)
270 register struct type
*ntype
; /* New type */
271 struct objfile
*objfile
;
273 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
275 ntype
= alloc_type (TYPE_OBJFILE (type
));
280 /* We have storage, but need to reset it. */
283 objfile
= TYPE_OBJFILE (ntype
);
284 memset ((char *) ntype
, 0, sizeof (struct type
));
285 TYPE_OBJFILE (ntype
) = objfile
;
288 TYPE_TARGET_TYPE (ntype
) = type
;
290 TYPE_LENGTH (ntype
) = 1;
291 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
297 /* Given a type TYPE, return a type of functions that return that type.
298 May need to construct such a type if this is the first use. */
301 lookup_function_type (struct type
*type
)
303 return make_function_type (type
, (struct type
**) 0);
307 /* Make a "c-v" variant of a type -- a type that is identical to the
308 one supplied except that it may have const or volatile attributes
309 CNST is a flag for setting the const attribute
310 VOLTL is a flag for setting the volatile attribute
311 TYPE is the base type whose variant we are creating.
312 TYPEPTR, if nonzero, points
313 to a pointer to memory where the reference type should be stored.
314 If *TYPEPTR is zero, update it to point to the reference type we return.
315 We allocate new memory if needed. */
318 make_cv_type (int cnst
, int voltl
, struct type
*type
, struct type
**typeptr
)
320 register struct type
*ntype
; /* New type */
321 register struct type
*tmp_type
= type
; /* tmp type */
322 struct objfile
*objfile
;
324 ntype
= TYPE_CV_TYPE (type
);
326 while (ntype
!= type
)
328 if ((TYPE_CONST (ntype
) == cnst
) &&
329 (TYPE_VOLATILE (ntype
) == voltl
))
333 else if (*typeptr
== 0)
335 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
340 ntype
= TYPE_CV_TYPE (ntype
);
343 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
345 ntype
= alloc_type (TYPE_OBJFILE (type
));
350 /* We have storage, but need to reset it. */
353 objfile
= TYPE_OBJFILE (ntype
);
354 /* memset ((char *) ntype, 0, sizeof (struct type)); */
355 TYPE_OBJFILE (ntype
) = objfile
;
358 /* Copy original type */
359 memcpy ((char *) ntype
, (char *) type
, sizeof (struct type
));
360 /* But zero out fields that shouldn't be copied */
361 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0; /* Need new pointer kind */
362 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0; /* Need new referene kind */
363 /* Note: TYPE_TARGET_TYPE can be left as is */
365 /* Set flags appropriately */
367 TYPE_FLAGS (ntype
) |= TYPE_FLAG_CONST
;
369 TYPE_FLAGS (ntype
) &= ~TYPE_FLAG_CONST
;
372 TYPE_FLAGS (ntype
) |= TYPE_FLAG_VOLATILE
;
374 TYPE_FLAGS (ntype
) &= ~TYPE_FLAG_VOLATILE
;
376 /* Fix the chain of cv variants */
377 TYPE_CV_TYPE (ntype
) = type
;
378 TYPE_CV_TYPE (tmp_type
) = ntype
;
386 /* Implement direct support for MEMBER_TYPE in GNU C++.
387 May need to construct such a type if this is the first use.
388 The TYPE is the type of the member. The DOMAIN is the type
389 of the aggregate that the member belongs to. */
392 lookup_member_type (struct type
*type
, struct type
*domain
)
394 register struct type
*mtype
;
396 mtype
= alloc_type (TYPE_OBJFILE (type
));
397 smash_to_member_type (mtype
, domain
, type
);
401 /* Allocate a stub method whose return type is TYPE.
402 This apparently happens for speed of symbol reading, since parsing
403 out the arguments to the method is cpu-intensive, the way we are doing
404 it. So, we will fill in arguments later.
405 This always returns a fresh type. */
408 allocate_stub_method (struct type
*type
)
412 mtype
= alloc_type (TYPE_OBJFILE (type
));
413 TYPE_TARGET_TYPE (mtype
) = type
;
414 /* _DOMAIN_TYPE (mtype) = unknown yet */
415 /* _ARG_TYPES (mtype) = unknown yet */
416 TYPE_FLAGS (mtype
) = TYPE_FLAG_STUB
;
417 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
418 TYPE_LENGTH (mtype
) = 1;
422 /* Create a range type using either a blank type supplied in RESULT_TYPE,
423 or creating a new type, inheriting the objfile from INDEX_TYPE.
425 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
426 HIGH_BOUND, inclusive.
428 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
429 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
432 create_range_type (struct type
*result_type
, struct type
*index_type
,
433 int low_bound
, int high_bound
)
435 if (result_type
== NULL
)
437 result_type
= alloc_type (TYPE_OBJFILE (index_type
));
439 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
440 TYPE_TARGET_TYPE (result_type
) = index_type
;
441 if (TYPE_FLAGS (index_type
) & TYPE_FLAG_STUB
)
442 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
444 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
445 TYPE_NFIELDS (result_type
) = 2;
446 TYPE_FIELDS (result_type
) = (struct field
*)
447 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
448 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
449 TYPE_FIELD_BITPOS (result_type
, 0) = low_bound
;
450 TYPE_FIELD_BITPOS (result_type
, 1) = high_bound
;
451 TYPE_FIELD_TYPE (result_type
, 0) = builtin_type_int
; /* FIXME */
452 TYPE_FIELD_TYPE (result_type
, 1) = builtin_type_int
; /* FIXME */
455 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
457 return (result_type
);
460 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE.
461 Return 1 of type is a range type, 0 if it is discrete (and bounds
462 will fit in LONGEST), or -1 otherwise. */
465 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
467 CHECK_TYPEDEF (type
);
468 switch (TYPE_CODE (type
))
470 case TYPE_CODE_RANGE
:
471 *lowp
= TYPE_LOW_BOUND (type
);
472 *highp
= TYPE_HIGH_BOUND (type
);
475 if (TYPE_NFIELDS (type
) > 0)
477 /* The enums may not be sorted by value, so search all
481 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
482 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
484 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
485 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
486 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
487 *highp
= TYPE_FIELD_BITPOS (type
, i
);
490 /* Set unsigned indicator if warranted. */
493 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
507 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
509 if (!TYPE_UNSIGNED (type
))
511 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
515 /* ... fall through for unsigned ints ... */
518 /* This round-about calculation is to avoid shifting by
519 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
520 if TYPE_LENGTH (type) == sizeof (LONGEST). */
521 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
522 *highp
= (*highp
- 1) | *highp
;
529 /* Create an array type using either a blank type supplied in RESULT_TYPE,
530 or creating a new type, inheriting the objfile from RANGE_TYPE.
532 Elements will be of type ELEMENT_TYPE, the indices will be of type
535 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
536 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
539 create_array_type (struct type
*result_type
, struct type
*element_type
,
540 struct type
*range_type
)
542 LONGEST low_bound
, high_bound
;
544 if (result_type
== NULL
)
546 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
548 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
549 TYPE_TARGET_TYPE (result_type
) = element_type
;
550 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
551 low_bound
= high_bound
= 0;
552 CHECK_TYPEDEF (element_type
);
553 TYPE_LENGTH (result_type
) =
554 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
555 TYPE_NFIELDS (result_type
) = 1;
556 TYPE_FIELDS (result_type
) =
557 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
558 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
559 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
560 TYPE_VPTR_FIELDNO (result_type
) = -1;
562 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
563 if (TYPE_LENGTH (result_type
) == 0)
564 TYPE_FLAGS (result_type
) |= TYPE_FLAG_TARGET_STUB
;
566 return (result_type
);
569 /* Create a string type using either a blank type supplied in RESULT_TYPE,
570 or creating a new type. String types are similar enough to array of
571 char types that we can use create_array_type to build the basic type
572 and then bash it into a string type.
574 For fixed length strings, the range type contains 0 as the lower
575 bound and the length of the string minus one as the upper bound.
577 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
578 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
581 create_string_type (struct type
*result_type
, struct type
*range_type
)
583 result_type
= create_array_type (result_type
,
584 *current_language
->string_char_type
,
586 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
587 return (result_type
);
591 create_set_type (struct type
*result_type
, struct type
*domain_type
)
593 LONGEST low_bound
, high_bound
, bit_length
;
594 if (result_type
== NULL
)
596 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
598 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
599 TYPE_NFIELDS (result_type
) = 1;
600 TYPE_FIELDS (result_type
) = (struct field
*)
601 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
602 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
604 if (!(TYPE_FLAGS (domain_type
) & TYPE_FLAG_STUB
))
606 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
607 low_bound
= high_bound
= 0;
608 bit_length
= high_bound
- low_bound
+ 1;
609 TYPE_LENGTH (result_type
)
610 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
612 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
615 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
617 return (result_type
);
621 /* Construct and return a type of the form:
622 struct NAME { ELT_TYPE ELT_NAME[N]; }
623 We use these types for SIMD registers. For example, the type of
624 the SSE registers on the late x86-family processors is:
625 struct __builtin_v4sf { float f[4]; }
626 built by the function call:
627 init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4)
628 The type returned is a permanent type, allocated using malloc; it
629 doesn't live in any objfile's obstack. */
631 init_simd_type (char *name
,
632 struct type
*elt_type
,
639 /* Build the field structure. */
640 f
= xmalloc (sizeof (*f
));
641 memset (f
, 0, sizeof (*f
));
643 f
->type
= create_array_type (0, elt_type
,
644 create_range_type (0, builtin_type_int
,
648 /* Build a struct type with that field. */
649 t
= init_type (TYPE_CODE_STRUCT
, n
* TYPE_LENGTH (elt_type
), 0, 0, 0);
658 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
659 A MEMBER is a wierd thing -- it amounts to a typed offset into
660 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
661 include the offset (that's the value of the MEMBER itself), but does
662 include the structure type into which it points (for some reason).
664 When "smashing" the type, we preserve the objfile that the
665 old type pointed to, since we aren't changing where the type is actually
669 smash_to_member_type (struct type
*type
, struct type
*domain
,
670 struct type
*to_type
)
672 struct objfile
*objfile
;
674 objfile
= TYPE_OBJFILE (type
);
676 memset ((char *) type
, 0, sizeof (struct type
));
677 TYPE_OBJFILE (type
) = objfile
;
678 TYPE_TARGET_TYPE (type
) = to_type
;
679 TYPE_DOMAIN_TYPE (type
) = domain
;
680 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
681 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
684 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
685 METHOD just means `function that gets an extra "this" argument'.
687 When "smashing" the type, we preserve the objfile that the
688 old type pointed to, since we aren't changing where the type is actually
692 smash_to_method_type (struct type
*type
, struct type
*domain
,
693 struct type
*to_type
, struct type
**args
)
695 struct objfile
*objfile
;
697 objfile
= TYPE_OBJFILE (type
);
699 memset ((char *) type
, 0, sizeof (struct type
));
700 TYPE_OBJFILE (type
) = objfile
;
701 TYPE_TARGET_TYPE (type
) = to_type
;
702 TYPE_DOMAIN_TYPE (type
) = domain
;
703 TYPE_ARG_TYPES (type
) = args
;
704 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
705 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
708 /* Return a typename for a struct/union/enum type without "struct ",
709 "union ", or "enum ". If the type has a NULL name, return NULL. */
712 type_name_no_tag (register const struct type
*type
)
714 if (TYPE_TAG_NAME (type
) != NULL
)
715 return TYPE_TAG_NAME (type
);
717 /* Is there code which expects this to return the name if there is no
718 tag name? My guess is that this is mainly used for C++ in cases where
719 the two will always be the same. */
720 return TYPE_NAME (type
);
723 /* Lookup a primitive type named NAME.
724 Return zero if NAME is not a primitive type. */
727 lookup_primitive_typename (char *name
)
729 struct type
**const *p
;
731 for (p
= current_language
->la_builtin_type_vector
; *p
!= NULL
; p
++)
733 if (STREQ ((**p
)->name
, name
))
741 /* Lookup a typedef or primitive type named NAME,
742 visible in lexical block BLOCK.
743 If NOERR is nonzero, return zero if NAME is not suitably defined. */
746 lookup_typename (char *name
, struct block
*block
, int noerr
)
748 register struct symbol
*sym
;
749 register struct type
*tmp
;
751 sym
= lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
752 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
754 tmp
= lookup_primitive_typename (name
);
759 else if (!tmp
&& noerr
)
765 error ("No type named %s.", name
);
768 return (SYMBOL_TYPE (sym
));
772 lookup_unsigned_typename (char *name
)
774 char *uns
= alloca (strlen (name
) + 10);
776 strcpy (uns
, "unsigned ");
777 strcpy (uns
+ 9, name
);
778 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
782 lookup_signed_typename (char *name
)
785 char *uns
= alloca (strlen (name
) + 8);
787 strcpy (uns
, "signed ");
788 strcpy (uns
+ 7, name
);
789 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
790 /* If we don't find "signed FOO" just try again with plain "FOO". */
793 return lookup_typename (name
, (struct block
*) NULL
, 0);
796 /* Lookup a structure type named "struct NAME",
797 visible in lexical block BLOCK. */
800 lookup_struct (char *name
, struct block
*block
)
802 register struct symbol
*sym
;
804 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
805 (struct symtab
**) NULL
);
809 error ("No struct type named %s.", name
);
811 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
813 error ("This context has class, union or enum %s, not a struct.", name
);
815 return (SYMBOL_TYPE (sym
));
818 /* Lookup a union type named "union NAME",
819 visible in lexical block BLOCK. */
822 lookup_union (char *name
, struct block
*block
)
824 register struct symbol
*sym
;
827 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
828 (struct symtab
**) NULL
);
831 error ("No union type named %s.", name
);
833 t
= SYMBOL_TYPE (sym
);
835 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
838 /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
839 * a further "declared_type" field to discover it is really a union.
841 if (HAVE_CPLUS_STRUCT (t
))
842 if (TYPE_DECLARED_TYPE (t
) == DECLARED_TYPE_UNION
)
845 /* If we get here, it's not a union */
846 error ("This context has class, struct or enum %s, not a union.", name
);
850 /* Lookup an enum type named "enum NAME",
851 visible in lexical block BLOCK. */
854 lookup_enum (char *name
, struct block
*block
)
856 register struct symbol
*sym
;
858 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
859 (struct symtab
**) NULL
);
862 error ("No enum type named %s.", name
);
864 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
866 error ("This context has class, struct or union %s, not an enum.", name
);
868 return (SYMBOL_TYPE (sym
));
871 /* Lookup a template type named "template NAME<TYPE>",
872 visible in lexical block BLOCK. */
875 lookup_template_type (char *name
, struct type
*type
, struct block
*block
)
878 char *nam
= (char *) alloca (strlen (name
) + strlen (type
->name
) + 4);
881 strcat (nam
, type
->name
);
882 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
884 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
888 error ("No template type named %s.", name
);
890 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
892 error ("This context has class, union or enum %s, not a struct.", name
);
894 return (SYMBOL_TYPE (sym
));
897 /* Given a type TYPE, lookup the type of the component of type named NAME.
899 TYPE can be either a struct or union, or a pointer or reference to a struct or
900 union. If it is a pointer or reference, its target type is automatically used.
901 Thus '.' and '->' are interchangable, as specified for the definitions of the
902 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
904 If NOERR is nonzero, return zero if NAME is not suitably defined.
905 If NAME is the name of a baseclass type, return that type. */
908 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
914 CHECK_TYPEDEF (type
);
915 if (TYPE_CODE (type
) != TYPE_CODE_PTR
916 && TYPE_CODE (type
) != TYPE_CODE_REF
)
918 type
= TYPE_TARGET_TYPE (type
);
921 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
922 TYPE_CODE (type
) != TYPE_CODE_UNION
)
924 target_terminal_ours ();
925 gdb_flush (gdb_stdout
);
926 fprintf_unfiltered (gdb_stderr
, "Type ");
927 type_print (type
, "", gdb_stderr
, -1);
928 error (" is not a structure or union type.");
932 /* FIXME: This change put in by Michael seems incorrect for the case where
933 the structure tag name is the same as the member name. I.E. when doing
934 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
939 typename
= type_name_no_tag (type
);
940 if (typename
!= NULL
&& STREQ (typename
, name
))
945 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
947 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
949 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
951 return TYPE_FIELD_TYPE (type
, i
);
955 /* OK, it's not in this class. Recursively check the baseclasses. */
956 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
960 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, noerr
);
972 target_terminal_ours ();
973 gdb_flush (gdb_stdout
);
974 fprintf_unfiltered (gdb_stderr
, "Type ");
975 type_print (type
, "", gdb_stderr
, -1);
976 fprintf_unfiltered (gdb_stderr
, " has no component named ");
977 fputs_filtered (name
, gdb_stderr
);
979 return (struct type
*) -1; /* For lint */
982 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
983 valid. Callers should be aware that in some cases (for example,
984 the type or one of its baseclasses is a stub type and we are
985 debugging a .o file), this function will not be able to find the virtual
986 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
990 fill_in_vptr_fieldno (struct type
*type
)
992 CHECK_TYPEDEF (type
);
994 if (TYPE_VPTR_FIELDNO (type
) < 0)
998 /* We must start at zero in case the first (and only) baseclass is
999 virtual (and hence we cannot share the table pointer). */
1000 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1002 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, i
));
1003 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
)) >= 0)
1005 TYPE_VPTR_FIELDNO (type
)
1006 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
));
1007 TYPE_VPTR_BASETYPE (type
)
1008 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type
, i
));
1015 /* Find the method and field indices for the destructor in class type T.
1016 Return 1 if the destructor was found, otherwise, return 0. */
1019 get_destructor_fn_field (struct type
*t
, int *method_indexp
, int *field_indexp
)
1023 for (i
= 0; i
< TYPE_NFN_FIELDS (t
); i
++)
1026 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1028 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (t
, i
); j
++)
1030 if (DESTRUCTOR_PREFIX_P (TYPE_FN_FIELD_PHYSNAME (f
, j
)))
1041 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1043 If this is a stubbed struct (i.e. declared as struct foo *), see if
1044 we can find a full definition in some other file. If so, copy this
1045 definition, so we can use it in future. There used to be a comment (but
1046 not any code) that if we don't find a full definition, we'd set a flag
1047 so we don't spend time in the future checking the same type. That would
1048 be a mistake, though--we might load in more symbols which contain a
1049 full definition for the type.
1051 This used to be coded as a macro, but I don't think it is called
1052 often enough to merit such treatment. */
1054 struct complaint stub_noname_complaint
=
1055 {"stub type has NULL name", 0, 0};
1058 check_typedef (register struct type
*type
)
1060 struct type
*orig_type
= type
;
1061 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1063 if (!TYPE_TARGET_TYPE (type
))
1068 /* It is dangerous to call lookup_symbol if we are currently
1069 reading a symtab. Infinite recursion is one danger. */
1070 if (currently_reading_symtab
)
1073 name
= type_name_no_tag (type
);
1074 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1075 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
1076 as appropriate? (this code was written before TYPE_NAME and
1077 TYPE_TAG_NAME were separate). */
1080 complain (&stub_noname_complaint
);
1083 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
1084 (struct symtab
**) NULL
);
1086 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1088 TYPE_TARGET_TYPE (type
) = alloc_type (NULL
); /* TYPE_CODE_UNDEF */
1090 type
= TYPE_TARGET_TYPE (type
);
1093 /* If this is a struct/class/union with no fields, then check whether a
1094 full definition exists somewhere else. This is for systems where a
1095 type definition with no fields is issued for such types, instead of
1096 identifying them as stub types in the first place */
1098 if (TYPE_IS_OPAQUE (type
) && opaque_type_resolution
&& !currently_reading_symtab
)
1100 char *name
= type_name_no_tag (type
);
1101 struct type
*newtype
;
1104 complain (&stub_noname_complaint
);
1107 newtype
= lookup_transparent_type (name
);
1110 memcpy ((char *) type
, (char *) newtype
, sizeof (struct type
));
1113 /* Otherwise, rely on the stub flag being set for opaque/stubbed types */
1114 else if ((TYPE_FLAGS (type
) & TYPE_FLAG_STUB
) && !currently_reading_symtab
)
1116 char *name
= type_name_no_tag (type
);
1117 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1118 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
1119 as appropriate? (this code was written before TYPE_NAME and
1120 TYPE_TAG_NAME were separate). */
1124 complain (&stub_noname_complaint
);
1127 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0, (struct symtab
**) NULL
);
1130 memcpy ((char *) type
, (char *) SYMBOL_TYPE (sym
), sizeof (struct type
));
1134 if (TYPE_FLAGS (type
) & TYPE_FLAG_TARGET_STUB
)
1136 struct type
*range_type
;
1137 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1139 if (TYPE_FLAGS (target_type
) & (TYPE_FLAG_STUB
| TYPE_FLAG_TARGET_STUB
))
1142 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1143 && TYPE_NFIELDS (type
) == 1
1144 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
1145 == TYPE_CODE_RANGE
))
1147 /* Now recompute the length of the array type, based on its
1148 number of elements and the target type's length. */
1149 TYPE_LENGTH (type
) =
1150 ((TYPE_FIELD_BITPOS (range_type
, 1)
1151 - TYPE_FIELD_BITPOS (range_type
, 0)
1153 * TYPE_LENGTH (target_type
));
1154 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1156 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1158 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1159 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1162 /* Cache TYPE_LENGTH for future use. */
1163 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1167 /* New code added to support parsing of Cfront stabs strings */
1169 #define INIT_EXTRA { pextras->len=0; pextras->str[0]='\0'; }
1170 #define ADD_EXTRA(c) { pextras->str[pextras->len++]=c; }
1173 add_name (struct extra
*pextras
, char *n
)
1177 if ((nlen
= (n
? strlen (n
) : 0)) == 0)
1179 sprintf (pextras
->str
+ pextras
->len
, "%d%s", nlen
, n
);
1180 pextras
->len
= strlen (pextras
->str
);
1184 add_mangled_type (struct extra
*pextras
, struct type
*t
)
1186 enum type_code tcode
;
1190 tcode
= TYPE_CODE (t
);
1191 tlen
= TYPE_LENGTH (t
);
1192 tflags
= TYPE_FLAGS (t
);
1193 tname
= TYPE_NAME (t
);
1194 /* args of "..." seem to get mangled as "e" */
1212 if ((pname
= strrchr (tname
, 'l'), pname
) && !strcmp (pname
, "long"))
1225 static struct complaint msg
=
1226 {"Bad int type code length x%x\n", 0, 0};
1228 complain (&msg
, tlen
);
1247 static struct complaint msg
=
1248 {"Bad float type code length x%x\n", 0, 0};
1249 complain (&msg
, tlen
);
1255 /* followed by what it's a ref to */
1259 /* followed by what it's a ptr to */
1261 case TYPE_CODE_TYPEDEF
:
1263 static struct complaint msg
=
1264 {"Typedefs in overloaded functions not yet supported\n", 0, 0};
1267 /* followed by type bytes & name */
1269 case TYPE_CODE_FUNC
:
1271 /* followed by func's arg '_' & ret types */
1273 case TYPE_CODE_VOID
:
1276 case TYPE_CODE_METHOD
:
1278 /* followed by name of class and func's arg '_' & ret types */
1279 add_name (pextras
, tname
);
1280 ADD_EXTRA ('F'); /* then mangle function */
1282 case TYPE_CODE_STRUCT
: /* C struct */
1283 case TYPE_CODE_UNION
: /* C union */
1284 case TYPE_CODE_ENUM
: /* Enumeration type */
1285 /* followed by name of type */
1286 add_name (pextras
, tname
);
1289 /* errors possible types/not supported */
1290 case TYPE_CODE_CHAR
:
1291 case TYPE_CODE_ARRAY
: /* Array type */
1292 case TYPE_CODE_MEMBER
: /* Member type */
1293 case TYPE_CODE_BOOL
:
1294 case TYPE_CODE_COMPLEX
: /* Complex float */
1295 case TYPE_CODE_UNDEF
:
1296 case TYPE_CODE_SET
: /* Pascal sets */
1297 case TYPE_CODE_RANGE
:
1298 case TYPE_CODE_STRING
:
1299 case TYPE_CODE_BITSTRING
:
1300 case TYPE_CODE_ERROR
:
1303 static struct complaint msg
=
1304 {"Unknown type code x%x\n", 0, 0};
1305 complain (&msg
, tcode
);
1309 add_mangled_type (pextras
, t
->target_type
);
1314 cfront_mangle_name (struct type
*type
, int i
, int j
)
1317 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
1319 f
= TYPE_FN_FIELDLIST1 (type
, i
); /* moved from below */
1321 /* kludge to support cfront methods - gdb expects to find "F" for
1322 ARM_mangled names, so when we mangle, we have to add it here */
1326 char *arm_mangled_name
;
1327 struct fn_field
*method
= &f
[j
];
1328 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1329 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1330 char *newname
= type_name_no_tag (type
);
1332 struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
1333 int nargs
= TYPE_NFIELDS (ftype
); /* number of args */
1334 struct extra extras
, *pextras
= &extras
;
1337 if (TYPE_FN_FIELD_STATIC_P (f
, j
)) /* j for sublist within this list */
1340 /* add args here! */
1341 if (nargs
<= 1) /* no args besides this */
1345 for (k
= 1; k
< nargs
; k
++)
1348 t
= TYPE_FIELD_TYPE (ftype
, k
);
1349 add_mangled_type (pextras
, t
);
1353 printf ("add_mangled_type: %s\n", extras
.str
); /* FIXME */
1354 arm_mangled_name
= malloc (strlen (mangled_name
) + extras
.len
);
1355 sprintf (arm_mangled_name
, "%s%s", mangled_name
, extras
.str
);
1356 xfree (mangled_name
);
1357 mangled_name
= arm_mangled_name
;
1363 /* End of new code added to support parsing of Cfront stabs strings */
1365 /* Parse a type expression in the string [P..P+LENGTH). If an error occurs,
1366 silently return builtin_type_void. */
1369 safe_parse_type (char *p
, int length
)
1371 struct ui_file
*saved_gdb_stderr
;
1374 /* Suppress error messages. */
1375 saved_gdb_stderr
= gdb_stderr
;
1376 gdb_stderr
= ui_file_new ();
1378 /* Call parse_and_eval_type() without fear of longjmp()s. */
1379 if (!gdb_parse_and_eval_type (p
, length
, &type
))
1380 type
= builtin_type_void
;
1382 /* Stop suppressing error messages. */
1383 ui_file_delete (gdb_stderr
);
1384 gdb_stderr
= saved_gdb_stderr
;
1389 /* Ugly hack to convert method stubs into method types.
1391 He ain't kiddin'. This demangles the name of the method into a string
1392 including argument types, parses out each argument type, generates
1393 a string casting a zero to that type, evaluates the string, and stuffs
1394 the resulting type into an argtype vector!!! Then it knows the type
1395 of the whole function (including argument types for overloading),
1396 which info used to be in the stab's but was removed to hack back
1397 the space required for them. */
1400 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1403 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1404 char *demangled_name
= cplus_demangle (mangled_name
,
1405 DMGL_PARAMS
| DMGL_ANSI
);
1406 char *argtypetext
, *p
;
1407 int depth
= 0, argcount
= 1;
1408 struct type
**argtypes
;
1411 /* Make sure we got back a function string that we can use. */
1413 p
= strchr (demangled_name
, '(');
1415 if (demangled_name
== NULL
|| p
== NULL
)
1416 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
1418 /* Now, read in the parameters that define this type. */
1423 if (*p
== '(' || *p
== '<')
1427 else if (*p
== ')' || *p
== '>')
1431 else if (*p
== ',' && depth
== 0)
1439 /* We need two more slots: one for the THIS pointer, and one for the
1440 NULL [...] or void [end of arglist]. */
1442 argtypes
= (struct type
**)
1443 TYPE_ALLOC (type
, (argcount
+ 2) * sizeof (struct type
*));
1445 /* FIXME: This is wrong for static member functions. */
1446 argtypes
[0] = lookup_pointer_type (type
);
1449 if (*p
!= ')') /* () means no args, skip while */
1454 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1456 /* Avoid parsing of ellipsis, they will be handled below. */
1457 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0)
1459 argtypes
[argcount
] =
1460 safe_parse_type (argtypetext
, p
- argtypetext
);
1463 argtypetext
= p
+ 1;
1466 if (*p
== '(' || *p
== '<')
1470 else if (*p
== ')' || *p
== '>')
1479 if (p
[-2] != '.') /* Not '...' */
1481 argtypes
[argcount
] = builtin_type_void
; /* List terminator */
1485 argtypes
[argcount
] = NULL
; /* Ellist terminator */
1488 xfree (demangled_name
);
1490 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1492 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1494 /* Now update the old "stub" type into a real type. */
1495 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1496 TYPE_DOMAIN_TYPE (mtype
) = type
;
1497 TYPE_ARG_TYPES (mtype
) = argtypes
;
1498 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1499 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1502 const struct cplus_struct_type cplus_struct_default
;
1505 allocate_cplus_struct_type (struct type
*type
)
1507 if (!HAVE_CPLUS_STRUCT (type
))
1509 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1510 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1511 *(TYPE_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1515 /* Helper function to initialize the standard scalar types.
1517 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1518 of the string pointed to by name in the type_obstack for that objfile,
1519 and initialize the type name to that copy. There are places (mipsread.c
1520 in particular, where init_type is called with a NULL value for NAME). */
1523 init_type (enum type_code code
, int length
, int flags
, char *name
,
1524 struct objfile
*objfile
)
1526 register struct type
*type
;
1528 type
= alloc_type (objfile
);
1529 TYPE_CODE (type
) = code
;
1530 TYPE_LENGTH (type
) = length
;
1531 TYPE_FLAGS (type
) |= flags
;
1532 if ((name
!= NULL
) && (objfile
!= NULL
))
1535 obsavestring (name
, strlen (name
), &objfile
->type_obstack
);
1539 TYPE_NAME (type
) = name
;
1544 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
1546 INIT_CPLUS_SPECIFIC (type
);
1551 /* Look up a fundamental type for the specified objfile.
1552 May need to construct such a type if this is the first use.
1554 Some object file formats (ELF, COFF, etc) do not define fundamental
1555 types such as "int" or "double". Others (stabs for example), do
1556 define fundamental types.
1558 For the formats which don't provide fundamental types, gdb can create
1559 such types, using defaults reasonable for the current language and
1560 the current target machine.
1562 NOTE: This routine is obsolescent. Each debugging format reader
1563 should manage it's own fundamental types, either creating them from
1564 suitable defaults or reading them from the debugging information,
1565 whichever is appropriate. The DWARF reader has already been
1566 fixed to do this. Once the other readers are fixed, this routine
1567 will go away. Also note that fundamental types should be managed
1568 on a compilation unit basis in a multi-language environment, not
1569 on a linkage unit basis as is done here. */
1573 lookup_fundamental_type (struct objfile
*objfile
, int typeid)
1575 register struct type
**typep
;
1576 register int nbytes
;
1578 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1580 error ("internal error - invalid fundamental type id %d", typeid);
1583 /* If this is the first time we need a fundamental type for this objfile
1584 then we need to initialize the vector of type pointers. */
1586 if (objfile
->fundamental_types
== NULL
)
1588 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1589 objfile
->fundamental_types
= (struct type
**)
1590 obstack_alloc (&objfile
->type_obstack
, nbytes
);
1591 memset ((char *) objfile
->fundamental_types
, 0, nbytes
);
1592 OBJSTAT (objfile
, n_types
+= FT_NUM_MEMBERS
);
1595 /* Look for this particular type in the fundamental type vector. If one is
1596 not found, create and install one appropriate for the current language. */
1598 typep
= objfile
->fundamental_types
+ typeid;
1601 *typep
= create_fundamental_type (objfile
, typeid);
1608 can_dereference (struct type
*t
)
1610 /* FIXME: Should we return true for references as well as pointers? */
1614 && TYPE_CODE (t
) == TYPE_CODE_PTR
1615 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1619 is_integral_type (struct type
*t
)
1624 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
1625 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
1626 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
1627 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
1628 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
1631 /* Chill varying string and arrays are represented as follows:
1633 struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
1635 Return true if TYPE is such a Chill varying type. */
1638 chill_varying_type (struct type
*type
)
1640 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1641 || TYPE_NFIELDS (type
) != 2
1642 || strcmp (TYPE_FIELD_NAME (type
, 0), "__var_length") != 0)
1647 /* Check whether BASE is an ancestor or base class or DCLASS
1648 Return 1 if so, and 0 if not.
1649 Note: callers may want to check for identity of the types before
1650 calling this function -- identical types are considered to satisfy
1651 the ancestor relationship even if they're identical */
1654 is_ancestor (struct type
*base
, struct type
*dclass
)
1658 CHECK_TYPEDEF (base
);
1659 CHECK_TYPEDEF (dclass
);
1663 if (TYPE_NAME (base
) && TYPE_NAME (dclass
) &&
1664 !strcmp (TYPE_NAME (base
), TYPE_NAME (dclass
)))
1667 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1668 if (is_ancestor (base
, TYPE_BASECLASS (dclass
, i
)))
1676 /* See whether DCLASS has a virtual table. This routine is aimed at
1677 the HP/Taligent ANSI C++ runtime model, and may not work with other
1678 runtime models. Return 1 => Yes, 0 => No. */
1681 has_vtable (struct type
*dclass
)
1683 /* In the HP ANSI C++ runtime model, a class has a vtable only if it
1684 has virtual functions or virtual bases. */
1688 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1691 /* First check for the presence of virtual bases */
1692 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
1693 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1694 if (B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
))
1697 /* Next check for virtual functions */
1698 if (TYPE_FN_FIELDLISTS (dclass
))
1699 for (i
= 0; i
< TYPE_NFN_FIELDS (dclass
); i
++)
1700 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, i
), 0))
1703 /* Recurse on non-virtual bases to see if any of them needs a vtable */
1704 if (TYPE_FIELD_VIRTUAL_BITS (dclass
))
1705 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1706 if ((!B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass
), i
)) &&
1707 (has_vtable (TYPE_FIELD_TYPE (dclass
, i
))))
1710 /* Well, maybe we don't need a virtual table */
1714 /* Return a pointer to the "primary base class" of DCLASS.
1716 A NULL return indicates that DCLASS has no primary base, or that it
1717 couldn't be found (insufficient information).
1719 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
1720 and may not work with other runtime models. */
1723 primary_base_class (struct type
*dclass
)
1725 /* In HP ANSI C++'s runtime model, a "primary base class" of a class
1726 is the first directly inherited, non-virtual base class that
1727 requires a virtual table */
1731 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1734 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1735 if (!TYPE_FIELD_VIRTUAL (dclass
, i
) &&
1736 has_vtable (TYPE_FIELD_TYPE (dclass
, i
)))
1737 return TYPE_FIELD_TYPE (dclass
, i
);
1742 /* Global manipulated by virtual_base_list[_aux]() */
1744 static struct vbase
*current_vbase_list
= NULL
;
1746 /* Return a pointer to a null-terminated list of struct vbase
1747 items. The vbasetype pointer of each item in the list points to the
1748 type information for a virtual base of the argument DCLASS.
1750 Helper function for virtual_base_list().
1751 Note: the list goes backward, right-to-left. virtual_base_list()
1752 copies the items out in reverse order. */
1755 virtual_base_list_aux (struct type
*dclass
)
1757 struct vbase
*tmp_vbase
;
1760 if (TYPE_CODE (dclass
) != TYPE_CODE_CLASS
)
1763 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1765 /* Recurse on this ancestor, first */
1766 virtual_base_list_aux (TYPE_FIELD_TYPE (dclass
, i
));
1768 /* If this current base is itself virtual, add it to the list */
1769 if (BASETYPE_VIA_VIRTUAL (dclass
, i
))
1771 struct type
*basetype
= TYPE_FIELD_TYPE (dclass
, i
);
1773 /* Check if base already recorded */
1774 tmp_vbase
= current_vbase_list
;
1777 if (tmp_vbase
->vbasetype
== basetype
)
1778 break; /* found it */
1779 tmp_vbase
= tmp_vbase
->next
;
1782 if (!tmp_vbase
) /* normal exit from loop */
1784 /* Allocate new item for this virtual base */
1785 tmp_vbase
= (struct vbase
*) xmalloc (sizeof (struct vbase
));
1787 /* Stick it on at the end of the list */
1788 tmp_vbase
->vbasetype
= basetype
;
1789 tmp_vbase
->next
= current_vbase_list
;
1790 current_vbase_list
= tmp_vbase
;
1793 } /* for loop over bases */
1797 /* Compute the list of virtual bases in the right order. Virtual
1798 bases are laid out in the object's memory area in order of their
1799 occurrence in a depth-first, left-to-right search through the
1802 Argument DCLASS is the type whose virtual bases are required.
1803 Return value is the address of a null-terminated array of pointers
1804 to struct type items.
1806 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
1807 and may not work with other runtime models.
1809 This routine merely hands off the argument to virtual_base_list_aux()
1810 and then copies the result into an array to save space. */
1813 virtual_base_list (struct type
*dclass
)
1815 register struct vbase
*tmp_vbase
;
1816 register struct vbase
*tmp_vbase_2
;
1819 struct type
**vbase_array
;
1821 current_vbase_list
= NULL
;
1822 virtual_base_list_aux (dclass
);
1824 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
1829 vbase_array
= (struct type
**) xmalloc ((count
+ 1) * sizeof (struct type
*));
1831 for (i
= count
- 1, tmp_vbase
= current_vbase_list
; i
>= 0; i
--, tmp_vbase
= tmp_vbase
->next
)
1832 vbase_array
[i
] = tmp_vbase
->vbasetype
;
1834 /* Get rid of constructed chain */
1835 tmp_vbase_2
= tmp_vbase
= current_vbase_list
;
1838 tmp_vbase
= tmp_vbase
->next
;
1839 xfree (tmp_vbase_2
);
1840 tmp_vbase_2
= tmp_vbase
;
1843 vbase_array
[count
] = NULL
;
1847 /* Return the length of the virtual base list of the type DCLASS. */
1850 virtual_base_list_length (struct type
*dclass
)
1853 register struct vbase
*tmp_vbase
;
1855 current_vbase_list
= NULL
;
1856 virtual_base_list_aux (dclass
);
1858 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; i
++, tmp_vbase
= tmp_vbase
->next
)
1863 /* Return the number of elements of the virtual base list of the type
1864 DCLASS, ignoring those appearing in the primary base (and its
1865 primary base, recursively). */
1868 virtual_base_list_length_skip_primaries (struct type
*dclass
)
1871 register struct vbase
*tmp_vbase
;
1872 struct type
*primary
;
1874 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
1877 return virtual_base_list_length (dclass
);
1879 current_vbase_list
= NULL
;
1880 virtual_base_list_aux (dclass
);
1882 for (i
= 0, tmp_vbase
= current_vbase_list
; tmp_vbase
!= NULL
; tmp_vbase
= tmp_vbase
->next
)
1884 if (virtual_base_index (tmp_vbase
->vbasetype
, primary
) >= 0)
1892 /* Return the index (position) of type BASE, which is a virtual base
1893 class of DCLASS, in the latter's virtual base list. A return of -1
1894 indicates "not found" or a problem. */
1897 virtual_base_index (struct type
*base
, struct type
*dclass
)
1899 register struct type
*vbase
;
1902 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
1903 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
1907 vbase
= TYPE_VIRTUAL_BASE_LIST (dclass
)[0];
1912 vbase
= TYPE_VIRTUAL_BASE_LIST (dclass
)[++i
];
1915 return vbase
? i
: -1;
1920 /* Return the index (position) of type BASE, which is a virtual base
1921 class of DCLASS, in the latter's virtual base list. Skip over all
1922 bases that may appear in the virtual base list of the primary base
1923 class of DCLASS (recursively). A return of -1 indicates "not
1924 found" or a problem. */
1927 virtual_base_index_skip_primaries (struct type
*base
, struct type
*dclass
)
1929 register struct type
*vbase
;
1931 struct type
*primary
;
1933 if ((TYPE_CODE (dclass
) != TYPE_CODE_CLASS
) ||
1934 (TYPE_CODE (base
) != TYPE_CODE_CLASS
))
1937 primary
= TYPE_RUNTIME_PTR (dclass
) ? TYPE_PRIMARY_BASE (dclass
) : NULL
;
1941 vbase
= TYPE_VIRTUAL_BASE_LIST (dclass
)[0];
1944 if (!primary
|| (virtual_base_index_skip_primaries (vbase
, primary
) < 0))
1948 vbase
= TYPE_VIRTUAL_BASE_LIST (dclass
)[++i
];
1951 return vbase
? j
: -1;
1954 /* Return position of a derived class DCLASS in the list of
1955 * primary bases starting with the remotest ancestor.
1956 * Position returned is 0-based. */
1959 class_index_in_primary_list (struct type
*dclass
)
1961 struct type
*pbc
; /* primary base class */
1963 /* Simply recurse on primary base */
1964 pbc
= TYPE_PRIMARY_BASE (dclass
);
1966 return 1 + class_index_in_primary_list (pbc
);
1971 /* Return a count of the number of virtual functions a type has.
1972 * This includes all the virtual functions it inherits from its
1976 /* pai: FIXME This doesn't do the right thing: count redefined virtual
1977 * functions only once (latest redefinition)
1981 count_virtual_fns (struct type
*dclass
)
1983 int fn
, oi
; /* function and overloaded instance indices */
1984 int vfuncs
; /* count to return */
1986 /* recurse on bases that can share virtual table */
1987 struct type
*pbc
= primary_base_class (dclass
);
1989 vfuncs
= count_virtual_fns (pbc
);
1993 for (fn
= 0; fn
< TYPE_NFN_FIELDS (dclass
); fn
++)
1994 for (oi
= 0; oi
< TYPE_FN_FIELDLIST_LENGTH (dclass
, fn
); oi
++)
1995 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass
, fn
), oi
))
2003 /* Functions for overload resolution begin here */
2005 /* Compare two badness vectors A and B and return the result.
2006 * 0 => A and B are identical
2007 * 1 => A and B are incomparable
2008 * 2 => A is better than B
2009 * 3 => A is worse than B */
2012 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
2016 short found_pos
= 0; /* any positives in c? */
2017 short found_neg
= 0; /* any negatives in c? */
2019 /* differing lengths => incomparable */
2020 if (a
->length
!= b
->length
)
2023 /* Subtract b from a */
2024 for (i
= 0; i
< a
->length
; i
++)
2026 tmp
= a
->rank
[i
] - b
->rank
[i
];
2036 return 1; /* incomparable */
2038 return 3; /* A > B */
2044 return 2; /* A < B */
2046 return 0; /* A == B */
2050 /* Rank a function by comparing its parameter types (PARMS, length NPARMS),
2051 * to the types of an argument list (ARGS, length NARGS).
2052 * Return a pointer to a badness vector. This has NARGS + 1 entries. */
2054 struct badness_vector
*
2055 rank_function (struct type
**parms
, int nparms
, struct type
**args
, int nargs
)
2058 struct badness_vector
*bv
;
2059 int min_len
= nparms
< nargs
? nparms
: nargs
;
2061 bv
= xmalloc (sizeof (struct badness_vector
));
2062 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank */
2063 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
2065 /* First compare the lengths of the supplied lists.
2066 * If there is a mismatch, set it to a high value. */
2068 /* pai/1997-06-03 FIXME: when we have debug info about default
2069 * arguments and ellipsis parameter lists, we should consider those
2070 * and rank the length-match more finely. */
2072 LENGTH_MATCH (bv
) = (nargs
!= nparms
) ? LENGTH_MISMATCH_BADNESS
: 0;
2074 /* Now rank all the parameters of the candidate function */
2075 for (i
= 1; i
<= min_len
; i
++)
2076 bv
->rank
[i
] = rank_one_type (parms
[i
-1], args
[i
-1]);
2078 /* If more arguments than parameters, add dummy entries */
2079 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2080 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2085 /* Compare one type (PARM) for compatibility with another (ARG).
2086 * PARM is intended to be the parameter type of a function; and
2087 * ARG is the supplied argument's type. This function tests if
2088 * the latter can be converted to the former.
2090 * Return 0 if they are identical types;
2091 * Otherwise, return an integer which corresponds to how compatible
2092 * PARM is to ARG. The higher the return value, the worse the match.
2093 * Generally the "bad" conversions are all uniformly assigned a 100 */
2096 rank_one_type (struct type
*parm
, struct type
*arg
)
2098 /* Identical type pointers */
2099 /* However, this still doesn't catch all cases of same type for arg
2100 * and param. The reason is that builtin types are different from
2101 * the same ones constructed from the object. */
2105 /* Resolve typedefs */
2106 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2107 parm
= check_typedef (parm
);
2108 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2109 arg
= check_typedef (arg
);
2112 Well, damnit, if the names are exactly the same,
2113 i'll say they are exactly the same. This happens when we generate
2114 method stubs. The types won't point to the same address, but they
2115 really are the same.
2118 if (TYPE_NAME (parm
) && TYPE_NAME (arg
) &&
2119 !strcmp (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2122 /* Check if identical after resolving typedefs */
2126 /* See through references, since we can almost make non-references
2128 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2129 return (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
))
2130 + REFERENCE_CONVERSION_BADNESS
);
2131 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2132 return (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
)
2133 + REFERENCE_CONVERSION_BADNESS
);
2135 /* Debugging only. */
2136 fprintf_filtered (gdb_stderr
,"------ Arg is %s [%d], parm is %s [%d]\n",
2137 TYPE_NAME (arg
), TYPE_CODE (arg
), TYPE_NAME (parm
), TYPE_CODE (parm
));
2139 /* x -> y means arg of type x being supplied for parameter of type y */
2141 switch (TYPE_CODE (parm
))
2144 switch (TYPE_CODE (arg
))
2147 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2148 return VOID_PTR_CONVERSION_BADNESS
;
2150 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2151 case TYPE_CODE_ARRAY
:
2152 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2153 case TYPE_CODE_FUNC
:
2154 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
);
2156 case TYPE_CODE_ENUM
:
2157 case TYPE_CODE_CHAR
:
2158 case TYPE_CODE_RANGE
:
2159 case TYPE_CODE_BOOL
:
2160 return POINTER_CONVERSION_BADNESS
;
2162 return INCOMPATIBLE_TYPE_BADNESS
;
2164 case TYPE_CODE_ARRAY
:
2165 switch (TYPE_CODE (arg
))
2168 case TYPE_CODE_ARRAY
:
2169 return rank_one_type (TYPE_TARGET_TYPE (parm
), TYPE_TARGET_TYPE (arg
));
2171 return INCOMPATIBLE_TYPE_BADNESS
;
2173 case TYPE_CODE_FUNC
:
2174 switch (TYPE_CODE (arg
))
2176 case TYPE_CODE_PTR
: /* funcptr -> func */
2177 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
));
2179 return INCOMPATIBLE_TYPE_BADNESS
;
2182 switch (TYPE_CODE (arg
))
2185 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2187 /* Deal with signed, unsigned, and plain chars and
2188 signed and unsigned ints */
2189 if (TYPE_NOSIGN (parm
))
2191 /* This case only for character types */
2192 if (TYPE_NOSIGN (arg
)) /* plain char -> plain char */
2195 return INTEGER_COERCION_BADNESS
; /* signed/unsigned char -> plain char */
2197 else if (TYPE_UNSIGNED (parm
))
2199 if (TYPE_UNSIGNED (arg
))
2201 if (!strcmp_iw (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2202 return 0; /* unsigned int -> unsigned int, or unsigned long -> unsigned long */
2203 else if (!strcmp_iw (TYPE_NAME (arg
), "int") && !strcmp_iw (TYPE_NAME (parm
), "long"))
2204 return INTEGER_PROMOTION_BADNESS
; /* unsigned int -> unsigned long */
2206 return INTEGER_COERCION_BADNESS
; /* unsigned long -> unsigned int */
2210 if (!strcmp_iw (TYPE_NAME (arg
), "long") && !strcmp_iw (TYPE_NAME (parm
), "int"))
2211 return INTEGER_COERCION_BADNESS
; /* signed long -> unsigned int */
2213 return INTEGER_CONVERSION_BADNESS
; /* signed int/long -> unsigned int/long */
2216 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2218 if (!strcmp_iw (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2220 else if (!strcmp_iw (TYPE_NAME (arg
), "int") && !strcmp_iw (TYPE_NAME (parm
), "long"))
2221 return INTEGER_PROMOTION_BADNESS
;
2223 return INTEGER_COERCION_BADNESS
;
2226 return INTEGER_COERCION_BADNESS
;
2228 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2229 return INTEGER_PROMOTION_BADNESS
;
2231 return INTEGER_COERCION_BADNESS
;
2232 case TYPE_CODE_ENUM
:
2233 case TYPE_CODE_CHAR
:
2234 case TYPE_CODE_RANGE
:
2235 case TYPE_CODE_BOOL
:
2236 return INTEGER_PROMOTION_BADNESS
;
2238 return INT_FLOAT_CONVERSION_BADNESS
;
2240 return NS_POINTER_CONVERSION_BADNESS
;
2242 return INCOMPATIBLE_TYPE_BADNESS
;
2245 case TYPE_CODE_ENUM
:
2246 switch (TYPE_CODE (arg
))
2249 case TYPE_CODE_CHAR
:
2250 case TYPE_CODE_RANGE
:
2251 case TYPE_CODE_BOOL
:
2252 case TYPE_CODE_ENUM
:
2253 return INTEGER_COERCION_BADNESS
;
2255 return INT_FLOAT_CONVERSION_BADNESS
;
2257 return INCOMPATIBLE_TYPE_BADNESS
;
2260 case TYPE_CODE_CHAR
:
2261 switch (TYPE_CODE (arg
))
2263 case TYPE_CODE_RANGE
:
2264 case TYPE_CODE_BOOL
:
2265 case TYPE_CODE_ENUM
:
2266 return INTEGER_COERCION_BADNESS
;
2268 return INT_FLOAT_CONVERSION_BADNESS
;
2270 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2271 return INTEGER_COERCION_BADNESS
;
2272 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2273 return INTEGER_PROMOTION_BADNESS
;
2274 /* >>> !! else fall through !! <<< */
2275 case TYPE_CODE_CHAR
:
2276 /* Deal with signed, unsigned, and plain chars for C++
2277 and with int cases falling through from previous case */
2278 if (TYPE_NOSIGN (parm
))
2280 if (TYPE_NOSIGN (arg
))
2283 return INTEGER_COERCION_BADNESS
;
2285 else if (TYPE_UNSIGNED (parm
))
2287 if (TYPE_UNSIGNED (arg
))
2290 return INTEGER_PROMOTION_BADNESS
;
2292 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2295 return INTEGER_COERCION_BADNESS
;
2297 return INCOMPATIBLE_TYPE_BADNESS
;
2300 case TYPE_CODE_RANGE
:
2301 switch (TYPE_CODE (arg
))
2304 case TYPE_CODE_CHAR
:
2305 case TYPE_CODE_RANGE
:
2306 case TYPE_CODE_BOOL
:
2307 case TYPE_CODE_ENUM
:
2308 return INTEGER_COERCION_BADNESS
;
2310 return INT_FLOAT_CONVERSION_BADNESS
;
2312 return INCOMPATIBLE_TYPE_BADNESS
;
2315 case TYPE_CODE_BOOL
:
2316 switch (TYPE_CODE (arg
))
2319 case TYPE_CODE_CHAR
:
2320 case TYPE_CODE_RANGE
:
2321 case TYPE_CODE_ENUM
:
2324 return BOOLEAN_CONVERSION_BADNESS
;
2325 case TYPE_CODE_BOOL
:
2328 return INCOMPATIBLE_TYPE_BADNESS
;
2332 switch (TYPE_CODE (arg
))
2335 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2336 return FLOAT_PROMOTION_BADNESS
;
2337 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2340 return FLOAT_CONVERSION_BADNESS
;
2342 case TYPE_CODE_BOOL
:
2343 case TYPE_CODE_ENUM
:
2344 case TYPE_CODE_RANGE
:
2345 case TYPE_CODE_CHAR
:
2346 return INT_FLOAT_CONVERSION_BADNESS
;
2348 return INCOMPATIBLE_TYPE_BADNESS
;
2351 case TYPE_CODE_COMPLEX
:
2352 switch (TYPE_CODE (arg
))
2353 { /* Strictly not needed for C++, but... */
2355 return FLOAT_PROMOTION_BADNESS
;
2356 case TYPE_CODE_COMPLEX
:
2359 return INCOMPATIBLE_TYPE_BADNESS
;
2362 case TYPE_CODE_STRUCT
:
2363 /* currently same as TYPE_CODE_CLASS */
2364 switch (TYPE_CODE (arg
))
2366 case TYPE_CODE_STRUCT
:
2367 /* Check for derivation */
2368 if (is_ancestor (parm
, arg
))
2369 return BASE_CONVERSION_BADNESS
;
2370 /* else fall through */
2372 return INCOMPATIBLE_TYPE_BADNESS
;
2375 case TYPE_CODE_UNION
:
2376 switch (TYPE_CODE (arg
))
2378 case TYPE_CODE_UNION
:
2380 return INCOMPATIBLE_TYPE_BADNESS
;
2383 case TYPE_CODE_MEMBER
:
2384 switch (TYPE_CODE (arg
))
2387 return INCOMPATIBLE_TYPE_BADNESS
;
2390 case TYPE_CODE_METHOD
:
2391 switch (TYPE_CODE (arg
))
2395 return INCOMPATIBLE_TYPE_BADNESS
;
2399 switch (TYPE_CODE (arg
))
2403 return INCOMPATIBLE_TYPE_BADNESS
;
2408 switch (TYPE_CODE (arg
))
2412 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0), TYPE_FIELD_TYPE (arg
, 0));
2414 return INCOMPATIBLE_TYPE_BADNESS
;
2417 case TYPE_CODE_VOID
:
2419 return INCOMPATIBLE_TYPE_BADNESS
;
2420 } /* switch (TYPE_CODE (arg)) */
2424 /* End of functions for overload resolution */
2427 print_bit_vector (B_TYPE
*bits
, int nbits
)
2431 for (bitno
= 0; bitno
< nbits
; bitno
++)
2433 if ((bitno
% 8) == 0)
2435 puts_filtered (" ");
2437 if (B_TST (bits
, bitno
))
2439 printf_filtered ("1");
2443 printf_filtered ("0");
2448 /* The args list is a strange beast. It is either terminated by a NULL
2449 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
2450 type for normal fixed argcount functions. (FIXME someday)
2451 Also note the first arg should be the "this" pointer, we may not want to
2452 include it since we may get into a infinitely recursive situation. */
2455 print_arg_types (struct type
**args
, int spaces
)
2459 while (*args
!= NULL
)
2461 recursive_dump_type (*args
, spaces
+ 2);
2462 if ((*args
++)->code
== TYPE_CODE_VOID
)
2471 dump_fn_fieldlists (struct type
*type
, int spaces
)
2477 printfi_filtered (spaces
, "fn_fieldlists ");
2478 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2479 printf_filtered ("\n");
2480 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2482 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2483 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2485 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2486 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2488 printf_filtered (") length %d\n",
2489 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2490 for (overload_idx
= 0;
2491 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2494 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2496 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2497 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2499 printf_filtered (")\n");
2500 printfi_filtered (spaces
+ 8, "type ");
2501 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
2502 printf_filtered ("\n");
2504 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2507 printfi_filtered (spaces
+ 8, "args ");
2508 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
2509 printf_filtered ("\n");
2511 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
), spaces
);
2512 printfi_filtered (spaces
+ 8, "fcontext ");
2513 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2515 printf_filtered ("\n");
2517 printfi_filtered (spaces
+ 8, "is_const %d\n",
2518 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2519 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2520 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2521 printfi_filtered (spaces
+ 8, "is_private %d\n",
2522 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2523 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2524 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2525 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2526 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2527 printfi_filtered (spaces
+ 8, "voffset %u\n",
2528 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2534 print_cplus_stuff (struct type
*type
, int spaces
)
2536 printfi_filtered (spaces
, "n_baseclasses %d\n",
2537 TYPE_N_BASECLASSES (type
));
2538 printfi_filtered (spaces
, "nfn_fields %d\n",
2539 TYPE_NFN_FIELDS (type
));
2540 printfi_filtered (spaces
, "nfn_fields_total %d\n",
2541 TYPE_NFN_FIELDS_TOTAL (type
));
2542 if (TYPE_N_BASECLASSES (type
) > 0)
2544 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2545 TYPE_N_BASECLASSES (type
));
2546 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
2547 printf_filtered (")");
2549 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2550 TYPE_N_BASECLASSES (type
));
2551 puts_filtered ("\n");
2553 if (TYPE_NFIELDS (type
) > 0)
2555 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2557 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
2558 TYPE_NFIELDS (type
));
2559 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
2560 printf_filtered (")");
2561 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2562 TYPE_NFIELDS (type
));
2563 puts_filtered ("\n");
2565 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2567 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
2568 TYPE_NFIELDS (type
));
2569 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
2570 printf_filtered (")");
2571 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2572 TYPE_NFIELDS (type
));
2573 puts_filtered ("\n");
2576 if (TYPE_NFN_FIELDS (type
) > 0)
2578 dump_fn_fieldlists (type
, spaces
);
2582 static struct obstack dont_print_type_obstack
;
2585 recursive_dump_type (struct type
*type
, int spaces
)
2590 obstack_begin (&dont_print_type_obstack
, 0);
2592 if (TYPE_NFIELDS (type
) > 0
2593 || (TYPE_CPLUS_SPECIFIC (type
) && TYPE_NFN_FIELDS (type
) > 0))
2595 struct type
**first_dont_print
2596 = (struct type
**) obstack_base (&dont_print_type_obstack
);
2598 int i
= (struct type
**) obstack_next_free (&dont_print_type_obstack
)
2603 if (type
== first_dont_print
[i
])
2605 printfi_filtered (spaces
, "type node ");
2606 gdb_print_host_address (type
, gdb_stdout
);
2607 printf_filtered (" <same as already seen type>\n");
2612 obstack_ptr_grow (&dont_print_type_obstack
, type
);
2615 printfi_filtered (spaces
, "type node ");
2616 gdb_print_host_address (type
, gdb_stdout
);
2617 printf_filtered ("\n");
2618 printfi_filtered (spaces
, "name '%s' (",
2619 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
2620 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
2621 printf_filtered (")\n");
2622 if (TYPE_TAG_NAME (type
) != NULL
)
2624 printfi_filtered (spaces
, "tagname '%s' (",
2625 TYPE_TAG_NAME (type
));
2626 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
2627 printf_filtered (")\n");
2629 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
2630 switch (TYPE_CODE (type
))
2632 case TYPE_CODE_UNDEF
:
2633 printf_filtered ("(TYPE_CODE_UNDEF)");
2636 printf_filtered ("(TYPE_CODE_PTR)");
2638 case TYPE_CODE_ARRAY
:
2639 printf_filtered ("(TYPE_CODE_ARRAY)");
2641 case TYPE_CODE_STRUCT
:
2642 printf_filtered ("(TYPE_CODE_STRUCT)");
2644 case TYPE_CODE_UNION
:
2645 printf_filtered ("(TYPE_CODE_UNION)");
2647 case TYPE_CODE_ENUM
:
2648 printf_filtered ("(TYPE_CODE_ENUM)");
2650 case TYPE_CODE_FUNC
:
2651 printf_filtered ("(TYPE_CODE_FUNC)");
2654 printf_filtered ("(TYPE_CODE_INT)");
2657 printf_filtered ("(TYPE_CODE_FLT)");
2659 case TYPE_CODE_VOID
:
2660 printf_filtered ("(TYPE_CODE_VOID)");
2663 printf_filtered ("(TYPE_CODE_SET)");
2665 case TYPE_CODE_RANGE
:
2666 printf_filtered ("(TYPE_CODE_RANGE)");
2668 case TYPE_CODE_STRING
:
2669 printf_filtered ("(TYPE_CODE_STRING)");
2671 case TYPE_CODE_ERROR
:
2672 printf_filtered ("(TYPE_CODE_ERROR)");
2674 case TYPE_CODE_MEMBER
:
2675 printf_filtered ("(TYPE_CODE_MEMBER)");
2677 case TYPE_CODE_METHOD
:
2678 printf_filtered ("(TYPE_CODE_METHOD)");
2681 printf_filtered ("(TYPE_CODE_REF)");
2683 case TYPE_CODE_CHAR
:
2684 printf_filtered ("(TYPE_CODE_CHAR)");
2686 case TYPE_CODE_BOOL
:
2687 printf_filtered ("(TYPE_CODE_BOOL)");
2689 case TYPE_CODE_TYPEDEF
:
2690 printf_filtered ("(TYPE_CODE_TYPEDEF)");
2693 printf_filtered ("(UNKNOWN TYPE CODE)");
2696 puts_filtered ("\n");
2697 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
2698 printfi_filtered (spaces
, "objfile ");
2699 gdb_print_host_address (TYPE_OBJFILE (type
), gdb_stdout
);
2700 printf_filtered ("\n");
2701 printfi_filtered (spaces
, "target_type ");
2702 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
2703 printf_filtered ("\n");
2704 if (TYPE_TARGET_TYPE (type
) != NULL
)
2706 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
2708 printfi_filtered (spaces
, "pointer_type ");
2709 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
2710 printf_filtered ("\n");
2711 printfi_filtered (spaces
, "reference_type ");
2712 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
2713 printf_filtered ("\n");
2714 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
2715 if (TYPE_FLAGS (type
) & TYPE_FLAG_UNSIGNED
)
2717 puts_filtered (" TYPE_FLAG_UNSIGNED");
2719 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
2721 puts_filtered (" TYPE_FLAG_STUB");
2723 puts_filtered ("\n");
2724 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
2725 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
2726 puts_filtered ("\n");
2727 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
2729 printfi_filtered (spaces
+ 2,
2730 "[%d] bitpos %d bitsize %d type ",
2731 idx
, TYPE_FIELD_BITPOS (type
, idx
),
2732 TYPE_FIELD_BITSIZE (type
, idx
));
2733 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
2734 printf_filtered (" name '%s' (",
2735 TYPE_FIELD_NAME (type
, idx
) != NULL
2736 ? TYPE_FIELD_NAME (type
, idx
)
2738 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
2739 printf_filtered (")\n");
2740 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
2742 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
2745 printfi_filtered (spaces
, "vptr_basetype ");
2746 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
2747 puts_filtered ("\n");
2748 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
2750 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
2752 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
2753 switch (TYPE_CODE (type
))
2755 case TYPE_CODE_METHOD
:
2756 case TYPE_CODE_FUNC
:
2757 printfi_filtered (spaces
, "arg_types ");
2758 gdb_print_host_address (TYPE_ARG_TYPES (type
), gdb_stdout
);
2759 puts_filtered ("\n");
2760 print_arg_types (TYPE_ARG_TYPES (type
), spaces
);
2763 case TYPE_CODE_STRUCT
:
2764 printfi_filtered (spaces
, "cplus_stuff ");
2765 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
2766 puts_filtered ("\n");
2767 print_cplus_stuff (type
, spaces
);
2771 /* We have to pick one of the union types to be able print and test
2772 the value. Pick cplus_struct_type, even though we know it isn't
2773 any particular one. */
2774 printfi_filtered (spaces
, "type_specific ");
2775 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
2776 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
2778 printf_filtered (" (unknown data form)");
2780 printf_filtered ("\n");
2785 obstack_free (&dont_print_type_obstack
, NULL
);
2788 static void build_gdbtypes (void);
2790 build_gdbtypes (void)
2793 init_type (TYPE_CODE_VOID
, 1,
2795 "void", (struct objfile
*) NULL
);
2797 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
2799 "char", (struct objfile
*) NULL
);
2800 TYPE_FLAGS (builtin_type_char
) |= TYPE_FLAG_NOSIGN
;
2801 builtin_type_true_char
=
2802 init_type (TYPE_CODE_CHAR
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
2804 "true character", (struct objfile
*) NULL
);
2805 builtin_type_signed_char
=
2806 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
2808 "signed char", (struct objfile
*) NULL
);
2809 builtin_type_unsigned_char
=
2810 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
2812 "unsigned char", (struct objfile
*) NULL
);
2813 builtin_type_short
=
2814 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
2816 "short", (struct objfile
*) NULL
);
2817 builtin_type_unsigned_short
=
2818 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
2820 "unsigned short", (struct objfile
*) NULL
);
2822 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
2824 "int", (struct objfile
*) NULL
);
2825 builtin_type_unsigned_int
=
2826 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
2828 "unsigned int", (struct objfile
*) NULL
);
2830 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
2832 "long", (struct objfile
*) NULL
);
2833 builtin_type_unsigned_long
=
2834 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
2836 "unsigned long", (struct objfile
*) NULL
);
2837 builtin_type_long_long
=
2838 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
2840 "long long", (struct objfile
*) NULL
);
2841 builtin_type_unsigned_long_long
=
2842 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
2844 "unsigned long long", (struct objfile
*) NULL
);
2845 builtin_type_float
=
2846 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
2848 "float", (struct objfile
*) NULL
);
2849 builtin_type_double
=
2850 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
2852 "double", (struct objfile
*) NULL
);
2853 builtin_type_long_double
=
2854 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
2856 "long double", (struct objfile
*) NULL
);
2857 builtin_type_complex
=
2858 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
2860 "complex", (struct objfile
*) NULL
);
2861 TYPE_TARGET_TYPE (builtin_type_complex
) = builtin_type_float
;
2862 builtin_type_double_complex
=
2863 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
2865 "double complex", (struct objfile
*) NULL
);
2866 TYPE_TARGET_TYPE (builtin_type_double_complex
) = builtin_type_double
;
2867 builtin_type_string
=
2868 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
2870 "string", (struct objfile
*) NULL
);
2872 init_type (TYPE_CODE_INT
, 8 / 8,
2874 "int8_t", (struct objfile
*) NULL
);
2875 builtin_type_uint8
=
2876 init_type (TYPE_CODE_INT
, 8 / 8,
2878 "uint8_t", (struct objfile
*) NULL
);
2879 builtin_type_int16
=
2880 init_type (TYPE_CODE_INT
, 16 / 8,
2882 "int16_t", (struct objfile
*) NULL
);
2883 builtin_type_uint16
=
2884 init_type (TYPE_CODE_INT
, 16 / 8,
2886 "uint16_t", (struct objfile
*) NULL
);
2887 builtin_type_int32
=
2888 init_type (TYPE_CODE_INT
, 32 / 8,
2890 "int32_t", (struct objfile
*) NULL
);
2891 builtin_type_uint32
=
2892 init_type (TYPE_CODE_INT
, 32 / 8,
2894 "uint32_t", (struct objfile
*) NULL
);
2895 builtin_type_int64
=
2896 init_type (TYPE_CODE_INT
, 64 / 8,
2898 "int64_t", (struct objfile
*) NULL
);
2899 builtin_type_uint64
=
2900 init_type (TYPE_CODE_INT
, 64 / 8,
2902 "uint64_t", (struct objfile
*) NULL
);
2904 init_type (TYPE_CODE_BOOL
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
2906 "bool", (struct objfile
*) NULL
);
2908 /* Add user knob for controlling resolution of opaque types */
2910 (add_set_cmd ("opaque-type-resolution", class_support
, var_boolean
, (char *) &opaque_type_resolution
,
2911 "Set resolution of opaque struct/class/union types (if set before loading symbols).",
2914 opaque_type_resolution
= 1;
2917 /* Build SIMD types. */
2919 = init_simd_type ("__builtin_v4sf", builtin_type_float
, "f", 4);
2921 = init_simd_type ("__builtin_v4si", builtin_type_int32
, "f", 4);
2923 = init_simd_type ("__builtin_v8qi", builtin_type_int8
, "f", 8);
2925 = init_simd_type ("__builtin_v4hi", builtin_type_int16
, "f", 4);
2927 = init_simd_type ("__builtin_v2si", builtin_type_int32
, "f", 2);
2929 /* Pointer/Address types. */
2930 /* NOTE: At present there is no way of differentiating between at
2931 target address and the target C language pointer type type even
2932 though the two can be different (cf d10v) */
2933 builtin_type_ptr
= make_pointer_type (builtin_type_void
, NULL
);
2934 builtin_type_CORE_ADDR
=
2935 init_type (TYPE_CODE_INT
, TARGET_ADDR_BIT
/ 8,
2937 "__CORE_ADDR", (struct objfile
*) NULL
);
2938 builtin_type_bfd_vma
=
2939 init_type (TYPE_CODE_INT
, TARGET_BFD_VMA_BIT
/ 8,
2941 "__bfd_vma", (struct objfile
*) NULL
);
2945 extern void _initialize_gdbtypes (void);
2947 _initialize_gdbtypes (void)
2949 struct cmd_list_element
*c
;
2952 /* FIXME - For the moment, handle types by swapping them in and out.
2953 Should be using the per-architecture data-pointer and a large
2955 register_gdbarch_swap (&builtin_type_void
, sizeof (struct type
*), NULL
);
2956 register_gdbarch_swap (&builtin_type_char
, sizeof (struct type
*), NULL
);
2957 register_gdbarch_swap (&builtin_type_short
, sizeof (struct type
*), NULL
);
2958 register_gdbarch_swap (&builtin_type_int
, sizeof (struct type
*), NULL
);
2959 register_gdbarch_swap (&builtin_type_long
, sizeof (struct type
*), NULL
);
2960 register_gdbarch_swap (&builtin_type_long_long
, sizeof (struct type
*), NULL
);
2961 register_gdbarch_swap (&builtin_type_signed_char
, sizeof (struct type
*), NULL
);
2962 register_gdbarch_swap (&builtin_type_unsigned_char
, sizeof (struct type
*), NULL
);
2963 register_gdbarch_swap (&builtin_type_unsigned_short
, sizeof (struct type
*), NULL
);
2964 register_gdbarch_swap (&builtin_type_unsigned_int
, sizeof (struct type
*), NULL
);
2965 register_gdbarch_swap (&builtin_type_unsigned_long
, sizeof (struct type
*), NULL
);
2966 register_gdbarch_swap (&builtin_type_unsigned_long_long
, sizeof (struct type
*), NULL
);
2967 register_gdbarch_swap (&builtin_type_float
, sizeof (struct type
*), NULL
);
2968 register_gdbarch_swap (&builtin_type_double
, sizeof (struct type
*), NULL
);
2969 register_gdbarch_swap (&builtin_type_long_double
, sizeof (struct type
*), NULL
);
2970 register_gdbarch_swap (&builtin_type_complex
, sizeof (struct type
*), NULL
);
2971 register_gdbarch_swap (&builtin_type_double_complex
, sizeof (struct type
*), NULL
);
2972 register_gdbarch_swap (&builtin_type_string
, sizeof (struct type
*), NULL
);
2973 register_gdbarch_swap (&builtin_type_int8
, sizeof (struct type
*), NULL
);
2974 register_gdbarch_swap (&builtin_type_uint8
, sizeof (struct type
*), NULL
);
2975 register_gdbarch_swap (&builtin_type_int16
, sizeof (struct type
*), NULL
);
2976 register_gdbarch_swap (&builtin_type_uint16
, sizeof (struct type
*), NULL
);
2977 register_gdbarch_swap (&builtin_type_int32
, sizeof (struct type
*), NULL
);
2978 register_gdbarch_swap (&builtin_type_uint32
, sizeof (struct type
*), NULL
);
2979 register_gdbarch_swap (&builtin_type_int64
, sizeof (struct type
*), NULL
);
2980 register_gdbarch_swap (&builtin_type_uint64
, sizeof (struct type
*), NULL
);
2981 register_gdbarch_swap (&builtin_type_v4sf
, sizeof (struct type
*), NULL
);
2982 register_gdbarch_swap (&builtin_type_v4si
, sizeof (struct type
*), NULL
);
2983 register_gdbarch_swap (&builtin_type_v8qi
, sizeof (struct type
*), NULL
);
2984 register_gdbarch_swap (&builtin_type_v4hi
, sizeof (struct type
*), NULL
);
2985 register_gdbarch_swap (&builtin_type_v2si
, sizeof (struct type
*), NULL
);
2986 REGISTER_GDBARCH_SWAP (builtin_type_ptr
);
2987 REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR
);
2988 REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma
);
2989 register_gdbarch_swap (NULL
, 0, build_gdbtypes
);
2992 add_set_cmd ("overload", no_class
, var_zinteger
, (char *) &overload_debug
,
2993 "Set debugging of C++ overloading.\n\
2994 When enabled, ranking of the functions\n\
2995 is displayed.", &setdebuglist
),