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. Indices will be of type INDEX_TYPE, and will
318 range from LOW_BOUND to HIGH_BOUND, inclusive.
320 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
321 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
324 create_range_type (result_type
, index_type
, low_bound
, high_bound
)
325 struct type
*result_type
;
326 struct type
*index_type
;
330 if (result_type
== NULL
)
332 result_type
= alloc_type (TYPE_OBJFILE (index_type
));
334 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
335 TYPE_TARGET_TYPE (result_type
) = index_type
;
336 TYPE_LENGTH (result_type
) = TYPE_LENGTH (index_type
);
337 TYPE_NFIELDS (result_type
) = 2;
338 TYPE_FIELDS (result_type
) = (struct field
*)
339 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
340 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
341 TYPE_FIELD_BITPOS (result_type
, 0) = low_bound
;
342 TYPE_FIELD_BITPOS (result_type
, 1) = high_bound
;
343 TYPE_FIELD_TYPE (result_type
, 0) = builtin_type_int
; /* FIXME */
344 TYPE_FIELD_TYPE (result_type
, 1) = builtin_type_int
; /* FIXME */
346 return (result_type
);
350 /* Create an array type using either a blank type supplied in RESULT_TYPE,
351 or creating a new type. Elements will be of type ELEMENT_TYPE, the
352 indices will be of type RANGE_TYPE.
354 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
355 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
358 create_array_type (result_type
, element_type
, range_type
)
359 struct type
*result_type
;
360 struct type
*element_type
;
361 struct type
*range_type
;
366 if (TYPE_CODE (range_type
) != TYPE_CODE_RANGE
)
368 /* FIXME: We only handle range types at the moment. Complain and
369 create a dummy range type to use. */
370 warning ("internal error: array index type must be a range type");
371 range_type
= lookup_fundamental_type (TYPE_OBJFILE (range_type
),
373 range_type
= create_range_type ((struct type
*) NULL
, range_type
, 0, 0);
375 if (result_type
== NULL
)
377 result_type
= alloc_type (TYPE_OBJFILE (element_type
));
379 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
380 TYPE_TARGET_TYPE (result_type
) = element_type
;
381 low_bound
= TYPE_FIELD_BITPOS (range_type
, 0);
382 high_bound
= TYPE_FIELD_BITPOS (range_type
, 1);
383 TYPE_LENGTH (result_type
) =
384 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
385 TYPE_NFIELDS (result_type
) = 1;
386 TYPE_FIELDS (result_type
) =
387 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
388 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
389 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
390 TYPE_VPTR_FIELDNO (result_type
) = -1;
392 return (result_type
);
395 /* Create a string type using either a blank type supplied in RESULT_TYPE,
396 or creating a new type. String types are similar enough to array of
397 char types that we can use create_array_type to build the basic type
398 and then bash it into a string type.
400 For fixed length strings, the range type contains 0 as the lower
401 bound and the length of the string minus one as the upper bound.
403 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
404 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
407 create_string_type (result_type
, range_type
)
408 struct type
*result_type
;
409 struct type
*range_type
;
411 result_type
= create_array_type (result_type
, builtin_type_char
, range_type
);
412 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
413 return (result_type
);
416 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
417 A MEMBER is a wierd thing -- it amounts to a typed offset into
418 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
419 include the offset (that's the value of the MEMBER itself), but does
420 include the structure type into which it points (for some reason).
422 When "smashing" the type, we preserve the objfile that the
423 old type pointed to, since we aren't changing where the type is actually
427 smash_to_member_type (type
, domain
, to_type
)
430 struct type
*to_type
;
432 struct objfile
*objfile
;
434 objfile
= TYPE_OBJFILE (type
);
436 memset ((char *) type
, 0, sizeof (struct type
));
437 TYPE_OBJFILE (type
) = objfile
;
438 TYPE_TARGET_TYPE (type
) = to_type
;
439 TYPE_DOMAIN_TYPE (type
) = domain
;
440 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
441 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
444 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
445 METHOD just means `function that gets an extra "this" argument'.
447 When "smashing" the type, we preserve the objfile that the
448 old type pointed to, since we aren't changing where the type is actually
452 smash_to_method_type (type
, domain
, to_type
, args
)
455 struct type
*to_type
;
458 struct objfile
*objfile
;
460 objfile
= TYPE_OBJFILE (type
);
462 memset ((char *) type
, 0, sizeof (struct type
));
463 TYPE_OBJFILE (type
) = objfile
;
464 TYPE_TARGET_TYPE (type
) = to_type
;
465 TYPE_DOMAIN_TYPE (type
) = domain
;
466 TYPE_ARG_TYPES (type
) = args
;
467 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
468 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
471 /* Return a typename for a struct/union/enum type
472 without the tag qualifier. If the type has a NULL name,
476 type_name_no_tag (type
)
477 register const struct type
*type
;
481 if ((name
= TYPE_NAME (type
)) != NULL
)
483 switch (TYPE_CODE (type
))
485 case TYPE_CODE_STRUCT
:
486 if(!strncmp (name
, "struct ", 7))
491 case TYPE_CODE_UNION
:
492 if(!strncmp (name
, "union ", 6))
498 if(!strncmp (name
, "enum ", 5))
503 default: /* To avoid -Wall warnings */
510 /* Lookup a primitive type named NAME.
511 Return zero if NAME is not a primitive type.*/
514 lookup_primitive_typename (name
)
517 struct type
** const *p
;
519 for (p
= current_language
-> la_builtin_type_vector
; *p
!= NULL
; p
++)
521 if (STREQ ((**p
) -> name
, name
))
529 /* Lookup a typedef or primitive type named NAME,
530 visible in lexical block BLOCK.
531 If NOERR is nonzero, return zero if NAME is not suitably defined. */
534 lookup_typename (name
, block
, noerr
)
539 register struct symbol
*sym
;
540 register struct type
*tmp
;
542 sym
= lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
543 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
545 tmp
= lookup_primitive_typename (name
);
550 else if (!tmp
&& noerr
)
556 error ("No type named %s.", name
);
559 return (SYMBOL_TYPE (sym
));
563 lookup_unsigned_typename (name
)
566 char *uns
= alloca (strlen (name
) + 10);
568 strcpy (uns
, "unsigned ");
569 strcpy (uns
+ 9, name
);
570 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
574 lookup_signed_typename (name
)
578 char *uns
= alloca (strlen (name
) + 8);
580 strcpy (uns
, "signed ");
581 strcpy (uns
+ 7, name
);
582 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
583 /* If we don't find "signed FOO" just try again with plain "FOO". */
586 return lookup_typename (name
, (struct block
*) NULL
, 0);
589 /* Lookup a structure type named "struct NAME",
590 visible in lexical block BLOCK. */
593 lookup_struct (name
, block
)
597 register struct symbol
*sym
;
599 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
600 (struct symtab
**) NULL
);
604 error ("No struct type named %s.", name
);
606 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
608 error ("This context has class, union or enum %s, not a struct.", name
);
610 return (SYMBOL_TYPE (sym
));
613 /* Lookup a union type named "union NAME",
614 visible in lexical block BLOCK. */
617 lookup_union (name
, block
)
621 register struct symbol
*sym
;
623 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
624 (struct symtab
**) NULL
);
628 error ("No union type named %s.", name
);
630 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_UNION
)
632 error ("This context has class, struct or enum %s, not a union.", name
);
634 return (SYMBOL_TYPE (sym
));
637 /* Lookup an enum type named "enum NAME",
638 visible in lexical block BLOCK. */
641 lookup_enum (name
, block
)
645 register struct symbol
*sym
;
647 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
648 (struct symtab
**) NULL
);
651 error ("No enum type named %s.", name
);
653 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
655 error ("This context has class, struct or union %s, not an enum.", name
);
657 return (SYMBOL_TYPE (sym
));
660 /* Lookup a template type named "template NAME<TYPE>",
661 visible in lexical block BLOCK. */
664 lookup_template_type (name
, type
, block
)
670 char *nam
= (char*) alloca(strlen(name
) + strlen(type
->name
) + 4);
673 strcat (nam
, type
->name
);
674 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
676 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
680 error ("No template type named %s.", name
);
682 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
684 error ("This context has class, union or enum %s, not a struct.", name
);
686 return (SYMBOL_TYPE (sym
));
689 /* Given a type TYPE, lookup the type of the component of type named
691 If NOERR is nonzero, return zero if NAME is not suitably defined. */
694 lookup_struct_elt_type (type
, name
, noerr
)
701 if (TYPE_CODE (type
) == TYPE_CODE_PTR
||
702 TYPE_CODE (type
) == TYPE_CODE_REF
)
703 type
= TYPE_TARGET_TYPE (type
);
705 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
706 TYPE_CODE (type
) != TYPE_CODE_UNION
)
708 target_terminal_ours ();
710 fprintf (stderr
, "Type ");
711 type_print (type
, "", stderr
, -1);
712 error (" is not a structure or union type.");
715 check_stub_type (type
);
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
, 0);
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 /* This function is really horrible, but to avoid it, there would need
755 to be more filling in of forward references. */
758 fill_in_vptr_fieldno (type
)
761 if (TYPE_VPTR_FIELDNO (type
) < 0)
764 for (i
= 1; i
< TYPE_N_BASECLASSES (type
); i
++)
766 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, i
));
767 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
)) >= 0)
769 TYPE_VPTR_FIELDNO (type
)
770 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
));
771 TYPE_VPTR_BASETYPE (type
)
772 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type
, i
));
779 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
781 If this is a stubbed struct (i.e. declared as struct foo *), see if
782 we can find a full definition in some other file. If so, copy this
783 definition, so we can use it in future. If not, set a flag so we
784 don't waste too much time in future. (FIXME, this doesn't seem
787 This used to be coded as a macro, but I don't think it is called
788 often enough to merit such treatment.
791 struct complaint stub_noname_complaint
=
792 {"stub type has NULL name", 0, 0};
795 check_stub_type (type
)
798 if (TYPE_FLAGS(type
) & TYPE_FLAG_STUB
)
800 char* name
= type_name_no_tag (type
);
804 complain (&stub_noname_complaint
);
807 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
808 (struct symtab
**) NULL
);
811 memcpy ((char *)type
, (char *)SYMBOL_TYPE(sym
), sizeof (struct type
));
816 /* Ugly hack to convert method stubs into method types.
818 He ain't kiddin'. This demangles the name of the method into a string
819 including argument types, parses out each argument type, generates
820 a string casting a zero to that type, evaluates the string, and stuffs
821 the resulting type into an argtype vector!!! Then it knows the type
822 of the whole function (including argument types for overloading),
823 which info used to be in the stab's but was removed to hack back
824 the space required for them. */
827 check_stub_method (type
, i
, j
)
833 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
834 char *demangled_name
= cplus_demangle (mangled_name
,
835 DMGL_PARAMS
| DMGL_ANSI
);
836 char *argtypetext
, *p
;
837 int depth
= 0, argcount
= 1;
838 struct type
**argtypes
;
841 if (demangled_name
== NULL
)
843 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
846 /* Now, read in the parameters that define this type. */
847 argtypetext
= strchr (demangled_name
, '(') + 1;
859 else if (*p
== ',' && depth
== 0)
867 /* We need two more slots: one for the THIS pointer, and one for the
868 NULL [...] or void [end of arglist]. */
870 argtypes
= (struct type
**)
871 TYPE_ALLOC (type
, (argcount
+ 2) * sizeof (struct type
*));
873 argtypes
[0] = lookup_pointer_type (type
);
876 if (*p
!= ')') /* () means no args, skip while */
881 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
884 parse_and_eval_type (argtypetext
, p
- argtypetext
);
902 if (p
[-2] != '.') /* Not '...' */
904 argtypes
[argcount
] = builtin_type_void
; /* List terminator */
908 argtypes
[argcount
] = NULL
; /* Ellist terminator */
911 free (demangled_name
);
913 f
= TYPE_FN_FIELDLIST1 (type
, i
);
914 TYPE_FN_FIELD_PHYSNAME (f
, j
) = mangled_name
;
916 /* Now update the old "stub" type into a real type. */
917 mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
918 TYPE_DOMAIN_TYPE (mtype
) = type
;
919 TYPE_ARG_TYPES (mtype
) = argtypes
;
920 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
921 TYPE_FN_FIELD_STUB (f
, j
) = 0;
924 const struct cplus_struct_type cplus_struct_default
;
927 allocate_cplus_struct_type (type
)
930 if (!HAVE_CPLUS_STRUCT (type
))
932 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
933 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
934 *(TYPE_CPLUS_SPECIFIC(type
)) = cplus_struct_default
;
938 /* Helper function to initialize the standard scalar types.
940 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
941 of the string pointed to by name in the type_obstack for that objfile,
942 and initialize the type name to that copy. There are places (mipsread.c
943 in particular, where init_type is called with a NULL value for NAME). */
946 init_type (code
, length
, flags
, name
, objfile
)
951 struct objfile
*objfile
;
953 register struct type
*type
;
955 type
= alloc_type (objfile
);
956 TYPE_CODE (type
) = code
;
957 TYPE_LENGTH (type
) = length
;
958 TYPE_FLAGS (type
) |= flags
;
959 if ((name
!= NULL
) && (objfile
!= NULL
))
962 obsavestring (name
, strlen (name
), &objfile
-> type_obstack
);
966 TYPE_NAME (type
) = name
;
971 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
973 INIT_CPLUS_SPECIFIC (type
);
978 /* Look up a fundamental type for the specified objfile.
979 May need to construct such a type if this is the first use.
981 Some object file formats (ELF, COFF, etc) do not define fundamental
982 types such as "int" or "double". Others (stabs for example), do
983 define fundamental types.
985 For the formats which don't provide fundamental types, gdb can create
986 such types, using defaults reasonable for the current language and
987 the current target machine.
989 NOTE: This routine is obsolescent. Each debugging format reader
990 should manage it's own fundamental types, either creating them from
991 suitable defaults or reading them from the debugging information,
992 whichever is appropriate. The DWARF reader has already been
993 fixed to do this. Once the other readers are fixed, this routine
994 will go away. Also note that fundamental types should be managed
995 on a compilation unit basis in a multi-language environment, not
996 on a linkage unit basis as is done here. */
1000 lookup_fundamental_type (objfile
, typeid)
1001 struct objfile
*objfile
;
1004 register struct type
**typep
;
1005 register int nbytes
;
1007 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1009 error ("internal error - invalid fundamental type id %d", typeid);
1012 /* If this is the first time we need a fundamental type for this objfile
1013 then we need to initialize the vector of type pointers. */
1015 if (objfile
-> fundamental_types
== NULL
)
1017 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1018 objfile
-> fundamental_types
= (struct type
**)
1019 obstack_alloc (&objfile
-> type_obstack
, nbytes
);
1020 memset ((char *) objfile
-> fundamental_types
, 0, nbytes
);
1023 /* Look for this particular type in the fundamental type vector. If one is
1024 not found, create and install one appropriate for the current language. */
1026 typep
= objfile
-> fundamental_types
+ typeid;
1029 *typep
= create_fundamental_type (objfile
, typeid);
1035 #if MAINTENANCE_CMDS
1038 print_bit_vector (bits
, nbits
)
1044 for (bitno
= 0; bitno
< nbits
; bitno
++)
1046 if ((bitno
% 8) == 0)
1048 puts_filtered (" ");
1050 if (B_TST (bits
, bitno
))
1052 printf_filtered ("1");
1056 printf_filtered ("0");
1061 /* The args list is a strange beast. It is either terminated by a NULL
1062 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
1063 type for normal fixed argcount functions. (FIXME someday)
1064 Also note the first arg should be the "this" pointer, we may not want to
1065 include it since we may get into a infinitely recursive situation. */
1068 print_arg_types (args
, spaces
)
1074 while (*args
!= NULL
)
1076 recursive_dump_type (*args
, spaces
+ 2);
1077 if ((*args
++) -> code
== TYPE_CODE_VOID
)
1086 dump_fn_fieldlists (type
, spaces
)
1094 printfi_filtered (spaces
, "fn_fieldlists 0x%x\n",
1095 TYPE_FN_FIELDLISTS (type
));
1096 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
1098 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
1099 printfi_filtered (spaces
+ 2, "[%d] name '%s' (0x%x) length %d\n",
1101 TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
1102 TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
1103 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
1104 for (overload_idx
= 0;
1105 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
1108 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (0x%x)\n",
1110 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
1111 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
1112 printfi_filtered (spaces
+ 8, "type 0x%x\n",
1113 TYPE_FN_FIELD_TYPE (f
, overload_idx
));
1114 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
1116 printfi_filtered (spaces
+ 8, "args 0x%x\n",
1117 TYPE_FN_FIELD_ARGS (f
, overload_idx
));
1118 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
), spaces
);
1119 printfi_filtered (spaces
+ 8, "fcontext 0x%x\n",
1120 TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
));
1121 printfi_filtered (spaces
+ 8, "is_const %d\n",
1122 TYPE_FN_FIELD_CONST (f
, overload_idx
));
1123 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
1124 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
1125 printfi_filtered (spaces
+ 8, "is_private %d\n",
1126 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
1127 printfi_filtered (spaces
+ 8, "is_protected %d\n",
1128 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
1129 printfi_filtered (spaces
+ 8, "is_stub %d\n",
1130 TYPE_FN_FIELD_STUB (f
, overload_idx
));
1131 printfi_filtered (spaces
+ 8, "voffset %u\n",
1132 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
1138 print_cplus_stuff (type
, spaces
)
1142 printfi_filtered (spaces
, "n_baseclasses %d\n",
1143 TYPE_N_BASECLASSES (type
));
1144 printfi_filtered (spaces
, "nfn_fields %d\n",
1145 TYPE_NFN_FIELDS (type
));
1146 printfi_filtered (spaces
, "nfn_fields_total %d\n",
1147 TYPE_NFN_FIELDS_TOTAL (type
));
1148 if (TYPE_N_BASECLASSES (type
) > 0)
1150 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *0x%x)",
1151 TYPE_N_BASECLASSES (type
),
1152 TYPE_FIELD_VIRTUAL_BITS (type
));
1153 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
1154 TYPE_N_BASECLASSES (type
));
1155 puts_filtered ("\n");
1157 if (TYPE_NFIELDS (type
) > 0)
1159 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
1161 printfi_filtered (spaces
, "private_field_bits (%d bits at *0x%x)",
1162 TYPE_NFIELDS (type
),
1163 TYPE_FIELD_PRIVATE_BITS (type
));
1164 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
1165 TYPE_NFIELDS (type
));
1166 puts_filtered ("\n");
1168 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
1170 printfi_filtered (spaces
, "protected_field_bits (%d bits at *0x%x)",
1171 TYPE_NFIELDS (type
),
1172 TYPE_FIELD_PROTECTED_BITS (type
));
1173 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
1174 TYPE_NFIELDS (type
));
1175 puts_filtered ("\n");
1178 if (TYPE_NFN_FIELDS (type
) > 0)
1180 dump_fn_fieldlists (type
, spaces
);
1185 recursive_dump_type (type
, spaces
)
1191 printfi_filtered (spaces
, "type node 0x%x\n", type
);
1192 printfi_filtered (spaces
, "name '%s' (0x%x)\n", TYPE_NAME (type
),
1193 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
1194 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
1195 switch (TYPE_CODE (type
))
1197 case TYPE_CODE_UNDEF
:
1198 printf_filtered ("(TYPE_CODE_UNDEF)");
1201 printf_filtered ("(TYPE_CODE_PTR)");
1203 case TYPE_CODE_ARRAY
:
1204 printf_filtered ("(TYPE_CODE_ARRAY)");
1206 case TYPE_CODE_STRUCT
:
1207 printf_filtered ("(TYPE_CODE_STRUCT)");
1209 case TYPE_CODE_UNION
:
1210 printf_filtered ("(TYPE_CODE_UNION)");
1212 case TYPE_CODE_ENUM
:
1213 printf_filtered ("(TYPE_CODE_ENUM)");
1215 case TYPE_CODE_FUNC
:
1216 printf_filtered ("(TYPE_CODE_FUNC)");
1219 printf_filtered ("(TYPE_CODE_INT)");
1222 printf_filtered ("(TYPE_CODE_FLT)");
1224 case TYPE_CODE_VOID
:
1225 printf_filtered ("(TYPE_CODE_VOID)");
1228 printf_filtered ("(TYPE_CODE_SET)");
1230 case TYPE_CODE_RANGE
:
1231 printf_filtered ("(TYPE_CODE_RANGE)");
1233 case TYPE_CODE_STRING
:
1234 printf_filtered ("(TYPE_CODE_STRING)");
1236 case TYPE_CODE_ERROR
:
1237 printf_filtered ("(TYPE_CODE_ERROR)");
1239 case TYPE_CODE_MEMBER
:
1240 printf_filtered ("(TYPE_CODE_MEMBER)");
1242 case TYPE_CODE_METHOD
:
1243 printf_filtered ("(TYPE_CODE_METHOD)");
1246 printf_filtered ("(TYPE_CODE_REF)");
1248 case TYPE_CODE_CHAR
:
1249 printf_filtered ("(TYPE_CODE_CHAR)");
1251 case TYPE_CODE_BOOL
:
1252 printf_filtered ("(TYPE_CODE_BOOL)");
1255 printf_filtered ("(UNKNOWN TYPE CODE)");
1258 puts_filtered ("\n");
1259 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
1260 printfi_filtered (spaces
, "objfile 0x%x\n", TYPE_OBJFILE (type
));
1261 printfi_filtered (spaces
, "target_type 0x%x\n", TYPE_TARGET_TYPE (type
));
1262 if (TYPE_TARGET_TYPE (type
) != NULL
)
1264 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
1266 printfi_filtered (spaces
, "pointer_type 0x%x\n",
1267 TYPE_POINTER_TYPE (type
));
1268 printfi_filtered (spaces
, "reference_type 0x%x\n",
1269 TYPE_REFERENCE_TYPE (type
));
1270 printfi_filtered (spaces
, "function_type 0x%x\n",
1271 TYPE_FUNCTION_TYPE (type
));
1272 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
1273 if (TYPE_FLAGS (type
) & TYPE_FLAG_UNSIGNED
)
1275 puts_filtered (" TYPE_FLAG_UNSIGNED");
1277 if (TYPE_FLAGS (type
) & TYPE_FLAG_SIGNED
)
1279 puts_filtered (" TYPE_FLAG_SIGNED");
1281 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
1283 puts_filtered (" TYPE_FLAG_STUB");
1285 puts_filtered ("\n");
1286 printfi_filtered (spaces
, "nfields %d 0x%x\n", TYPE_NFIELDS (type
),
1287 TYPE_FIELDS (type
));
1288 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
1290 printfi_filtered (spaces
+ 2,
1291 "[%d] bitpos %d bitsize %d type 0x%x name '%s' (0x%x)\n",
1292 idx
, TYPE_FIELD_BITPOS (type
, idx
),
1293 TYPE_FIELD_BITSIZE (type
, idx
),
1294 TYPE_FIELD_TYPE (type
, idx
),
1295 TYPE_FIELD_NAME (type
, idx
),
1296 TYPE_FIELD_NAME (type
, idx
) != NULL
1297 ? TYPE_FIELD_NAME (type
, idx
)
1299 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
1301 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
1304 printfi_filtered (spaces
, "vptr_basetype 0x%x\n",
1305 TYPE_VPTR_BASETYPE (type
));
1306 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
1308 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
1310 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
1311 switch (TYPE_CODE (type
))
1313 case TYPE_CODE_METHOD
:
1314 case TYPE_CODE_FUNC
:
1315 printfi_filtered (spaces
, "arg_types 0x%x\n", TYPE_ARG_TYPES (type
));
1316 print_arg_types (TYPE_ARG_TYPES (type
), spaces
);
1319 case TYPE_CODE_STRUCT
:
1320 printfi_filtered (spaces
, "cplus_stuff 0x%x\n",
1321 TYPE_CPLUS_SPECIFIC (type
));
1322 print_cplus_stuff (type
, spaces
);
1326 /* We have to pick one of the union types to be able print and test
1327 the value. Pick cplus_struct_type, even though we know it isn't
1328 any particular one. */
1329 printfi_filtered (spaces
, "type_specific 0x%x",
1330 TYPE_CPLUS_SPECIFIC (type
));
1331 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
1333 printf_filtered (" (unknown data form)");
1335 printf_filtered ("\n");
1341 #endif /* MAINTENANCE_CMDS */
1344 _initialize_gdbtypes ()
1347 init_type (TYPE_CODE_VOID
, 1,
1349 "void", (struct objfile
*) NULL
);
1351 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1353 "char", (struct objfile
*) NULL
);
1354 builtin_type_signed_char
=
1355 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1357 "signed char", (struct objfile
*) NULL
);
1358 builtin_type_unsigned_char
=
1359 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1361 "unsigned char", (struct objfile
*) NULL
);
1362 builtin_type_short
=
1363 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1365 "short", (struct objfile
*) NULL
);
1366 builtin_type_unsigned_short
=
1367 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1369 "unsigned short", (struct objfile
*) NULL
);
1371 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1373 "int", (struct objfile
*) NULL
);
1374 builtin_type_unsigned_int
=
1375 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1377 "unsigned int", (struct objfile
*) NULL
);
1379 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1381 "long", (struct objfile
*) NULL
);
1382 builtin_type_unsigned_long
=
1383 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1385 "unsigned long", (struct objfile
*) NULL
);
1386 builtin_type_long_long
=
1387 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1389 "long long", (struct objfile
*) NULL
);
1390 builtin_type_unsigned_long_long
=
1391 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1393 "unsigned long long", (struct objfile
*) NULL
);
1394 builtin_type_float
=
1395 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1397 "float", (struct objfile
*) NULL
);
1398 builtin_type_double
=
1399 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1401 "double", (struct objfile
*) NULL
);
1402 builtin_type_long_double
=
1403 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1405 "long double", (struct objfile
*) NULL
);
1406 builtin_type_complex
=
1407 init_type (TYPE_CODE_FLT
, TARGET_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
1409 "complex", (struct objfile
*) NULL
);
1410 builtin_type_double_complex
=
1411 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
1413 "double complex", (struct objfile
*) NULL
);
1414 builtin_type_string
=
1415 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1417 "string", (struct objfile
*) NULL
);