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
);
351 /* A lot of code assumes that the "index type" of an array/string/
352 set/bitstring is specifically a range type, though in some languages
353 it can be any discrete type. */
356 force_to_range_type (type
)
359 switch (TYPE_CODE (type
))
361 case TYPE_CODE_RANGE
:
366 int low_bound
= TYPE_FIELD_BITPOS (type
, 0);
367 int high_bound
= TYPE_FIELD_BITPOS (type
, TYPE_NFIELDS (type
) - 1);
368 struct type
*range_type
=
369 create_range_type (NULL
, type
, low_bound
, high_bound
);
370 TYPE_NAME (range_type
) = TYPE_NAME (range_type
);
371 TYPE_DUMMY_RANGE (range_type
) = 1;
376 struct type
*range_type
= create_range_type (NULL
, type
, 0, 1);
377 TYPE_NAME (range_type
) = TYPE_NAME (range_type
);
378 TYPE_DUMMY_RANGE (range_type
) = 1;
383 struct type
*range_type
= create_range_type (NULL
, type
, 0, 255);
384 TYPE_NAME (range_type
) = TYPE_NAME (range_type
);
385 TYPE_DUMMY_RANGE (range_type
) = 1;
390 static struct complaint msg
=
391 { "array index type must be a discrete type", 0, 0};
394 return create_range_type (NULL
, builtin_type_int
, 0, 0);
399 /* Create an array type using either a blank type supplied in RESULT_TYPE,
400 or creating a new type, inheriting the objfile from RANGE_TYPE.
402 Elements will be of type ELEMENT_TYPE, the indices will be of type
405 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
406 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
409 create_array_type (result_type
, element_type
, range_type
)
410 struct type
*result_type
;
411 struct type
*element_type
;
412 struct type
*range_type
;
417 range_type
= force_to_range_type (range_type
);
418 if (result_type
== NULL
)
420 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
422 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
423 TYPE_TARGET_TYPE (result_type
) = element_type
;
424 low_bound
= TYPE_LOW_BOUND (range_type
);
425 high_bound
= TYPE_HIGH_BOUND (range_type
);
426 TYPE_LENGTH (result_type
) =
427 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
428 TYPE_NFIELDS (result_type
) = 1;
429 TYPE_FIELDS (result_type
) =
430 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
431 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
432 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
433 TYPE_VPTR_FIELDNO (result_type
) = -1;
435 return (result_type
);
438 /* Create a string type using either a blank type supplied in RESULT_TYPE,
439 or creating a new type. String types are similar enough to array of
440 char types that we can use create_array_type to build the basic type
441 and then bash it into a string type.
443 For fixed length strings, the range type contains 0 as the lower
444 bound and the length of the string minus one as the upper bound.
446 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
447 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
450 create_string_type (result_type
, range_type
)
451 struct type
*result_type
;
452 struct type
*range_type
;
454 result_type
= create_array_type (result_type
,
455 *current_language
->string_char_type
,
457 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
458 return (result_type
);
462 create_set_type (result_type
, domain_type
)
463 struct type
*result_type
;
464 struct type
*domain_type
;
466 int low_bound
, high_bound
, bit_length
;
467 if (result_type
== NULL
)
469 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
471 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
472 TYPE_NFIELDS (result_type
) = 1;
473 TYPE_FIELDS (result_type
) = (struct field
*)
474 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
475 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
477 if (! (TYPE_FLAGS (domain_type
) & TYPE_FLAG_STUB
))
479 domain_type
= force_to_range_type (domain_type
);
480 low_bound
= TYPE_LOW_BOUND (domain_type
);
481 high_bound
= TYPE_HIGH_BOUND (domain_type
);
482 bit_length
= high_bound
- low_bound
+ 1;
483 TYPE_LENGTH (result_type
)
484 = ((bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
)
487 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
488 return (result_type
);
491 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
492 A MEMBER is a wierd thing -- it amounts to a typed offset into
493 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
494 include the offset (that's the value of the MEMBER itself), but does
495 include the structure type into which it points (for some reason).
497 When "smashing" the type, we preserve the objfile that the
498 old type pointed to, since we aren't changing where the type is actually
502 smash_to_member_type (type
, domain
, to_type
)
505 struct type
*to_type
;
507 struct objfile
*objfile
;
509 objfile
= TYPE_OBJFILE (type
);
511 memset ((char *) type
, 0, sizeof (struct type
));
512 TYPE_OBJFILE (type
) = objfile
;
513 TYPE_TARGET_TYPE (type
) = to_type
;
514 TYPE_DOMAIN_TYPE (type
) = domain
;
515 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
516 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
519 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
520 METHOD just means `function that gets an extra "this" argument'.
522 When "smashing" the type, we preserve the objfile that the
523 old type pointed to, since we aren't changing where the type is actually
527 smash_to_method_type (type
, domain
, to_type
, args
)
530 struct type
*to_type
;
533 struct objfile
*objfile
;
535 objfile
= TYPE_OBJFILE (type
);
537 memset ((char *) type
, 0, sizeof (struct type
));
538 TYPE_OBJFILE (type
) = objfile
;
539 TYPE_TARGET_TYPE (type
) = to_type
;
540 TYPE_DOMAIN_TYPE (type
) = domain
;
541 TYPE_ARG_TYPES (type
) = args
;
542 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
543 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
546 /* Return a typename for a struct/union/enum type without "struct ",
547 "union ", or "enum ". If the type has a NULL name, return NULL. */
550 type_name_no_tag (type
)
551 register const struct type
*type
;
553 if (TYPE_TAG_NAME (type
) != NULL
)
554 return TYPE_TAG_NAME (type
);
556 /* Is there code which expects this to return the name if there is no
557 tag name? My guess is that this is mainly used for C++ in cases where
558 the two will always be the same. */
559 return TYPE_NAME (type
);
562 /* Lookup a primitive type named NAME.
563 Return zero if NAME is not a primitive type.*/
566 lookup_primitive_typename (name
)
569 struct type
** const *p
;
571 for (p
= current_language
-> la_builtin_type_vector
; *p
!= NULL
; p
++)
573 if (STREQ ((**p
) -> name
, name
))
581 /* Lookup a typedef or primitive type named NAME,
582 visible in lexical block BLOCK.
583 If NOERR is nonzero, return zero if NAME is not suitably defined. */
586 lookup_typename (name
, block
, noerr
)
591 register struct symbol
*sym
;
592 register struct type
*tmp
;
594 sym
= lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
595 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
597 tmp
= lookup_primitive_typename (name
);
602 else if (!tmp
&& noerr
)
608 error ("No type named %s.", name
);
611 return (SYMBOL_TYPE (sym
));
615 lookup_unsigned_typename (name
)
618 char *uns
= alloca (strlen (name
) + 10);
620 strcpy (uns
, "unsigned ");
621 strcpy (uns
+ 9, name
);
622 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
626 lookup_signed_typename (name
)
630 char *uns
= alloca (strlen (name
) + 8);
632 strcpy (uns
, "signed ");
633 strcpy (uns
+ 7, name
);
634 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
635 /* If we don't find "signed FOO" just try again with plain "FOO". */
638 return lookup_typename (name
, (struct block
*) NULL
, 0);
641 /* Lookup a structure type named "struct NAME",
642 visible in lexical block BLOCK. */
645 lookup_struct (name
, block
)
649 register struct symbol
*sym
;
651 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
652 (struct symtab
**) NULL
);
656 error ("No struct type named %s.", name
);
658 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
660 error ("This context has class, union or enum %s, not a struct.", name
);
662 return (SYMBOL_TYPE (sym
));
665 /* Lookup a union type named "union NAME",
666 visible in lexical block BLOCK. */
669 lookup_union (name
, block
)
673 register struct symbol
*sym
;
675 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
676 (struct symtab
**) NULL
);
680 error ("No union type named %s.", name
);
682 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_UNION
)
684 error ("This context has class, struct or enum %s, not a union.", name
);
686 return (SYMBOL_TYPE (sym
));
689 /* Lookup an enum type named "enum NAME",
690 visible in lexical block BLOCK. */
693 lookup_enum (name
, block
)
697 register struct symbol
*sym
;
699 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
700 (struct symtab
**) NULL
);
703 error ("No enum type named %s.", name
);
705 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
707 error ("This context has class, struct or union %s, not an enum.", name
);
709 return (SYMBOL_TYPE (sym
));
712 /* Lookup a template type named "template NAME<TYPE>",
713 visible in lexical block BLOCK. */
716 lookup_template_type (name
, type
, block
)
722 char *nam
= (char*) alloca(strlen(name
) + strlen(type
->name
) + 4);
725 strcat (nam
, type
->name
);
726 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
728 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
732 error ("No template type named %s.", name
);
734 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
736 error ("This context has class, union or enum %s, not a struct.", name
);
738 return (SYMBOL_TYPE (sym
));
741 /* Given a type TYPE, lookup the type of the component of type named NAME.
743 TYPE can be either a struct or union, or a pointer or reference to a struct or
744 union. If it is a pointer or reference, its target type is automatically used.
745 Thus '.' and '->' are interchangable, as specified for the definitions of the
746 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
748 If NOERR is nonzero, return zero if NAME is not suitably defined.
749 If NAME is the name of a baseclass type, return that type. */
752 lookup_struct_elt_type (type
, name
, noerr
)
759 while (TYPE_CODE (type
) == TYPE_CODE_PTR
||
760 TYPE_CODE (type
) == TYPE_CODE_REF
)
761 type
= TYPE_TARGET_TYPE (type
);
763 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
764 TYPE_CODE (type
) != TYPE_CODE_UNION
)
766 target_terminal_ours ();
767 gdb_flush (gdb_stdout
);
768 fprintf_unfiltered (gdb_stderr
, "Type ");
769 type_print (type
, "", gdb_stderr
, -1);
770 error (" is not a structure or union type.");
773 check_stub_type (type
);
776 /* FIXME: This change put in by Michael seems incorrect for the case where
777 the structure tag name is the same as the member name. I.E. when doing
778 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
783 typename
= type_name_no_tag (type
);
784 if (typename
!= NULL
&& STREQ (typename
, name
))
789 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
791 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
793 if (t_field_name
&& STREQ (t_field_name
, name
))
795 return TYPE_FIELD_TYPE (type
, i
);
799 /* OK, it's not in this class. Recursively check the baseclasses. */
800 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
804 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, noerr
);
816 target_terminal_ours ();
817 gdb_flush (gdb_stdout
);
818 fprintf_unfiltered (gdb_stderr
, "Type ");
819 type_print (type
, "", gdb_stderr
, -1);
820 fprintf_unfiltered (gdb_stderr
, " has no component named ");
821 fputs_filtered (name
, gdb_stderr
);
823 return (struct type
*)-1; /* For lint */
826 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
827 valid. Callers should be aware that in some cases (for example,
828 the type or one of its baseclasses is a stub type and we are
829 debugging a .o file), this function will not be able to find the virtual
830 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
834 fill_in_vptr_fieldno (type
)
837 check_stub_type (type
);
839 if (TYPE_VPTR_FIELDNO (type
) < 0)
843 /* We must start at zero in case the first (and only) baseclass is
844 virtual (and hence we cannot share the table pointer). */
845 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
847 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, i
));
848 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
)) >= 0)
850 TYPE_VPTR_FIELDNO (type
)
851 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
));
852 TYPE_VPTR_BASETYPE (type
)
853 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type
, i
));
860 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
862 If this is a stubbed struct (i.e. declared as struct foo *), see if
863 we can find a full definition in some other file. If so, copy this
864 definition, so we can use it in future. There used to be a comment (but
865 not any code) that if we don't find a full definition, we'd set a flag
866 so we don't spend time in the future checking the same type. That would
867 be a mistake, though--we might load in more symbols which contain a
868 full definition for the type.
870 This used to be coded as a macro, but I don't think it is called
871 often enough to merit such treatment. */
873 struct complaint stub_noname_complaint
=
874 {"stub type has NULL name", 0, 0};
877 check_stub_type (type
)
880 if (TYPE_FLAGS(type
) & TYPE_FLAG_STUB
)
882 char* name
= type_name_no_tag (type
);
883 /* FIXME: shouldn't we separately check the TYPE_NAME and the
884 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
885 as appropriate? (this code was written before TYPE_NAME and
886 TYPE_TAG_NAME were separate). */
890 complain (&stub_noname_complaint
);
893 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
894 (struct symtab
**) NULL
);
897 memcpy ((char *)type
,
898 (char *)SYMBOL_TYPE(sym
),
899 sizeof (struct type
));
903 if (TYPE_FLAGS (type
) & TYPE_FLAG_TARGET_STUB
)
905 struct type
*range_type
;
907 check_stub_type (TYPE_TARGET_TYPE (type
));
908 if (!(TYPE_FLAGS (TYPE_TARGET_TYPE (type
)) & TYPE_FLAG_STUB
)
909 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
910 && TYPE_NFIELDS (type
) == 1
911 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
914 /* Now recompute the length of the array type, based on its
915 number of elements and the target type's length. */
917 ((TYPE_FIELD_BITPOS (range_type
, 1)
918 - TYPE_FIELD_BITPOS (range_type
, 0)
920 * TYPE_LENGTH (TYPE_TARGET_TYPE (type
)));
921 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
926 /* Ugly hack to convert method stubs into method types.
928 He ain't kiddin'. This demangles the name of the method into a string
929 including argument types, parses out each argument type, generates
930 a string casting a zero to that type, evaluates the string, and stuffs
931 the resulting type into an argtype vector!!! Then it knows the type
932 of the whole function (including argument types for overloading),
933 which info used to be in the stab's but was removed to hack back
934 the space required for them. */
937 check_stub_method (type
, i
, j
)
943 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
944 char *demangled_name
= cplus_demangle (mangled_name
,
945 DMGL_PARAMS
| DMGL_ANSI
);
946 char *argtypetext
, *p
;
947 int depth
= 0, argcount
= 1;
948 struct type
**argtypes
;
951 if (demangled_name
== NULL
)
953 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
956 /* Now, read in the parameters that define this type. */
957 argtypetext
= strchr (demangled_name
, '(') + 1;
969 else if (*p
== ',' && depth
== 0)
977 /* We need two more slots: one for the THIS pointer, and one for the
978 NULL [...] or void [end of arglist]. */
980 argtypes
= (struct type
**)
981 TYPE_ALLOC (type
, (argcount
+ 2) * sizeof (struct type
*));
983 /* FIXME: This is wrong for static member functions. */
984 argtypes
[0] = lookup_pointer_type (type
);
987 if (*p
!= ')') /* () means no args, skip while */
992 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
994 /* Avoid parsing of ellipsis, they will be handled below. */
995 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0)
998 parse_and_eval_type (argtypetext
, p
- argtypetext
);
1001 argtypetext
= p
+ 1;
1017 if (p
[-2] != '.') /* Not '...' */
1019 argtypes
[argcount
] = builtin_type_void
; /* List terminator */
1023 argtypes
[argcount
] = NULL
; /* Ellist terminator */
1026 free (demangled_name
);
1028 f
= TYPE_FN_FIELDLIST1 (type
, i
);
1029 TYPE_FN_FIELD_PHYSNAME (f
, j
) = mangled_name
;
1031 /* Now update the old "stub" type into a real type. */
1032 mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1033 TYPE_DOMAIN_TYPE (mtype
) = type
;
1034 TYPE_ARG_TYPES (mtype
) = argtypes
;
1035 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1036 TYPE_FN_FIELD_STUB (f
, j
) = 0;
1039 const struct cplus_struct_type cplus_struct_default
;
1042 allocate_cplus_struct_type (type
)
1045 if (!HAVE_CPLUS_STRUCT (type
))
1047 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1048 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1049 *(TYPE_CPLUS_SPECIFIC(type
)) = cplus_struct_default
;
1053 /* Helper function to initialize the standard scalar types.
1055 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1056 of the string pointed to by name in the type_obstack for that objfile,
1057 and initialize the type name to that copy. There are places (mipsread.c
1058 in particular, where init_type is called with a NULL value for NAME). */
1061 init_type (code
, length
, flags
, name
, objfile
)
1062 enum type_code code
;
1066 struct objfile
*objfile
;
1068 register struct type
*type
;
1070 type
= alloc_type (objfile
);
1071 TYPE_CODE (type
) = code
;
1072 TYPE_LENGTH (type
) = length
;
1073 TYPE_FLAGS (type
) |= flags
;
1074 if ((name
!= NULL
) && (objfile
!= NULL
))
1077 obsavestring (name
, strlen (name
), &objfile
-> type_obstack
);
1081 TYPE_NAME (type
) = name
;
1086 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
1088 INIT_CPLUS_SPECIFIC (type
);
1093 /* Look up a fundamental type for the specified objfile.
1094 May need to construct such a type if this is the first use.
1096 Some object file formats (ELF, COFF, etc) do not define fundamental
1097 types such as "int" or "double". Others (stabs for example), do
1098 define fundamental types.
1100 For the formats which don't provide fundamental types, gdb can create
1101 such types, using defaults reasonable for the current language and
1102 the current target machine.
1104 NOTE: This routine is obsolescent. Each debugging format reader
1105 should manage it's own fundamental types, either creating them from
1106 suitable defaults or reading them from the debugging information,
1107 whichever is appropriate. The DWARF reader has already been
1108 fixed to do this. Once the other readers are fixed, this routine
1109 will go away. Also note that fundamental types should be managed
1110 on a compilation unit basis in a multi-language environment, not
1111 on a linkage unit basis as is done here. */
1115 lookup_fundamental_type (objfile
, typeid)
1116 struct objfile
*objfile
;
1119 register struct type
**typep
;
1120 register int nbytes
;
1122 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1124 error ("internal error - invalid fundamental type id %d", typeid);
1127 /* If this is the first time we need a fundamental type for this objfile
1128 then we need to initialize the vector of type pointers. */
1130 if (objfile
-> fundamental_types
== NULL
)
1132 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1133 objfile
-> fundamental_types
= (struct type
**)
1134 obstack_alloc (&objfile
-> type_obstack
, nbytes
);
1135 memset ((char *) objfile
-> fundamental_types
, 0, nbytes
);
1138 /* Look for this particular type in the fundamental type vector. If one is
1139 not found, create and install one appropriate for the current language. */
1141 typep
= objfile
-> fundamental_types
+ typeid;
1144 *typep
= create_fundamental_type (objfile
, typeid);
1154 /* FIXME: Should we return true for references as well as pointers? */
1157 && TYPE_CODE (t
) == TYPE_CODE_PTR
1158 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1161 /* Chill varying string and arrays are represented as follows:
1163 struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
1165 Return true if TYPE is such a Chill varying type. */
1168 chill_varying_type (type
)
1171 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1172 || TYPE_NFIELDS (type
) != 2
1173 || strcmp (TYPE_FIELD_NAME (type
, 0), "__var_length") != 0)
1178 #if MAINTENANCE_CMDS
1181 print_bit_vector (bits
, nbits
)
1187 for (bitno
= 0; bitno
< nbits
; bitno
++)
1189 if ((bitno
% 8) == 0)
1191 puts_filtered (" ");
1193 if (B_TST (bits
, bitno
))
1195 printf_filtered ("1");
1199 printf_filtered ("0");
1204 /* The args list is a strange beast. It is either terminated by a NULL
1205 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
1206 type for normal fixed argcount functions. (FIXME someday)
1207 Also note the first arg should be the "this" pointer, we may not want to
1208 include it since we may get into a infinitely recursive situation. */
1211 print_arg_types (args
, spaces
)
1217 while (*args
!= NULL
)
1219 recursive_dump_type (*args
, spaces
+ 2);
1220 if ((*args
++) -> code
== TYPE_CODE_VOID
)
1229 dump_fn_fieldlists (type
, spaces
)
1237 printfi_filtered (spaces
, "fn_fieldlists ");
1238 gdb_print_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
1239 printf_filtered ("\n");
1240 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
1242 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
1243 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
1245 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
1246 gdb_print_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
1248 printf_filtered (") length %d\n",
1249 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
1250 for (overload_idx
= 0;
1251 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
1254 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
1256 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
1257 gdb_print_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
1259 printf_filtered (")\n");
1260 printfi_filtered (spaces
+ 8, "type ");
1261 gdb_print_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
1262 printf_filtered ("\n");
1264 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
1267 printfi_filtered (spaces
+ 8, "args ");
1268 gdb_print_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
1269 printf_filtered ("\n");
1271 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
), spaces
);
1272 printfi_filtered (spaces
+ 8, "fcontext ");
1273 gdb_print_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
1275 printf_filtered ("\n");
1277 printfi_filtered (spaces
+ 8, "is_const %d\n",
1278 TYPE_FN_FIELD_CONST (f
, overload_idx
));
1279 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
1280 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
1281 printfi_filtered (spaces
+ 8, "is_private %d\n",
1282 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
1283 printfi_filtered (spaces
+ 8, "is_protected %d\n",
1284 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
1285 printfi_filtered (spaces
+ 8, "is_stub %d\n",
1286 TYPE_FN_FIELD_STUB (f
, overload_idx
));
1287 printfi_filtered (spaces
+ 8, "voffset %u\n",
1288 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
1294 print_cplus_stuff (type
, spaces
)
1298 printfi_filtered (spaces
, "n_baseclasses %d\n",
1299 TYPE_N_BASECLASSES (type
));
1300 printfi_filtered (spaces
, "nfn_fields %d\n",
1301 TYPE_NFN_FIELDS (type
));
1302 printfi_filtered (spaces
, "nfn_fields_total %d\n",
1303 TYPE_NFN_FIELDS_TOTAL (type
));
1304 if (TYPE_N_BASECLASSES (type
) > 0)
1306 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
1307 TYPE_N_BASECLASSES (type
));
1308 gdb_print_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
1309 printf_filtered (")");
1311 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
1312 TYPE_N_BASECLASSES (type
));
1313 puts_filtered ("\n");
1315 if (TYPE_NFIELDS (type
) > 0)
1317 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
1319 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
1320 TYPE_NFIELDS (type
));
1321 gdb_print_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
1322 printf_filtered (")");
1323 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
1324 TYPE_NFIELDS (type
));
1325 puts_filtered ("\n");
1327 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
1329 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
1330 TYPE_NFIELDS (type
));
1331 gdb_print_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
1332 printf_filtered (")");
1333 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
1334 TYPE_NFIELDS (type
));
1335 puts_filtered ("\n");
1338 if (TYPE_NFN_FIELDS (type
) > 0)
1340 dump_fn_fieldlists (type
, spaces
);
1345 recursive_dump_type (type
, spaces
)
1351 printfi_filtered (spaces
, "type node ");
1352 gdb_print_address (type
, gdb_stdout
);
1353 printf_filtered ("\n");
1354 printfi_filtered (spaces
, "name '%s' (",
1355 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
1356 gdb_print_address (TYPE_NAME (type
), gdb_stdout
);
1357 printf_filtered (")\n");
1358 if (TYPE_TAG_NAME (type
) != NULL
)
1360 printfi_filtered (spaces
, "tagname '%s' (",
1361 TYPE_TAG_NAME (type
));
1362 gdb_print_address (TYPE_TAG_NAME (type
), gdb_stdout
);
1363 printf_filtered (")\n");
1365 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
1366 switch (TYPE_CODE (type
))
1368 case TYPE_CODE_UNDEF
:
1369 printf_filtered ("(TYPE_CODE_UNDEF)");
1372 printf_filtered ("(TYPE_CODE_PTR)");
1374 case TYPE_CODE_ARRAY
:
1375 printf_filtered ("(TYPE_CODE_ARRAY)");
1377 case TYPE_CODE_STRUCT
:
1378 printf_filtered ("(TYPE_CODE_STRUCT)");
1380 case TYPE_CODE_UNION
:
1381 printf_filtered ("(TYPE_CODE_UNION)");
1383 case TYPE_CODE_ENUM
:
1384 printf_filtered ("(TYPE_CODE_ENUM)");
1386 case TYPE_CODE_FUNC
:
1387 printf_filtered ("(TYPE_CODE_FUNC)");
1390 printf_filtered ("(TYPE_CODE_INT)");
1393 printf_filtered ("(TYPE_CODE_FLT)");
1395 case TYPE_CODE_VOID
:
1396 printf_filtered ("(TYPE_CODE_VOID)");
1399 printf_filtered ("(TYPE_CODE_SET)");
1401 case TYPE_CODE_RANGE
:
1402 printf_filtered ("(TYPE_CODE_RANGE)");
1404 case TYPE_CODE_STRING
:
1405 printf_filtered ("(TYPE_CODE_STRING)");
1407 case TYPE_CODE_ERROR
:
1408 printf_filtered ("(TYPE_CODE_ERROR)");
1410 case TYPE_CODE_MEMBER
:
1411 printf_filtered ("(TYPE_CODE_MEMBER)");
1413 case TYPE_CODE_METHOD
:
1414 printf_filtered ("(TYPE_CODE_METHOD)");
1417 printf_filtered ("(TYPE_CODE_REF)");
1419 case TYPE_CODE_CHAR
:
1420 printf_filtered ("(TYPE_CODE_CHAR)");
1422 case TYPE_CODE_BOOL
:
1423 printf_filtered ("(TYPE_CODE_BOOL)");
1426 printf_filtered ("(UNKNOWN TYPE CODE)");
1429 puts_filtered ("\n");
1430 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
1431 printfi_filtered (spaces
, "objfile ");
1432 gdb_print_address (TYPE_OBJFILE (type
), gdb_stdout
);
1433 printf_filtered ("\n");
1434 printfi_filtered (spaces
, "target_type ");
1435 gdb_print_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
1436 printf_filtered ("\n");
1437 if (TYPE_TARGET_TYPE (type
) != NULL
)
1439 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
1441 printfi_filtered (spaces
, "pointer_type ");
1442 gdb_print_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
1443 printf_filtered ("\n");
1444 printfi_filtered (spaces
, "reference_type ");
1445 gdb_print_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
1446 printf_filtered ("\n");
1447 printfi_filtered (spaces
, "function_type ");
1448 gdb_print_address (TYPE_FUNCTION_TYPE (type
), gdb_stdout
);
1449 printf_filtered ("\n");
1450 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
1451 if (TYPE_FLAGS (type
) & TYPE_FLAG_UNSIGNED
)
1453 puts_filtered (" TYPE_FLAG_UNSIGNED");
1455 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
1457 puts_filtered (" TYPE_FLAG_STUB");
1459 puts_filtered ("\n");
1460 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
1461 gdb_print_address (TYPE_FIELDS (type
), gdb_stdout
);
1462 puts_filtered ("\n");
1463 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
1465 printfi_filtered (spaces
+ 2,
1466 "[%d] bitpos %d bitsize %d type ",
1467 idx
, TYPE_FIELD_BITPOS (type
, idx
),
1468 TYPE_FIELD_BITSIZE (type
, idx
));
1469 gdb_print_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
1470 printf_filtered (" name '%s' (",
1471 TYPE_FIELD_NAME (type
, idx
) != NULL
1472 ? TYPE_FIELD_NAME (type
, idx
)
1474 gdb_print_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
1475 printf_filtered (")\n");
1476 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
1478 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
1481 printfi_filtered (spaces
, "vptr_basetype ");
1482 gdb_print_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
1483 puts_filtered ("\n");
1484 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
1486 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
1488 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
1489 switch (TYPE_CODE (type
))
1491 case TYPE_CODE_METHOD
:
1492 case TYPE_CODE_FUNC
:
1493 printfi_filtered (spaces
, "arg_types ");
1494 gdb_print_address (TYPE_ARG_TYPES (type
), gdb_stdout
);
1495 puts_filtered ("\n");
1496 print_arg_types (TYPE_ARG_TYPES (type
), spaces
);
1499 case TYPE_CODE_STRUCT
:
1500 printfi_filtered (spaces
, "cplus_stuff ");
1501 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1502 puts_filtered ("\n");
1503 print_cplus_stuff (type
, spaces
);
1507 /* We have to pick one of the union types to be able print and test
1508 the value. Pick cplus_struct_type, even though we know it isn't
1509 any particular one. */
1510 printfi_filtered (spaces
, "type_specific ");
1511 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1512 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
1514 printf_filtered (" (unknown data form)");
1516 printf_filtered ("\n");
1522 #endif /* MAINTENANCE_CMDS */
1525 _initialize_gdbtypes ()
1528 init_type (TYPE_CODE_VOID
, 1,
1530 "void", (struct objfile
*) NULL
);
1532 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1534 "char", (struct objfile
*) NULL
);
1535 builtin_type_signed_char
=
1536 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1538 "signed char", (struct objfile
*) NULL
);
1539 builtin_type_unsigned_char
=
1540 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1542 "unsigned char", (struct objfile
*) NULL
);
1543 builtin_type_short
=
1544 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1546 "short", (struct objfile
*) NULL
);
1547 builtin_type_unsigned_short
=
1548 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1550 "unsigned short", (struct objfile
*) NULL
);
1552 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1554 "int", (struct objfile
*) NULL
);
1555 builtin_type_unsigned_int
=
1556 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1558 "unsigned int", (struct objfile
*) NULL
);
1560 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1562 "long", (struct objfile
*) NULL
);
1563 builtin_type_unsigned_long
=
1564 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1566 "unsigned long", (struct objfile
*) NULL
);
1567 builtin_type_long_long
=
1568 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1570 "long long", (struct objfile
*) NULL
);
1571 builtin_type_unsigned_long_long
=
1572 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1574 "unsigned long long", (struct objfile
*) NULL
);
1575 builtin_type_float
=
1576 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1578 "float", (struct objfile
*) NULL
);
1579 builtin_type_double
=
1580 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1582 "double", (struct objfile
*) NULL
);
1583 builtin_type_long_double
=
1584 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1586 "long double", (struct objfile
*) NULL
);
1587 builtin_type_complex
=
1588 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1590 "complex", (struct objfile
*) NULL
);
1591 TYPE_TARGET_TYPE (builtin_type_complex
) = builtin_type_float
;
1592 builtin_type_double_complex
=
1593 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1595 "double complex", (struct objfile
*) NULL
);
1596 TYPE_TARGET_TYPE (builtin_type_double_complex
) = builtin_type_double
;
1597 builtin_type_string
=
1598 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1600 "string", (struct objfile
*) NULL
);