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
);
421 create_set_type (result_type
, domain_type
)
422 struct type
*result_type
;
423 struct type
*domain_type
;
425 if (result_type
== NULL
)
427 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
429 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
430 TYPE_NFIELDS (result_type
) = 1;
431 TYPE_FIELDS (result_type
) = (struct field
*)
432 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
433 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
434 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
435 if (TYPE_CODE (domain_type
) != TYPE_CODE_RANGE
)
436 TYPE_LENGTH (result_type
) = 4; /* Error? */
439 int low_bound
= TYPE_FIELD_BITPOS (domain_type
, 0);
440 int high_bound
= TYPE_FIELD_BITPOS (domain_type
, 1);
441 int bit_length
= high_bound
- low_bound
+ 1;
442 if (bit_length
<= TARGET_CHAR_BIT
)
443 TYPE_LENGTH (result_type
) = 1;
444 else if (bit_length
<= TARGET_SHORT_BIT
)
445 TYPE_LENGTH (result_type
) = TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
;
447 TYPE_LENGTH (result_type
)
448 = ((bit_length
+ TARGET_INT_BIT
- 1) / TARGET_INT_BIT
)
451 return (result_type
);
454 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
455 A MEMBER is a wierd thing -- it amounts to a typed offset into
456 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
457 include the offset (that's the value of the MEMBER itself), but does
458 include the structure type into which it points (for some reason).
460 When "smashing" the type, we preserve the objfile that the
461 old type pointed to, since we aren't changing where the type is actually
465 smash_to_member_type (type
, domain
, to_type
)
468 struct type
*to_type
;
470 struct objfile
*objfile
;
472 objfile
= TYPE_OBJFILE (type
);
474 memset ((char *) type
, 0, sizeof (struct type
));
475 TYPE_OBJFILE (type
) = objfile
;
476 TYPE_TARGET_TYPE (type
) = to_type
;
477 TYPE_DOMAIN_TYPE (type
) = domain
;
478 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
479 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
482 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
483 METHOD just means `function that gets an extra "this" argument'.
485 When "smashing" the type, we preserve the objfile that the
486 old type pointed to, since we aren't changing where the type is actually
490 smash_to_method_type (type
, domain
, to_type
, args
)
493 struct type
*to_type
;
496 struct objfile
*objfile
;
498 objfile
= TYPE_OBJFILE (type
);
500 memset ((char *) type
, 0, sizeof (struct type
));
501 TYPE_OBJFILE (type
) = objfile
;
502 TYPE_TARGET_TYPE (type
) = to_type
;
503 TYPE_DOMAIN_TYPE (type
) = domain
;
504 TYPE_ARG_TYPES (type
) = args
;
505 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
506 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
509 /* Return a typename for a struct/union/enum type without "struct ",
510 "union ", or "enum ". If the type has a NULL name, return NULL. */
513 type_name_no_tag (type
)
514 register const struct type
*type
;
516 if (TYPE_TAG_NAME (type
) != NULL
)
517 return TYPE_TAG_NAME (type
);
519 /* Is there code which expects this to return the name if there is no
520 tag name? My guess is that this is mainly used for C++ in cases where
521 the two will always be the same. */
522 return TYPE_NAME (type
);
525 /* Lookup a primitive type named NAME.
526 Return zero if NAME is not a primitive type.*/
529 lookup_primitive_typename (name
)
532 struct type
** const *p
;
534 for (p
= current_language
-> la_builtin_type_vector
; *p
!= NULL
; p
++)
536 if (STREQ ((**p
) -> name
, name
))
544 /* Lookup a typedef or primitive type named NAME,
545 visible in lexical block BLOCK.
546 If NOERR is nonzero, return zero if NAME is not suitably defined. */
549 lookup_typename (name
, block
, noerr
)
554 register struct symbol
*sym
;
555 register struct type
*tmp
;
557 sym
= lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
558 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
560 tmp
= lookup_primitive_typename (name
);
565 else if (!tmp
&& noerr
)
571 error ("No type named %s.", name
);
574 return (SYMBOL_TYPE (sym
));
578 lookup_unsigned_typename (name
)
581 char *uns
= alloca (strlen (name
) + 10);
583 strcpy (uns
, "unsigned ");
584 strcpy (uns
+ 9, name
);
585 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
589 lookup_signed_typename (name
)
593 char *uns
= alloca (strlen (name
) + 8);
595 strcpy (uns
, "signed ");
596 strcpy (uns
+ 7, name
);
597 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
598 /* If we don't find "signed FOO" just try again with plain "FOO". */
601 return lookup_typename (name
, (struct block
*) NULL
, 0);
604 /* Lookup a structure type named "struct NAME",
605 visible in lexical block BLOCK. */
608 lookup_struct (name
, block
)
612 register struct symbol
*sym
;
614 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
615 (struct symtab
**) NULL
);
619 error ("No struct type named %s.", name
);
621 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
623 error ("This context has class, union or enum %s, not a struct.", name
);
625 return (SYMBOL_TYPE (sym
));
628 /* Lookup a union type named "union NAME",
629 visible in lexical block BLOCK. */
632 lookup_union (name
, block
)
636 register struct symbol
*sym
;
638 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
639 (struct symtab
**) NULL
);
643 error ("No union type named %s.", name
);
645 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_UNION
)
647 error ("This context has class, struct or enum %s, not a union.", name
);
649 return (SYMBOL_TYPE (sym
));
652 /* Lookup an enum type named "enum NAME",
653 visible in lexical block BLOCK. */
656 lookup_enum (name
, block
)
660 register struct symbol
*sym
;
662 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
663 (struct symtab
**) NULL
);
666 error ("No enum type named %s.", name
);
668 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
670 error ("This context has class, struct or union %s, not an enum.", name
);
672 return (SYMBOL_TYPE (sym
));
675 /* Lookup a template type named "template NAME<TYPE>",
676 visible in lexical block BLOCK. */
679 lookup_template_type (name
, type
, block
)
685 char *nam
= (char*) alloca(strlen(name
) + strlen(type
->name
) + 4);
688 strcat (nam
, type
->name
);
689 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
691 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
695 error ("No template type named %s.", name
);
697 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
699 error ("This context has class, union or enum %s, not a struct.", name
);
701 return (SYMBOL_TYPE (sym
));
704 /* Given a type TYPE, lookup the type of the component of type named NAME.
706 TYPE can be either a struct or union, or a pointer or reference to a struct or
707 union. If it is a pointer or reference, its target type is automatically used.
708 Thus '.' and '->' are interchangable, as specified for the definitions of the
709 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
711 If NOERR is nonzero, return zero if NAME is not suitably defined.
712 If NAME is the name of a baseclass type, return that type. */
715 lookup_struct_elt_type (type
, name
, noerr
)
722 while (TYPE_CODE (type
) == TYPE_CODE_PTR
||
723 TYPE_CODE (type
) == TYPE_CODE_REF
)
724 type
= TYPE_TARGET_TYPE (type
);
726 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
727 TYPE_CODE (type
) != TYPE_CODE_UNION
)
729 target_terminal_ours ();
730 gdb_flush (gdb_stdout
);
731 fprintf_unfiltered (gdb_stderr
, "Type ");
732 type_print (type
, "", gdb_stderr
, -1);
733 error (" is not a structure or union type.");
736 check_stub_type (type
);
739 /* FIXME: This change put in by Michael seems incorrect for the case where
740 the structure tag name is the same as the member name. I.E. when doing
741 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
746 typename
= type_name_no_tag (type
);
747 if (typename
!= NULL
&& STREQ (typename
, name
))
752 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
754 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
756 if (t_field_name
&& STREQ (t_field_name
, name
))
758 return TYPE_FIELD_TYPE (type
, i
);
762 /* OK, it's not in this class. Recursively check the baseclasses. */
763 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
767 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, noerr
);
779 target_terminal_ours ();
780 gdb_flush (gdb_stdout
);
781 fprintf_unfiltered (gdb_stderr
, "Type ");
782 type_print (type
, "", gdb_stderr
, -1);
783 fprintf_unfiltered (gdb_stderr
, " has no component named ");
784 fputs_filtered (name
, gdb_stderr
);
786 return (struct type
*)-1; /* For lint */
789 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
790 valid. Callers should be aware that in some cases (for example,
791 the type or one of its baseclasses is a stub type and we are
792 debugging a .o file), this function will not be able to find the virtual
793 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
797 fill_in_vptr_fieldno (type
)
800 check_stub_type (type
);
802 if (TYPE_VPTR_FIELDNO (type
) < 0)
806 /* We must start at zero in case the first (and only) baseclass is
807 virtual (and hence we cannot share the table pointer). */
808 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
810 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, i
));
811 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
)) >= 0)
813 TYPE_VPTR_FIELDNO (type
)
814 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
));
815 TYPE_VPTR_BASETYPE (type
)
816 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type
, i
));
823 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
825 If this is a stubbed struct (i.e. declared as struct foo *), see if
826 we can find a full definition in some other file. If so, copy this
827 definition, so we can use it in future. There used to be a comment (but
828 not any code) that if we don't find a full definition, we'd set a flag
829 so we don't spend time in the future checking the same type. That would
830 be a mistake, though--we might load in more symbols which contain a
831 full definition for the type.
833 This used to be coded as a macro, but I don't think it is called
834 often enough to merit such treatment. */
836 struct complaint stub_noname_complaint
=
837 {"stub type has NULL name", 0, 0};
840 check_stub_type (type
)
843 if (TYPE_FLAGS(type
) & TYPE_FLAG_STUB
)
845 char* name
= type_name_no_tag (type
);
846 /* FIXME: shouldn't we separately check the TYPE_NAME and the
847 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
848 as appropriate? (this code was written before TYPE_NAME and
849 TYPE_TAG_NAME were separate). */
853 complain (&stub_noname_complaint
);
856 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
857 (struct symtab
**) NULL
);
860 memcpy ((char *)type
,
861 (char *)SYMBOL_TYPE(sym
),
862 sizeof (struct type
));
866 if (TYPE_FLAGS (type
) & TYPE_FLAG_TARGET_STUB
)
868 struct type
*range_type
;
870 check_stub_type (TYPE_TARGET_TYPE (type
));
871 if (!(TYPE_FLAGS (TYPE_TARGET_TYPE (type
)) & TYPE_FLAG_STUB
)
872 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
873 && TYPE_NFIELDS (type
) == 1
874 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
877 /* Now recompute the length of the array type, based on its
878 number of elements and the target type's length. */
880 ((TYPE_FIELD_BITPOS (range_type
, 1)
881 - TYPE_FIELD_BITPOS (range_type
, 0)
883 * TYPE_LENGTH (TYPE_TARGET_TYPE (type
)));
884 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
889 /* Ugly hack to convert method stubs into method types.
891 He ain't kiddin'. This demangles the name of the method into a string
892 including argument types, parses out each argument type, generates
893 a string casting a zero to that type, evaluates the string, and stuffs
894 the resulting type into an argtype vector!!! Then it knows the type
895 of the whole function (including argument types for overloading),
896 which info used to be in the stab's but was removed to hack back
897 the space required for them. */
900 check_stub_method (type
, i
, j
)
906 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
907 char *demangled_name
= cplus_demangle (mangled_name
,
908 DMGL_PARAMS
| DMGL_ANSI
);
909 char *argtypetext
, *p
;
910 int depth
= 0, argcount
= 1;
911 struct type
**argtypes
;
914 if (demangled_name
== NULL
)
916 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
919 /* Now, read in the parameters that define this type. */
920 argtypetext
= strchr (demangled_name
, '(') + 1;
932 else if (*p
== ',' && depth
== 0)
940 /* We need two more slots: one for the THIS pointer, and one for the
941 NULL [...] or void [end of arglist]. */
943 argtypes
= (struct type
**)
944 TYPE_ALLOC (type
, (argcount
+ 2) * sizeof (struct type
*));
946 argtypes
[0] = lookup_pointer_type (type
);
949 if (*p
!= ')') /* () means no args, skip while */
954 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
957 parse_and_eval_type (argtypetext
, p
- argtypetext
);
975 if (p
[-2] != '.') /* Not '...' */
977 argtypes
[argcount
] = builtin_type_void
; /* List terminator */
981 argtypes
[argcount
] = NULL
; /* Ellist terminator */
984 free (demangled_name
);
986 f
= TYPE_FN_FIELDLIST1 (type
, i
);
987 TYPE_FN_FIELD_PHYSNAME (f
, j
) = mangled_name
;
989 /* Now update the old "stub" type into a real type. */
990 mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
991 TYPE_DOMAIN_TYPE (mtype
) = type
;
992 TYPE_ARG_TYPES (mtype
) = argtypes
;
993 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
994 TYPE_FN_FIELD_STUB (f
, j
) = 0;
997 const struct cplus_struct_type cplus_struct_default
;
1000 allocate_cplus_struct_type (type
)
1003 if (!HAVE_CPLUS_STRUCT (type
))
1005 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1006 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1007 *(TYPE_CPLUS_SPECIFIC(type
)) = cplus_struct_default
;
1011 /* Helper function to initialize the standard scalar types.
1013 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1014 of the string pointed to by name in the type_obstack for that objfile,
1015 and initialize the type name to that copy. There are places (mipsread.c
1016 in particular, where init_type is called with a NULL value for NAME). */
1019 init_type (code
, length
, flags
, name
, objfile
)
1020 enum type_code code
;
1024 struct objfile
*objfile
;
1026 register struct type
*type
;
1028 type
= alloc_type (objfile
);
1029 TYPE_CODE (type
) = code
;
1030 TYPE_LENGTH (type
) = length
;
1031 TYPE_FLAGS (type
) |= flags
;
1032 if ((name
!= NULL
) && (objfile
!= NULL
))
1035 obsavestring (name
, strlen (name
), &objfile
-> type_obstack
);
1039 TYPE_NAME (type
) = name
;
1044 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
1046 INIT_CPLUS_SPECIFIC (type
);
1051 /* Look up a fundamental type for the specified objfile.
1052 May need to construct such a type if this is the first use.
1054 Some object file formats (ELF, COFF, etc) do not define fundamental
1055 types such as "int" or "double". Others (stabs for example), do
1056 define fundamental types.
1058 For the formats which don't provide fundamental types, gdb can create
1059 such types, using defaults reasonable for the current language and
1060 the current target machine.
1062 NOTE: This routine is obsolescent. Each debugging format reader
1063 should manage it's own fundamental types, either creating them from
1064 suitable defaults or reading them from the debugging information,
1065 whichever is appropriate. The DWARF reader has already been
1066 fixed to do this. Once the other readers are fixed, this routine
1067 will go away. Also note that fundamental types should be managed
1068 on a compilation unit basis in a multi-language environment, not
1069 on a linkage unit basis as is done here. */
1073 lookup_fundamental_type (objfile
, typeid)
1074 struct objfile
*objfile
;
1077 register struct type
**typep
;
1078 register int nbytes
;
1080 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1082 error ("internal error - invalid fundamental type id %d", typeid);
1085 /* If this is the first time we need a fundamental type for this objfile
1086 then we need to initialize the vector of type pointers. */
1088 if (objfile
-> fundamental_types
== NULL
)
1090 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1091 objfile
-> fundamental_types
= (struct type
**)
1092 obstack_alloc (&objfile
-> type_obstack
, nbytes
);
1093 memset ((char *) objfile
-> fundamental_types
, 0, nbytes
);
1096 /* Look for this particular type in the fundamental type vector. If one is
1097 not found, create and install one appropriate for the current language. */
1099 typep
= objfile
-> fundamental_types
+ typeid;
1102 *typep
= create_fundamental_type (objfile
, typeid);
1108 #if MAINTENANCE_CMDS
1111 print_bit_vector (bits
, nbits
)
1117 for (bitno
= 0; bitno
< nbits
; bitno
++)
1119 if ((bitno
% 8) == 0)
1121 puts_filtered (" ");
1123 if (B_TST (bits
, bitno
))
1125 printf_filtered ("1");
1129 printf_filtered ("0");
1134 /* The args list is a strange beast. It is either terminated by a NULL
1135 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
1136 type for normal fixed argcount functions. (FIXME someday)
1137 Also note the first arg should be the "this" pointer, we may not want to
1138 include it since we may get into a infinitely recursive situation. */
1141 print_arg_types (args
, spaces
)
1147 while (*args
!= NULL
)
1149 recursive_dump_type (*args
, spaces
+ 2);
1150 if ((*args
++) -> code
== TYPE_CODE_VOID
)
1159 dump_fn_fieldlists (type
, spaces
)
1167 printfi_filtered (spaces
, "fn_fieldlists 0x%lx\n",
1168 (unsigned long) TYPE_FN_FIELDLISTS (type
));
1169 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
1171 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
1172 printfi_filtered (spaces
+ 2, "[%d] name '%s' (0x%lx) length %d\n",
1174 TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
1175 (unsigned long) TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
1176 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
1177 for (overload_idx
= 0;
1178 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
1181 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (0x%lx)\n",
1183 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
1184 (unsigned long) TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
1185 printfi_filtered (spaces
+ 8, "type 0x%lx\n",
1186 (unsigned long) TYPE_FN_FIELD_TYPE (f
, overload_idx
));
1187 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
1189 printfi_filtered (spaces
+ 8, "args 0x%lx\n",
1190 (unsigned long) TYPE_FN_FIELD_ARGS (f
, overload_idx
));
1191 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
), spaces
);
1192 printfi_filtered (spaces
+ 8, "fcontext 0x%lx\n",
1193 (unsigned long) TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
));
1194 printfi_filtered (spaces
+ 8, "is_const %d\n",
1195 TYPE_FN_FIELD_CONST (f
, overload_idx
));
1196 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
1197 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
1198 printfi_filtered (spaces
+ 8, "is_private %d\n",
1199 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
1200 printfi_filtered (spaces
+ 8, "is_protected %d\n",
1201 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
1202 printfi_filtered (spaces
+ 8, "is_stub %d\n",
1203 TYPE_FN_FIELD_STUB (f
, overload_idx
));
1204 printfi_filtered (spaces
+ 8, "voffset %u\n",
1205 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
1211 print_cplus_stuff (type
, spaces
)
1215 printfi_filtered (spaces
, "n_baseclasses %d\n",
1216 TYPE_N_BASECLASSES (type
));
1217 printfi_filtered (spaces
, "nfn_fields %d\n",
1218 TYPE_NFN_FIELDS (type
));
1219 printfi_filtered (spaces
, "nfn_fields_total %d\n",
1220 TYPE_NFN_FIELDS_TOTAL (type
));
1221 if (TYPE_N_BASECLASSES (type
) > 0)
1223 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *0x%lx)",
1224 TYPE_N_BASECLASSES (type
),
1225 (unsigned long) TYPE_FIELD_VIRTUAL_BITS (type
));
1226 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
1227 TYPE_N_BASECLASSES (type
));
1228 puts_filtered ("\n");
1230 if (TYPE_NFIELDS (type
) > 0)
1232 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
1234 printfi_filtered (spaces
, "private_field_bits (%d bits at *0x%lx)",
1235 TYPE_NFIELDS (type
),
1236 (unsigned long) TYPE_FIELD_PRIVATE_BITS (type
));
1237 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
1238 TYPE_NFIELDS (type
));
1239 puts_filtered ("\n");
1241 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
1243 printfi_filtered (spaces
, "protected_field_bits (%d bits at *0x%lx)",
1244 TYPE_NFIELDS (type
),
1245 (unsigned long) TYPE_FIELD_PROTECTED_BITS (type
));
1246 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
1247 TYPE_NFIELDS (type
));
1248 puts_filtered ("\n");
1251 if (TYPE_NFN_FIELDS (type
) > 0)
1253 dump_fn_fieldlists (type
, spaces
);
1258 recursive_dump_type (type
, spaces
)
1264 printfi_filtered (spaces
, "type node 0x%lx\n", (unsigned long)type
);
1265 printfi_filtered (spaces
, "name '%s' (0x%lx)\n",
1266 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>",
1267 (unsigned long)TYPE_NAME (type
));
1268 if (TYPE_TAG_NAME (type
) != NULL
)
1269 printfi_filtered (spaces
, "tagname '%s' (0x%lx)\n",
1270 TYPE_TAG_NAME (type
),
1271 (unsigned long)TYPE_TAG_NAME (type
));
1272 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
1273 switch (TYPE_CODE (type
))
1275 case TYPE_CODE_UNDEF
:
1276 printf_filtered ("(TYPE_CODE_UNDEF)");
1279 printf_filtered ("(TYPE_CODE_PTR)");
1281 case TYPE_CODE_ARRAY
:
1282 printf_filtered ("(TYPE_CODE_ARRAY)");
1284 case TYPE_CODE_STRUCT
:
1285 printf_filtered ("(TYPE_CODE_STRUCT)");
1287 case TYPE_CODE_UNION
:
1288 printf_filtered ("(TYPE_CODE_UNION)");
1290 case TYPE_CODE_ENUM
:
1291 printf_filtered ("(TYPE_CODE_ENUM)");
1293 case TYPE_CODE_FUNC
:
1294 printf_filtered ("(TYPE_CODE_FUNC)");
1297 printf_filtered ("(TYPE_CODE_INT)");
1300 printf_filtered ("(TYPE_CODE_FLT)");
1302 case TYPE_CODE_VOID
:
1303 printf_filtered ("(TYPE_CODE_VOID)");
1306 printf_filtered ("(TYPE_CODE_SET)");
1308 case TYPE_CODE_RANGE
:
1309 printf_filtered ("(TYPE_CODE_RANGE)");
1311 case TYPE_CODE_STRING
:
1312 printf_filtered ("(TYPE_CODE_STRING)");
1314 case TYPE_CODE_ERROR
:
1315 printf_filtered ("(TYPE_CODE_ERROR)");
1317 case TYPE_CODE_MEMBER
:
1318 printf_filtered ("(TYPE_CODE_MEMBER)");
1320 case TYPE_CODE_METHOD
:
1321 printf_filtered ("(TYPE_CODE_METHOD)");
1324 printf_filtered ("(TYPE_CODE_REF)");
1326 case TYPE_CODE_CHAR
:
1327 printf_filtered ("(TYPE_CODE_CHAR)");
1329 case TYPE_CODE_BOOL
:
1330 printf_filtered ("(TYPE_CODE_BOOL)");
1333 printf_filtered ("(UNKNOWN TYPE CODE)");
1336 puts_filtered ("\n");
1337 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
1338 printfi_filtered (spaces
, "objfile 0x%lx\n",
1339 (unsigned long) TYPE_OBJFILE (type
));
1340 printfi_filtered (spaces
, "target_type 0x%lx\n",
1341 (unsigned long) TYPE_TARGET_TYPE (type
));
1342 if (TYPE_TARGET_TYPE (type
) != NULL
)
1344 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
1346 printfi_filtered (spaces
, "pointer_type 0x%lx\n",
1347 (unsigned long) TYPE_POINTER_TYPE (type
));
1348 printfi_filtered (spaces
, "reference_type 0x%lx\n",
1349 (unsigned long) TYPE_REFERENCE_TYPE (type
));
1350 printfi_filtered (spaces
, "function_type 0x%lx\n",
1351 (unsigned long) TYPE_FUNCTION_TYPE (type
));
1352 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
1353 if (TYPE_FLAGS (type
) & TYPE_FLAG_UNSIGNED
)
1355 puts_filtered (" TYPE_FLAG_UNSIGNED");
1357 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
1359 puts_filtered (" TYPE_FLAG_STUB");
1361 puts_filtered ("\n");
1362 printfi_filtered (spaces
, "nfields %d 0x%lx\n", TYPE_NFIELDS (type
),
1363 (unsigned long) TYPE_FIELDS (type
));
1364 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
1366 printfi_filtered (spaces
+ 2,
1367 "[%d] bitpos %d bitsize %d type 0x%lx name '%s' (0x%lx)\n",
1368 idx
, TYPE_FIELD_BITPOS (type
, idx
),
1369 TYPE_FIELD_BITSIZE (type
, idx
),
1370 (unsigned long) TYPE_FIELD_TYPE (type
, idx
),
1371 TYPE_FIELD_NAME (type
, idx
) != NULL
1372 ? TYPE_FIELD_NAME (type
, idx
)
1374 (unsigned long) TYPE_FIELD_NAME (type
, idx
));
1375 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
1377 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
1380 printfi_filtered (spaces
, "vptr_basetype 0x%lx\n",
1381 (unsigned long) TYPE_VPTR_BASETYPE (type
));
1382 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
1384 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
1386 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
1387 switch (TYPE_CODE (type
))
1389 case TYPE_CODE_METHOD
:
1390 case TYPE_CODE_FUNC
:
1391 printfi_filtered (spaces
, "arg_types 0x%lx\n",
1392 (unsigned long) TYPE_ARG_TYPES (type
));
1393 print_arg_types (TYPE_ARG_TYPES (type
), spaces
);
1396 case TYPE_CODE_STRUCT
:
1397 printfi_filtered (spaces
, "cplus_stuff 0x%lx\n",
1398 (unsigned long) TYPE_CPLUS_SPECIFIC (type
));
1399 print_cplus_stuff (type
, spaces
);
1403 /* We have to pick one of the union types to be able print and test
1404 the value. Pick cplus_struct_type, even though we know it isn't
1405 any particular one. */
1406 printfi_filtered (spaces
, "type_specific 0x%lx",
1407 (unsigned long) TYPE_CPLUS_SPECIFIC (type
));
1408 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
1410 printf_filtered (" (unknown data form)");
1412 printf_filtered ("\n");
1418 #endif /* MAINTENANCE_CMDS */
1421 _initialize_gdbtypes ()
1424 init_type (TYPE_CODE_VOID
, 1,
1426 "void", (struct objfile
*) NULL
);
1428 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1430 "char", (struct objfile
*) NULL
);
1431 builtin_type_signed_char
=
1432 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1434 "signed char", (struct objfile
*) NULL
);
1435 builtin_type_unsigned_char
=
1436 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1438 "unsigned char", (struct objfile
*) NULL
);
1439 builtin_type_short
=
1440 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1442 "short", (struct objfile
*) NULL
);
1443 builtin_type_unsigned_short
=
1444 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1446 "unsigned short", (struct objfile
*) NULL
);
1448 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1450 "int", (struct objfile
*) NULL
);
1451 builtin_type_unsigned_int
=
1452 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1454 "unsigned int", (struct objfile
*) NULL
);
1456 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1458 "long", (struct objfile
*) NULL
);
1459 builtin_type_unsigned_long
=
1460 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1462 "unsigned long", (struct objfile
*) NULL
);
1463 builtin_type_long_long
=
1464 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1466 "long long", (struct objfile
*) NULL
);
1467 builtin_type_unsigned_long_long
=
1468 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1470 "unsigned long long", (struct objfile
*) NULL
);
1471 builtin_type_float
=
1472 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1474 "float", (struct objfile
*) NULL
);
1475 builtin_type_double
=
1476 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1478 "double", (struct objfile
*) NULL
);
1479 builtin_type_long_double
=
1480 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1482 "long double", (struct objfile
*) NULL
);
1483 builtin_type_complex
=
1484 init_type (TYPE_CODE_FLT
, TARGET_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
1486 "complex", (struct objfile
*) NULL
);
1487 builtin_type_double_complex
=
1488 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
1490 "double complex", (struct objfile
*) NULL
);
1491 builtin_type_string
=
1492 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1494 "string", (struct objfile
*) NULL
);