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"
34 /* Alloc a new type structure and fill it with some defaults. If
35 OBJFILE is non-NULL, then allocate the space for the type structure
36 in that objfile's type_obstack. */
40 struct objfile
*objfile
;
42 register struct type
*type
;
44 /* Alloc the structure and start off with all fields zeroed. */
48 type
= (struct type
*) xmalloc (sizeof (struct type
));
52 type
= (struct type
*) obstack_alloc (&objfile
-> type_obstack
,
53 sizeof (struct type
));
55 memset ((char *) type
, 0, sizeof (struct type
));
57 /* Initialize the fields that might not be zero. */
59 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
60 TYPE_OBJFILE (type
) = objfile
;
61 TYPE_VPTR_FIELDNO (type
) = -1;
66 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
67 to a pointer to memory where the pointer type should be stored.
68 If *TYPEPTR is zero, update it to point to the pointer type we return.
69 We allocate new memory if needed. */
72 make_pointer_type (type
, typeptr
)
74 struct type
**typeptr
;
76 register struct type
*ntype
; /* New type */
77 struct objfile
*objfile
;
79 ntype
= TYPE_POINTER_TYPE (type
);
83 return ntype
; /* Don't care about alloc, and have new type. */
84 else if (*typeptr
== 0)
86 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
90 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
92 ntype
= alloc_type (TYPE_OBJFILE (type
));
96 else /* We have storage, but need to reset it. */
99 objfile
= TYPE_OBJFILE (ntype
);
100 memset ((char *) ntype
, 0, sizeof (struct type
));
101 TYPE_OBJFILE (ntype
) = objfile
;
104 TYPE_TARGET_TYPE (ntype
) = type
;
105 TYPE_POINTER_TYPE (type
) = ntype
;
107 /* FIXME! Assume the machine has only one representation for pointers! */
109 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
110 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
112 /* pointers are unsigned */
113 TYPE_FLAGS (ntype
) |= TYPE_FLAG_UNSIGNED
;
115 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
116 TYPE_POINTER_TYPE (type
) = ntype
;
121 /* Given a type TYPE, return a type of pointers to that type.
122 May need to construct such a type if this is the first use. */
125 lookup_pointer_type (type
)
128 return make_pointer_type (type
, (struct type
**)0);
131 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero, points
132 to a pointer to memory where the reference type should be stored.
133 If *TYPEPTR is zero, update it to point to the reference type we return.
134 We allocate new memory if needed. */
137 make_reference_type (type
, typeptr
)
139 struct type
**typeptr
;
141 register struct type
*ntype
; /* New type */
142 struct objfile
*objfile
;
144 ntype
= TYPE_REFERENCE_TYPE (type
);
148 return ntype
; /* Don't care about alloc, and have new type. */
149 else if (*typeptr
== 0)
151 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
155 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
157 ntype
= alloc_type (TYPE_OBJFILE (type
));
161 else /* We have storage, but need to reset it. */
164 objfile
= TYPE_OBJFILE (ntype
);
165 memset ((char *) ntype
, 0, sizeof (struct type
));
166 TYPE_OBJFILE (ntype
) = objfile
;
169 TYPE_TARGET_TYPE (ntype
) = type
;
170 TYPE_REFERENCE_TYPE (type
) = ntype
;
172 /* FIXME! Assume the machine has only one representation for references,
173 and that it matches the (only) representation for pointers! */
175 TYPE_LENGTH (ntype
) = TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
176 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
178 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
179 TYPE_REFERENCE_TYPE (type
) = ntype
;
184 /* Same as above, but caller doesn't care about memory allocation details. */
187 lookup_reference_type (type
)
190 return make_reference_type (type
, (struct type
**)0);
193 /* Lookup a function type that returns type TYPE. TYPEPTR, if nonzero, points
194 to a pointer to memory where the function type should be stored.
195 If *TYPEPTR is zero, update it to point to the function type we return.
196 We allocate new memory if needed. */
199 make_function_type (type
, typeptr
)
201 struct type
**typeptr
;
203 register struct type
*ntype
; /* New type */
204 struct objfile
*objfile
;
206 ntype
= TYPE_FUNCTION_TYPE (type
);
210 return ntype
; /* Don't care about alloc, and have new type. */
211 else if (*typeptr
== 0)
213 *typeptr
= ntype
; /* Tracking alloc, and we have new type. */
217 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
219 ntype
= alloc_type (TYPE_OBJFILE (type
));
223 else /* We have storage, but need to reset it. */
226 objfile
= TYPE_OBJFILE (ntype
);
227 memset ((char *) ntype
, 0, sizeof (struct type
));
228 TYPE_OBJFILE (ntype
) = objfile
;
231 TYPE_TARGET_TYPE (ntype
) = type
;
232 TYPE_FUNCTION_TYPE (type
) = ntype
;
234 TYPE_LENGTH (ntype
) = 1;
235 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
237 if (!TYPE_FUNCTION_TYPE (type
)) /* Remember it, if don't have one. */
238 TYPE_FUNCTION_TYPE (type
) = ntype
;
244 /* Given a type TYPE, return a type of functions that return that type.
245 May need to construct such a type if this is the first use. */
248 lookup_function_type (type
)
251 return make_function_type (type
, (struct type
**)0);
254 /* Implement direct support for MEMBER_TYPE in GNU C++.
255 May need to construct such a type if this is the first use.
256 The TYPE is the type of the member. The DOMAIN is the type
257 of the aggregate that the member belongs to. */
260 lookup_member_type (type
, domain
)
264 register struct type
*mtype
;
266 mtype
= alloc_type (TYPE_OBJFILE (type
));
267 smash_to_member_type (mtype
, domain
, type
);
271 /* Allocate a stub method whose return type is TYPE.
272 This apparently happens for speed of symbol reading, since parsing
273 out the arguments to the method is cpu-intensive, the way we are doing
274 it. So, we will fill in arguments later.
275 This always returns a fresh type. */
278 allocate_stub_method (type
)
283 mtype
= alloc_type (TYPE_OBJFILE (type
));
284 TYPE_TARGET_TYPE (mtype
) = type
;
285 /* _DOMAIN_TYPE (mtype) = unknown yet */
286 /* _ARG_TYPES (mtype) = unknown yet */
287 TYPE_FLAGS (mtype
) = TYPE_FLAG_STUB
;
288 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
289 TYPE_LENGTH (mtype
) = 1;
293 /* Create an array type. Elements will be of type TYPE, and there will
296 Eventually this should be extended to take two more arguments which
297 specify the bounds of the array and the type of the index.
298 It should also be changed to be a "lookup" function, with the
299 appropriate data structures added to the type field.
300 Then read array type should call here. */
303 create_array_type (element_type
, number
)
304 struct type
*element_type
;
307 struct type
*result_type
;
308 struct type
*range_type
;
310 result_type
= alloc_type (TYPE_OBJFILE (element_type
));
312 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
313 TYPE_TARGET_TYPE (result_type
) = element_type
;
314 TYPE_LENGTH (result_type
) = number
* TYPE_LENGTH (element_type
);
315 TYPE_NFIELDS (result_type
) = 1;
316 TYPE_FIELDS (result_type
) = (struct field
*)
317 TYPE_ALLOC (result_type
, sizeof (struct field
));
320 /* Create range type. */
321 range_type
= alloc_type (TYPE_OBJFILE (result_type
));
322 TYPE_CODE (range_type
) = TYPE_CODE_RANGE
;
323 TYPE_TARGET_TYPE (range_type
) = builtin_type_int
; /* FIXME */
325 /* This should never be needed. */
326 TYPE_LENGTH (range_type
) = sizeof (int);
328 TYPE_NFIELDS (range_type
) = 2;
329 TYPE_FIELDS (range_type
) = (struct field
*)
330 TYPE_ALLOC (range_type
, 2 * sizeof (struct field
));
331 TYPE_FIELD_BITPOS (range_type
, 0) = 0; /* FIXME */
332 TYPE_FIELD_BITPOS (range_type
, 1) = number
-1; /* FIXME */
333 TYPE_FIELD_TYPE (range_type
, 0) = builtin_type_int
; /* FIXME */
334 TYPE_FIELD_TYPE (range_type
, 1) = builtin_type_int
; /* FIXME */
336 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
337 TYPE_VPTR_FIELDNO (result_type
) = -1;
339 return (result_type
);
343 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
344 A MEMBER is a wierd thing -- it amounts to a typed offset into
345 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
346 include the offset (that's the value of the MEMBER itself), but does
347 include the structure type into which it points (for some reason).
349 When "smashing" the type, we preserve the objfile that the
350 old type pointed to, since we aren't changing where the type is actually
354 smash_to_member_type (type
, domain
, to_type
)
357 struct type
*to_type
;
359 struct objfile
*objfile
;
361 objfile
= TYPE_OBJFILE (type
);
363 memset ((char *) type
, 0, sizeof (struct type
));
364 TYPE_OBJFILE (type
) = objfile
;
365 TYPE_TARGET_TYPE (type
) = to_type
;
366 TYPE_DOMAIN_TYPE (type
) = domain
;
367 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
368 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
371 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
372 METHOD just means `function that gets an extra "this" argument'.
374 When "smashing" the type, we preserve the objfile that the
375 old type pointed to, since we aren't changing where the type is actually
379 smash_to_method_type (type
, domain
, to_type
, args
)
382 struct type
*to_type
;
385 struct objfile
*objfile
;
387 objfile
= TYPE_OBJFILE (type
);
389 memset ((char *) type
, 0, sizeof (struct type
));
390 TYPE_OBJFILE (type
) = objfile
;
391 TYPE_TARGET_TYPE (type
) = to_type
;
392 TYPE_DOMAIN_TYPE (type
) = domain
;
393 TYPE_ARG_TYPES (type
) = args
;
394 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
395 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
398 /* Return a typename for a struct/union/enum type
399 without the tag qualifier. If the type has a NULL name,
403 type_name_no_tag (type
)
404 register const struct type
*type
;
408 if ((name
= TYPE_NAME (type
)) != NULL
)
410 switch (TYPE_CODE (type
))
412 case TYPE_CODE_STRUCT
:
413 if(!strncmp (name
, "struct ", 7))
418 case TYPE_CODE_UNION
:
419 if(!strncmp (name
, "union ", 6))
425 if(!strncmp (name
, "enum ", 5))
430 default: /* To avoid -Wall warnings */
437 /* Lookup a primitive type named NAME.
438 Return zero if NAME is not a primitive type.*/
441 lookup_primitive_typename (name
)
444 struct type
** const *p
;
446 for (p
= current_language
-> la_builtin_type_vector
; *p
!= NULL
; p
++)
448 if (!strcmp ((**p
) -> name
, name
))
456 /* Lookup a typedef or primitive type named NAME,
457 visible in lexical block BLOCK.
458 If NOERR is nonzero, return zero if NAME is not suitably defined. */
461 lookup_typename (name
, block
, noerr
)
466 register struct symbol
*sym
;
467 register struct type
*tmp
;
469 sym
= lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
470 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
472 tmp
= lookup_primitive_typename (name
);
477 else if (!tmp
&& noerr
)
483 error ("No type named %s.", name
);
486 return (SYMBOL_TYPE (sym
));
490 lookup_unsigned_typename (name
)
493 char *uns
= alloca (strlen (name
) + 10);
495 strcpy (uns
, "unsigned ");
496 strcpy (uns
+ 9, name
);
497 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
501 lookup_signed_typename (name
)
505 char *uns
= alloca (strlen (name
) + 8);
507 strcpy (uns
, "signed ");
508 strcpy (uns
+ 7, name
);
509 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
510 /* If we don't find "signed FOO" just try again with plain "FOO". */
513 return lookup_typename (name
, (struct block
*) NULL
, 0);
516 /* Lookup a structure type named "struct NAME",
517 visible in lexical block BLOCK. */
520 lookup_struct (name
, block
)
524 register struct symbol
*sym
;
526 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
527 (struct symtab
**) NULL
);
531 error ("No struct type named %s.", name
);
533 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
535 error ("This context has class, union or enum %s, not a struct.", name
);
537 return (SYMBOL_TYPE (sym
));
540 /* Lookup a union type named "union NAME",
541 visible in lexical block BLOCK. */
544 lookup_union (name
, block
)
548 register struct symbol
*sym
;
550 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
551 (struct symtab
**) NULL
);
555 error ("No union type named %s.", name
);
557 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_UNION
)
559 error ("This context has class, struct or enum %s, not a union.", name
);
561 return (SYMBOL_TYPE (sym
));
564 /* Lookup an enum type named "enum NAME",
565 visible in lexical block BLOCK. */
568 lookup_enum (name
, block
)
572 register struct symbol
*sym
;
574 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
575 (struct symtab
**) NULL
);
578 error ("No enum type named %s.", name
);
580 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
582 error ("This context has class, struct or union %s, not an enum.", name
);
584 return (SYMBOL_TYPE (sym
));
587 /* Lookup a template type named "template NAME<TYPE>",
588 visible in lexical block BLOCK. */
591 lookup_template_type (name
, type
, block
)
597 char *nam
= (char*) alloca(strlen(name
) + strlen(type
->name
) + 4);
600 strcat (nam
, type
->name
);
601 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
603 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
607 error ("No template type named %s.", name
);
609 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
611 error ("This context has class, union or enum %s, not a struct.", name
);
613 return (SYMBOL_TYPE (sym
));
616 /* Given a type TYPE, lookup the type of the component of type named
618 If NOERR is nonzero, return zero if NAME is not suitably defined. */
621 lookup_struct_elt_type (type
, name
, noerr
)
628 if (TYPE_CODE (type
) == TYPE_CODE_PTR
||
629 TYPE_CODE (type
) == TYPE_CODE_REF
)
630 type
= TYPE_TARGET_TYPE (type
);
632 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
633 TYPE_CODE (type
) != TYPE_CODE_UNION
)
635 target_terminal_ours ();
637 fprintf (stderr
, "Type ");
638 type_print (type
, "", stderr
, -1);
639 error (" is not a structure or union type.");
642 check_stub_type (type
);
644 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
646 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
648 if (t_field_name
&& !strcmp (t_field_name
, name
))
650 return TYPE_FIELD_TYPE (type
, i
);
654 /* OK, it's not in this class. Recursively check the baseclasses. */
655 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
659 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, 0);
671 target_terminal_ours ();
673 fprintf (stderr
, "Type ");
674 type_print (type
, "", stderr
, -1);
675 fprintf (stderr
, " has no component named ");
676 fputs_filtered (name
, stderr
);
678 return (struct type
*)-1; /* For lint */
681 /* This function is really horrible, but to avoid it, there would need
682 to be more filling in of forward references. */
685 fill_in_vptr_fieldno (type
)
688 if (TYPE_VPTR_FIELDNO (type
) < 0)
691 for (i
= 1; i
< TYPE_N_BASECLASSES (type
); i
++)
693 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, i
));
694 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
)) >= 0)
696 TYPE_VPTR_FIELDNO (type
)
697 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
));
698 TYPE_VPTR_BASETYPE (type
)
699 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type
, i
));
706 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
708 If this is a stubbed struct (i.e. declared as struct foo *), see if
709 we can find a full definition in some other file. If so, copy this
710 definition, so we can use it in future. If not, set a flag so we
711 don't waste too much time in future. (FIXME, this doesn't seem
714 This used to be coded as a macro, but I don't think it is called
715 often enough to merit such treatment.
718 struct complaint stub_noname_complaint
=
719 {"stub type has NULL name", 0, 0};
722 check_stub_type (type
)
725 if (TYPE_FLAGS(type
) & TYPE_FLAG_STUB
)
727 char* name
= type_name_no_tag (type
);
731 complain (&stub_noname_complaint
, 0);
734 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
735 (struct symtab
**) NULL
);
738 memcpy ((char *)type
, (char *)SYMBOL_TYPE(sym
), sizeof (struct type
));
743 /* Ugly hack to convert method stubs into method types.
745 He ain't kiddin'. This demangles the name of the method into a string
746 including argument types, parses out each argument type, generates
747 a string casting a zero to that type, evaluates the string, and stuffs
748 the resulting type into an argtype vector!!! Then it knows the type
749 of the whole function (including argument types for overloading),
750 which info used to be in the stab's but was removed to hack back
751 the space required for them. */
754 check_stub_method (type
, i
, j
)
760 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
761 char *demangled_name
= cplus_demangle (mangled_name
,
762 DMGL_PARAMS
| DMGL_ANSI
);
763 char *argtypetext
, *p
;
764 int depth
= 0, argcount
= 1;
765 struct type
**argtypes
;
768 if (demangled_name
== NULL
)
770 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
773 /* Now, read in the parameters that define this type. */
774 argtypetext
= strchr (demangled_name
, '(') + 1;
786 else if (*p
== ',' && depth
== 0)
794 /* We need two more slots: one for the THIS pointer, and one for the
795 NULL [...] or void [end of arglist]. */
797 argtypes
= (struct type
**)
798 TYPE_ALLOC (type
, (argcount
+ 2) * sizeof (struct type
*));
800 argtypes
[0] = lookup_pointer_type (type
);
803 if (*p
!= ')') /* () means no args, skip while */
808 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
811 parse_and_eval_type (argtypetext
, p
- argtypetext
);
829 if (p
[-2] != '.') /* Not '...' */
831 argtypes
[argcount
] = builtin_type_void
; /* List terminator */
835 argtypes
[argcount
] = NULL
; /* Ellist terminator */
838 free (demangled_name
);
840 f
= TYPE_FN_FIELDLIST1 (type
, i
);
841 TYPE_FN_FIELD_PHYSNAME (f
, j
) = mangled_name
;
843 /* Now update the old "stub" type into a real type. */
844 mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
845 TYPE_DOMAIN_TYPE (mtype
) = type
;
846 TYPE_ARG_TYPES (mtype
) = argtypes
;
847 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
848 TYPE_FN_FIELD_STUB (f
, j
) = 0;
851 const struct cplus_struct_type cplus_struct_default
;
854 allocate_cplus_struct_type (type
)
857 if (!HAVE_CPLUS_STRUCT (type
))
859 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
860 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
861 *(TYPE_CPLUS_SPECIFIC(type
)) = cplus_struct_default
;
865 /* Helper function to initialize the standard scalar types.
867 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
868 of the string pointed to by name in the type_obstack for that objfile,
869 and initialize the type name to that copy. There are places (mipsread.c
870 in particular, where init_type is called with a NULL value for NAME). */
873 init_type (code
, length
, flags
, name
, objfile
)
878 struct objfile
*objfile
;
880 register struct type
*type
;
882 type
= alloc_type (objfile
);
883 TYPE_CODE (type
) = code
;
884 TYPE_LENGTH (type
) = length
;
885 TYPE_FLAGS (type
) |= flags
;
886 if ((name
!= NULL
) && (objfile
!= NULL
))
889 obsavestring (name
, strlen (name
), &objfile
-> type_obstack
);
893 TYPE_NAME (type
) = name
;
898 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
900 INIT_CPLUS_SPECIFIC (type
);
905 /* Look up a fundamental type for the specified objfile.
906 May need to construct such a type if this is the first use.
908 Some object file formats (ELF, COFF, etc) do not define fundamental
909 types such as "int" or "double". Others (stabs for example), do
910 define fundamental types.
912 For the formats which don't provide fundamental types, gdb can create
913 such types, using defaults reasonable for the current language and
914 the current target machine.
916 NOTE: This routine is obsolescent. Each debugging format reader
917 should manage it's own fundamental types, either creating them from
918 suitable defaults or reading them from the debugging information,
919 whichever is appropriate. The DWARF reader has already been
920 fixed to do this. Once the other readers are fixed, this routine
921 will go away. Also note that fundamental types should be managed
922 on a compilation unit basis in a multi-language environment, not
923 on a linkage unit basis as is done here. */
927 lookup_fundamental_type (objfile
, typeid)
928 struct objfile
*objfile
;
931 register struct type
**typep
;
934 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
936 error ("internal error - invalid fundamental type id %d", typeid);
939 /* If this is the first time we need a fundamental type for this objfile
940 then we need to initialize the vector of type pointers. */
942 if (objfile
-> fundamental_types
== NULL
)
944 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
945 objfile
-> fundamental_types
= (struct type
**)
946 obstack_alloc (&objfile
-> type_obstack
, nbytes
);
947 memset ((char *) objfile
-> fundamental_types
, 0, nbytes
);
950 /* Look for this particular type in the fundamental type vector. If one is
951 not found, create and install one appropriate for the current language. */
953 typep
= objfile
-> fundamental_types
+ typeid;
956 *typep
= create_fundamental_type (objfile
, typeid);
965 print_bit_vector (bits
, nbits
)
971 for (bitno
= 0; bitno
< nbits
; bitno
++)
973 if ((bitno
% 8) == 0)
977 if (B_TST (bits
, bitno
))
979 printf_filtered ("1");
983 printf_filtered ("0");
988 /* The args list is a strange beast. It is either terminated by a NULL
989 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
990 type for normal fixed argcount functions. (FIXME someday)
991 Also note the first arg should be the "this" pointer, we may not want to
992 include it since we may get into a infinitely recursive situation. */
995 print_arg_types (args
, spaces
)
1001 while (*args
!= NULL
)
1003 recursive_dump_type (*args
, spaces
+ 2);
1004 if ((*args
++) -> code
== TYPE_CODE_VOID
)
1013 dump_fn_fieldlists (type
, spaces
)
1021 printfi_filtered (spaces
, "fn_fieldlists 0x%x\n",
1022 TYPE_FN_FIELDLISTS (type
));
1023 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
1025 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
1026 printfi_filtered (spaces
+ 2, "[%d] name '%s' (0x%x) length %d\n",
1028 TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
1029 TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
1030 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
1031 for (overload_idx
= 0;
1032 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
1035 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (0x%x)\n",
1037 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
1038 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
1039 printfi_filtered (spaces
+ 8, "type 0x%x\n",
1040 TYPE_FN_FIELD_TYPE (f
, overload_idx
));
1041 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
1043 printfi_filtered (spaces
+ 8, "args 0x%x\n",
1044 TYPE_FN_FIELD_ARGS (f
, overload_idx
));
1045 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
), spaces
);
1046 printfi_filtered (spaces
+ 8, "fcontext 0x%x\n",
1047 TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
));
1048 printfi_filtered (spaces
+ 8, "is_const %d\n",
1049 TYPE_FN_FIELD_CONST (f
, overload_idx
));
1050 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
1051 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
1052 printfi_filtered (spaces
+ 8, "is_private %d\n",
1053 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
1054 printfi_filtered (spaces
+ 8, "is_protected %d\n",
1055 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
1056 printfi_filtered (spaces
+ 8, "is_stub %d\n",
1057 TYPE_FN_FIELD_STUB (f
, overload_idx
));
1058 printfi_filtered (spaces
+ 8, "voffset %u\n",
1059 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
1065 print_cplus_stuff (type
, spaces
)
1071 printfi_filtered (spaces
, "n_baseclasses %d\n",
1072 TYPE_N_BASECLASSES (type
));
1073 printfi_filtered (spaces
, "nfn_fields %d\n",
1074 TYPE_NFN_FIELDS (type
));
1075 printfi_filtered (spaces
, "nfn_fields_total %d\n",
1076 TYPE_NFN_FIELDS_TOTAL (type
));
1077 if (TYPE_N_BASECLASSES (type
) > 0)
1079 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *0x%x)",
1080 TYPE_N_BASECLASSES (type
),
1081 TYPE_FIELD_VIRTUAL_BITS (type
));
1082 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
1083 TYPE_N_BASECLASSES (type
));
1084 puts_filtered ("\n");
1086 if (TYPE_NFIELDS (type
) > 0)
1088 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
1090 printfi_filtered (spaces
, "private_field_bits (%d bits at *0x%x)",
1091 TYPE_NFIELDS (type
),
1092 TYPE_FIELD_PRIVATE_BITS (type
));
1093 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
1094 TYPE_NFIELDS (type
));
1095 puts_filtered ("\n");
1097 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
1099 printfi_filtered (spaces
, "protected_field_bits (%d bits at *0x%x)",
1100 TYPE_NFIELDS (type
),
1101 TYPE_FIELD_PROTECTED_BITS (type
));
1102 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
1103 TYPE_NFIELDS (type
));
1104 puts_filtered ("\n");
1107 if (TYPE_NFN_FIELDS (type
) > 0)
1109 dump_fn_fieldlists (type
, spaces
);
1114 recursive_dump_type (type
, spaces
)
1120 printfi_filtered (spaces
, "type node 0x%x\n", type
);
1121 printfi_filtered (spaces
, "name '%s' (0x%x)\n", TYPE_NAME (type
),
1122 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
1123 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
1124 switch (TYPE_CODE (type
))
1126 case TYPE_CODE_UNDEF
:
1127 printf_filtered ("(TYPE_CODE_UNDEF)");
1130 printf_filtered ("(TYPE_CODE_PTR)");
1132 case TYPE_CODE_ARRAY
:
1133 printf_filtered ("(TYPE_CODE_ARRAY)");
1135 case TYPE_CODE_STRUCT
:
1136 printf_filtered ("(TYPE_CODE_STRUCT)");
1138 case TYPE_CODE_UNION
:
1139 printf_filtered ("(TYPE_CODE_UNION)");
1141 case TYPE_CODE_ENUM
:
1142 printf_filtered ("(TYPE_CODE_ENUM)");
1144 case TYPE_CODE_FUNC
:
1145 printf_filtered ("(TYPE_CODE_FUNC)");
1148 printf_filtered ("(TYPE_CODE_INT)");
1151 printf_filtered ("(TYPE_CODE_FLT)");
1153 case TYPE_CODE_VOID
:
1154 printf_filtered ("(TYPE_CODE_VOID)");
1157 printf_filtered ("(TYPE_CODE_SET)");
1159 case TYPE_CODE_RANGE
:
1160 printf_filtered ("(TYPE_CODE_RANGE)");
1162 case TYPE_CODE_PASCAL_ARRAY
:
1163 printf_filtered ("(TYPE_CODE_PASCAL_ARRAY)");
1165 case TYPE_CODE_ERROR
:
1166 printf_filtered ("(TYPE_CODE_ERROR)");
1168 case TYPE_CODE_MEMBER
:
1169 printf_filtered ("(TYPE_CODE_MEMBER)");
1171 case TYPE_CODE_METHOD
:
1172 printf_filtered ("(TYPE_CODE_METHOD)");
1175 printf_filtered ("(TYPE_CODE_REF)");
1177 case TYPE_CODE_CHAR
:
1178 printf_filtered ("(TYPE_CODE_CHAR)");
1180 case TYPE_CODE_BOOL
:
1181 printf_filtered ("(TYPE_CODE_BOOL)");
1184 printf_filtered ("(UNKNOWN TYPE CODE)");
1187 puts_filtered ("\n");
1188 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
1189 printfi_filtered (spaces
, "objfile 0x%x\n", TYPE_OBJFILE (type
));
1190 printfi_filtered (spaces
, "target_type 0x%x\n", TYPE_TARGET_TYPE (type
));
1191 if (TYPE_TARGET_TYPE (type
) != NULL
)
1193 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
1195 printfi_filtered (spaces
, "pointer_type 0x%x\n",
1196 TYPE_POINTER_TYPE (type
));
1197 printfi_filtered (spaces
, "reference_type 0x%x\n",
1198 TYPE_REFERENCE_TYPE (type
));
1199 printfi_filtered (spaces
, "function_type 0x%x\n",
1200 TYPE_FUNCTION_TYPE (type
));
1201 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
1202 if (TYPE_FLAGS (type
) & TYPE_FLAG_UNSIGNED
)
1204 puts_filtered (" TYPE_FLAG_UNSIGNED");
1206 if (TYPE_FLAGS (type
) & TYPE_FLAG_SIGNED
)
1208 puts_filtered (" TYPE_FLAG_SIGNED");
1210 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
1212 puts_filtered (" TYPE_FLAG_STUB");
1214 puts_filtered ("\n");
1215 printfi_filtered (spaces
, "nfields %d 0x%x\n", TYPE_NFIELDS (type
),
1216 TYPE_FIELDS (type
));
1217 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
1219 printfi_filtered (spaces
+ 2,
1220 "[%d] bitpos %d bitsize %d type 0x%x name '%s' (0x%x)\n",
1221 idx
, TYPE_FIELD_BITPOS (type
, idx
),
1222 TYPE_FIELD_BITSIZE (type
, idx
),
1223 TYPE_FIELD_TYPE (type
, idx
),
1224 TYPE_FIELD_NAME (type
, idx
),
1225 TYPE_FIELD_NAME (type
, idx
) != NULL
1226 ? TYPE_FIELD_NAME (type
, idx
)
1228 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
1230 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
1233 printfi_filtered (spaces
, "vptr_basetype 0x%x\n",
1234 TYPE_VPTR_BASETYPE (type
));
1235 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
1237 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
1239 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
1240 switch (TYPE_CODE (type
))
1242 case TYPE_CODE_METHOD
:
1243 case TYPE_CODE_FUNC
:
1244 printfi_filtered (spaces
, "arg_types 0x%x\n", TYPE_ARG_TYPES (type
));
1245 print_arg_types (TYPE_ARG_TYPES (type
), spaces
);
1248 case TYPE_CODE_STRUCT
:
1249 printfi_filtered (spaces
, "cplus_stuff 0x%x\n",
1250 TYPE_CPLUS_SPECIFIC (type
));
1251 print_cplus_stuff (type
, spaces
);
1255 /* We have to pick one of the union types to be able print and test
1256 the value. Pick cplus_struct_type, even though we know it isn't
1257 any particular one. */
1258 printfi_filtered (spaces
, "type_specific 0x%x",
1259 TYPE_CPLUS_SPECIFIC (type
));
1260 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
1262 printf_filtered (" (unknown data form)");
1264 printf_filtered ("\n");
1270 #endif /* MAINTENANCE_CMDS */