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
, builtin_type_char
, range_type
);
455 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
456 return (result_type
);
460 create_set_type (result_type
, domain_type
)
461 struct type
*result_type
;
462 struct type
*domain_type
;
464 int low_bound
, high_bound
, bit_length
;
465 if (result_type
== NULL
)
467 result_type
= alloc_type (TYPE_OBJFILE (domain_type
));
469 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
470 TYPE_NFIELDS (result_type
) = 1;
471 TYPE_FIELDS (result_type
) = (struct field
*)
472 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
473 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
475 if (! (TYPE_FLAGS (domain_type
) & TYPE_FLAG_STUB
))
477 domain_type
= force_to_range_type (domain_type
);
478 low_bound
= TYPE_LOW_BOUND (domain_type
);
479 high_bound
= TYPE_HIGH_BOUND (domain_type
);
480 bit_length
= high_bound
- low_bound
+ 1;
481 TYPE_LENGTH (result_type
)
482 = ((bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
)
485 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
486 return (result_type
);
489 /* Create an F77 literal complex type composed of the two types we are
490 given as arguments. */
493 f77_create_literal_complex_type (type_arg1
, type_arg2
)
494 struct type
*type_arg1
;
495 struct type
*type_arg2
;
499 /* First make sure that the 2 components of the complex
500 number both have the same type */
502 if (TYPE_CODE (type_arg1
) != TYPE_CODE (type_arg2
))
503 error ("Both components of a F77 complex number must have the same type!");
505 result
= alloc_type (TYPE_OBJFILE (type_arg1
));
507 TYPE_CODE (result
) = TYPE_CODE_LITERAL_COMPLEX
;
508 TYPE_LENGTH (result
) = TYPE_LENGTH(type_arg1
) * 2;
513 /* Create a F77 LITERAL string type supplied by the user from the keyboard.
515 Elements will be of type ELEMENT_TYPE, the indices will be of type
518 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
519 sure it is TYPE_CODE_UNDEF before we bash it into an array type?
521 This is a total clone of create_array_type() except that there are
522 a few simplyfing assumptions (e.g all bound types are simple). */
525 f77_create_literal_string_type (result_type
, range_type
)
526 struct type
*result_type
;
527 struct type
*range_type
;
532 if (TYPE_CODE (range_type
) != TYPE_CODE_RANGE
)
534 /* FIXME: We only handle range types at the moment. Complain and
535 create a dummy range type to use. */
536 warning ("internal error: array index type must be a range type");
537 range_type
= lookup_fundamental_type (TYPE_OBJFILE (range_type
),
539 range_type
= create_range_type ((struct type
*) NULL
, range_type
, 0, 0);
541 if (result_type
== NULL
)
542 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
543 TYPE_CODE (result_type
) = TYPE_CODE_LITERAL_STRING
;
544 TYPE_TARGET_TYPE (result_type
) = builtin_type_f_character
;
545 low_bound
= TYPE_FIELD_BITPOS (range_type
, 0);
546 high_bound
= TYPE_FIELD_BITPOS (range_type
, 1);
548 /* Safely can assume that all bound types are simple */
550 TYPE_LENGTH (result_type
) =
551 TYPE_LENGTH (builtin_type_f_character
) * (high_bound
- low_bound
+ 1);
553 TYPE_NFIELDS (result_type
) = 1;
554 TYPE_FIELDS (result_type
) =
555 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
556 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
557 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
558 TYPE_VPTR_FIELDNO (result_type
) = -1;
560 /* Remember that all literal strings in F77 are of the
563 TYPE_ARRAY_LOWER_BOUND_TYPE (result_type
) = BOUND_SIMPLE
;
564 TYPE_ARRAY_UPPER_BOUND_TYPE (result_type
) = BOUND_SIMPLE
;
569 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
570 A MEMBER is a wierd thing -- it amounts to a typed offset into
571 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
572 include the offset (that's the value of the MEMBER itself), but does
573 include the structure type into which it points (for some reason).
575 When "smashing" the type, we preserve the objfile that the
576 old type pointed to, since we aren't changing where the type is actually
580 smash_to_member_type (type
, domain
, to_type
)
583 struct type
*to_type
;
585 struct objfile
*objfile
;
587 objfile
= TYPE_OBJFILE (type
);
589 memset ((char *) type
, 0, sizeof (struct type
));
590 TYPE_OBJFILE (type
) = objfile
;
591 TYPE_TARGET_TYPE (type
) = to_type
;
592 TYPE_DOMAIN_TYPE (type
) = domain
;
593 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
594 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
597 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
598 METHOD just means `function that gets an extra "this" argument'.
600 When "smashing" the type, we preserve the objfile that the
601 old type pointed to, since we aren't changing where the type is actually
605 smash_to_method_type (type
, domain
, to_type
, args
)
608 struct type
*to_type
;
611 struct objfile
*objfile
;
613 objfile
= TYPE_OBJFILE (type
);
615 memset ((char *) type
, 0, sizeof (struct type
));
616 TYPE_OBJFILE (type
) = objfile
;
617 TYPE_TARGET_TYPE (type
) = to_type
;
618 TYPE_DOMAIN_TYPE (type
) = domain
;
619 TYPE_ARG_TYPES (type
) = args
;
620 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
621 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
624 /* Return a typename for a struct/union/enum type without "struct ",
625 "union ", or "enum ". If the type has a NULL name, return NULL. */
628 type_name_no_tag (type
)
629 register const struct type
*type
;
631 if (TYPE_TAG_NAME (type
) != NULL
)
632 return TYPE_TAG_NAME (type
);
634 /* Is there code which expects this to return the name if there is no
635 tag name? My guess is that this is mainly used for C++ in cases where
636 the two will always be the same. */
637 return TYPE_NAME (type
);
640 /* Lookup a primitive type named NAME.
641 Return zero if NAME is not a primitive type.*/
644 lookup_primitive_typename (name
)
647 struct type
** const *p
;
649 for (p
= current_language
-> la_builtin_type_vector
; *p
!= NULL
; p
++)
651 if (STREQ ((**p
) -> name
, name
))
659 /* Lookup a typedef or primitive type named NAME,
660 visible in lexical block BLOCK.
661 If NOERR is nonzero, return zero if NAME is not suitably defined. */
664 lookup_typename (name
, block
, noerr
)
669 register struct symbol
*sym
;
670 register struct type
*tmp
;
672 sym
= lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
673 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
675 tmp
= lookup_primitive_typename (name
);
680 else if (!tmp
&& noerr
)
686 error ("No type named %s.", name
);
689 return (SYMBOL_TYPE (sym
));
693 lookup_unsigned_typename (name
)
696 char *uns
= alloca (strlen (name
) + 10);
698 strcpy (uns
, "unsigned ");
699 strcpy (uns
+ 9, name
);
700 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
704 lookup_signed_typename (name
)
708 char *uns
= alloca (strlen (name
) + 8);
710 strcpy (uns
, "signed ");
711 strcpy (uns
+ 7, name
);
712 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
713 /* If we don't find "signed FOO" just try again with plain "FOO". */
716 return lookup_typename (name
, (struct block
*) NULL
, 0);
719 /* Lookup a structure type named "struct NAME",
720 visible in lexical block BLOCK. */
723 lookup_struct (name
, block
)
727 register struct symbol
*sym
;
729 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
730 (struct symtab
**) NULL
);
734 error ("No struct type named %s.", name
);
736 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
738 error ("This context has class, union or enum %s, not a struct.", name
);
740 return (SYMBOL_TYPE (sym
));
743 /* Lookup a union type named "union NAME",
744 visible in lexical block BLOCK. */
747 lookup_union (name
, block
)
751 register struct symbol
*sym
;
753 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
754 (struct symtab
**) NULL
);
758 error ("No union type named %s.", name
);
760 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_UNION
)
762 error ("This context has class, struct or enum %s, not a union.", name
);
764 return (SYMBOL_TYPE (sym
));
767 /* Lookup an enum type named "enum NAME",
768 visible in lexical block BLOCK. */
771 lookup_enum (name
, block
)
775 register struct symbol
*sym
;
777 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
778 (struct symtab
**) NULL
);
781 error ("No enum type named %s.", name
);
783 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
785 error ("This context has class, struct or union %s, not an enum.", name
);
787 return (SYMBOL_TYPE (sym
));
790 /* Lookup a template type named "template NAME<TYPE>",
791 visible in lexical block BLOCK. */
794 lookup_template_type (name
, type
, block
)
800 char *nam
= (char*) alloca(strlen(name
) + strlen(type
->name
) + 4);
803 strcat (nam
, type
->name
);
804 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
806 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
810 error ("No template type named %s.", name
);
812 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
814 error ("This context has class, union or enum %s, not a struct.", name
);
816 return (SYMBOL_TYPE (sym
));
819 /* Given a type TYPE, lookup the type of the component of type named NAME.
821 TYPE can be either a struct or union, or a pointer or reference to a struct or
822 union. If it is a pointer or reference, its target type is automatically used.
823 Thus '.' and '->' are interchangable, as specified for the definitions of the
824 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
826 If NOERR is nonzero, return zero if NAME is not suitably defined.
827 If NAME is the name of a baseclass type, return that type. */
830 lookup_struct_elt_type (type
, name
, noerr
)
837 while (TYPE_CODE (type
) == TYPE_CODE_PTR
||
838 TYPE_CODE (type
) == TYPE_CODE_REF
)
839 type
= TYPE_TARGET_TYPE (type
);
841 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
842 TYPE_CODE (type
) != TYPE_CODE_UNION
)
844 target_terminal_ours ();
845 gdb_flush (gdb_stdout
);
846 fprintf_unfiltered (gdb_stderr
, "Type ");
847 type_print (type
, "", gdb_stderr
, -1);
848 error (" is not a structure or union type.");
851 check_stub_type (type
);
854 /* FIXME: This change put in by Michael seems incorrect for the case where
855 the structure tag name is the same as the member name. I.E. when doing
856 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
861 typename
= type_name_no_tag (type
);
862 if (typename
!= NULL
&& STREQ (typename
, name
))
867 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
869 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
871 if (t_field_name
&& STREQ (t_field_name
, name
))
873 return TYPE_FIELD_TYPE (type
, i
);
877 /* OK, it's not in this class. Recursively check the baseclasses. */
878 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
882 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, noerr
);
894 target_terminal_ours ();
895 gdb_flush (gdb_stdout
);
896 fprintf_unfiltered (gdb_stderr
, "Type ");
897 type_print (type
, "", gdb_stderr
, -1);
898 fprintf_unfiltered (gdb_stderr
, " has no component named ");
899 fputs_filtered (name
, gdb_stderr
);
901 return (struct type
*)-1; /* For lint */
904 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
905 valid. Callers should be aware that in some cases (for example,
906 the type or one of its baseclasses is a stub type and we are
907 debugging a .o file), this function will not be able to find the virtual
908 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
912 fill_in_vptr_fieldno (type
)
915 check_stub_type (type
);
917 if (TYPE_VPTR_FIELDNO (type
) < 0)
921 /* We must start at zero in case the first (and only) baseclass is
922 virtual (and hence we cannot share the table pointer). */
923 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
925 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, i
));
926 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
)) >= 0)
928 TYPE_VPTR_FIELDNO (type
)
929 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
));
930 TYPE_VPTR_BASETYPE (type
)
931 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type
, i
));
938 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
940 If this is a stubbed struct (i.e. declared as struct foo *), see if
941 we can find a full definition in some other file. If so, copy this
942 definition, so we can use it in future. There used to be a comment (but
943 not any code) that if we don't find a full definition, we'd set a flag
944 so we don't spend time in the future checking the same type. That would
945 be a mistake, though--we might load in more symbols which contain a
946 full definition for the type.
948 This used to be coded as a macro, but I don't think it is called
949 often enough to merit such treatment. */
951 struct complaint stub_noname_complaint
=
952 {"stub type has NULL name", 0, 0};
955 check_stub_type (type
)
958 if (TYPE_FLAGS(type
) & TYPE_FLAG_STUB
)
960 char* name
= type_name_no_tag (type
);
961 /* FIXME: shouldn't we separately check the TYPE_NAME and the
962 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
963 as appropriate? (this code was written before TYPE_NAME and
964 TYPE_TAG_NAME were separate). */
968 complain (&stub_noname_complaint
);
971 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
972 (struct symtab
**) NULL
);
975 memcpy ((char *)type
,
976 (char *)SYMBOL_TYPE(sym
),
977 sizeof (struct type
));
981 if (TYPE_FLAGS (type
) & TYPE_FLAG_TARGET_STUB
)
983 struct type
*range_type
;
985 check_stub_type (TYPE_TARGET_TYPE (type
));
986 if (!(TYPE_FLAGS (TYPE_TARGET_TYPE (type
)) & TYPE_FLAG_STUB
)
987 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
988 && TYPE_NFIELDS (type
) == 1
989 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
992 /* Now recompute the length of the array type, based on its
993 number of elements and the target type's length. */
995 ((TYPE_FIELD_BITPOS (range_type
, 1)
996 - TYPE_FIELD_BITPOS (range_type
, 0)
998 * TYPE_LENGTH (TYPE_TARGET_TYPE (type
)));
999 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1004 /* Ugly hack to convert method stubs into method types.
1006 He ain't kiddin'. This demangles the name of the method into a string
1007 including argument types, parses out each argument type, generates
1008 a string casting a zero to that type, evaluates the string, and stuffs
1009 the resulting type into an argtype vector!!! Then it knows the type
1010 of the whole function (including argument types for overloading),
1011 which info used to be in the stab's but was removed to hack back
1012 the space required for them. */
1015 check_stub_method (type
, i
, j
)
1021 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
1022 char *demangled_name
= cplus_demangle (mangled_name
,
1023 DMGL_PARAMS
| DMGL_ANSI
);
1024 char *argtypetext
, *p
;
1025 int depth
= 0, argcount
= 1;
1026 struct type
**argtypes
;
1029 if (demangled_name
== NULL
)
1031 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
1034 /* Now, read in the parameters that define this type. */
1035 argtypetext
= strchr (demangled_name
, '(') + 1;
1047 else if (*p
== ',' && depth
== 0)
1055 /* We need two more slots: one for the THIS pointer, and one for the
1056 NULL [...] or void [end of arglist]. */
1058 argtypes
= (struct type
**)
1059 TYPE_ALLOC (type
, (argcount
+ 2) * sizeof (struct type
*));
1061 /* FIXME: This is wrong for static member functions. */
1062 argtypes
[0] = lookup_pointer_type (type
);
1065 if (*p
!= ')') /* () means no args, skip while */
1070 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1072 /* Avoid parsing of ellipsis, they will be handled below. */
1073 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0)
1075 argtypes
[argcount
] =
1076 parse_and_eval_type (argtypetext
, p
- argtypetext
);
1079 argtypetext
= p
+ 1;
1095 if (p
[-2] != '.') /* Not '...' */
1097 argtypes
[argcount
] = builtin_type_void
; /* List terminator */
1101 argtypes
[argcount
] = NULL
; /* Ellist terminator */
1104 free (demangled_name
);
1106 f
= TYPE_FN_FIELDLIST1 (type
, i
);
1107 TYPE_FN_FIELD_PHYSNAME (f
, j
) = mangled_name
;
1109 /* Now update the old "stub" type into a real type. */
1110 mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1111 TYPE_DOMAIN_TYPE (mtype
) = type
;
1112 TYPE_ARG_TYPES (mtype
) = argtypes
;
1113 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1114 TYPE_FN_FIELD_STUB (f
, j
) = 0;
1117 const struct cplus_struct_type cplus_struct_default
;
1120 allocate_cplus_struct_type (type
)
1123 if (!HAVE_CPLUS_STRUCT (type
))
1125 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1126 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1127 *(TYPE_CPLUS_SPECIFIC(type
)) = cplus_struct_default
;
1131 /* Helper function to initialize the standard scalar types.
1133 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1134 of the string pointed to by name in the type_obstack for that objfile,
1135 and initialize the type name to that copy. There are places (mipsread.c
1136 in particular, where init_type is called with a NULL value for NAME). */
1139 init_type (code
, length
, flags
, name
, objfile
)
1140 enum type_code code
;
1144 struct objfile
*objfile
;
1146 register struct type
*type
;
1148 type
= alloc_type (objfile
);
1149 TYPE_CODE (type
) = code
;
1150 TYPE_LENGTH (type
) = length
;
1151 TYPE_FLAGS (type
) |= flags
;
1152 if ((name
!= NULL
) && (objfile
!= NULL
))
1155 obsavestring (name
, strlen (name
), &objfile
-> type_obstack
);
1159 TYPE_NAME (type
) = name
;
1164 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
1166 INIT_CPLUS_SPECIFIC (type
);
1171 /* Look up a fundamental type for the specified objfile.
1172 May need to construct such a type if this is the first use.
1174 Some object file formats (ELF, COFF, etc) do not define fundamental
1175 types such as "int" or "double". Others (stabs for example), do
1176 define fundamental types.
1178 For the formats which don't provide fundamental types, gdb can create
1179 such types, using defaults reasonable for the current language and
1180 the current target machine.
1182 NOTE: This routine is obsolescent. Each debugging format reader
1183 should manage it's own fundamental types, either creating them from
1184 suitable defaults or reading them from the debugging information,
1185 whichever is appropriate. The DWARF reader has already been
1186 fixed to do this. Once the other readers are fixed, this routine
1187 will go away. Also note that fundamental types should be managed
1188 on a compilation unit basis in a multi-language environment, not
1189 on a linkage unit basis as is done here. */
1193 lookup_fundamental_type (objfile
, typeid)
1194 struct objfile
*objfile
;
1197 register struct type
**typep
;
1198 register int nbytes
;
1200 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1202 error ("internal error - invalid fundamental type id %d", typeid);
1205 /* If this is the first time we need a fundamental type for this objfile
1206 then we need to initialize the vector of type pointers. */
1208 if (objfile
-> fundamental_types
== NULL
)
1210 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1211 objfile
-> fundamental_types
= (struct type
**)
1212 obstack_alloc (&objfile
-> type_obstack
, nbytes
);
1213 memset ((char *) objfile
-> fundamental_types
, 0, nbytes
);
1216 /* Look for this particular type in the fundamental type vector. If one is
1217 not found, create and install one appropriate for the current language. */
1219 typep
= objfile
-> fundamental_types
+ typeid;
1222 *typep
= create_fundamental_type (objfile
, typeid);
1232 /* FIXME: Should we return true for references as well as pointers? */
1235 && TYPE_CODE (t
) == TYPE_CODE_PTR
1236 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1239 /* Chill varying string and arrays are represented as follows:
1241 struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
1243 Return true if TYPE is such a Chill varying type. */
1246 chill_varying_type (type
)
1249 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1250 || TYPE_NFIELDS (type
) != 2
1251 || strcmp (TYPE_FIELD_NAME (type
, 0), "__var_length") != 0)
1256 #if MAINTENANCE_CMDS
1259 print_bit_vector (bits
, nbits
)
1265 for (bitno
= 0; bitno
< nbits
; bitno
++)
1267 if ((bitno
% 8) == 0)
1269 puts_filtered (" ");
1271 if (B_TST (bits
, bitno
))
1273 printf_filtered ("1");
1277 printf_filtered ("0");
1282 /* The args list is a strange beast. It is either terminated by a NULL
1283 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
1284 type for normal fixed argcount functions. (FIXME someday)
1285 Also note the first arg should be the "this" pointer, we may not want to
1286 include it since we may get into a infinitely recursive situation. */
1289 print_arg_types (args
, spaces
)
1295 while (*args
!= NULL
)
1297 recursive_dump_type (*args
, spaces
+ 2);
1298 if ((*args
++) -> code
== TYPE_CODE_VOID
)
1307 dump_fn_fieldlists (type
, spaces
)
1315 printfi_filtered (spaces
, "fn_fieldlists ");
1316 gdb_print_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
1317 printf_filtered ("\n");
1318 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
1320 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
1321 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
1323 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
1324 gdb_print_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
1326 printf_filtered (") length %d\n",
1327 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
1328 for (overload_idx
= 0;
1329 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
1332 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
1334 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
1335 gdb_print_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
1337 printf_filtered (")\n");
1338 printfi_filtered (spaces
+ 8, "type ");
1339 gdb_print_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
1340 printf_filtered ("\n");
1342 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
1345 printfi_filtered (spaces
+ 8, "args ");
1346 gdb_print_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
1347 printf_filtered ("\n");
1349 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
), spaces
);
1350 printfi_filtered (spaces
+ 8, "fcontext ");
1351 gdb_print_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
1353 printf_filtered ("\n");
1355 printfi_filtered (spaces
+ 8, "is_const %d\n",
1356 TYPE_FN_FIELD_CONST (f
, overload_idx
));
1357 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
1358 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
1359 printfi_filtered (spaces
+ 8, "is_private %d\n",
1360 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
1361 printfi_filtered (spaces
+ 8, "is_protected %d\n",
1362 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
1363 printfi_filtered (spaces
+ 8, "is_stub %d\n",
1364 TYPE_FN_FIELD_STUB (f
, overload_idx
));
1365 printfi_filtered (spaces
+ 8, "voffset %u\n",
1366 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
1372 print_cplus_stuff (type
, spaces
)
1376 printfi_filtered (spaces
, "n_baseclasses %d\n",
1377 TYPE_N_BASECLASSES (type
));
1378 printfi_filtered (spaces
, "nfn_fields %d\n",
1379 TYPE_NFN_FIELDS (type
));
1380 printfi_filtered (spaces
, "nfn_fields_total %d\n",
1381 TYPE_NFN_FIELDS_TOTAL (type
));
1382 if (TYPE_N_BASECLASSES (type
) > 0)
1384 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
1385 TYPE_N_BASECLASSES (type
));
1386 gdb_print_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
1387 printf_filtered (")");
1389 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
1390 TYPE_N_BASECLASSES (type
));
1391 puts_filtered ("\n");
1393 if (TYPE_NFIELDS (type
) > 0)
1395 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
1397 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
1398 TYPE_NFIELDS (type
));
1399 gdb_print_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
1400 printf_filtered (")");
1401 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
1402 TYPE_NFIELDS (type
));
1403 puts_filtered ("\n");
1405 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
1407 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
1408 TYPE_NFIELDS (type
));
1409 gdb_print_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
1410 printf_filtered (")");
1411 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
1412 TYPE_NFIELDS (type
));
1413 puts_filtered ("\n");
1416 if (TYPE_NFN_FIELDS (type
) > 0)
1418 dump_fn_fieldlists (type
, spaces
);
1423 recursive_dump_type (type
, spaces
)
1429 printfi_filtered (spaces
, "type node ");
1430 gdb_print_address (type
, gdb_stdout
);
1431 printf_filtered ("\n");
1432 printfi_filtered (spaces
, "name '%s' (",
1433 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
1434 gdb_print_address (TYPE_NAME (type
), gdb_stdout
);
1435 printf_filtered (")\n");
1436 if (TYPE_TAG_NAME (type
) != NULL
)
1438 printfi_filtered (spaces
, "tagname '%s' (",
1439 TYPE_TAG_NAME (type
));
1440 gdb_print_address (TYPE_TAG_NAME (type
), gdb_stdout
);
1441 printf_filtered (")\n");
1443 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
1444 switch (TYPE_CODE (type
))
1446 case TYPE_CODE_UNDEF
:
1447 printf_filtered ("(TYPE_CODE_UNDEF)");
1450 printf_filtered ("(TYPE_CODE_PTR)");
1452 case TYPE_CODE_ARRAY
:
1453 printf_filtered ("(TYPE_CODE_ARRAY)");
1455 case TYPE_CODE_STRUCT
:
1456 printf_filtered ("(TYPE_CODE_STRUCT)");
1458 case TYPE_CODE_UNION
:
1459 printf_filtered ("(TYPE_CODE_UNION)");
1461 case TYPE_CODE_ENUM
:
1462 printf_filtered ("(TYPE_CODE_ENUM)");
1464 case TYPE_CODE_FUNC
:
1465 printf_filtered ("(TYPE_CODE_FUNC)");
1468 printf_filtered ("(TYPE_CODE_INT)");
1471 printf_filtered ("(TYPE_CODE_FLT)");
1473 case TYPE_CODE_VOID
:
1474 printf_filtered ("(TYPE_CODE_VOID)");
1477 printf_filtered ("(TYPE_CODE_SET)");
1479 case TYPE_CODE_RANGE
:
1480 printf_filtered ("(TYPE_CODE_RANGE)");
1482 case TYPE_CODE_STRING
:
1483 printf_filtered ("(TYPE_CODE_STRING)");
1485 case TYPE_CODE_ERROR
:
1486 printf_filtered ("(TYPE_CODE_ERROR)");
1488 case TYPE_CODE_MEMBER
:
1489 printf_filtered ("(TYPE_CODE_MEMBER)");
1491 case TYPE_CODE_METHOD
:
1492 printf_filtered ("(TYPE_CODE_METHOD)");
1495 printf_filtered ("(TYPE_CODE_REF)");
1497 case TYPE_CODE_CHAR
:
1498 printf_filtered ("(TYPE_CODE_CHAR)");
1500 case TYPE_CODE_BOOL
:
1501 printf_filtered ("(TYPE_CODE_BOOL)");
1504 printf_filtered ("(UNKNOWN TYPE CODE)");
1507 puts_filtered ("\n");
1508 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
1509 printfi_filtered (spaces
, "objfile ");
1510 gdb_print_address (TYPE_OBJFILE (type
), gdb_stdout
);
1511 printf_filtered ("\n");
1512 printfi_filtered (spaces
, "target_type ");
1513 gdb_print_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
1514 printf_filtered ("\n");
1515 if (TYPE_TARGET_TYPE (type
) != NULL
)
1517 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
1519 printfi_filtered (spaces
, "pointer_type ");
1520 gdb_print_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
1521 printf_filtered ("\n");
1522 printfi_filtered (spaces
, "reference_type ");
1523 gdb_print_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
1524 printf_filtered ("\n");
1525 printfi_filtered (spaces
, "function_type ");
1526 gdb_print_address (TYPE_FUNCTION_TYPE (type
), gdb_stdout
);
1527 printf_filtered ("\n");
1528 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
1529 if (TYPE_FLAGS (type
) & TYPE_FLAG_UNSIGNED
)
1531 puts_filtered (" TYPE_FLAG_UNSIGNED");
1533 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
1535 puts_filtered (" TYPE_FLAG_STUB");
1537 puts_filtered ("\n");
1538 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
1539 gdb_print_address (TYPE_FIELDS (type
), gdb_stdout
);
1540 puts_filtered ("\n");
1541 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
1543 printfi_filtered (spaces
+ 2,
1544 "[%d] bitpos %d bitsize %d type ",
1545 idx
, TYPE_FIELD_BITPOS (type
, idx
),
1546 TYPE_FIELD_BITSIZE (type
, idx
));
1547 gdb_print_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
1548 printf_filtered (" name '%s' (",
1549 TYPE_FIELD_NAME (type
, idx
) != NULL
1550 ? TYPE_FIELD_NAME (type
, idx
)
1552 gdb_print_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
1553 printf_filtered (")\n");
1554 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
1556 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
1559 printfi_filtered (spaces
, "vptr_basetype ");
1560 gdb_print_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
1561 puts_filtered ("\n");
1562 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
1564 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
1566 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
1567 switch (TYPE_CODE (type
))
1569 case TYPE_CODE_METHOD
:
1570 case TYPE_CODE_FUNC
:
1571 printfi_filtered (spaces
, "arg_types ");
1572 gdb_print_address (TYPE_ARG_TYPES (type
), gdb_stdout
);
1573 puts_filtered ("\n");
1574 print_arg_types (TYPE_ARG_TYPES (type
), spaces
);
1577 case TYPE_CODE_STRUCT
:
1578 printfi_filtered (spaces
, "cplus_stuff ");
1579 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1580 puts_filtered ("\n");
1581 print_cplus_stuff (type
, spaces
);
1585 /* We have to pick one of the union types to be able print and test
1586 the value. Pick cplus_struct_type, even though we know it isn't
1587 any particular one. */
1588 printfi_filtered (spaces
, "type_specific ");
1589 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1590 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
1592 printf_filtered (" (unknown data form)");
1594 printf_filtered ("\n");
1600 #endif /* MAINTENANCE_CMDS */
1603 _initialize_gdbtypes ()
1606 init_type (TYPE_CODE_VOID
, 1,
1608 "void", (struct objfile
*) NULL
);
1610 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1612 "char", (struct objfile
*) NULL
);
1613 builtin_type_signed_char
=
1614 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1616 "signed char", (struct objfile
*) NULL
);
1617 builtin_type_unsigned_char
=
1618 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1620 "unsigned char", (struct objfile
*) NULL
);
1621 builtin_type_short
=
1622 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1624 "short", (struct objfile
*) NULL
);
1625 builtin_type_unsigned_short
=
1626 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1628 "unsigned short", (struct objfile
*) NULL
);
1630 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1632 "int", (struct objfile
*) NULL
);
1633 builtin_type_unsigned_int
=
1634 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1636 "unsigned int", (struct objfile
*) NULL
);
1638 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1640 "long", (struct objfile
*) NULL
);
1641 builtin_type_unsigned_long
=
1642 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1644 "unsigned long", (struct objfile
*) NULL
);
1645 builtin_type_long_long
=
1646 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1648 "long long", (struct objfile
*) NULL
);
1649 builtin_type_unsigned_long_long
=
1650 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1652 "unsigned long long", (struct objfile
*) NULL
);
1653 builtin_type_float
=
1654 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1656 "float", (struct objfile
*) NULL
);
1657 builtin_type_double
=
1658 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1660 "double", (struct objfile
*) NULL
);
1661 builtin_type_long_double
=
1662 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1664 "long double", (struct objfile
*) NULL
);
1665 builtin_type_complex
=
1666 init_type (TYPE_CODE_FLT
, TARGET_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
1668 "complex", (struct objfile
*) NULL
);
1669 builtin_type_double_complex
=
1670 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
1672 "double complex", (struct objfile
*) NULL
);
1673 builtin_type_string
=
1674 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1676 "string", (struct objfile
*) NULL
);