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 domain_type
= force_to_range_type (domain_type
);
470 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
471 TYPE_NFIELDS (result_type
) = 1;
472 TYPE_FIELDS (result_type
) = (struct field
*)
473 TYPE_ALLOC (result_type
, 1 * sizeof (struct field
));
474 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
475 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
476 low_bound
= TYPE_LOW_BOUND (domain_type
);
477 high_bound
= TYPE_HIGH_BOUND (domain_type
);
478 bit_length
= high_bound
- low_bound
+ 1;
479 if (bit_length
<= TARGET_CHAR_BIT
)
480 TYPE_LENGTH (result_type
) = 1;
481 else if (bit_length
<= TARGET_SHORT_BIT
)
482 TYPE_LENGTH (result_type
) = TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
;
484 TYPE_LENGTH (result_type
)
485 = ((bit_length
+ TARGET_INT_BIT
- 1) / TARGET_INT_BIT
)
487 return (result_type
);
490 /* Create an F77 literal complex type composed of the two types we are
491 given as arguments. */
494 f77_create_literal_complex_type (type_arg1
, type_arg2
)
495 struct type
*type_arg1
;
496 struct type
*type_arg2
;
500 /* First make sure that the 2 components of the complex
501 number both have the same type */
503 if (TYPE_CODE (type_arg1
) != TYPE_CODE (type_arg2
))
504 error ("Both components of a F77 complex number must have the same type!");
506 result
= alloc_type (TYPE_OBJFILE (type_arg1
));
508 TYPE_CODE (result
) = TYPE_CODE_LITERAL_COMPLEX
;
509 TYPE_LENGTH (result
) = TYPE_LENGTH(type_arg1
) * 2;
514 /* Create a F77 LITERAL string type supplied by the user from the keyboard.
516 Elements will be of type ELEMENT_TYPE, the indices will be of type
519 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
520 sure it is TYPE_CODE_UNDEF before we bash it into an array type?
522 This is a total clone of create_array_type() except that there are
523 a few simplyfing assumptions (e.g all bound types are simple). */
526 f77_create_literal_string_type (result_type
, range_type
)
527 struct type
*result_type
;
528 struct type
*range_type
;
533 if (TYPE_CODE (range_type
) != TYPE_CODE_RANGE
)
535 /* FIXME: We only handle range types at the moment. Complain and
536 create a dummy range type to use. */
537 warning ("internal error: array index type must be a range type");
538 range_type
= lookup_fundamental_type (TYPE_OBJFILE (range_type
),
540 range_type
= create_range_type ((struct type
*) NULL
, range_type
, 0, 0);
542 if (result_type
== NULL
)
543 result_type
= alloc_type (TYPE_OBJFILE (range_type
));
544 TYPE_CODE (result_type
) = TYPE_CODE_LITERAL_STRING
;
545 TYPE_TARGET_TYPE (result_type
) = builtin_type_f_character
;
546 low_bound
= TYPE_FIELD_BITPOS (range_type
, 0);
547 high_bound
= TYPE_FIELD_BITPOS (range_type
, 1);
549 /* Safely can assume that all bound types are simple */
551 TYPE_LENGTH (result_type
) =
552 TYPE_LENGTH (builtin_type_f_character
) * (high_bound
- low_bound
+ 1);
554 TYPE_NFIELDS (result_type
) = 1;
555 TYPE_FIELDS (result_type
) =
556 (struct field
*) TYPE_ALLOC (result_type
, sizeof (struct field
));
557 memset (TYPE_FIELDS (result_type
), 0, sizeof (struct field
));
558 TYPE_FIELD_TYPE (result_type
, 0) = range_type
;
559 TYPE_VPTR_FIELDNO (result_type
) = -1;
561 /* Remember that all literal strings in F77 are of the
564 TYPE_ARRAY_LOWER_BOUND_TYPE (result_type
) = BOUND_SIMPLE
;
565 TYPE_ARRAY_UPPER_BOUND_TYPE (result_type
) = BOUND_SIMPLE
;
570 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
571 A MEMBER is a wierd thing -- it amounts to a typed offset into
572 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
573 include the offset (that's the value of the MEMBER itself), but does
574 include the structure type into which it points (for some reason).
576 When "smashing" the type, we preserve the objfile that the
577 old type pointed to, since we aren't changing where the type is actually
581 smash_to_member_type (type
, domain
, to_type
)
584 struct type
*to_type
;
586 struct objfile
*objfile
;
588 objfile
= TYPE_OBJFILE (type
);
590 memset ((char *) type
, 0, sizeof (struct type
));
591 TYPE_OBJFILE (type
) = objfile
;
592 TYPE_TARGET_TYPE (type
) = to_type
;
593 TYPE_DOMAIN_TYPE (type
) = domain
;
594 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
595 TYPE_CODE (type
) = TYPE_CODE_MEMBER
;
598 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
599 METHOD just means `function that gets an extra "this" argument'.
601 When "smashing" the type, we preserve the objfile that the
602 old type pointed to, since we aren't changing where the type is actually
606 smash_to_method_type (type
, domain
, to_type
, args
)
609 struct type
*to_type
;
612 struct objfile
*objfile
;
614 objfile
= TYPE_OBJFILE (type
);
616 memset ((char *) type
, 0, sizeof (struct type
));
617 TYPE_OBJFILE (type
) = objfile
;
618 TYPE_TARGET_TYPE (type
) = to_type
;
619 TYPE_DOMAIN_TYPE (type
) = domain
;
620 TYPE_ARG_TYPES (type
) = args
;
621 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
622 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
625 /* Return a typename for a struct/union/enum type without "struct ",
626 "union ", or "enum ". If the type has a NULL name, return NULL. */
629 type_name_no_tag (type
)
630 register const struct type
*type
;
632 if (TYPE_TAG_NAME (type
) != NULL
)
633 return TYPE_TAG_NAME (type
);
635 /* Is there code which expects this to return the name if there is no
636 tag name? My guess is that this is mainly used for C++ in cases where
637 the two will always be the same. */
638 return TYPE_NAME (type
);
641 /* Lookup a primitive type named NAME.
642 Return zero if NAME is not a primitive type.*/
645 lookup_primitive_typename (name
)
648 struct type
** const *p
;
650 for (p
= current_language
-> la_builtin_type_vector
; *p
!= NULL
; p
++)
652 if (STREQ ((**p
) -> name
, name
))
660 /* Lookup a typedef or primitive type named NAME,
661 visible in lexical block BLOCK.
662 If NOERR is nonzero, return zero if NAME is not suitably defined. */
665 lookup_typename (name
, block
, noerr
)
670 register struct symbol
*sym
;
671 register struct type
*tmp
;
673 sym
= lookup_symbol (name
, block
, VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
674 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
676 tmp
= lookup_primitive_typename (name
);
681 else if (!tmp
&& noerr
)
687 error ("No type named %s.", name
);
690 return (SYMBOL_TYPE (sym
));
694 lookup_unsigned_typename (name
)
697 char *uns
= alloca (strlen (name
) + 10);
699 strcpy (uns
, "unsigned ");
700 strcpy (uns
+ 9, name
);
701 return (lookup_typename (uns
, (struct block
*) NULL
, 0));
705 lookup_signed_typename (name
)
709 char *uns
= alloca (strlen (name
) + 8);
711 strcpy (uns
, "signed ");
712 strcpy (uns
+ 7, name
);
713 t
= lookup_typename (uns
, (struct block
*) NULL
, 1);
714 /* If we don't find "signed FOO" just try again with plain "FOO". */
717 return lookup_typename (name
, (struct block
*) NULL
, 0);
720 /* Lookup a structure type named "struct NAME",
721 visible in lexical block BLOCK. */
724 lookup_struct (name
, block
)
728 register struct symbol
*sym
;
730 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
731 (struct symtab
**) NULL
);
735 error ("No struct type named %s.", name
);
737 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
739 error ("This context has class, union or enum %s, not a struct.", name
);
741 return (SYMBOL_TYPE (sym
));
744 /* Lookup a union type named "union NAME",
745 visible in lexical block BLOCK. */
748 lookup_union (name
, block
)
752 register struct symbol
*sym
;
754 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
755 (struct symtab
**) NULL
);
759 error ("No union type named %s.", name
);
761 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_UNION
)
763 error ("This context has class, struct or enum %s, not a union.", name
);
765 return (SYMBOL_TYPE (sym
));
768 /* Lookup an enum type named "enum NAME",
769 visible in lexical block BLOCK. */
772 lookup_enum (name
, block
)
776 register struct symbol
*sym
;
778 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
779 (struct symtab
**) NULL
);
782 error ("No enum type named %s.", name
);
784 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
786 error ("This context has class, struct or union %s, not an enum.", name
);
788 return (SYMBOL_TYPE (sym
));
791 /* Lookup a template type named "template NAME<TYPE>",
792 visible in lexical block BLOCK. */
795 lookup_template_type (name
, type
, block
)
801 char *nam
= (char*) alloca(strlen(name
) + strlen(type
->name
) + 4);
804 strcat (nam
, type
->name
);
805 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
807 sym
= lookup_symbol (nam
, block
, VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
811 error ("No template type named %s.", name
);
813 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
815 error ("This context has class, union or enum %s, not a struct.", name
);
817 return (SYMBOL_TYPE (sym
));
820 /* Given a type TYPE, lookup the type of the component of type named NAME.
822 TYPE can be either a struct or union, or a pointer or reference to a struct or
823 union. If it is a pointer or reference, its target type is automatically used.
824 Thus '.' and '->' are interchangable, as specified for the definitions of the
825 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
827 If NOERR is nonzero, return zero if NAME is not suitably defined.
828 If NAME is the name of a baseclass type, return that type. */
831 lookup_struct_elt_type (type
, name
, noerr
)
838 while (TYPE_CODE (type
) == TYPE_CODE_PTR
||
839 TYPE_CODE (type
) == TYPE_CODE_REF
)
840 type
= TYPE_TARGET_TYPE (type
);
842 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&&
843 TYPE_CODE (type
) != TYPE_CODE_UNION
)
845 target_terminal_ours ();
846 gdb_flush (gdb_stdout
);
847 fprintf_unfiltered (gdb_stderr
, "Type ");
848 type_print (type
, "", gdb_stderr
, -1);
849 error (" is not a structure or union type.");
852 check_stub_type (type
);
855 /* FIXME: This change put in by Michael seems incorrect for the case where
856 the structure tag name is the same as the member name. I.E. when doing
857 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
862 typename
= type_name_no_tag (type
);
863 if (typename
!= NULL
&& STREQ (typename
, name
))
868 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
870 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
872 if (t_field_name
&& STREQ (t_field_name
, name
))
874 return TYPE_FIELD_TYPE (type
, i
);
878 /* OK, it's not in this class. Recursively check the baseclasses. */
879 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
883 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, noerr
);
895 target_terminal_ours ();
896 gdb_flush (gdb_stdout
);
897 fprintf_unfiltered (gdb_stderr
, "Type ");
898 type_print (type
, "", gdb_stderr
, -1);
899 fprintf_unfiltered (gdb_stderr
, " has no component named ");
900 fputs_filtered (name
, gdb_stderr
);
902 return (struct type
*)-1; /* For lint */
905 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
906 valid. Callers should be aware that in some cases (for example,
907 the type or one of its baseclasses is a stub type and we are
908 debugging a .o file), this function will not be able to find the virtual
909 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
913 fill_in_vptr_fieldno (type
)
916 check_stub_type (type
);
918 if (TYPE_VPTR_FIELDNO (type
) < 0)
922 /* We must start at zero in case the first (and only) baseclass is
923 virtual (and hence we cannot share the table pointer). */
924 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
926 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, i
));
927 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
)) >= 0)
929 TYPE_VPTR_FIELDNO (type
)
930 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
));
931 TYPE_VPTR_BASETYPE (type
)
932 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type
, i
));
939 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
941 If this is a stubbed struct (i.e. declared as struct foo *), see if
942 we can find a full definition in some other file. If so, copy this
943 definition, so we can use it in future. There used to be a comment (but
944 not any code) that if we don't find a full definition, we'd set a flag
945 so we don't spend time in the future checking the same type. That would
946 be a mistake, though--we might load in more symbols which contain a
947 full definition for the type.
949 This used to be coded as a macro, but I don't think it is called
950 often enough to merit such treatment. */
952 struct complaint stub_noname_complaint
=
953 {"stub type has NULL name", 0, 0};
956 check_stub_type (type
)
959 if (TYPE_FLAGS(type
) & TYPE_FLAG_STUB
)
961 char* name
= type_name_no_tag (type
);
962 /* FIXME: shouldn't we separately check the TYPE_NAME and the
963 TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
964 as appropriate? (this code was written before TYPE_NAME and
965 TYPE_TAG_NAME were separate). */
969 complain (&stub_noname_complaint
);
972 sym
= lookup_symbol (name
, 0, STRUCT_NAMESPACE
, 0,
973 (struct symtab
**) NULL
);
976 memcpy ((char *)type
,
977 (char *)SYMBOL_TYPE(sym
),
978 sizeof (struct type
));
982 if (TYPE_FLAGS (type
) & TYPE_FLAG_TARGET_STUB
)
984 struct type
*range_type
;
986 check_stub_type (TYPE_TARGET_TYPE (type
));
987 if (!(TYPE_FLAGS (TYPE_TARGET_TYPE (type
)) & TYPE_FLAG_STUB
)
988 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
989 && TYPE_NFIELDS (type
) == 1
990 && (TYPE_CODE (range_type
= TYPE_FIELD_TYPE (type
, 0))
993 /* Now recompute the length of the array type, based on its
994 number of elements and the target type's length. */
996 ((TYPE_FIELD_BITPOS (range_type
, 1)
997 - TYPE_FIELD_BITPOS (range_type
, 0)
999 * TYPE_LENGTH (TYPE_TARGET_TYPE (type
)));
1000 TYPE_FLAGS (type
) &= ~TYPE_FLAG_TARGET_STUB
;
1005 /* Ugly hack to convert method stubs into method types.
1007 He ain't kiddin'. This demangles the name of the method into a string
1008 including argument types, parses out each argument type, generates
1009 a string casting a zero to that type, evaluates the string, and stuffs
1010 the resulting type into an argtype vector!!! Then it knows the type
1011 of the whole function (including argument types for overloading),
1012 which info used to be in the stab's but was removed to hack back
1013 the space required for them. */
1016 check_stub_method (type
, i
, j
)
1022 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
1023 char *demangled_name
= cplus_demangle (mangled_name
,
1024 DMGL_PARAMS
| DMGL_ANSI
);
1025 char *argtypetext
, *p
;
1026 int depth
= 0, argcount
= 1;
1027 struct type
**argtypes
;
1030 if (demangled_name
== NULL
)
1032 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name
);
1035 /* Now, read in the parameters that define this type. */
1036 argtypetext
= strchr (demangled_name
, '(') + 1;
1048 else if (*p
== ',' && depth
== 0)
1056 /* We need two more slots: one for the THIS pointer, and one for the
1057 NULL [...] or void [end of arglist]. */
1059 argtypes
= (struct type
**)
1060 TYPE_ALLOC (type
, (argcount
+ 2) * sizeof (struct type
*));
1062 /* FIXME: This is wrong for static member functions. */
1063 argtypes
[0] = lookup_pointer_type (type
);
1066 if (*p
!= ')') /* () means no args, skip while */
1071 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1073 /* Avoid parsing of ellipsis, they will be handled below. */
1074 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0)
1076 argtypes
[argcount
] =
1077 parse_and_eval_type (argtypetext
, p
- argtypetext
);
1080 argtypetext
= p
+ 1;
1096 if (p
[-2] != '.') /* Not '...' */
1098 argtypes
[argcount
] = builtin_type_void
; /* List terminator */
1102 argtypes
[argcount
] = NULL
; /* Ellist terminator */
1105 free (demangled_name
);
1107 f
= TYPE_FN_FIELDLIST1 (type
, i
);
1108 TYPE_FN_FIELD_PHYSNAME (f
, j
) = mangled_name
;
1110 /* Now update the old "stub" type into a real type. */
1111 mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1112 TYPE_DOMAIN_TYPE (mtype
) = type
;
1113 TYPE_ARG_TYPES (mtype
) = argtypes
;
1114 TYPE_FLAGS (mtype
) &= ~TYPE_FLAG_STUB
;
1115 TYPE_FN_FIELD_STUB (f
, j
) = 0;
1118 const struct cplus_struct_type cplus_struct_default
;
1121 allocate_cplus_struct_type (type
)
1124 if (!HAVE_CPLUS_STRUCT (type
))
1126 TYPE_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1127 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1128 *(TYPE_CPLUS_SPECIFIC(type
)) = cplus_struct_default
;
1132 /* Helper function to initialize the standard scalar types.
1134 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1135 of the string pointed to by name in the type_obstack for that objfile,
1136 and initialize the type name to that copy. There are places (mipsread.c
1137 in particular, where init_type is called with a NULL value for NAME). */
1140 init_type (code
, length
, flags
, name
, objfile
)
1141 enum type_code code
;
1145 struct objfile
*objfile
;
1147 register struct type
*type
;
1149 type
= alloc_type (objfile
);
1150 TYPE_CODE (type
) = code
;
1151 TYPE_LENGTH (type
) = length
;
1152 TYPE_FLAGS (type
) |= flags
;
1153 if ((name
!= NULL
) && (objfile
!= NULL
))
1156 obsavestring (name
, strlen (name
), &objfile
-> type_obstack
);
1160 TYPE_NAME (type
) = name
;
1165 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
1167 INIT_CPLUS_SPECIFIC (type
);
1172 /* Look up a fundamental type for the specified objfile.
1173 May need to construct such a type if this is the first use.
1175 Some object file formats (ELF, COFF, etc) do not define fundamental
1176 types such as "int" or "double". Others (stabs for example), do
1177 define fundamental types.
1179 For the formats which don't provide fundamental types, gdb can create
1180 such types, using defaults reasonable for the current language and
1181 the current target machine.
1183 NOTE: This routine is obsolescent. Each debugging format reader
1184 should manage it's own fundamental types, either creating them from
1185 suitable defaults or reading them from the debugging information,
1186 whichever is appropriate. The DWARF reader has already been
1187 fixed to do this. Once the other readers are fixed, this routine
1188 will go away. Also note that fundamental types should be managed
1189 on a compilation unit basis in a multi-language environment, not
1190 on a linkage unit basis as is done here. */
1194 lookup_fundamental_type (objfile
, typeid)
1195 struct objfile
*objfile
;
1198 register struct type
**typep
;
1199 register int nbytes
;
1201 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
1203 error ("internal error - invalid fundamental type id %d", typeid);
1206 /* If this is the first time we need a fundamental type for this objfile
1207 then we need to initialize the vector of type pointers. */
1209 if (objfile
-> fundamental_types
== NULL
)
1211 nbytes
= FT_NUM_MEMBERS
* sizeof (struct type
*);
1212 objfile
-> fundamental_types
= (struct type
**)
1213 obstack_alloc (&objfile
-> type_obstack
, nbytes
);
1214 memset ((char *) objfile
-> fundamental_types
, 0, nbytes
);
1217 /* Look for this particular type in the fundamental type vector. If one is
1218 not found, create and install one appropriate for the current language. */
1220 typep
= objfile
-> fundamental_types
+ typeid;
1223 *typep
= create_fundamental_type (objfile
, typeid);
1233 /* FIXME: Should we return true for references as well as pointers? */
1236 && TYPE_CODE (t
) == TYPE_CODE_PTR
1237 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1240 #if MAINTENANCE_CMDS
1243 print_bit_vector (bits
, nbits
)
1249 for (bitno
= 0; bitno
< nbits
; bitno
++)
1251 if ((bitno
% 8) == 0)
1253 puts_filtered (" ");
1255 if (B_TST (bits
, bitno
))
1257 printf_filtered ("1");
1261 printf_filtered ("0");
1266 /* The args list is a strange beast. It is either terminated by a NULL
1267 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
1268 type for normal fixed argcount functions. (FIXME someday)
1269 Also note the first arg should be the "this" pointer, we may not want to
1270 include it since we may get into a infinitely recursive situation. */
1273 print_arg_types (args
, spaces
)
1279 while (*args
!= NULL
)
1281 recursive_dump_type (*args
, spaces
+ 2);
1282 if ((*args
++) -> code
== TYPE_CODE_VOID
)
1291 dump_fn_fieldlists (type
, spaces
)
1299 printfi_filtered (spaces
, "fn_fieldlists ");
1300 gdb_print_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
1301 printf_filtered ("\n");
1302 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
1304 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
1305 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
1307 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
1308 gdb_print_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
1310 printf_filtered (") length %d\n",
1311 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
1312 for (overload_idx
= 0;
1313 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
1316 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
1318 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
1319 gdb_print_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
1321 printf_filtered (")\n");
1322 printfi_filtered (spaces
+ 8, "type ");
1323 gdb_print_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
), gdb_stdout
);
1324 printf_filtered ("\n");
1326 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
1329 printfi_filtered (spaces
+ 8, "args ");
1330 gdb_print_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
), gdb_stdout
);
1331 printf_filtered ("\n");
1333 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
), spaces
);
1334 printfi_filtered (spaces
+ 8, "fcontext ");
1335 gdb_print_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
1337 printf_filtered ("\n");
1339 printfi_filtered (spaces
+ 8, "is_const %d\n",
1340 TYPE_FN_FIELD_CONST (f
, overload_idx
));
1341 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
1342 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
1343 printfi_filtered (spaces
+ 8, "is_private %d\n",
1344 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
1345 printfi_filtered (spaces
+ 8, "is_protected %d\n",
1346 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
1347 printfi_filtered (spaces
+ 8, "is_stub %d\n",
1348 TYPE_FN_FIELD_STUB (f
, overload_idx
));
1349 printfi_filtered (spaces
+ 8, "voffset %u\n",
1350 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
1356 print_cplus_stuff (type
, spaces
)
1360 printfi_filtered (spaces
, "n_baseclasses %d\n",
1361 TYPE_N_BASECLASSES (type
));
1362 printfi_filtered (spaces
, "nfn_fields %d\n",
1363 TYPE_NFN_FIELDS (type
));
1364 printfi_filtered (spaces
, "nfn_fields_total %d\n",
1365 TYPE_NFN_FIELDS_TOTAL (type
));
1366 if (TYPE_N_BASECLASSES (type
) > 0)
1368 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
1369 TYPE_N_BASECLASSES (type
));
1370 gdb_print_address (TYPE_FIELD_VIRTUAL_BITS (type
), gdb_stdout
);
1371 printf_filtered (")");
1373 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
1374 TYPE_N_BASECLASSES (type
));
1375 puts_filtered ("\n");
1377 if (TYPE_NFIELDS (type
) > 0)
1379 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
1381 printfi_filtered (spaces
, "private_field_bits (%d bits at *",
1382 TYPE_NFIELDS (type
));
1383 gdb_print_address (TYPE_FIELD_PRIVATE_BITS (type
), gdb_stdout
);
1384 printf_filtered (")");
1385 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
1386 TYPE_NFIELDS (type
));
1387 puts_filtered ("\n");
1389 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
1391 printfi_filtered (spaces
, "protected_field_bits (%d bits at *",
1392 TYPE_NFIELDS (type
));
1393 gdb_print_address (TYPE_FIELD_PROTECTED_BITS (type
), gdb_stdout
);
1394 printf_filtered (")");
1395 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
1396 TYPE_NFIELDS (type
));
1397 puts_filtered ("\n");
1400 if (TYPE_NFN_FIELDS (type
) > 0)
1402 dump_fn_fieldlists (type
, spaces
);
1407 recursive_dump_type (type
, spaces
)
1413 printfi_filtered (spaces
, "type node ");
1414 gdb_print_address (type
, gdb_stdout
);
1415 printf_filtered ("\n");
1416 printfi_filtered (spaces
, "name '%s' (",
1417 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
1418 gdb_print_address (TYPE_NAME (type
), gdb_stdout
);
1419 printf_filtered (")\n");
1420 if (TYPE_TAG_NAME (type
) != NULL
)
1422 printfi_filtered (spaces
, "tagname '%s' (",
1423 TYPE_TAG_NAME (type
));
1424 gdb_print_address (TYPE_TAG_NAME (type
), gdb_stdout
);
1425 printf_filtered (")\n");
1427 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
1428 switch (TYPE_CODE (type
))
1430 case TYPE_CODE_UNDEF
:
1431 printf_filtered ("(TYPE_CODE_UNDEF)");
1434 printf_filtered ("(TYPE_CODE_PTR)");
1436 case TYPE_CODE_ARRAY
:
1437 printf_filtered ("(TYPE_CODE_ARRAY)");
1439 case TYPE_CODE_STRUCT
:
1440 printf_filtered ("(TYPE_CODE_STRUCT)");
1442 case TYPE_CODE_UNION
:
1443 printf_filtered ("(TYPE_CODE_UNION)");
1445 case TYPE_CODE_ENUM
:
1446 printf_filtered ("(TYPE_CODE_ENUM)");
1448 case TYPE_CODE_FUNC
:
1449 printf_filtered ("(TYPE_CODE_FUNC)");
1452 printf_filtered ("(TYPE_CODE_INT)");
1455 printf_filtered ("(TYPE_CODE_FLT)");
1457 case TYPE_CODE_VOID
:
1458 printf_filtered ("(TYPE_CODE_VOID)");
1461 printf_filtered ("(TYPE_CODE_SET)");
1463 case TYPE_CODE_RANGE
:
1464 printf_filtered ("(TYPE_CODE_RANGE)");
1466 case TYPE_CODE_STRING
:
1467 printf_filtered ("(TYPE_CODE_STRING)");
1469 case TYPE_CODE_ERROR
:
1470 printf_filtered ("(TYPE_CODE_ERROR)");
1472 case TYPE_CODE_MEMBER
:
1473 printf_filtered ("(TYPE_CODE_MEMBER)");
1475 case TYPE_CODE_METHOD
:
1476 printf_filtered ("(TYPE_CODE_METHOD)");
1479 printf_filtered ("(TYPE_CODE_REF)");
1481 case TYPE_CODE_CHAR
:
1482 printf_filtered ("(TYPE_CODE_CHAR)");
1484 case TYPE_CODE_BOOL
:
1485 printf_filtered ("(TYPE_CODE_BOOL)");
1488 printf_filtered ("(UNKNOWN TYPE CODE)");
1491 puts_filtered ("\n");
1492 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
1493 printfi_filtered (spaces
, "objfile ");
1494 gdb_print_address (TYPE_OBJFILE (type
), gdb_stdout
);
1495 printf_filtered ("\n");
1496 printfi_filtered (spaces
, "target_type ");
1497 gdb_print_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
1498 printf_filtered ("\n");
1499 if (TYPE_TARGET_TYPE (type
) != NULL
)
1501 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
1503 printfi_filtered (spaces
, "pointer_type ");
1504 gdb_print_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
1505 printf_filtered ("\n");
1506 printfi_filtered (spaces
, "reference_type ");
1507 gdb_print_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
1508 printf_filtered ("\n");
1509 printfi_filtered (spaces
, "function_type ");
1510 gdb_print_address (TYPE_FUNCTION_TYPE (type
), gdb_stdout
);
1511 printf_filtered ("\n");
1512 printfi_filtered (spaces
, "flags 0x%x", TYPE_FLAGS (type
));
1513 if (TYPE_FLAGS (type
) & TYPE_FLAG_UNSIGNED
)
1515 puts_filtered (" TYPE_FLAG_UNSIGNED");
1517 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
1519 puts_filtered (" TYPE_FLAG_STUB");
1521 puts_filtered ("\n");
1522 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
1523 gdb_print_address (TYPE_FIELDS (type
), gdb_stdout
);
1524 puts_filtered ("\n");
1525 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
1527 printfi_filtered (spaces
+ 2,
1528 "[%d] bitpos %d bitsize %d type ",
1529 idx
, TYPE_FIELD_BITPOS (type
, idx
),
1530 TYPE_FIELD_BITSIZE (type
, idx
));
1531 gdb_print_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
1532 printf_filtered (" name '%s' (",
1533 TYPE_FIELD_NAME (type
, idx
) != NULL
1534 ? TYPE_FIELD_NAME (type
, idx
)
1536 gdb_print_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
1537 printf_filtered (")\n");
1538 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
1540 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
1543 printfi_filtered (spaces
, "vptr_basetype ");
1544 gdb_print_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
1545 puts_filtered ("\n");
1546 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
1548 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
1550 printfi_filtered (spaces
, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type
));
1551 switch (TYPE_CODE (type
))
1553 case TYPE_CODE_METHOD
:
1554 case TYPE_CODE_FUNC
:
1555 printfi_filtered (spaces
, "arg_types ");
1556 gdb_print_address (TYPE_ARG_TYPES (type
), gdb_stdout
);
1557 puts_filtered ("\n");
1558 print_arg_types (TYPE_ARG_TYPES (type
), spaces
);
1561 case TYPE_CODE_STRUCT
:
1562 printfi_filtered (spaces
, "cplus_stuff ");
1563 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1564 puts_filtered ("\n");
1565 print_cplus_stuff (type
, spaces
);
1569 /* We have to pick one of the union types to be able print and test
1570 the value. Pick cplus_struct_type, even though we know it isn't
1571 any particular one. */
1572 printfi_filtered (spaces
, "type_specific ");
1573 gdb_print_address (TYPE_CPLUS_SPECIFIC (type
), gdb_stdout
);
1574 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
)
1576 printf_filtered (" (unknown data form)");
1578 printf_filtered ("\n");
1584 #endif /* MAINTENANCE_CMDS */
1587 _initialize_gdbtypes ()
1590 init_type (TYPE_CODE_VOID
, 1,
1592 "void", (struct objfile
*) NULL
);
1594 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1596 "char", (struct objfile
*) NULL
);
1597 builtin_type_signed_char
=
1598 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1600 "signed char", (struct objfile
*) NULL
);
1601 builtin_type_unsigned_char
=
1602 init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1604 "unsigned char", (struct objfile
*) NULL
);
1605 builtin_type_short
=
1606 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1608 "short", (struct objfile
*) NULL
);
1609 builtin_type_unsigned_short
=
1610 init_type (TYPE_CODE_INT
, TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
1612 "unsigned short", (struct objfile
*) NULL
);
1614 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1616 "int", (struct objfile
*) NULL
);
1617 builtin_type_unsigned_int
=
1618 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1620 "unsigned int", (struct objfile
*) NULL
);
1622 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1624 "long", (struct objfile
*) NULL
);
1625 builtin_type_unsigned_long
=
1626 init_type (TYPE_CODE_INT
, TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
1628 "unsigned long", (struct objfile
*) NULL
);
1629 builtin_type_long_long
=
1630 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1632 "long long", (struct objfile
*) NULL
);
1633 builtin_type_unsigned_long_long
=
1634 init_type (TYPE_CODE_INT
, TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
1636 "unsigned long long", (struct objfile
*) NULL
);
1637 builtin_type_float
=
1638 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
1640 "float", (struct objfile
*) NULL
);
1641 builtin_type_double
=
1642 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1644 "double", (struct objfile
*) NULL
);
1645 builtin_type_long_double
=
1646 init_type (TYPE_CODE_FLT
, TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
1648 "long double", (struct objfile
*) NULL
);
1649 builtin_type_complex
=
1650 init_type (TYPE_CODE_FLT
, TARGET_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
1652 "complex", (struct objfile
*) NULL
);
1653 builtin_type_double_complex
=
1654 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
1656 "double complex", (struct objfile
*) NULL
);
1657 builtin_type_string
=
1658 init_type (TYPE_CODE_STRING
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
1660 "string", (struct objfile
*) NULL
);