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 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
231 ntype
= alloc_type (TYPE_OBJFILE (type
));
235 else /* We have storage, but need to reset it. */
238 objfile
= TYPE_OBJFILE (ntype
);
239 memset ((char *) ntype
, 0, sizeof (struct type
));
240 TYPE_OBJFILE (ntype
) = objfile
;
243 TYPE_TARGET_TYPE (ntype
) = type
;
245 TYPE_LENGTH (ntype
) = 1;
246 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
252 /* Given a type TYPE, return a type of functions that return that type.
253 May need to construct such a type if this is the first use. */
256 lookup_function_type (type
)
259 return make_function_type (type
, (struct type
**)0);
262 /* Implement direct support for MEMBER_TYPE in GNU C++.
263 May need to construct such a type if this is the first use.
264 The TYPE is the type of the member. The DOMAIN is the type
265 of the aggregate that the member belongs to. */
268 lookup_member_type (type
, domain
)
272 register struct type
*mtype
;
274 mtype
= alloc_type (TYPE_OBJFILE (type
));
275 smash_to_member_type (mtype
, domain
, type
);
279 /* Allocate a stub method whose return type is TYPE.
280 This apparently happens for speed of symbol reading, since parsing
281 out the arguments to the method is cpu-intensive, the way we are doing
282 it. So, we will fill in arguments later.
283 This always returns a fresh type. */
286 allocate_stub_method (type
)
291 mtype
= alloc_type (TYPE_OBJFILE (type
));
292 TYPE_TARGET_TYPE (mtype
) = type
;
293 /* _DOMAIN_TYPE (mtype) = unknown yet */
294 /* _ARG_TYPES (mtype) = unknown yet */
295 TYPE_FLAGS (mtype
) = TYPE_FLAG_STUB
;
296 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
297 TYPE_LENGTH (mtype
) = 1;
301 /* Create a range type using either a blank type supplied in RESULT_TYPE,
302 or creating a new type, inheriting the objfile from INDEX_TYPE.
304 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
305 HIGH_BOUND, inclusive.
307 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
308 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
311 create_range_type (result_type
, index_type
, low_bound
, high_bound
)
312 struct type
*result_type
;
313 struct type
*index_type
;
317 if (result_type
== NULL
)
319 result_type
= alloc_type (TYPE_OBJFILE (index_type
));
321 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
322 TYPE_TARGET_TYPE (result_type
) = index_type
;
323 TYPE_LENGTH (result_type
) = TYPE_LENGTH (index_type
);
324 TYPE_NFIELDS (result_type
) = 2;
325 TYPE_FIELDS (result_type
) = (struct field
*)
326 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
327 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
328 TYPE_FIELD_BITPOS (result_type
, 0) = low_bound
;
329 TYPE_FIELD_BITPOS (result_type
, 1) = high_bound
;
330 TYPE_FIELD_TYPE (result_type
, 0) = builtin_type_int
; /* FIXME */
331 TYPE_FIELD_TYPE (result_type
, 1) = builtin_type_int
; /* FIXME */
333 return (result_type
);
336 /* A lot of code assumes that the "index type" of an array/string/
337 set/bitstring is specifically a range type, though in some languages
338 it can be any discrete type. */
341 force_to_range_type (type
)
344 switch (TYPE_CODE (type
))
346 case TYPE_CODE_RANGE
:
351 int low_bound
= TYPE_FIELD_BITPOS (type
, 0);
352 int high_bound
= TYPE_FIELD_BITPOS (type
, TYPE_NFIELDS (type
) - 1);
353 struct type
*range_type
=
354 create_range_type (NULL
, type
, low_bound
, high_bound
);
355 TYPE_NAME (range_type
) = TYPE_NAME (range_type
);
356 TYPE_DUMMY_RANGE (range_type
) = 1;
361 struct type
*range_type
= create_range_type (NULL
, type
, 0, 1);
362 TYPE_NAME (range_type
) = TYPE_NAME (range_type
);
363 TYPE_DUMMY_RANGE (range_type
) = 1;
368 struct type
*range_type
= create_range_type (NULL
, type
, 0, 255);
369 TYPE_NAME (range_type
) = TYPE_NAME (range_type
);
370 TYPE_DUMMY_RANGE (range_type
) = 1;
375 static struct complaint msg
=
376 { "array index type must be a discrete type", 0, 0};
379 return create_range_type (NULL
, builtin_type_int
, 0, 0);
384 /* Create an array type using either a blank type supplied in RESULT_TYPE,
385 or creating a new type, inheriting the objfile from RANGE_TYPE.
387 Elements will be of type ELEMENT_TYPE, the indices will be of type
390 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
391 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
394 create_array_type (result_type
, element_type
, range_type
)
395 struct type
*result_type
;
396 struct type
*element_type
;
397 struct type
*range_type
;
402 range_type
= force_to_range_type (range_type
);
403 if (result_type
== NULL
)
405 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
407 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
408 TYPE_TARGET_TYPE (result_type
) = element_type
;
409 low_bound
= TYPE_LOW_BOUND (range_type
);
410 high_bound
= TYPE_HIGH_BOUND (range_type
);
411 TYPE_LENGTH (result_type
) =
412 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
413 TYPE_NFIELDS (result_type
) = 1;
414 TYPE_FIELDS (result_type
) =
415 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
416 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
417 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
418 TYPE_VPTR_FIELDNO (result_type
) = -1;
420 return (result_type
);
423 /* Create a string type using either a blank type supplied in RESULT_TYPE,
424 or creating a new type. String types are similar enough to array of
425 char types that we can use create_array_type to build the basic type
426 and then bash it into a string type.
428 For fixed length strings, the range type contains 0 as the lower
429 bound and the length of the string minus one as the upper bound.
431 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
432 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
435 create_string_type (result_type
, range_type
)
436 struct type
*result_type
;
437 struct type
*range_type
;
439 result_type
= create_array_type (result_type
,
440 *current_language
->string_char_type
,
442 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
443 return (result_type
);
447 create_set_type (result_type
, domain_type
)
448 struct type
*result_type
;
449 struct type
*domain_type
;
451 int low_bound
, high_bound
, bit_length
;
452 if (result_type
== NULL
)
454 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
456 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
457 TYPE_NFIELDS (result_type
) = 1;
458 TYPE_FIELDS (result_type
) = (struct field
*)
459 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
460 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
462 if (! (TYPE_FLAGS (domain_type
) & TYPE_FLAG_STUB
))
464 domain_type
= force_to_range_type (domain_type
);
465 low_bound
= TYPE_LOW_BOUND (domain_type
);
466 high_bound
= TYPE_HIGH_BOUND (domain_type
);
467 bit_length
= high_bound
- low_bound
+ 1;
468 TYPE_LENGTH (result_type
)
469 = ((bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
)
472 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
473 return (result_type
);
476 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
477 A MEMBER is a wierd thing -- it amounts to a typed offset into
478 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
479 include the offset (that's the value of the MEMBER itself), but does
480 include the structure type into which it points (for some reason).
482 When "smashing" the type, we preserve the objfile that the
483 old type pointed to, since we aren't changing where the type is actually
487 smash_to_member_type (type
, domain
, to_type
)
490 struct type
*to_type
;
492 struct objfile
*objfile
;
494 objfile
= TYPE_OBJFILE (type
);
496 memset ((char *) type
, 0, sizeof (struct type
));
497 TYPE_OBJFILE (type
) = objfile
;
498 TYPE_TARGET_TYPE (type
) = to_type
;
499 TYPE_DOMAIN_TYPE (type
) = domain
;
500 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
501 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
504 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
505 METHOD just means `function that gets an extra "this" argument'.
507 When "smashing" the type, we preserve the objfile that the
508 old type pointed to, since we aren't changing where the type is actually
512 smash_to_method_type (type
, domain
, to_type
, args
)
515 struct type
*to_type
;
518 struct objfile
*objfile
;
520 objfile
= TYPE_OBJFILE (type
);
522 memset ((char *) type
, 0, sizeof (struct type
));
523 TYPE_OBJFILE (type
) = objfile
;
524 TYPE_TARGET_TYPE (type
) = to_type
;
525 TYPE_DOMAIN_TYPE (type
) = domain
;
526 TYPE_ARG_TYPES (type
) = args
;
527 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
528 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
531 /* Return a typename for a struct/union/enum type without "struct ",
532 "union ", or "enum ". If the type has a NULL name, return NULL. */
535 type_name_no_tag (type
)
536 register const struct type
*type
;
538 if (TYPE_TAG_NAME (type
) != NULL
)
539 return TYPE_TAG_NAME (type
);
541 /* Is there code which expects this to return the name if there is no
542 tag name? My guess is that this is mainly used for C++ in cases where
543 the two will always be the same. */
544 return TYPE_NAME (type
);
547 /* Lookup a primitive type named NAME.
548 Return zero if NAME is not a primitive type.*/
551 lookup_primitive_typename (name
)
554 struct type
** const *p
;
556 for (p
= current_language
-> la_builtin_type_vector
; *p
!= NULL
; p
++)
558 if (STREQ ((**p
) -> name
, name
))
566 /* Lookup a typedef or primitive type named NAME,
567 visible in lexical block BLOCK.
568 If NOERR is nonzero, return zero if NAME is not suitably defined. */
571 lookup_typename (name
, block
, noerr
)
576 register struct symbol
*sym
;
577 register struct type
*tmp
;
579 sym
= lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
580 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
582 tmp
= lookup_primitive_typename (name
);
587 else if (!tmp
&& noerr
)
593 error ("No type named %s.", name
);
596 return (SYMBOL_TYPE (sym
));
600 lookup_unsigned_typename (name
)
603 char *uns
= alloca (strlen (name
) + 10);
605 strcpy (uns
, "unsigned ");
606 strcpy (uns
+ 9, name
);
607 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
611 lookup_signed_typename (name
)
615 char *uns
= alloca (strlen (name
) + 8);
617 strcpy (uns
, "signed ");
618 strcpy (uns
+ 7, name
);
619 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
620 /* If we don't find "signed FOO" just try again with plain "FOO". */
623 return lookup_typename (name
, (struct block
*) NULL
, 0);
626 /* Lookup a structure type named "struct NAME",
627 visible in lexical block BLOCK. */
630 lookup_struct (name
, block
)
634 register struct symbol
*sym
;
636 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
637 (struct symtab
**) NULL
);
641 error ("No struct type named %s.", name
);
643 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
645 error ("This context has class, union or enum %s, not a struct.", name
);
647 return (SYMBOL_TYPE (sym
));
650 /* Lookup a union type named "union NAME",
651 visible in lexical block BLOCK. */
654 lookup_union (name
, block
)
658 register struct symbol
*sym
;
660 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
661 (struct symtab
**) NULL
);
665 error ("No union type named %s.", name
);
667 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_UNION
)
669 error ("This context has class, struct or enum %s, not a union.", name
);
671 return (SYMBOL_TYPE (sym
));
674 /* Lookup an enum type named "enum NAME",
675 visible in lexical block BLOCK. */
678 lookup_enum (name
, block
)
682 register struct symbol
*sym
;
684 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
685 (struct symtab
**) NULL
);
688 error ("No enum type named %s.", name
);
690 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
692 error ("This context has class, struct or union %s, not an enum.", name
);
694 return (SYMBOL_TYPE (sym
));
697 /* Lookup a template type named "template NAME<TYPE>",
698 visible in lexical block BLOCK. */
701 lookup_template_type (name
, type
, block
)
707 char *nam
= (char*) alloca(strlen(name
) + strlen(type
->name
) + 4);
710 strcat (nam
, type
->name
);
711 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
713 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
717 error ("No template type named %s.", name
);
719 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
721 error ("This context has class, union or enum %s, not a struct.", name
);
723 return (SYMBOL_TYPE (sym
));
726 /* Given a type TYPE, lookup the type of the component of type named NAME.
728 TYPE can be either a struct or union, or a pointer or reference to a struct or
729 union. If it is a pointer or reference, its target type is automatically used.
730 Thus '.' and '->' are interchangable, as specified for the definitions of the
731 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
733 If NOERR is nonzero, return zero if NAME is not suitably defined.
734 If NAME is the name of a baseclass type, return that type. */
737 lookup_struct_elt_type (type
, name
, noerr
)
744 while (TYPE_CODE (type
) == TYPE_CODE_PTR
||
745 TYPE_CODE (type
) == TYPE_CODE_REF
)
746 type
= TYPE_TARGET_TYPE (type
);
748 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
749 TYPE_CODE (type
) != TYPE_CODE_UNION
)
751 target_terminal_ours ();
752 gdb_flush (gdb_stdout
);
753 fprintf_unfiltered (gdb_stderr
, "Type ");
754 type_print (type
, "", gdb_stderr
, -1);
755 error (" is not a structure or union type.");
758 check_stub_type (type
);
761 /* FIXME: This change put in by Michael seems incorrect for the case where
762 the structure tag name is the same as the member name. I.E. when doing
763 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
768 typename
= type_name_no_tag (type
);
769 if (typename
!= NULL
&& STREQ (typename
, name
))
774 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
776 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
778 if (t_field_name
&& STREQ (t_field_name
, name
))
780 return TYPE_FIELD_TYPE (type
, i
);
784 /* OK, it's not in this class. Recursively check the baseclasses. */
785 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
789 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, noerr
);
801 target_terminal_ours ();
802 gdb_flush (gdb_stdout
);
803 fprintf_unfiltered (gdb_stderr
, "Type ");
804 type_print (type
, "", gdb_stderr
, -1);
805 fprintf_unfiltered (gdb_stderr
, " has no component named ");
806 fputs_filtered (name
, gdb_stderr
);
808 return (struct type
*)-1; /* For lint */
811 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
812 valid. Callers should be aware that in some cases (for example,
813 the type or one of its baseclasses is a stub type and we are
814 debugging a .o file), this function will not be able to find the virtual
815 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
819 fill_in_vptr_fieldno (type
)
822 check_stub_type (type
);
824 if (TYPE_VPTR_FIELDNO (type
) < 0)
828 /* We must start at zero in case the first (and only) baseclass is
829 virtual (and hence we cannot share the table pointer). */
830 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
832 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, i
));
833 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
)) >= 0)
835 TYPE_VPTR_FIELDNO (type
)
836 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
));
837 TYPE_VPTR_BASETYPE (type
)
838 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type
, i
));
845 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
847 If this is a stubbed struct (i.e. declared as struct foo *), see if
848 we can find a full definition in some other file. If so, copy this
849 definition, so we can use it in future. There used to be a comment (but
850 not any code) that if we don't find a full definition, we'd set a flag
851 so we don't spend time in the future checking the same type. That would
852 be a mistake, though--we might load in more symbols which contain a
853 full definition for the type.
855 This used to be coded as a macro, but I don't think it is called
856 often enough to merit such treatment. */
858 struct complaint stub_noname_complaint
=
859 {"stub type has NULL name", 0, 0};
862 check_stub_type (type
)
865 if (TYPE_FLAGS(type
) & TYPE_FLAG_STUB
)
867 char* name
= type_name_no_tag (type
);
868 /* FIXME: shouldn't we separately check the TYPE_NAME and the
869 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
870 as appropriate? (this code was written before TYPE_NAME and
871 TYPE_TAG_NAME were separate). */
875 complain (&stub_noname_complaint
);
878 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
879 (struct symtab
**) NULL
);
882 memcpy ((char *)type
,
883 (char *)SYMBOL_TYPE(sym
),
884 sizeof (struct type
));
888 if (TYPE_FLAGS (type
) & TYPE_FLAG_TARGET_STUB
)
890 struct type
*range_type
;
892 check_stub_type (TYPE_TARGET_TYPE (type
));
893 if (!(TYPE_FLAGS (TYPE_TARGET_TYPE (type
)) & TYPE_FLAG_STUB
)
894 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
895 && TYPE_NFIELDS (type
) == 1
896 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
899 /* Now recompute the length of the array type, based on its
900 number of elements and the target type's length. */
902 ((TYPE_FIELD_BITPOS (range_type
, 1)
903 - TYPE_FIELD_BITPOS (range_type
, 0)
905 * TYPE_LENGTH (TYPE_TARGET_TYPE (type
)));
906 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
911 /* Ugly hack to convert method stubs into method types.
913 He ain't kiddin'. This demangles the name of the method into a string
914 including argument types, parses out each argument type, generates
915 a string casting a zero to that type, evaluates the string, and stuffs
916 the resulting type into an argtype vector!!! Then it knows the type
917 of the whole function (including argument types for overloading),
918 which info used to be in the stab's but was removed to hack back
919 the space required for them. */
922 check_stub_method (type
, i
, j
)
928 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
929 char *demangled_name
= cplus_demangle (mangled_name
,
930 DMGL_PARAMS
| DMGL_ANSI
);
931 char *argtypetext
, *p
;
932 int depth
= 0, argcount
= 1;
933 struct type
**argtypes
;
936 if (demangled_name
== NULL
)
938 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
941 /* Now, read in the parameters that define this type. */
942 argtypetext
= strchr (demangled_name
, '(') + 1;
954 else if (*p
== ',' && depth
== 0)
962 /* We need two more slots: one for the THIS pointer, and one for the
963 NULL [...] or void [end of arglist]. */
965 argtypes
= (struct type
**)
966 TYPE_ALLOC (type
, (argcount
+ 2) * sizeof (struct type
*));
968 /* FIXME: This is wrong for static member functions. */
969 argtypes
[0] = lookup_pointer_type (type
);
972 if (*p
!= ')') /* () means no args, skip while */
977 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
979 /* Avoid parsing of ellipsis, they will be handled below. */
980 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0)
983 parse_and_eval_type (argtypetext
, p
- argtypetext
);
1002 if (p
[-2] != '.') /* Not '...' */
1004 argtypes
[argcount
] = builtin_type_void
; /* List terminator */
1008 argtypes
[argcount
] = NULL
; /* Ellist terminator */
1011 free (demangled_name
);
1013 f
= TYPE_FN_FIELDLIST1 (type
, i
);
1014 TYPE_FN_FIELD_PHYSNAME (f
, j
) = mangled_name
;
1016 /* Now update the old "stub" type into a real type. */
1017 mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1018 TYPE_DOMAIN_TYPE (mtype
) = type
;
1019 TYPE_ARG_TYPES (mtype
) = argtypes
;
1020 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1021 TYPE_FN_FIELD_STUB (f
, j
) = 0;
1024 const struct cplus_struct_type cplus_struct_default
;
1027 allocate_cplus_struct_type (type
)
1030 if (!HAVE_CPLUS_STRUCT (type
))
1032 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1033 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1034 *(TYPE_CPLUS_SPECIFIC(type
)) = cplus_struct_default
;
1038 /* Helper function to initialize the standard scalar types.
1040 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1041 of the string pointed to by name in the type_obstack for that objfile,
1042 and initialize the type name to that copy. There are places (mipsread.c
1043 in particular, where init_type is called with a NULL value for NAME). */
1046 init_type (code
, length
, flags
, name
, objfile
)
1047 enum type_code code
;
1051 struct objfile
*objfile
;
1053 register struct type
*type
;
1055 type
= alloc_type (objfile
);
1056 TYPE_CODE (type
) = code
;
1057 TYPE_LENGTH (type
) = length
;
1058 TYPE_FLAGS (type
) |= flags
;
1059 if ((name
!= NULL
) && (objfile
!= NULL
))
1062 obsavestring (name
, strlen (name
), &objfile
-> type_obstack
);
1066 TYPE_NAME (type
) = name
;
1071 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
1073 INIT_CPLUS_SPECIFIC (type
);
1078 /* Look up a fundamental type for the specified objfile.
1079 May need to construct such a type if this is the first use.
1081 Some object file formats (ELF, COFF, etc) do not define fundamental
1082 types such as "int" or "double". Others (stabs for example), do
1083 define fundamental types.
1085 For the formats which don't provide fundamental types, gdb can create
1086 such types, using defaults reasonable for the current language and
1087 the current target machine.
1089 NOTE: This routine is obsolescent. Each debugging format reader
1090 should manage it's own fundamental types, either creating them from
1091 suitable defaults or reading them from the debugging information,
1092 whichever is appropriate. The DWARF reader has already been
1093 fixed to do this. Once the other readers are fixed, this routine
1094 will go away. Also note that fundamental types should be managed
1095 on a compilation unit basis in a multi-language environment, not
1096 on a linkage unit basis as is done here. */
1100 lookup_fundamental_type (objfile
, typeid)
1101 struct objfile
*objfile
;
1104 register struct type
**typep
;
1105 register int nbytes
;
1107 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1109 error ("internal error - invalid fundamental type id %d", typeid);
1112 /* If this is the first time we need a fundamental type for this objfile
1113 then we need to initialize the vector of type pointers. */
1115 if (objfile
-> fundamental_types
== NULL
)
1117 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1118 objfile
-> fundamental_types
= (struct type
**)
1119 obstack_alloc (&objfile
-> type_obstack
, nbytes
);
1120 memset ((char *) objfile
-> fundamental_types
, 0, nbytes
);
1123 /* Look for this particular type in the fundamental type vector. If one is
1124 not found, create and install one appropriate for the current language. */
1126 typep
= objfile
-> fundamental_types
+ typeid;
1129 *typep
= create_fundamental_type (objfile
, typeid);
1139 /* FIXME: Should we return true for references as well as pointers? */
1142 && TYPE_CODE (t
) == TYPE_CODE_PTR
1143 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1146 /* Chill varying string and arrays are represented as follows:
1148 struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
1150 Return true if TYPE is such a Chill varying type. */
1153 chill_varying_type (type
)
1156 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1157 || TYPE_NFIELDS (type
) != 2
1158 || strcmp (TYPE_FIELD_NAME (type
, 0), "__var_length") != 0)
1163 #if MAINTENANCE_CMDS
1166 print_bit_vector (bits
, nbits
)
1172 for (bitno
= 0; bitno
< nbits
; bitno
++)
1174 if ((bitno
% 8) == 0)
1176 puts_filtered (" ");
1178 if (B_TST (bits
, bitno
))
1180 printf_filtered ("1");
1184 printf_filtered ("0");
1189 /* The args list is a strange beast. It is either terminated by a NULL
1190 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
1191 type for normal fixed argcount functions. (FIXME someday)
1192 Also note the first arg should be the "this" pointer, we may not want to
1193 include it since we may get into a infinitely recursive situation. */
1196 print_arg_types (args
, spaces
)
1202 while (*args
!= NULL
)
1204 recursive_dump_type (*args
, spaces
+ 2);
1205 if ((*args
++) -> code
== TYPE_CODE_VOID
)
1214 dump_fn_fieldlists (type
, spaces
)
1222 printfi_filtered (spaces
, "fn_fieldlists ");
1223 gdb_print_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
1224 printf_filtered ("\n");
1225 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
1227 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
1228 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
1230 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
1231 gdb_print_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
1233 printf_filtered (") length %d\n",
1234 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
1235 for (overload_idx
= 0;
1236 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
1239 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
1241 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
1242 gdb_print_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
1244 printf_filtered (")\n");
1245 printfi_filtered (spaces
+ 8, "type ");
1246 gdb_print_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
1247 printf_filtered ("\n");
1249 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
1252 printfi_filtered (spaces
+ 8, "args ");
1253 gdb_print_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
1254 printf_filtered ("\n");
1256 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
), spaces
);
1257 printfi_filtered (spaces
+ 8, "fcontext ");
1258 gdb_print_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
1260 printf_filtered ("\n");
1262 printfi_filtered (spaces
+ 8, "is_const %d\n",
1263 TYPE_FN_FIELD_CONST (f
, overload_idx
));
1264 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
1265 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
1266 printfi_filtered (spaces
+ 8, "is_private %d\n",
1267 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
1268 printfi_filtered (spaces
+ 8, "is_protected %d\n",
1269 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
1270 printfi_filtered (spaces
+ 8, "is_stub %d\n",
1271 TYPE_FN_FIELD_STUB (f
, overload_idx
));
1272 printfi_filtered (spaces
+ 8, "voffset %u\n",
1273 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
1279 print_cplus_stuff (type
, spaces
)
1283 printfi_filtered (spaces
, "n_baseclasses %d\n",
1284 TYPE_N_BASECLASSES (type
));
1285 printfi_filtered (spaces
, "nfn_fields %d\n",
1286 TYPE_NFN_FIELDS (type
));
1287 printfi_filtered (spaces
, "nfn_fields_total %d\n",
1288 TYPE_NFN_FIELDS_TOTAL (type
));
1289 if (TYPE_N_BASECLASSES (type
) > 0)
1291 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
1292 TYPE_N_BASECLASSES (type
));
1293 gdb_print_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
1294 printf_filtered (")");
1296 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
1297 TYPE_N_BASECLASSES (type
));
1298 puts_filtered ("\n");
1300 if (TYPE_NFIELDS (type
) > 0)
1302 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
1304 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
1305 TYPE_NFIELDS (type
));
1306 gdb_print_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
1307 printf_filtered (")");
1308 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
1309 TYPE_NFIELDS (type
));
1310 puts_filtered ("\n");
1312 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
1314 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
1315 TYPE_NFIELDS (type
));
1316 gdb_print_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
1317 printf_filtered (")");
1318 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
1319 TYPE_NFIELDS (type
));
1320 puts_filtered ("\n");
1323 if (TYPE_NFN_FIELDS (type
) > 0)
1325 dump_fn_fieldlists (type
, spaces
);
1330 recursive_dump_type (type
, spaces
)
1336 printfi_filtered (spaces
, "type node ");
1337 gdb_print_address (type
, gdb_stdout
);
1338 printf_filtered ("\n");
1339 printfi_filtered (spaces
, "name '%s' (",
1340 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
1341 gdb_print_address (TYPE_NAME (type
), gdb_stdout
);
1342 printf_filtered (")\n");
1343 if (TYPE_TAG_NAME (type
) != NULL
)
1345 printfi_filtered (spaces
, "tagname '%s' (",
1346 TYPE_TAG_NAME (type
));
1347 gdb_print_address (TYPE_TAG_NAME (type
), gdb_stdout
);
1348 printf_filtered (")\n");
1350 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
1351 switch (TYPE_CODE (type
))
1353 case TYPE_CODE_UNDEF
:
1354 printf_filtered ("(TYPE_CODE_UNDEF)");
1357 printf_filtered ("(TYPE_CODE_PTR)");
1359 case TYPE_CODE_ARRAY
:
1360 printf_filtered ("(TYPE_CODE_ARRAY)");
1362 case TYPE_CODE_STRUCT
:
1363 printf_filtered ("(TYPE_CODE_STRUCT)");
1365 case TYPE_CODE_UNION
:
1366 printf_filtered ("(TYPE_CODE_UNION)");
1368 case TYPE_CODE_ENUM
:
1369 printf_filtered ("(TYPE_CODE_ENUM)");
1371 case TYPE_CODE_FUNC
:
1372 printf_filtered ("(TYPE_CODE_FUNC)");
1375 printf_filtered ("(TYPE_CODE_INT)");
1378 printf_filtered ("(TYPE_CODE_FLT)");
1380 case TYPE_CODE_VOID
:
1381 printf_filtered ("(TYPE_CODE_VOID)");
1384 printf_filtered ("(TYPE_CODE_SET)");
1386 case TYPE_CODE_RANGE
:
1387 printf_filtered ("(TYPE_CODE_RANGE)");
1389 case TYPE_CODE_STRING
:
1390 printf_filtered ("(TYPE_CODE_STRING)");
1392 case TYPE_CODE_ERROR
:
1393 printf_filtered ("(TYPE_CODE_ERROR)");
1395 case TYPE_CODE_MEMBER
:
1396 printf_filtered ("(TYPE_CODE_MEMBER)");
1398 case TYPE_CODE_METHOD
:
1399 printf_filtered ("(TYPE_CODE_METHOD)");
1402 printf_filtered ("(TYPE_CODE_REF)");
1404 case TYPE_CODE_CHAR
:
1405 printf_filtered ("(TYPE_CODE_CHAR)");
1407 case TYPE_CODE_BOOL
:
1408 printf_filtered ("(TYPE_CODE_BOOL)");
1411 printf_filtered ("(UNKNOWN TYPE CODE)");
1414 puts_filtered ("\n");
1415 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
1416 printfi_filtered (spaces
, "objfile ");
1417 gdb_print_address (TYPE_OBJFILE (type
), gdb_stdout
);
1418 printf_filtered ("\n");
1419 printfi_filtered (spaces
, "target_type ");
1420 gdb_print_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
1421 printf_filtered ("\n");
1422 if (TYPE_TARGET_TYPE (type
) != NULL
)
1424 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
1426 printfi_filtered (spaces
, "pointer_type ");
1427 gdb_print_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
1428 printf_filtered ("\n");
1429 printfi_filtered (spaces
, "reference_type ");
1430 gdb_print_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
1431 printf_filtered ("\n");
1432 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
1433 if (TYPE_FLAGS (type
) & TYPE_FLAG_UNSIGNED
)
1435 puts_filtered (" TYPE_FLAG_UNSIGNED");
1437 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
1439 puts_filtered (" TYPE_FLAG_STUB");
1441 puts_filtered ("\n");
1442 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
1443 gdb_print_address (TYPE_FIELDS (type
), gdb_stdout
);
1444 puts_filtered ("\n");
1445 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
1447 printfi_filtered (spaces
+ 2,
1448 "[%d] bitpos %d bitsize %d type ",
1449 idx
, TYPE_FIELD_BITPOS (type
, idx
),
1450 TYPE_FIELD_BITSIZE (type
, idx
));
1451 gdb_print_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
1452 printf_filtered (" name '%s' (",
1453 TYPE_FIELD_NAME (type
, idx
) != NULL
1454 ? TYPE_FIELD_NAME (type
, idx
)
1456 gdb_print_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
1457 printf_filtered (")\n");
1458 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
1460 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
1463 printfi_filtered (spaces
, "vptr_basetype ");
1464 gdb_print_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
1465 puts_filtered ("\n");
1466 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
1468 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
1470 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
1471 switch (TYPE_CODE (type
))
1473 case TYPE_CODE_METHOD
:
1474 case TYPE_CODE_FUNC
:
1475 printfi_filtered (spaces
, "arg_types ");
1476 gdb_print_address (TYPE_ARG_TYPES (type
), gdb_stdout
);
1477 puts_filtered ("\n");
1478 print_arg_types (TYPE_ARG_TYPES (type
), spaces
);
1481 case TYPE_CODE_STRUCT
:
1482 printfi_filtered (spaces
, "cplus_stuff ");
1483 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1484 puts_filtered ("\n");
1485 print_cplus_stuff (type
, spaces
);
1489 /* We have to pick one of the union types to be able print and test
1490 the value. Pick cplus_struct_type, even though we know it isn't
1491 any particular one. */
1492 printfi_filtered (spaces
, "type_specific ");
1493 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1494 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
1496 printf_filtered (" (unknown data form)");
1498 printf_filtered ("\n");
1504 #endif /* MAINTENANCE_CMDS */
1507 _initialize_gdbtypes ()
1510 init_type (TYPE_CODE_VOID
, 1,
1512 "void", (struct objfile
*) NULL
);
1514 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1516 "char", (struct objfile
*) NULL
);
1517 builtin_type_signed_char
=
1518 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1520 "signed char", (struct objfile
*) NULL
);
1521 builtin_type_unsigned_char
=
1522 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1524 "unsigned char", (struct objfile
*) NULL
);
1525 builtin_type_short
=
1526 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1528 "short", (struct objfile
*) NULL
);
1529 builtin_type_unsigned_short
=
1530 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1532 "unsigned short", (struct objfile
*) NULL
);
1534 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1536 "int", (struct objfile
*) NULL
);
1537 builtin_type_unsigned_int
=
1538 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1540 "unsigned int", (struct objfile
*) NULL
);
1542 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1544 "long", (struct objfile
*) NULL
);
1545 builtin_type_unsigned_long
=
1546 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1548 "unsigned long", (struct objfile
*) NULL
);
1549 builtin_type_long_long
=
1550 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1552 "long long", (struct objfile
*) NULL
);
1553 builtin_type_unsigned_long_long
=
1554 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1556 "unsigned long long", (struct objfile
*) NULL
);
1557 builtin_type_float
=
1558 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1560 "float", (struct objfile
*) NULL
);
1561 builtin_type_double
=
1562 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1564 "double", (struct objfile
*) NULL
);
1565 builtin_type_long_double
=
1566 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1568 "long double", (struct objfile
*) NULL
);
1569 builtin_type_complex
=
1570 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1572 "complex", (struct objfile
*) NULL
);
1573 TYPE_TARGET_TYPE (builtin_type_complex
) = builtin_type_float
;
1574 builtin_type_double_complex
=
1575 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1577 "double complex", (struct objfile
*) NULL
);
1578 TYPE_TARGET_TYPE (builtin_type_double_complex
) = builtin_type_double
;
1579 builtin_type_string
=
1580 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1582 "string", (struct objfile
*) NULL
);