1 /* Support routines for manipulating internal types for GDB.
2 Copyright (C) 1992 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
28 #include "expression.h"
33 #include "complaints.h"
35 /* These variables point to the objects
36 representing the predefined C data types. */
38 struct type
*builtin_type_void
;
39 struct type
*builtin_type_char
;
40 struct type
*builtin_type_short
;
41 struct type
*builtin_type_int
;
42 struct type
*builtin_type_long
;
43 struct type
*builtin_type_long_long
;
44 struct type
*builtin_type_signed_char
;
45 struct type
*builtin_type_unsigned_char
;
46 struct type
*builtin_type_unsigned_short
;
47 struct type
*builtin_type_unsigned_int
;
48 struct type
*builtin_type_unsigned_long
;
49 struct type
*builtin_type_unsigned_long_long
;
50 struct type
*builtin_type_float
;
51 struct type
*builtin_type_double
;
52 struct type
*builtin_type_long_double
;
53 struct type
*builtin_type_complex
;
54 struct type
*builtin_type_double_complex
;
55 struct type
*builtin_type_string
;
57 /* Alloc a new type structure and fill it with some defaults. If
58 OBJFILE is non-NULL, then allocate the space for the type structure
59 in that objfile's type_obstack. */
63 struct objfile
*objfile
;
65 register struct type
*type
;
67 /* Alloc the structure and start off with all fields zeroed. */
71 type
= (struct type
*) xmalloc (sizeof (struct type
));
75 type
= (struct type
*) obstack_alloc (&objfile
-> type_obstack
,
76 sizeof (struct type
));
78 memset ((char *) type
, 0, sizeof (struct type
));
80 /* Initialize the fields that might not be zero. */
82 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
83 TYPE_OBJFILE (type
) = objfile
;
84 TYPE_VPTR_FIELDNO (type
) = -1;
89 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
90 to a pointer to memory where the pointer type should be stored.
91 If *TYPEPTR is zero, update it to point to the pointer type we return.
92 We allocate new memory if needed. */
95 make_pointer_type (type
, typeptr
)
97 struct type
**typeptr
;
99 register struct type
*ntype
; /* New type */
100 struct objfile
*objfile
;
102 ntype
= TYPE_POINTER_TYPE (type
);
106 return ntype
; /* Don't care about alloc, and have new type. */
107 else if (*typeptr
== 0)
109 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
113 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
115 ntype
= alloc_type (TYPE_OBJFILE (type
));
119 else /* We have storage, but need to reset it. */
122 objfile
= TYPE_OBJFILE (ntype
);
123 memset ((char *) ntype
, 0, sizeof (struct type
));
124 TYPE_OBJFILE (ntype
) = objfile
;
127 TYPE_TARGET_TYPE (ntype
) = type
;
128 TYPE_POINTER_TYPE (type
) = ntype
;
130 /* FIXME! Assume the machine has only one representation for pointers! */
132 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
133 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
135 /* pointers are unsigned */
136 TYPE_FLAGS (ntype
) |= TYPE_FLAG_UNSIGNED
;
138 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
139 TYPE_POINTER_TYPE (type
) = ntype
;
144 /* Given a type TYPE, return a type of pointers to that type.
145 May need to construct such a type if this is the first use. */
148 lookup_pointer_type (type
)
151 return make_pointer_type (type
, (struct type
**)0);
154 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero, points
155 to a pointer to memory where the reference type should be stored.
156 If *TYPEPTR is zero, update it to point to the reference type we return.
157 We allocate new memory if needed. */
160 make_reference_type (type
, typeptr
)
162 struct type
**typeptr
;
164 register struct type
*ntype
; /* New type */
165 struct objfile
*objfile
;
167 ntype
= TYPE_REFERENCE_TYPE (type
);
171 return ntype
; /* Don't care about alloc, and have new type. */
172 else if (*typeptr
== 0)
174 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
178 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
180 ntype
= alloc_type (TYPE_OBJFILE (type
));
184 else /* We have storage, but need to reset it. */
187 objfile
= TYPE_OBJFILE (ntype
);
188 memset ((char *) ntype
, 0, sizeof (struct type
));
189 TYPE_OBJFILE (ntype
) = objfile
;
192 TYPE_TARGET_TYPE (ntype
) = type
;
193 TYPE_REFERENCE_TYPE (type
) = ntype
;
195 /* FIXME! Assume the machine has only one representation for references,
196 and that it matches the (only) representation for pointers! */
198 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
199 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
201 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
202 TYPE_REFERENCE_TYPE (type
) = ntype
;
207 /* Same as above, but caller doesn't care about memory allocation details. */
210 lookup_reference_type (type
)
213 return make_reference_type (type
, (struct type
**)0);
216 /* Lookup a function type that returns type TYPE. TYPEPTR, if nonzero, points
217 to a pointer to memory where the function type should be stored.
218 If *TYPEPTR is zero, update it to point to the function type we return.
219 We allocate new memory if needed. */
222 make_function_type (type
, typeptr
)
224 struct type
**typeptr
;
226 register struct type
*ntype
; /* New type */
227 struct objfile
*objfile
;
229 ntype
= TYPE_FUNCTION_TYPE (type
);
233 return ntype
; /* Don't care about alloc, and have new type. */
234 else if (*typeptr
== 0)
236 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
240 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
242 ntype
= alloc_type (TYPE_OBJFILE (type
));
246 else /* We have storage, but need to reset it. */
249 objfile
= TYPE_OBJFILE (ntype
);
250 memset ((char *) ntype
, 0, sizeof (struct type
));
251 TYPE_OBJFILE (ntype
) = objfile
;
254 TYPE_TARGET_TYPE (ntype
) = type
;
255 TYPE_FUNCTION_TYPE (type
) = ntype
;
257 TYPE_LENGTH (ntype
) = 1;
258 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
260 if (!TYPE_FUNCTION_TYPE (type
)) /* Remember it, if don't have one. */
261 TYPE_FUNCTION_TYPE (type
) = ntype
;
267 /* Given a type TYPE, return a type of functions that return that type.
268 May need to construct such a type if this is the first use. */
271 lookup_function_type (type
)
274 return make_function_type (type
, (struct type
**)0);
277 /* Implement direct support for MEMBER_TYPE in GNU C++.
278 May need to construct such a type if this is the first use.
279 The TYPE is the type of the member. The DOMAIN is the type
280 of the aggregate that the member belongs to. */
283 lookup_member_type (type
, domain
)
287 register struct type
*mtype
;
289 mtype
= alloc_type (TYPE_OBJFILE (type
));
290 smash_to_member_type (mtype
, domain
, type
);
294 /* Allocate a stub method whose return type is TYPE.
295 This apparently happens for speed of symbol reading, since parsing
296 out the arguments to the method is cpu-intensive, the way we are doing
297 it. So, we will fill in arguments later.
298 This always returns a fresh type. */
301 allocate_stub_method (type
)
306 mtype
= alloc_type (TYPE_OBJFILE (type
));
307 TYPE_TARGET_TYPE (mtype
) = type
;
308 /* _DOMAIN_TYPE (mtype) = unknown yet */
309 /* _ARG_TYPES (mtype) = unknown yet */
310 TYPE_FLAGS (mtype
) = TYPE_FLAG_STUB
;
311 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
312 TYPE_LENGTH (mtype
) = 1;
316 /* Create a range type using either a blank type supplied in RESULT_TYPE,
317 or creating a new type, inheriting the objfile from INDEX_TYPE.
319 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
320 HIGH_BOUND, inclusive.
322 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
323 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
326 create_range_type (result_type
, index_type
, low_bound
, high_bound
)
327 struct type
*result_type
;
328 struct type
*index_type
;
332 if (result_type
== NULL
)
334 result_type
= alloc_type (TYPE_OBJFILE (index_type
));
336 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
337 TYPE_TARGET_TYPE (result_type
) = index_type
;
338 TYPE_LENGTH (result_type
) = TYPE_LENGTH (index_type
);
339 TYPE_NFIELDS (result_type
) = 2;
340 TYPE_FIELDS (result_type
) = (struct field
*)
341 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
342 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
343 TYPE_FIELD_BITPOS (result_type
, 0) = low_bound
;
344 TYPE_FIELD_BITPOS (result_type
, 1) = high_bound
;
345 TYPE_FIELD_TYPE (result_type
, 0) = builtin_type_int
; /* FIXME */
346 TYPE_FIELD_TYPE (result_type
, 1) = builtin_type_int
; /* FIXME */
348 return (result_type
);
352 /* Create an array type using either a blank type supplied in RESULT_TYPE,
353 or creating a new type, inheriting the objfile from RANGE_TYPE.
355 Elements will be of type ELEMENT_TYPE, the indices will be of type
358 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
359 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
362 create_array_type (result_type
, element_type
, range_type
)
363 struct type
*result_type
;
364 struct type
*element_type
;
365 struct type
*range_type
;
370 if (TYPE_CODE (range_type
) != TYPE_CODE_RANGE
)
372 /* FIXME: We only handle range types at the moment. Complain and
373 create a dummy range type to use. */
374 warning ("internal error: array index type must be a range type");
375 range_type
= lookup_fundamental_type (TYPE_OBJFILE (range_type
),
377 range_type
= create_range_type ((struct type
*) NULL
, range_type
, 0, 0);
379 if (result_type
== NULL
)
381 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
383 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
384 TYPE_TARGET_TYPE (result_type
) = element_type
;
385 low_bound
= TYPE_FIELD_BITPOS (range_type
, 0);
386 high_bound
= TYPE_FIELD_BITPOS (range_type
, 1);
387 TYPE_LENGTH (result_type
) =
388 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
389 TYPE_NFIELDS (result_type
) = 1;
390 TYPE_FIELDS (result_type
) =
391 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
392 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
393 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
394 TYPE_VPTR_FIELDNO (result_type
) = -1;
396 return (result_type
);
399 /* Create a string type using either a blank type supplied in RESULT_TYPE,
400 or creating a new type. String types are similar enough to array of
401 char types that we can use create_array_type to build the basic type
402 and then bash it into a string type.
404 For fixed length strings, the range type contains 0 as the lower
405 bound and the length of the string minus one as the upper bound.
407 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
408 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
411 create_string_type (result_type
, range_type
)
412 struct type
*result_type
;
413 struct type
*range_type
;
415 result_type
= create_array_type (result_type
, builtin_type_char
, range_type
);
416 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
417 return (result_type
);
420 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
421 A MEMBER is a wierd thing -- it amounts to a typed offset into
422 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
423 include the offset (that's the value of the MEMBER itself), but does
424 include the structure type into which it points (for some reason).
426 When "smashing" the type, we preserve the objfile that the
427 old type pointed to, since we aren't changing where the type is actually
431 smash_to_member_type (type
, domain
, to_type
)
434 struct type
*to_type
;
436 struct objfile
*objfile
;
438 objfile
= TYPE_OBJFILE (type
);
440 memset ((char *) type
, 0, sizeof (struct type
));
441 TYPE_OBJFILE (type
) = objfile
;
442 TYPE_TARGET_TYPE (type
) = to_type
;
443 TYPE_DOMAIN_TYPE (type
) = domain
;
444 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
445 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
448 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
449 METHOD just means `function that gets an extra "this" argument'.
451 When "smashing" the type, we preserve the objfile that the
452 old type pointed to, since we aren't changing where the type is actually
456 smash_to_method_type (type
, domain
, to_type
, args
)
459 struct type
*to_type
;
462 struct objfile
*objfile
;
464 objfile
= TYPE_OBJFILE (type
);
466 memset ((char *) type
, 0, sizeof (struct type
));
467 TYPE_OBJFILE (type
) = objfile
;
468 TYPE_TARGET_TYPE (type
) = to_type
;
469 TYPE_DOMAIN_TYPE (type
) = domain
;
470 TYPE_ARG_TYPES (type
) = args
;
471 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
472 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
475 /* Return a typename for a struct/union/enum type without "struct ",
476 "union ", or "enum ". If the type has a NULL name, return NULL. */
479 type_name_no_tag (type
)
480 register const struct type
*type
;
482 if (TYPE_TAG_NAME (type
) != NULL
)
483 return TYPE_TAG_NAME (type
);
485 /* Is there code which expects this to return the name if there is no
486 tag name? My guess is that this is mainly used for C++ in cases where
487 the two will always be the same. */
488 return TYPE_NAME (type
);
491 /* Lookup a primitive type named NAME.
492 Return zero if NAME is not a primitive type.*/
495 lookup_primitive_typename (name
)
498 struct type
** const *p
;
500 for (p
= current_language
-> la_builtin_type_vector
; *p
!= NULL
; p
++)
502 if (STREQ ((**p
) -> name
, name
))
510 /* Lookup a typedef or primitive type named NAME,
511 visible in lexical block BLOCK.
512 If NOERR is nonzero, return zero if NAME is not suitably defined. */
515 lookup_typename (name
, block
, noerr
)
520 register struct symbol
*sym
;
521 register struct type
*tmp
;
523 sym
= lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
524 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
526 tmp
= lookup_primitive_typename (name
);
531 else if (!tmp
&& noerr
)
537 error ("No type named %s.", name
);
540 return (SYMBOL_TYPE (sym
));
544 lookup_unsigned_typename (name
)
547 char *uns
= alloca (strlen (name
) + 10);
549 strcpy (uns
, "unsigned ");
550 strcpy (uns
+ 9, name
);
551 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
555 lookup_signed_typename (name
)
559 char *uns
= alloca (strlen (name
) + 8);
561 strcpy (uns
, "signed ");
562 strcpy (uns
+ 7, name
);
563 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
564 /* If we don't find "signed FOO" just try again with plain "FOO". */
567 return lookup_typename (name
, (struct block
*) NULL
, 0);
570 /* Lookup a structure type named "struct NAME",
571 visible in lexical block BLOCK. */
574 lookup_struct (name
, block
)
578 register struct symbol
*sym
;
580 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
581 (struct symtab
**) NULL
);
585 error ("No struct type named %s.", name
);
587 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
589 error ("This context has class, union or enum %s, not a struct.", name
);
591 return (SYMBOL_TYPE (sym
));
594 /* Lookup a union type named "union NAME",
595 visible in lexical block BLOCK. */
598 lookup_union (name
, block
)
602 register struct symbol
*sym
;
604 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
605 (struct symtab
**) NULL
);
609 error ("No union type named %s.", name
);
611 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_UNION
)
613 error ("This context has class, struct or enum %s, not a union.", name
);
615 return (SYMBOL_TYPE (sym
));
618 /* Lookup an enum type named "enum NAME",
619 visible in lexical block BLOCK. */
622 lookup_enum (name
, block
)
626 register struct symbol
*sym
;
628 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
629 (struct symtab
**) NULL
);
632 error ("No enum type named %s.", name
);
634 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
636 error ("This context has class, struct or union %s, not an enum.", name
);
638 return (SYMBOL_TYPE (sym
));
641 /* Lookup a template type named "template NAME<TYPE>",
642 visible in lexical block BLOCK. */
645 lookup_template_type (name
, type
, block
)
651 char *nam
= (char*) alloca(strlen(name
) + strlen(type
->name
) + 4);
654 strcat (nam
, type
->name
);
655 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
657 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
661 error ("No template type named %s.", name
);
663 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
665 error ("This context has class, union or enum %s, not a struct.", name
);
667 return (SYMBOL_TYPE (sym
));
670 /* Given a type TYPE, lookup the type of the component of type named NAME.
672 TYPE can be either a struct or union, or a pointer or reference to a struct or
673 union. If it is a pointer or reference, its target type is automatically used.
674 Thus '.' and '->' are interchangable, as specified for the definitions of the
675 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
677 If NOERR is nonzero, return zero if NAME is not suitably defined.
678 If NAME is the name of a baseclass type, return that type. */
681 lookup_struct_elt_type (type
, name
, noerr
)
691 if (TYPE_CODE (type
) == TYPE_CODE_PTR
||
692 TYPE_CODE (type
) == TYPE_CODE_REF
)
693 type
= TYPE_TARGET_TYPE (type
);
695 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
696 TYPE_CODE (type
) != TYPE_CODE_UNION
)
698 target_terminal_ours ();
700 fprintf (stderr
, "Type ");
701 type_print (type
, "", stderr
, -1);
702 error (" is not a structure or union type.");
705 check_stub_type (type
);
708 /* FIXME: This change put in by Michael seems incorrect for the case where
709 the structure tag name is the same as the member name. I.E. when doing
710 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
712 typename
= type_name_no_tag (type
);
713 if (typename
!= NULL
&& STREQ (typename
, name
))
717 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
719 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
721 if (t_field_name
&& STREQ (t_field_name
, name
))
723 return TYPE_FIELD_TYPE (type
, i
);
727 /* OK, it's not in this class. Recursively check the baseclasses. */
728 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
732 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, noerr
);
744 target_terminal_ours ();
746 fprintf (stderr
, "Type ");
747 type_print (type
, "", stderr
, -1);
748 fprintf (stderr
, " has no component named ");
749 fputs_filtered (name
, stderr
);
751 return (struct type
*)-1; /* For lint */
754 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
755 valid. Callers should be aware that in some cases (for example,
756 the type or one of its baseclasses is a stub type and we are
757 debugging a .o file), this function will not be able to find the virtual
758 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
762 fill_in_vptr_fieldno (type
)
765 check_stub_type (type
);
767 if (TYPE_VPTR_FIELDNO (type
) < 0)
771 /* We must start at zero in case the first (and only) baseclass is
772 virtual (and hence we cannot share the table pointer). */
773 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
775 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, i
));
776 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
)) >= 0)
778 TYPE_VPTR_FIELDNO (type
)
779 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
));
780 TYPE_VPTR_BASETYPE (type
)
781 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type
, i
));
788 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
790 If this is a stubbed struct (i.e. declared as struct foo *), see if
791 we can find a full definition in some other file. If so, copy this
792 definition, so we can use it in future. If not, set a flag so we
793 don't waste too much time in future. (FIXME, this doesn't seem
796 This used to be coded as a macro, but I don't think it is called
797 often enough to merit such treatment.
800 struct complaint stub_noname_complaint
=
801 {"stub type has NULL name", 0, 0};
804 check_stub_type (type
)
807 if (TYPE_FLAGS(type
) & TYPE_FLAG_STUB
)
809 char* name
= type_name_no_tag (type
);
810 /* FIXME: shouldn't we separately check the TYPE_NAME and the
811 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
812 as appropriate? (this code was written before TYPE_NAME and
813 TYPE_TAG_NAME were separate). */
817 complain (&stub_noname_complaint
);
820 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
821 (struct symtab
**) NULL
);
824 memcpy ((char *)type
, (char *)SYMBOL_TYPE(sym
), sizeof (struct type
));
829 /* Ugly hack to convert method stubs into method types.
831 He ain't kiddin'. This demangles the name of the method into a string
832 including argument types, parses out each argument type, generates
833 a string casting a zero to that type, evaluates the string, and stuffs
834 the resulting type into an argtype vector!!! Then it knows the type
835 of the whole function (including argument types for overloading),
836 which info used to be in the stab's but was removed to hack back
837 the space required for them. */
840 check_stub_method (type
, i
, j
)
846 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
847 char *demangled_name
= cplus_demangle (mangled_name
,
848 DMGL_PARAMS
| DMGL_ANSI
);
849 char *argtypetext
, *p
;
850 int depth
= 0, argcount
= 1;
851 struct type
**argtypes
;
854 if (demangled_name
== NULL
)
856 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
859 /* Now, read in the parameters that define this type. */
860 argtypetext
= strchr (demangled_name
, '(') + 1;
872 else if (*p
== ',' && depth
== 0)
880 /* We need two more slots: one for the THIS pointer, and one for the
881 NULL [...] or void [end of arglist]. */
883 argtypes
= (struct type
**)
884 TYPE_ALLOC (type
, (argcount
+ 2) * sizeof (struct type
*));
886 argtypes
[0] = lookup_pointer_type (type
);
889 if (*p
!= ')') /* () means no args, skip while */
894 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
897 parse_and_eval_type (argtypetext
, p
- argtypetext
);
915 if (p
[-2] != '.') /* Not '...' */
917 argtypes
[argcount
] = builtin_type_void
; /* List terminator */
921 argtypes
[argcount
] = NULL
; /* Ellist terminator */
924 free (demangled_name
);
926 f
= TYPE_FN_FIELDLIST1 (type
, i
);
927 TYPE_FN_FIELD_PHYSNAME (f
, j
) = mangled_name
;
929 /* Now update the old "stub" type into a real type. */
930 mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
931 TYPE_DOMAIN_TYPE (mtype
) = type
;
932 TYPE_ARG_TYPES (mtype
) = argtypes
;
933 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
934 TYPE_FN_FIELD_STUB (f
, j
) = 0;
937 const struct cplus_struct_type cplus_struct_default
;
940 allocate_cplus_struct_type (type
)
943 if (!HAVE_CPLUS_STRUCT (type
))
945 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
946 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
947 *(TYPE_CPLUS_SPECIFIC(type
)) = cplus_struct_default
;
951 /* Helper function to initialize the standard scalar types.
953 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
954 of the string pointed to by name in the type_obstack for that objfile,
955 and initialize the type name to that copy. There are places (mipsread.c
956 in particular, where init_type is called with a NULL value for NAME). */
959 init_type (code
, length
, flags
, name
, objfile
)
964 struct objfile
*objfile
;
966 register struct type
*type
;
968 type
= alloc_type (objfile
);
969 TYPE_CODE (type
) = code
;
970 TYPE_LENGTH (type
) = length
;
971 TYPE_FLAGS (type
) |= flags
;
972 if ((name
!= NULL
) && (objfile
!= NULL
))
975 obsavestring (name
, strlen (name
), &objfile
-> type_obstack
);
979 TYPE_NAME (type
) = name
;
984 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
986 INIT_CPLUS_SPECIFIC (type
);
991 /* Look up a fundamental type for the specified objfile.
992 May need to construct such a type if this is the first use.
994 Some object file formats (ELF, COFF, etc) do not define fundamental
995 types such as "int" or "double". Others (stabs for example), do
996 define fundamental types.
998 For the formats which don't provide fundamental types, gdb can create
999 such types, using defaults reasonable for the current language and
1000 the current target machine.
1002 NOTE: This routine is obsolescent. Each debugging format reader
1003 should manage it's own fundamental types, either creating them from
1004 suitable defaults or reading them from the debugging information,
1005 whichever is appropriate. The DWARF reader has already been
1006 fixed to do this. Once the other readers are fixed, this routine
1007 will go away. Also note that fundamental types should be managed
1008 on a compilation unit basis in a multi-language environment, not
1009 on a linkage unit basis as is done here. */
1013 lookup_fundamental_type (objfile
, typeid)
1014 struct objfile
*objfile
;
1017 register struct type
**typep
;
1018 register int nbytes
;
1020 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1022 error ("internal error - invalid fundamental type id %d", typeid);
1025 /* If this is the first time we need a fundamental type for this objfile
1026 then we need to initialize the vector of type pointers. */
1028 if (objfile
-> fundamental_types
== NULL
)
1030 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1031 objfile
-> fundamental_types
= (struct type
**)
1032 obstack_alloc (&objfile
-> type_obstack
, nbytes
);
1033 memset ((char *) objfile
-> fundamental_types
, 0, nbytes
);
1036 /* Look for this particular type in the fundamental type vector. If one is
1037 not found, create and install one appropriate for the current language. */
1039 typep
= objfile
-> fundamental_types
+ typeid;
1042 *typep
= create_fundamental_type (objfile
, typeid);
1048 #if MAINTENANCE_CMDS
1051 print_bit_vector (bits
, nbits
)
1057 for (bitno
= 0; bitno
< nbits
; bitno
++)
1059 if ((bitno
% 8) == 0)
1061 puts_filtered (" ");
1063 if (B_TST (bits
, bitno
))
1065 printf_filtered ("1");
1069 printf_filtered ("0");
1074 /* The args list is a strange beast. It is either terminated by a NULL
1075 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
1076 type for normal fixed argcount functions. (FIXME someday)
1077 Also note the first arg should be the "this" pointer, we may not want to
1078 include it since we may get into a infinitely recursive situation. */
1081 print_arg_types (args
, spaces
)
1087 while (*args
!= NULL
)
1089 recursive_dump_type (*args
, spaces
+ 2);
1090 if ((*args
++) -> code
== TYPE_CODE_VOID
)
1099 dump_fn_fieldlists (type
, spaces
)
1107 printfi_filtered (spaces
, "fn_fieldlists 0x%x\n",
1108 TYPE_FN_FIELDLISTS (type
));
1109 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
1111 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
1112 printfi_filtered (spaces
+ 2, "[%d] name '%s' (0x%x) length %d\n",
1114 TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
1115 TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
1116 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
1117 for (overload_idx
= 0;
1118 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
1121 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (0x%x)\n",
1123 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
1124 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
1125 printfi_filtered (spaces
+ 8, "type 0x%x\n",
1126 TYPE_FN_FIELD_TYPE (f
, overload_idx
));
1127 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
1129 printfi_filtered (spaces
+ 8, "args 0x%x\n",
1130 TYPE_FN_FIELD_ARGS (f
, overload_idx
));
1131 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
), spaces
);
1132 printfi_filtered (spaces
+ 8, "fcontext 0x%x\n",
1133 TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
));
1134 printfi_filtered (spaces
+ 8, "is_const %d\n",
1135 TYPE_FN_FIELD_CONST (f
, overload_idx
));
1136 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
1137 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
1138 printfi_filtered (spaces
+ 8, "is_private %d\n",
1139 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
1140 printfi_filtered (spaces
+ 8, "is_protected %d\n",
1141 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
1142 printfi_filtered (spaces
+ 8, "is_stub %d\n",
1143 TYPE_FN_FIELD_STUB (f
, overload_idx
));
1144 printfi_filtered (spaces
+ 8, "voffset %u\n",
1145 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
1151 print_cplus_stuff (type
, spaces
)
1155 printfi_filtered (spaces
, "n_baseclasses %d\n",
1156 TYPE_N_BASECLASSES (type
));
1157 printfi_filtered (spaces
, "nfn_fields %d\n",
1158 TYPE_NFN_FIELDS (type
));
1159 printfi_filtered (spaces
, "nfn_fields_total %d\n",
1160 TYPE_NFN_FIELDS_TOTAL (type
));
1161 if (TYPE_N_BASECLASSES (type
) > 0)
1163 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *0x%x)",
1164 TYPE_N_BASECLASSES (type
),
1165 TYPE_FIELD_VIRTUAL_BITS (type
));
1166 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
1167 TYPE_N_BASECLASSES (type
));
1168 puts_filtered ("\n");
1170 if (TYPE_NFIELDS (type
) > 0)
1172 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
1174 printfi_filtered (spaces
, "private_field_bits (%d bits at *0x%x)",
1175 TYPE_NFIELDS (type
),
1176 TYPE_FIELD_PRIVATE_BITS (type
));
1177 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
1178 TYPE_NFIELDS (type
));
1179 puts_filtered ("\n");
1181 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
1183 printfi_filtered (spaces
, "protected_field_bits (%d bits at *0x%x)",
1184 TYPE_NFIELDS (type
),
1185 TYPE_FIELD_PROTECTED_BITS (type
));
1186 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
1187 TYPE_NFIELDS (type
));
1188 puts_filtered ("\n");
1191 if (TYPE_NFN_FIELDS (type
) > 0)
1193 dump_fn_fieldlists (type
, spaces
);
1198 recursive_dump_type (type
, spaces
)
1204 printfi_filtered (spaces
, "type node 0x%x\n", type
);
1205 printfi_filtered (spaces
, "name '%s' (0x%x)\n", TYPE_NAME (type
),
1206 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
1207 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
1208 switch (TYPE_CODE (type
))
1210 case TYPE_CODE_UNDEF
:
1211 printf_filtered ("(TYPE_CODE_UNDEF)");
1214 printf_filtered ("(TYPE_CODE_PTR)");
1216 case TYPE_CODE_ARRAY
:
1217 printf_filtered ("(TYPE_CODE_ARRAY)");
1219 case TYPE_CODE_STRUCT
:
1220 printf_filtered ("(TYPE_CODE_STRUCT)");
1222 case TYPE_CODE_UNION
:
1223 printf_filtered ("(TYPE_CODE_UNION)");
1225 case TYPE_CODE_ENUM
:
1226 printf_filtered ("(TYPE_CODE_ENUM)");
1228 case TYPE_CODE_FUNC
:
1229 printf_filtered ("(TYPE_CODE_FUNC)");
1232 printf_filtered ("(TYPE_CODE_INT)");
1235 printf_filtered ("(TYPE_CODE_FLT)");
1237 case TYPE_CODE_VOID
:
1238 printf_filtered ("(TYPE_CODE_VOID)");
1241 printf_filtered ("(TYPE_CODE_SET)");
1243 case TYPE_CODE_RANGE
:
1244 printf_filtered ("(TYPE_CODE_RANGE)");
1246 case TYPE_CODE_STRING
:
1247 printf_filtered ("(TYPE_CODE_STRING)");
1249 case TYPE_CODE_ERROR
:
1250 printf_filtered ("(TYPE_CODE_ERROR)");
1252 case TYPE_CODE_MEMBER
:
1253 printf_filtered ("(TYPE_CODE_MEMBER)");
1255 case TYPE_CODE_METHOD
:
1256 printf_filtered ("(TYPE_CODE_METHOD)");
1259 printf_filtered ("(TYPE_CODE_REF)");
1261 case TYPE_CODE_CHAR
:
1262 printf_filtered ("(TYPE_CODE_CHAR)");
1264 case TYPE_CODE_BOOL
:
1265 printf_filtered ("(TYPE_CODE_BOOL)");
1268 printf_filtered ("(UNKNOWN TYPE CODE)");
1271 puts_filtered ("\n");
1272 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
1273 printfi_filtered (spaces
, "objfile 0x%x\n", TYPE_OBJFILE (type
));
1274 printfi_filtered (spaces
, "target_type 0x%x\n", TYPE_TARGET_TYPE (type
));
1275 if (TYPE_TARGET_TYPE (type
) != NULL
)
1277 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
1279 printfi_filtered (spaces
, "pointer_type 0x%x\n",
1280 TYPE_POINTER_TYPE (type
));
1281 printfi_filtered (spaces
, "reference_type 0x%x\n",
1282 TYPE_REFERENCE_TYPE (type
));
1283 printfi_filtered (spaces
, "function_type 0x%x\n",
1284 TYPE_FUNCTION_TYPE (type
));
1285 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
1286 if (TYPE_FLAGS (type
) & TYPE_FLAG_UNSIGNED
)
1288 puts_filtered (" TYPE_FLAG_UNSIGNED");
1290 if (TYPE_FLAGS (type
) & TYPE_FLAG_SIGNED
)
1292 puts_filtered (" TYPE_FLAG_SIGNED");
1294 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
1296 puts_filtered (" TYPE_FLAG_STUB");
1298 puts_filtered ("\n");
1299 printfi_filtered (spaces
, "nfields %d 0x%x\n", TYPE_NFIELDS (type
),
1300 TYPE_FIELDS (type
));
1301 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
1303 printfi_filtered (spaces
+ 2,
1304 "[%d] bitpos %d bitsize %d type 0x%x name '%s' (0x%x)\n",
1305 idx
, TYPE_FIELD_BITPOS (type
, idx
),
1306 TYPE_FIELD_BITSIZE (type
, idx
),
1307 TYPE_FIELD_TYPE (type
, idx
),
1308 TYPE_FIELD_NAME (type
, idx
),
1309 TYPE_FIELD_NAME (type
, idx
) != NULL
1310 ? TYPE_FIELD_NAME (type
, idx
)
1312 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
1314 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
1317 printfi_filtered (spaces
, "vptr_basetype 0x%x\n",
1318 TYPE_VPTR_BASETYPE (type
));
1319 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
1321 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
1323 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
1324 switch (TYPE_CODE (type
))
1326 case TYPE_CODE_METHOD
:
1327 case TYPE_CODE_FUNC
:
1328 printfi_filtered (spaces
, "arg_types 0x%x\n", TYPE_ARG_TYPES (type
));
1329 print_arg_types (TYPE_ARG_TYPES (type
), spaces
);
1332 case TYPE_CODE_STRUCT
:
1333 printfi_filtered (spaces
, "cplus_stuff 0x%x\n",
1334 TYPE_CPLUS_SPECIFIC (type
));
1335 print_cplus_stuff (type
, spaces
);
1339 /* We have to pick one of the union types to be able print and test
1340 the value. Pick cplus_struct_type, even though we know it isn't
1341 any particular one. */
1342 printfi_filtered (spaces
, "type_specific 0x%x",
1343 TYPE_CPLUS_SPECIFIC (type
));
1344 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
1346 printf_filtered (" (unknown data form)");
1348 printf_filtered ("\n");
1354 #endif /* MAINTENANCE_CMDS */
1357 _initialize_gdbtypes ()
1360 init_type (TYPE_CODE_VOID
, 1,
1362 "void", (struct objfile
*) NULL
);
1364 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1366 "char", (struct objfile
*) NULL
);
1367 builtin_type_signed_char
=
1368 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1370 "signed char", (struct objfile
*) NULL
);
1371 builtin_type_unsigned_char
=
1372 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1374 "unsigned char", (struct objfile
*) NULL
);
1375 builtin_type_short
=
1376 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1378 "short", (struct objfile
*) NULL
);
1379 builtin_type_unsigned_short
=
1380 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1382 "unsigned short", (struct objfile
*) NULL
);
1384 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1386 "int", (struct objfile
*) NULL
);
1387 builtin_type_unsigned_int
=
1388 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1390 "unsigned int", (struct objfile
*) NULL
);
1392 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1394 "long", (struct objfile
*) NULL
);
1395 builtin_type_unsigned_long
=
1396 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1398 "unsigned long", (struct objfile
*) NULL
);
1399 builtin_type_long_long
=
1400 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1402 "long long", (struct objfile
*) NULL
);
1403 builtin_type_unsigned_long_long
=
1404 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1406 "unsigned long long", (struct objfile
*) NULL
);
1407 builtin_type_float
=
1408 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1410 "float", (struct objfile
*) NULL
);
1411 builtin_type_double
=
1412 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1414 "double", (struct objfile
*) NULL
);
1415 builtin_type_long_double
=
1416 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1418 "long double", (struct objfile
*) NULL
);
1419 builtin_type_complex
=
1420 init_type (TYPE_CODE_FLT
, TARGET_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
1422 "complex", (struct objfile
*) NULL
);
1423 builtin_type_double_complex
=
1424 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
1426 "double complex", (struct objfile
*) NULL
);
1427 builtin_type_string
=
1428 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1430 "string", (struct objfile
*) NULL
);