1 /* Support routines for manipulating internal types for GDB.
3 Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
5 Contributed by Cygnus Support, using pieces from other GDB modules.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_string.h"
29 #include "expression.h"
34 #include "complaints.h"
38 #include "gdb_assert.h"
42 /* Initialize BADNESS constants. */
44 const struct rank LENGTH_MISMATCH_BADNESS
= {100,0};
46 const struct rank TOO_FEW_PARAMS_BADNESS
= {100,0};
47 const struct rank INCOMPATIBLE_TYPE_BADNESS
= {100,0};
49 const struct rank EXACT_MATCH_BADNESS
= {0,0};
51 const struct rank INTEGER_PROMOTION_BADNESS
= {1,0};
52 const struct rank FLOAT_PROMOTION_BADNESS
= {1,0};
53 const struct rank BASE_PTR_CONVERSION_BADNESS
= {1,0};
54 const struct rank INTEGER_CONVERSION_BADNESS
= {2,0};
55 const struct rank FLOAT_CONVERSION_BADNESS
= {2,0};
56 const struct rank INT_FLOAT_CONVERSION_BADNESS
= {2,0};
57 const struct rank VOID_PTR_CONVERSION_BADNESS
= {2,0};
58 const struct rank BOOL_PTR_CONVERSION_BADNESS
= {3,0};
59 const struct rank BASE_CONVERSION_BADNESS
= {2,0};
60 const struct rank REFERENCE_CONVERSION_BADNESS
= {2,0};
61 const struct rank NULL_POINTER_CONVERSION_BADNESS
= {2,0};
62 const struct rank NS_POINTER_CONVERSION_BADNESS
= {10,0};
64 /* Floatformat pairs. */
65 const struct floatformat
*floatformats_ieee_half
[BFD_ENDIAN_UNKNOWN
] = {
66 &floatformat_ieee_half_big
,
67 &floatformat_ieee_half_little
69 const struct floatformat
*floatformats_ieee_single
[BFD_ENDIAN_UNKNOWN
] = {
70 &floatformat_ieee_single_big
,
71 &floatformat_ieee_single_little
73 const struct floatformat
*floatformats_ieee_double
[BFD_ENDIAN_UNKNOWN
] = {
74 &floatformat_ieee_double_big
,
75 &floatformat_ieee_double_little
77 const struct floatformat
*floatformats_ieee_double_littlebyte_bigword
[BFD_ENDIAN_UNKNOWN
] = {
78 &floatformat_ieee_double_big
,
79 &floatformat_ieee_double_littlebyte_bigword
81 const struct floatformat
*floatformats_i387_ext
[BFD_ENDIAN_UNKNOWN
] = {
82 &floatformat_i387_ext
,
85 const struct floatformat
*floatformats_m68881_ext
[BFD_ENDIAN_UNKNOWN
] = {
86 &floatformat_m68881_ext
,
87 &floatformat_m68881_ext
89 const struct floatformat
*floatformats_arm_ext
[BFD_ENDIAN_UNKNOWN
] = {
90 &floatformat_arm_ext_big
,
91 &floatformat_arm_ext_littlebyte_bigword
93 const struct floatformat
*floatformats_ia64_spill
[BFD_ENDIAN_UNKNOWN
] = {
94 &floatformat_ia64_spill_big
,
95 &floatformat_ia64_spill_little
97 const struct floatformat
*floatformats_ia64_quad
[BFD_ENDIAN_UNKNOWN
] = {
98 &floatformat_ia64_quad_big
,
99 &floatformat_ia64_quad_little
101 const struct floatformat
*floatformats_vax_f
[BFD_ENDIAN_UNKNOWN
] = {
105 const struct floatformat
*floatformats_vax_d
[BFD_ENDIAN_UNKNOWN
] = {
109 const struct floatformat
*floatformats_ibm_long_double
[BFD_ENDIAN_UNKNOWN
] = {
110 &floatformat_ibm_long_double
,
111 &floatformat_ibm_long_double
115 int opaque_type_resolution
= 1;
117 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
118 struct cmd_list_element
*c
,
121 fprintf_filtered (file
, _("Resolution of opaque struct/class/union types "
122 "(if set before loading symbols) is %s.\n"),
126 int overload_debug
= 0;
128 show_overload_debug (struct ui_file
*file
, int from_tty
,
129 struct cmd_list_element
*c
, const char *value
)
131 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"),
139 }; /* Maximum extension is 128! FIXME */
141 static void print_bit_vector (B_TYPE
*, int);
142 static void print_arg_types (struct field
*, int, int);
143 static void dump_fn_fieldlists (struct type
*, int);
144 static void print_cplus_stuff (struct type
*, int);
147 /* Allocate a new OBJFILE-associated type structure and fill it
148 with some defaults. Space for the type structure is allocated
149 on the objfile's objfile_obstack. */
152 alloc_type (struct objfile
*objfile
)
156 gdb_assert (objfile
!= NULL
);
158 /* Alloc the structure and start off with all fields zeroed. */
159 type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct type
);
160 TYPE_MAIN_TYPE (type
) = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
162 OBJSTAT (objfile
, n_types
++);
164 TYPE_OBJFILE_OWNED (type
) = 1;
165 TYPE_OWNER (type
).objfile
= objfile
;
167 /* Initialize the fields that might not be zero. */
169 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
170 TYPE_VPTR_FIELDNO (type
) = -1;
171 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
176 /* Allocate a new GDBARCH-associated type structure and fill it
177 with some defaults. Space for the type structure is allocated
181 alloc_type_arch (struct gdbarch
*gdbarch
)
185 gdb_assert (gdbarch
!= NULL
);
187 /* Alloc the structure and start off with all fields zeroed. */
189 type
= XZALLOC (struct type
);
190 TYPE_MAIN_TYPE (type
) = XZALLOC (struct main_type
);
192 TYPE_OBJFILE_OWNED (type
) = 0;
193 TYPE_OWNER (type
).gdbarch
= gdbarch
;
195 /* Initialize the fields that might not be zero. */
197 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
198 TYPE_VPTR_FIELDNO (type
) = -1;
199 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
204 /* If TYPE is objfile-associated, allocate a new type structure
205 associated with the same objfile. If TYPE is gdbarch-associated,
206 allocate a new type structure associated with the same gdbarch. */
209 alloc_type_copy (const struct type
*type
)
211 if (TYPE_OBJFILE_OWNED (type
))
212 return alloc_type (TYPE_OWNER (type
).objfile
);
214 return alloc_type_arch (TYPE_OWNER (type
).gdbarch
);
217 /* If TYPE is gdbarch-associated, return that architecture.
218 If TYPE is objfile-associated, return that objfile's architecture. */
221 get_type_arch (const struct type
*type
)
223 if (TYPE_OBJFILE_OWNED (type
))
224 return get_objfile_arch (TYPE_OWNER (type
).objfile
);
226 return TYPE_OWNER (type
).gdbarch
;
230 /* Alloc a new type instance structure, fill it with some defaults,
231 and point it at OLDTYPE. Allocate the new type instance from the
232 same place as OLDTYPE. */
235 alloc_type_instance (struct type
*oldtype
)
239 /* Allocate the structure. */
241 if (! TYPE_OBJFILE_OWNED (oldtype
))
242 type
= XZALLOC (struct type
);
244 type
= OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype
)->objfile_obstack
,
247 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
249 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
254 /* Clear all remnants of the previous type at TYPE, in preparation for
255 replacing it with something else. Preserve owner information. */
257 smash_type (struct type
*type
)
259 int objfile_owned
= TYPE_OBJFILE_OWNED (type
);
260 union type_owner owner
= TYPE_OWNER (type
);
262 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
264 /* Restore owner information. */
265 TYPE_OBJFILE_OWNED (type
) = objfile_owned
;
266 TYPE_OWNER (type
) = owner
;
268 /* For now, delete the rings. */
269 TYPE_CHAIN (type
) = type
;
271 /* For now, leave the pointer/reference types alone. */
274 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
275 to a pointer to memory where the pointer type should be stored.
276 If *TYPEPTR is zero, update it to point to the pointer type we return.
277 We allocate new memory if needed. */
280 make_pointer_type (struct type
*type
, struct type
**typeptr
)
282 struct type
*ntype
; /* New type */
285 ntype
= TYPE_POINTER_TYPE (type
);
290 return ntype
; /* Don't care about alloc,
291 and have new type. */
292 else if (*typeptr
== 0)
294 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
299 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
301 ntype
= alloc_type_copy (type
);
305 else /* We have storage, but need to reset it. */
308 chain
= TYPE_CHAIN (ntype
);
310 TYPE_CHAIN (ntype
) = chain
;
313 TYPE_TARGET_TYPE (ntype
) = type
;
314 TYPE_POINTER_TYPE (type
) = ntype
;
316 /* FIXME! Assume the machine has only one representation for
320 = gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
321 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
323 /* Mark pointers as unsigned. The target converts between pointers
324 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
325 gdbarch_address_to_pointer. */
326 TYPE_UNSIGNED (ntype
) = 1;
328 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
329 TYPE_POINTER_TYPE (type
) = ntype
;
331 /* Update the length of all the other variants of this type. */
332 chain
= TYPE_CHAIN (ntype
);
333 while (chain
!= ntype
)
335 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
336 chain
= TYPE_CHAIN (chain
);
342 /* Given a type TYPE, return a type of pointers to that type.
343 May need to construct such a type if this is the first use. */
346 lookup_pointer_type (struct type
*type
)
348 return make_pointer_type (type
, (struct type
**) 0);
351 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
352 points to a pointer to memory where the reference type should be
353 stored. If *TYPEPTR is zero, update it to point to the reference
354 type we return. We allocate new memory if needed. */
357 make_reference_type (struct type
*type
, struct type
**typeptr
)
359 struct type
*ntype
; /* New type */
362 ntype
= TYPE_REFERENCE_TYPE (type
);
367 return ntype
; /* Don't care about alloc,
368 and have new type. */
369 else if (*typeptr
== 0)
371 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
376 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
378 ntype
= alloc_type_copy (type
);
382 else /* We have storage, but need to reset it. */
385 chain
= TYPE_CHAIN (ntype
);
387 TYPE_CHAIN (ntype
) = chain
;
390 TYPE_TARGET_TYPE (ntype
) = type
;
391 TYPE_REFERENCE_TYPE (type
) = ntype
;
393 /* FIXME! Assume the machine has only one representation for
394 references, and that it matches the (only) representation for
397 TYPE_LENGTH (ntype
) =
398 gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
399 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
401 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
402 TYPE_REFERENCE_TYPE (type
) = ntype
;
404 /* Update the length of all the other variants of this type. */
405 chain
= TYPE_CHAIN (ntype
);
406 while (chain
!= ntype
)
408 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
409 chain
= TYPE_CHAIN (chain
);
415 /* Same as above, but caller doesn't care about memory allocation
419 lookup_reference_type (struct type
*type
)
421 return make_reference_type (type
, (struct type
**) 0);
424 /* Lookup a function type that returns type TYPE. TYPEPTR, if
425 nonzero, points to a pointer to memory where the function type
426 should be stored. If *TYPEPTR is zero, update it to point to the
427 function type we return. We allocate new memory if needed. */
430 make_function_type (struct type
*type
, struct type
**typeptr
)
432 struct type
*ntype
; /* New type */
434 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
436 ntype
= alloc_type_copy (type
);
440 else /* We have storage, but need to reset it. */
446 TYPE_TARGET_TYPE (ntype
) = type
;
448 TYPE_LENGTH (ntype
) = 1;
449 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
451 INIT_FUNC_SPECIFIC (ntype
);
457 /* Given a type TYPE, return a type of functions that return that type.
458 May need to construct such a type if this is the first use. */
461 lookup_function_type (struct type
*type
)
463 return make_function_type (type
, (struct type
**) 0);
466 /* Identify address space identifier by name --
467 return the integer flag defined in gdbtypes.h. */
469 address_space_name_to_int (struct gdbarch
*gdbarch
, char *space_identifier
)
473 /* Check for known address space delimiters. */
474 if (!strcmp (space_identifier
, "code"))
475 return TYPE_INSTANCE_FLAG_CODE_SPACE
;
476 else if (!strcmp (space_identifier
, "data"))
477 return TYPE_INSTANCE_FLAG_DATA_SPACE
;
478 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
479 && gdbarch_address_class_name_to_type_flags (gdbarch
,
484 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
487 /* Identify address space identifier by integer flag as defined in
488 gdbtypes.h -- return the string version of the adress space name. */
491 address_space_int_to_name (struct gdbarch
*gdbarch
, int space_flag
)
493 if (space_flag
& TYPE_INSTANCE_FLAG_CODE_SPACE
)
495 else if (space_flag
& TYPE_INSTANCE_FLAG_DATA_SPACE
)
497 else if ((space_flag
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
498 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
499 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
504 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
506 If STORAGE is non-NULL, create the new type instance there.
507 STORAGE must be in the same obstack as TYPE. */
510 make_qualified_type (struct type
*type
, int new_flags
,
511 struct type
*storage
)
518 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
520 ntype
= TYPE_CHAIN (ntype
);
522 while (ntype
!= type
);
524 /* Create a new type instance. */
526 ntype
= alloc_type_instance (type
);
529 /* If STORAGE was provided, it had better be in the same objfile
530 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
531 if one objfile is freed and the other kept, we'd have
532 dangling pointers. */
533 gdb_assert (TYPE_OBJFILE (type
) == TYPE_OBJFILE (storage
));
536 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
537 TYPE_CHAIN (ntype
) = ntype
;
540 /* Pointers or references to the original type are not relevant to
542 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
543 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
545 /* Chain the new qualified type to the old type. */
546 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
547 TYPE_CHAIN (type
) = ntype
;
549 /* Now set the instance flags and return the new type. */
550 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
552 /* Set length of new type to that of the original type. */
553 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
558 /* Make an address-space-delimited variant of a type -- a type that
559 is identical to the one supplied except that it has an address
560 space attribute attached to it (such as "code" or "data").
562 The space attributes "code" and "data" are for Harvard
563 architectures. The address space attributes are for architectures
564 which have alternately sized pointers or pointers with alternate
568 make_type_with_address_space (struct type
*type
, int space_flag
)
570 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
571 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
572 | TYPE_INSTANCE_FLAG_DATA_SPACE
573 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
))
576 return make_qualified_type (type
, new_flags
, NULL
);
579 /* Make a "c-v" variant of a type -- a type that is identical to the
580 one supplied except that it may have const or volatile attributes
581 CNST is a flag for setting the const attribute
582 VOLTL is a flag for setting the volatile attribute
583 TYPE is the base type whose variant we are creating.
585 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
586 storage to hold the new qualified type; *TYPEPTR and TYPE must be
587 in the same objfile. Otherwise, allocate fresh memory for the new
588 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
589 new type we construct. */
591 make_cv_type (int cnst
, int voltl
,
593 struct type
**typeptr
)
595 struct type
*ntype
; /* New type */
597 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
598 & ~(TYPE_INSTANCE_FLAG_CONST
599 | TYPE_INSTANCE_FLAG_VOLATILE
));
602 new_flags
|= TYPE_INSTANCE_FLAG_CONST
;
605 new_flags
|= TYPE_INSTANCE_FLAG_VOLATILE
;
607 if (typeptr
&& *typeptr
!= NULL
)
609 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
610 a C-V variant chain that threads across objfiles: if one
611 objfile gets freed, then the other has a broken C-V chain.
613 This code used to try to copy over the main type from TYPE to
614 *TYPEPTR if they were in different objfiles, but that's
615 wrong, too: TYPE may have a field list or member function
616 lists, which refer to types of their own, etc. etc. The
617 whole shebang would need to be copied over recursively; you
618 can't have inter-objfile pointers. The only thing to do is
619 to leave stub types as stub types, and look them up afresh by
620 name each time you encounter them. */
621 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
));
624 ntype
= make_qualified_type (type
, new_flags
,
625 typeptr
? *typeptr
: NULL
);
633 /* Replace the contents of ntype with the type *type. This changes the
634 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
635 the changes are propogated to all types in the TYPE_CHAIN.
637 In order to build recursive types, it's inevitable that we'll need
638 to update types in place --- but this sort of indiscriminate
639 smashing is ugly, and needs to be replaced with something more
640 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
641 clear if more steps are needed. */
643 replace_type (struct type
*ntype
, struct type
*type
)
647 /* These two types had better be in the same objfile. Otherwise,
648 the assignment of one type's main type structure to the other
649 will produce a type with references to objects (names; field
650 lists; etc.) allocated on an objfile other than its own. */
651 gdb_assert (TYPE_OBJFILE (ntype
) == TYPE_OBJFILE (ntype
));
653 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
655 /* The type length is not a part of the main type. Update it for
656 each type on the variant chain. */
660 /* Assert that this element of the chain has no address-class bits
661 set in its flags. Such type variants might have type lengths
662 which are supposed to be different from the non-address-class
663 variants. This assertion shouldn't ever be triggered because
664 symbol readers which do construct address-class variants don't
665 call replace_type(). */
666 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
668 TYPE_LENGTH (chain
) = TYPE_LENGTH (type
);
669 chain
= TYPE_CHAIN (chain
);
671 while (ntype
!= chain
);
673 /* Assert that the two types have equivalent instance qualifiers.
674 This should be true for at least all of our debug readers. */
675 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
678 /* Implement direct support for MEMBER_TYPE in GNU C++.
679 May need to construct such a type if this is the first use.
680 The TYPE is the type of the member. The DOMAIN is the type
681 of the aggregate that the member belongs to. */
684 lookup_memberptr_type (struct type
*type
, struct type
*domain
)
688 mtype
= alloc_type_copy (type
);
689 smash_to_memberptr_type (mtype
, domain
, type
);
693 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
696 lookup_methodptr_type (struct type
*to_type
)
700 mtype
= alloc_type_copy (to_type
);
701 smash_to_methodptr_type (mtype
, to_type
);
705 /* Allocate a stub method whose return type is TYPE. This apparently
706 happens for speed of symbol reading, since parsing out the
707 arguments to the method is cpu-intensive, the way we are doing it.
708 So, we will fill in arguments later. This always returns a fresh
712 allocate_stub_method (struct type
*type
)
716 mtype
= alloc_type_copy (type
);
717 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
718 TYPE_LENGTH (mtype
) = 1;
719 TYPE_STUB (mtype
) = 1;
720 TYPE_TARGET_TYPE (mtype
) = type
;
721 /* _DOMAIN_TYPE (mtype) = unknown yet */
725 /* Create a range type using either a blank type supplied in
726 RESULT_TYPE, or creating a new type, inheriting the objfile from
729 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
730 to HIGH_BOUND, inclusive.
732 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
733 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
736 create_range_type (struct type
*result_type
, struct type
*index_type
,
737 LONGEST low_bound
, LONGEST high_bound
)
739 if (result_type
== NULL
)
740 result_type
= alloc_type_copy (index_type
);
741 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
742 TYPE_TARGET_TYPE (result_type
) = index_type
;
743 if (TYPE_STUB (index_type
))
744 TYPE_TARGET_STUB (result_type
) = 1;
746 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
747 TYPE_RANGE_DATA (result_type
) = (struct range_bounds
*)
748 TYPE_ZALLOC (result_type
, sizeof (struct range_bounds
));
749 TYPE_LOW_BOUND (result_type
) = low_bound
;
750 TYPE_HIGH_BOUND (result_type
) = high_bound
;
753 TYPE_UNSIGNED (result_type
) = 1;
758 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
759 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
760 bounds will fit in LONGEST), or -1 otherwise. */
763 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
765 CHECK_TYPEDEF (type
);
766 switch (TYPE_CODE (type
))
768 case TYPE_CODE_RANGE
:
769 *lowp
= TYPE_LOW_BOUND (type
);
770 *highp
= TYPE_HIGH_BOUND (type
);
773 if (TYPE_NFIELDS (type
) > 0)
775 /* The enums may not be sorted by value, so search all
779 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
780 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
782 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
783 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
784 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
785 *highp
= TYPE_FIELD_BITPOS (type
, i
);
788 /* Set unsigned indicator if warranted. */
791 TYPE_UNSIGNED (type
) = 1;
805 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
807 if (!TYPE_UNSIGNED (type
))
809 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
813 /* ... fall through for unsigned ints ... */
816 /* This round-about calculation is to avoid shifting by
817 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
818 if TYPE_LENGTH (type) == sizeof (LONGEST). */
819 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
820 *highp
= (*highp
- 1) | *highp
;
827 /* Assuming TYPE is a simple, non-empty array type, compute its upper
828 and lower bound. Save the low bound into LOW_BOUND if not NULL.
829 Save the high bound into HIGH_BOUND if not NULL.
831 Return 1 if the operation was successful. Return zero otherwise,
832 in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
834 We now simply use get_discrete_bounds call to get the values
835 of the low and high bounds.
836 get_discrete_bounds can return three values:
837 1, meaning that index is a range,
838 0, meaning that index is a discrete type,
839 or -1 for failure. */
842 get_array_bounds (struct type
*type
, LONGEST
*low_bound
, LONGEST
*high_bound
)
844 struct type
*index
= TYPE_INDEX_TYPE (type
);
852 res
= get_discrete_bounds (index
, &low
, &high
);
856 /* Check if the array bounds are undefined. */
858 && ((low_bound
&& TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type
))
859 || (high_bound
&& TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))))
871 /* Create an array type using either a blank type supplied in
872 RESULT_TYPE, or creating a new type, inheriting the objfile from
875 Elements will be of type ELEMENT_TYPE, the indices will be of type
878 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
879 sure it is TYPE_CODE_UNDEF before we bash it into an array
883 create_array_type (struct type
*result_type
,
884 struct type
*element_type
,
885 struct type
*range_type
)
887 LONGEST low_bound
, high_bound
;
889 if (result_type
== NULL
)
890 result_type
= alloc_type_copy (range_type
);
892 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
893 TYPE_TARGET_TYPE (result_type
) = element_type
;
894 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
895 low_bound
= high_bound
= 0;
896 CHECK_TYPEDEF (element_type
);
897 /* Be careful when setting the array length. Ada arrays can be
898 empty arrays with the high_bound being smaller than the low_bound.
899 In such cases, the array length should be zero. */
900 if (high_bound
< low_bound
)
901 TYPE_LENGTH (result_type
) = 0;
903 TYPE_LENGTH (result_type
) =
904 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
905 TYPE_NFIELDS (result_type
) = 1;
906 TYPE_FIELDS (result_type
) =
907 (struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
));
908 TYPE_INDEX_TYPE (result_type
) = range_type
;
909 TYPE_VPTR_FIELDNO (result_type
) = -1;
911 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays. */
912 if (TYPE_LENGTH (result_type
) == 0)
913 TYPE_TARGET_STUB (result_type
) = 1;
919 lookup_array_range_type (struct type
*element_type
,
920 int low_bound
, int high_bound
)
922 struct gdbarch
*gdbarch
= get_type_arch (element_type
);
923 struct type
*index_type
= builtin_type (gdbarch
)->builtin_int
;
924 struct type
*range_type
925 = create_range_type (NULL
, index_type
, low_bound
, high_bound
);
927 return create_array_type (NULL
, element_type
, range_type
);
930 /* Create a string type using either a blank type supplied in
931 RESULT_TYPE, or creating a new type. String types are similar
932 enough to array of char types that we can use create_array_type to
933 build the basic type and then bash it into a string type.
935 For fixed length strings, the range type contains 0 as the lower
936 bound and the length of the string minus one as the upper bound.
938 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
939 sure it is TYPE_CODE_UNDEF before we bash it into a string
943 create_string_type (struct type
*result_type
,
944 struct type
*string_char_type
,
945 struct type
*range_type
)
947 result_type
= create_array_type (result_type
,
950 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
955 lookup_string_range_type (struct type
*string_char_type
,
956 int low_bound
, int high_bound
)
958 struct type
*result_type
;
960 result_type
= lookup_array_range_type (string_char_type
,
961 low_bound
, high_bound
);
962 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
967 create_set_type (struct type
*result_type
, struct type
*domain_type
)
969 if (result_type
== NULL
)
970 result_type
= alloc_type_copy (domain_type
);
972 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
973 TYPE_NFIELDS (result_type
) = 1;
974 TYPE_FIELDS (result_type
) = TYPE_ZALLOC (result_type
, sizeof (struct field
));
976 if (!TYPE_STUB (domain_type
))
978 LONGEST low_bound
, high_bound
, bit_length
;
980 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
981 low_bound
= high_bound
= 0;
982 bit_length
= high_bound
- low_bound
+ 1;
983 TYPE_LENGTH (result_type
)
984 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
986 TYPE_UNSIGNED (result_type
) = 1;
988 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
993 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
994 and any array types nested inside it. */
997 make_vector_type (struct type
*array_type
)
999 struct type
*inner_array
, *elt_type
;
1002 /* Find the innermost array type, in case the array is
1003 multi-dimensional. */
1004 inner_array
= array_type
;
1005 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
1006 inner_array
= TYPE_TARGET_TYPE (inner_array
);
1008 elt_type
= TYPE_TARGET_TYPE (inner_array
);
1009 if (TYPE_CODE (elt_type
) == TYPE_CODE_INT
)
1011 flags
= TYPE_INSTANCE_FLAGS (elt_type
) | TYPE_INSTANCE_FLAG_NOTTEXT
;
1012 elt_type
= make_qualified_type (elt_type
, flags
, NULL
);
1013 TYPE_TARGET_TYPE (inner_array
) = elt_type
;
1016 TYPE_VECTOR (array_type
) = 1;
1020 init_vector_type (struct type
*elt_type
, int n
)
1022 struct type
*array_type
;
1024 array_type
= lookup_array_range_type (elt_type
, 0, n
- 1);
1025 make_vector_type (array_type
);
1029 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
1030 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1031 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1032 TYPE doesn't include the offset (that's the value of the MEMBER
1033 itself), but does include the structure type into which it points
1036 When "smashing" the type, we preserve the objfile that the old type
1037 pointed to, since we aren't changing where the type is actually
1041 smash_to_memberptr_type (struct type
*type
, struct type
*domain
,
1042 struct type
*to_type
)
1045 TYPE_TARGET_TYPE (type
) = to_type
;
1046 TYPE_DOMAIN_TYPE (type
) = domain
;
1047 /* Assume that a data member pointer is the same size as a normal
1050 = gdbarch_ptr_bit (get_type_arch (to_type
)) / TARGET_CHAR_BIT
;
1051 TYPE_CODE (type
) = TYPE_CODE_MEMBERPTR
;
1054 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1056 When "smashing" the type, we preserve the objfile that the old type
1057 pointed to, since we aren't changing where the type is actually
1061 smash_to_methodptr_type (struct type
*type
, struct type
*to_type
)
1064 TYPE_TARGET_TYPE (type
) = to_type
;
1065 TYPE_DOMAIN_TYPE (type
) = TYPE_DOMAIN_TYPE (to_type
);
1066 TYPE_LENGTH (type
) = cplus_method_ptr_size (to_type
);
1067 TYPE_CODE (type
) = TYPE_CODE_METHODPTR
;
1070 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
1071 METHOD just means `function that gets an extra "this" argument'.
1073 When "smashing" the type, we preserve the objfile that the old type
1074 pointed to, since we aren't changing where the type is actually
1078 smash_to_method_type (struct type
*type
, struct type
*domain
,
1079 struct type
*to_type
, struct field
*args
,
1080 int nargs
, int varargs
)
1083 TYPE_TARGET_TYPE (type
) = to_type
;
1084 TYPE_DOMAIN_TYPE (type
) = domain
;
1085 TYPE_FIELDS (type
) = args
;
1086 TYPE_NFIELDS (type
) = nargs
;
1088 TYPE_VARARGS (type
) = 1;
1089 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1090 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
1093 /* Return a typename for a struct/union/enum type without "struct ",
1094 "union ", or "enum ". If the type has a NULL name, return NULL. */
1097 type_name_no_tag (const struct type
*type
)
1099 if (TYPE_TAG_NAME (type
) != NULL
)
1100 return TYPE_TAG_NAME (type
);
1102 /* Is there code which expects this to return the name if there is
1103 no tag name? My guess is that this is mainly used for C++ in
1104 cases where the two will always be the same. */
1105 return TYPE_NAME (type
);
1108 /* A wrapper of type_name_no_tag which calls error if the type is anonymous.
1109 Since GCC PR debug/47510 DWARF provides associated information to detect the
1110 anonymous class linkage name from its typedef.
1112 Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
1116 type_name_no_tag_or_error (struct type
*type
)
1118 struct type
*saved_type
= type
;
1120 struct objfile
*objfile
;
1122 CHECK_TYPEDEF (type
);
1124 name
= type_name_no_tag (type
);
1128 name
= type_name_no_tag (saved_type
);
1129 objfile
= TYPE_OBJFILE (saved_type
);
1130 error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
1131 name
? name
: "<anonymous>", objfile
? objfile
->name
: "<arch>");
1134 /* Lookup a typedef or primitive type named NAME, visible in lexical
1135 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1136 suitably defined. */
1139 lookup_typename (const struct language_defn
*language
,
1140 struct gdbarch
*gdbarch
, const char *name
,
1141 const struct block
*block
, int noerr
)
1146 sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, 0);
1147 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1149 tmp
= language_lookup_primitive_type_by_name (language
, gdbarch
, name
);
1154 else if (!tmp
&& noerr
)
1160 error (_("No type named %s."), name
);
1163 return (SYMBOL_TYPE (sym
));
1167 lookup_unsigned_typename (const struct language_defn
*language
,
1168 struct gdbarch
*gdbarch
, char *name
)
1170 char *uns
= alloca (strlen (name
) + 10);
1172 strcpy (uns
, "unsigned ");
1173 strcpy (uns
+ 9, name
);
1174 return lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 0);
1178 lookup_signed_typename (const struct language_defn
*language
,
1179 struct gdbarch
*gdbarch
, char *name
)
1182 char *uns
= alloca (strlen (name
) + 8);
1184 strcpy (uns
, "signed ");
1185 strcpy (uns
+ 7, name
);
1186 t
= lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 1);
1187 /* If we don't find "signed FOO" just try again with plain "FOO". */
1190 return lookup_typename (language
, gdbarch
, name
, (struct block
*) NULL
, 0);
1193 /* Lookup a structure type named "struct NAME",
1194 visible in lexical block BLOCK. */
1197 lookup_struct (const char *name
, struct block
*block
)
1201 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1205 error (_("No struct type named %s."), name
);
1207 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1209 error (_("This context has class, union or enum %s, not a struct."),
1212 return (SYMBOL_TYPE (sym
));
1215 /* Lookup a union type named "union NAME",
1216 visible in lexical block BLOCK. */
1219 lookup_union (const char *name
, struct block
*block
)
1224 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1227 error (_("No union type named %s."), name
);
1229 t
= SYMBOL_TYPE (sym
);
1231 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1234 /* If we get here, it's not a union. */
1235 error (_("This context has class, struct or enum %s, not a union."),
1240 /* Lookup an enum type named "enum NAME",
1241 visible in lexical block BLOCK. */
1244 lookup_enum (const char *name
, struct block
*block
)
1248 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1251 error (_("No enum type named %s."), name
);
1253 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1255 error (_("This context has class, struct or union %s, not an enum."),
1258 return (SYMBOL_TYPE (sym
));
1261 /* Lookup a template type named "template NAME<TYPE>",
1262 visible in lexical block BLOCK. */
1265 lookup_template_type (char *name
, struct type
*type
,
1266 struct block
*block
)
1269 char *nam
= (char *)
1270 alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1274 strcat (nam
, TYPE_NAME (type
));
1275 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1277 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0);
1281 error (_("No template type named %s."), name
);
1283 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1285 error (_("This context has class, union or enum %s, not a struct."),
1288 return (SYMBOL_TYPE (sym
));
1291 /* Given a type TYPE, lookup the type of the component of type named
1294 TYPE can be either a struct or union, or a pointer or reference to
1295 a struct or union. If it is a pointer or reference, its target
1296 type is automatically used. Thus '.' and '->' are interchangable,
1297 as specified for the definitions of the expression element types
1298 STRUCTOP_STRUCT and STRUCTOP_PTR.
1300 If NOERR is nonzero, return zero if NAME is not suitably defined.
1301 If NAME is the name of a baseclass type, return that type. */
1304 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
1311 CHECK_TYPEDEF (type
);
1312 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1313 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1315 type
= TYPE_TARGET_TYPE (type
);
1318 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1319 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1321 typename
= type_to_string (type
);
1322 make_cleanup (xfree
, typename
);
1323 error (_("Type %s is not a structure or union type."), typename
);
1327 /* FIXME: This change put in by Michael seems incorrect for the case
1328 where the structure tag name is the same as the member name.
1329 I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
1330 foo; } bell;" Disabled by fnf. */
1334 typename
= type_name_no_tag (type
);
1335 if (typename
!= NULL
&& strcmp (typename
, name
) == 0)
1340 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1342 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1344 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1346 return TYPE_FIELD_TYPE (type
, i
);
1348 else if (!t_field_name
|| *t_field_name
== '\0')
1350 struct type
*subtype
1351 = lookup_struct_elt_type (TYPE_FIELD_TYPE (type
, i
), name
, 1);
1353 if (subtype
!= NULL
)
1358 /* OK, it's not in this class. Recursively check the baseclasses. */
1359 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1363 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, 1);
1375 typename
= type_to_string (type
);
1376 make_cleanup (xfree
, typename
);
1377 error (_("Type %s has no component named %s."), typename
, name
);
1380 /* Lookup the vptr basetype/fieldno values for TYPE.
1381 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1382 vptr_fieldno. Also, if found and basetype is from the same objfile,
1384 If not found, return -1 and ignore BASETYPEP.
1385 Callers should be aware that in some cases (for example,
1386 the type or one of its baseclasses is a stub type and we are
1387 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1388 this function will not be able to find the
1389 virtual function table pointer, and vptr_fieldno will remain -1 and
1390 vptr_basetype will remain NULL or incomplete. */
1393 get_vptr_fieldno (struct type
*type
, struct type
**basetypep
)
1395 CHECK_TYPEDEF (type
);
1397 if (TYPE_VPTR_FIELDNO (type
) < 0)
1401 /* We must start at zero in case the first (and only) baseclass
1402 is virtual (and hence we cannot share the table pointer). */
1403 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1405 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1407 struct type
*basetype
;
1409 fieldno
= get_vptr_fieldno (baseclass
, &basetype
);
1412 /* If the type comes from a different objfile we can't cache
1413 it, it may have a different lifetime. PR 2384 */
1414 if (TYPE_OBJFILE (type
) == TYPE_OBJFILE (basetype
))
1416 TYPE_VPTR_FIELDNO (type
) = fieldno
;
1417 TYPE_VPTR_BASETYPE (type
) = basetype
;
1420 *basetypep
= basetype
;
1431 *basetypep
= TYPE_VPTR_BASETYPE (type
);
1432 return TYPE_VPTR_FIELDNO (type
);
1437 stub_noname_complaint (void)
1439 complaint (&symfile_complaints
, _("stub type has NULL name"));
1442 /* Find the real type of TYPE. This function returns the real type,
1443 after removing all layers of typedefs, and completing opaque or stub
1444 types. Completion changes the TYPE argument, but stripping of
1447 Instance flags (e.g. const/volatile) are preserved as typedefs are
1448 stripped. If necessary a new qualified form of the underlying type
1451 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
1452 not been computed and we're either in the middle of reading symbols, or
1453 there was no name for the typedef in the debug info.
1455 NOTE: Lookup of opaque types can throw errors for invalid symbol files.
1456 QUITs in the symbol reading code can also throw.
1457 Thus this function can throw an exception.
1459 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
1462 If this is a stubbed struct (i.e. declared as struct foo *), see if
1463 we can find a full definition in some other file. If so, copy this
1464 definition, so we can use it in future. There used to be a comment
1465 (but not any code) that if we don't find a full definition, we'd
1466 set a flag so we don't spend time in the future checking the same
1467 type. That would be a mistake, though--we might load in more
1468 symbols which contain a full definition for the type. */
1471 check_typedef (struct type
*type
)
1473 struct type
*orig_type
= type
;
1474 /* While we're removing typedefs, we don't want to lose qualifiers.
1475 E.g., const/volatile. */
1476 int instance_flags
= TYPE_INSTANCE_FLAGS (type
);
1480 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1482 if (!TYPE_TARGET_TYPE (type
))
1487 /* It is dangerous to call lookup_symbol if we are currently
1488 reading a symtab. Infinite recursion is one danger. */
1489 if (currently_reading_symtab
)
1490 return make_qualified_type (type
, instance_flags
, NULL
);
1492 name
= type_name_no_tag (type
);
1493 /* FIXME: shouldn't we separately check the TYPE_NAME and
1494 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1495 VAR_DOMAIN as appropriate? (this code was written before
1496 TYPE_NAME and TYPE_TAG_NAME were separate). */
1499 stub_noname_complaint ();
1500 return make_qualified_type (type
, instance_flags
, NULL
);
1502 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1504 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1505 else /* TYPE_CODE_UNDEF */
1506 TYPE_TARGET_TYPE (type
) = alloc_type_arch (get_type_arch (type
));
1508 type
= TYPE_TARGET_TYPE (type
);
1510 /* Preserve the instance flags as we traverse down the typedef chain.
1512 Handling address spaces/classes is nasty, what do we do if there's a
1514 E.g., what if an outer typedef marks the type as class_1 and an inner
1515 typedef marks the type as class_2?
1516 This is the wrong place to do such error checking. We leave it to
1517 the code that created the typedef in the first place to flag the
1518 error. We just pick the outer address space (akin to letting the
1519 outer cast in a chain of casting win), instead of assuming
1520 "it can't happen". */
1522 const int ALL_SPACES
= (TYPE_INSTANCE_FLAG_CODE_SPACE
1523 | TYPE_INSTANCE_FLAG_DATA_SPACE
);
1524 const int ALL_CLASSES
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
;
1525 int new_instance_flags
= TYPE_INSTANCE_FLAGS (type
);
1527 /* Treat code vs data spaces and address classes separately. */
1528 if ((instance_flags
& ALL_SPACES
) != 0)
1529 new_instance_flags
&= ~ALL_SPACES
;
1530 if ((instance_flags
& ALL_CLASSES
) != 0)
1531 new_instance_flags
&= ~ALL_CLASSES
;
1533 instance_flags
|= new_instance_flags
;
1537 /* If this is a struct/class/union with no fields, then check
1538 whether a full definition exists somewhere else. This is for
1539 systems where a type definition with no fields is issued for such
1540 types, instead of identifying them as stub types in the first
1543 if (TYPE_IS_OPAQUE (type
)
1544 && opaque_type_resolution
1545 && !currently_reading_symtab
)
1547 char *name
= type_name_no_tag (type
);
1548 struct type
*newtype
;
1552 stub_noname_complaint ();
1553 return make_qualified_type (type
, instance_flags
, NULL
);
1555 newtype
= lookup_transparent_type (name
);
1559 /* If the resolved type and the stub are in the same
1560 objfile, then replace the stub type with the real deal.
1561 But if they're in separate objfiles, leave the stub
1562 alone; we'll just look up the transparent type every time
1563 we call check_typedef. We can't create pointers between
1564 types allocated to different objfiles, since they may
1565 have different lifetimes. Trying to copy NEWTYPE over to
1566 TYPE's objfile is pointless, too, since you'll have to
1567 move over any other types NEWTYPE refers to, which could
1568 be an unbounded amount of stuff. */
1569 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
1570 type
= make_qualified_type (newtype
,
1571 TYPE_INSTANCE_FLAGS (type
),
1577 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1579 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1581 char *name
= type_name_no_tag (type
);
1582 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1583 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1584 as appropriate? (this code was written before TYPE_NAME and
1585 TYPE_TAG_NAME were separate). */
1590 stub_noname_complaint ();
1591 return make_qualified_type (type
, instance_flags
, NULL
);
1593 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1596 /* Same as above for opaque types, we can replace the stub
1597 with the complete type only if they are in the same
1599 if (TYPE_OBJFILE (SYMBOL_TYPE(sym
)) == TYPE_OBJFILE (type
))
1600 type
= make_qualified_type (SYMBOL_TYPE (sym
),
1601 TYPE_INSTANCE_FLAGS (type
),
1604 type
= SYMBOL_TYPE (sym
);
1608 if (TYPE_TARGET_STUB (type
))
1610 struct type
*range_type
;
1611 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1613 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1615 /* Nothing we can do. */
1617 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1618 && TYPE_NFIELDS (type
) == 1
1619 && (TYPE_CODE (range_type
= TYPE_INDEX_TYPE (type
))
1620 == TYPE_CODE_RANGE
))
1622 /* Now recompute the length of the array type, based on its
1623 number of elements and the target type's length.
1624 Watch out for Ada null Ada arrays where the high bound
1625 is smaller than the low bound. */
1626 const LONGEST low_bound
= TYPE_LOW_BOUND (range_type
);
1627 const LONGEST high_bound
= TYPE_HIGH_BOUND (range_type
);
1630 if (high_bound
< low_bound
)
1634 /* For now, we conservatively take the array length to be 0
1635 if its length exceeds UINT_MAX. The code below assumes
1636 that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
1637 which is technically not guaranteed by C, but is usually true
1638 (because it would be true if x were unsigned with its
1639 high-order bit on). It uses the fact that
1640 high_bound-low_bound is always representable in
1641 ULONGEST and that if high_bound-low_bound+1 overflows,
1642 it overflows to 0. We must change these tests if we
1643 decide to increase the representation of TYPE_LENGTH
1644 from unsigned int to ULONGEST. */
1645 ULONGEST ulow
= low_bound
, uhigh
= high_bound
;
1646 ULONGEST tlen
= TYPE_LENGTH (target_type
);
1648 len
= tlen
* (uhigh
- ulow
+ 1);
1649 if (tlen
== 0 || (len
/ tlen
- 1 + ulow
) != uhigh
1653 TYPE_LENGTH (type
) = len
;
1654 TYPE_TARGET_STUB (type
) = 0;
1656 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1658 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1659 TYPE_TARGET_STUB (type
) = 0;
1663 type
= make_qualified_type (type
, instance_flags
, NULL
);
1665 /* Cache TYPE_LENGTH for future use. */
1666 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1671 /* Parse a type expression in the string [P..P+LENGTH). If an error
1672 occurs, silently return a void type. */
1674 static struct type
*
1675 safe_parse_type (struct gdbarch
*gdbarch
, char *p
, int length
)
1677 struct ui_file
*saved_gdb_stderr
;
1680 /* Suppress error messages. */
1681 saved_gdb_stderr
= gdb_stderr
;
1682 gdb_stderr
= ui_file_new ();
1684 /* Call parse_and_eval_type() without fear of longjmp()s. */
1685 if (!gdb_parse_and_eval_type (p
, length
, &type
))
1686 type
= builtin_type (gdbarch
)->builtin_void
;
1688 /* Stop suppressing error messages. */
1689 ui_file_delete (gdb_stderr
);
1690 gdb_stderr
= saved_gdb_stderr
;
1695 /* Ugly hack to convert method stubs into method types.
1697 He ain't kiddin'. This demangles the name of the method into a
1698 string including argument types, parses out each argument type,
1699 generates a string casting a zero to that type, evaluates the
1700 string, and stuffs the resulting type into an argtype vector!!!
1701 Then it knows the type of the whole function (including argument
1702 types for overloading), which info used to be in the stab's but was
1703 removed to hack back the space required for them. */
1706 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1708 struct gdbarch
*gdbarch
= get_type_arch (type
);
1710 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1711 char *demangled_name
= cplus_demangle (mangled_name
,
1712 DMGL_PARAMS
| DMGL_ANSI
);
1713 char *argtypetext
, *p
;
1714 int depth
= 0, argcount
= 1;
1715 struct field
*argtypes
;
1718 /* Make sure we got back a function string that we can use. */
1720 p
= strchr (demangled_name
, '(');
1724 if (demangled_name
== NULL
|| p
== NULL
)
1725 error (_("Internal: Cannot demangle mangled name `%s'."),
1728 /* Now, read in the parameters that define this type. */
1733 if (*p
== '(' || *p
== '<')
1737 else if (*p
== ')' || *p
== '>')
1741 else if (*p
== ',' && depth
== 0)
1749 /* If we read one argument and it was ``void'', don't count it. */
1750 if (strncmp (argtypetext
, "(void)", 6) == 0)
1753 /* We need one extra slot, for the THIS pointer. */
1755 argtypes
= (struct field
*)
1756 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
1759 /* Add THIS pointer for non-static methods. */
1760 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1761 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
1765 argtypes
[0].type
= lookup_pointer_type (type
);
1769 if (*p
!= ')') /* () means no args, skip while. */
1774 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1776 /* Avoid parsing of ellipsis, they will be handled below.
1777 Also avoid ``void'' as above. */
1778 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
1779 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
1781 argtypes
[argcount
].type
=
1782 safe_parse_type (gdbarch
, argtypetext
, p
- argtypetext
);
1785 argtypetext
= p
+ 1;
1788 if (*p
== '(' || *p
== '<')
1792 else if (*p
== ')' || *p
== '>')
1801 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1803 /* Now update the old "stub" type into a real type. */
1804 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1805 TYPE_DOMAIN_TYPE (mtype
) = type
;
1806 TYPE_FIELDS (mtype
) = argtypes
;
1807 TYPE_NFIELDS (mtype
) = argcount
;
1808 TYPE_STUB (mtype
) = 0;
1809 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1811 TYPE_VARARGS (mtype
) = 1;
1813 xfree (demangled_name
);
1816 /* This is the external interface to check_stub_method, above. This
1817 function unstubs all of the signatures for TYPE's METHOD_ID method
1818 name. After calling this function TYPE_FN_FIELD_STUB will be
1819 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1822 This function unfortunately can not die until stabs do. */
1825 check_stub_method_group (struct type
*type
, int method_id
)
1827 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
1828 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1829 int j
, found_stub
= 0;
1831 for (j
= 0; j
< len
; j
++)
1832 if (TYPE_FN_FIELD_STUB (f
, j
))
1835 check_stub_method (type
, method_id
, j
);
1838 /* GNU v3 methods with incorrect names were corrected when we read
1839 in type information, because it was cheaper to do it then. The
1840 only GNU v2 methods with incorrect method names are operators and
1841 destructors; destructors were also corrected when we read in type
1844 Therefore the only thing we need to handle here are v2 operator
1846 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
1849 char dem_opname
[256];
1851 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1853 dem_opname
, DMGL_ANSI
);
1855 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1859 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
1863 /* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */
1864 const struct cplus_struct_type cplus_struct_default
= { };
1867 allocate_cplus_struct_type (struct type
*type
)
1869 if (HAVE_CPLUS_STRUCT (type
))
1870 /* Structure was already allocated. Nothing more to do. */
1873 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_CPLUS_STUFF
;
1874 TYPE_RAW_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1875 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1876 *(TYPE_RAW_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1879 const struct gnat_aux_type gnat_aux_default
=
1882 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
1883 and allocate the associated gnat-specific data. The gnat-specific
1884 data is also initialized to gnat_aux_default. */
1886 allocate_gnat_aux_type (struct type
*type
)
1888 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_GNAT_STUFF
;
1889 TYPE_GNAT_SPECIFIC (type
) = (struct gnat_aux_type
*)
1890 TYPE_ALLOC (type
, sizeof (struct gnat_aux_type
));
1891 *(TYPE_GNAT_SPECIFIC (type
)) = gnat_aux_default
;
1895 /* Helper function to initialize the standard scalar types.
1897 If NAME is non-NULL, then we make a copy of the string pointed
1898 to by name in the objfile_obstack for that objfile, and initialize
1899 the type name to that copy. There are places (mipsread.c in particular),
1900 where init_type is called with a NULL value for NAME). */
1903 init_type (enum type_code code
, int length
, int flags
,
1904 char *name
, struct objfile
*objfile
)
1908 type
= alloc_type (objfile
);
1909 TYPE_CODE (type
) = code
;
1910 TYPE_LENGTH (type
) = length
;
1912 gdb_assert (!(flags
& (TYPE_FLAG_MIN
- 1)));
1913 if (flags
& TYPE_FLAG_UNSIGNED
)
1914 TYPE_UNSIGNED (type
) = 1;
1915 if (flags
& TYPE_FLAG_NOSIGN
)
1916 TYPE_NOSIGN (type
) = 1;
1917 if (flags
& TYPE_FLAG_STUB
)
1918 TYPE_STUB (type
) = 1;
1919 if (flags
& TYPE_FLAG_TARGET_STUB
)
1920 TYPE_TARGET_STUB (type
) = 1;
1921 if (flags
& TYPE_FLAG_STATIC
)
1922 TYPE_STATIC (type
) = 1;
1923 if (flags
& TYPE_FLAG_PROTOTYPED
)
1924 TYPE_PROTOTYPED (type
) = 1;
1925 if (flags
& TYPE_FLAG_INCOMPLETE
)
1926 TYPE_INCOMPLETE (type
) = 1;
1927 if (flags
& TYPE_FLAG_VARARGS
)
1928 TYPE_VARARGS (type
) = 1;
1929 if (flags
& TYPE_FLAG_VECTOR
)
1930 TYPE_VECTOR (type
) = 1;
1931 if (flags
& TYPE_FLAG_STUB_SUPPORTED
)
1932 TYPE_STUB_SUPPORTED (type
) = 1;
1933 if (flags
& TYPE_FLAG_FIXED_INSTANCE
)
1934 TYPE_FIXED_INSTANCE (type
) = 1;
1935 if (flags
& TYPE_FLAG_GNU_IFUNC
)
1936 TYPE_GNU_IFUNC (type
) = 1;
1939 TYPE_NAME (type
) = obsavestring (name
, strlen (name
),
1940 &objfile
->objfile_obstack
);
1944 if (name
&& strcmp (name
, "char") == 0)
1945 TYPE_NOSIGN (type
) = 1;
1949 case TYPE_CODE_STRUCT
:
1950 case TYPE_CODE_UNION
:
1951 case TYPE_CODE_NAMESPACE
:
1952 INIT_CPLUS_SPECIFIC (type
);
1955 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_FLOATFORMAT
;
1957 case TYPE_CODE_FUNC
:
1958 INIT_FUNC_SPECIFIC (type
);
1965 can_dereference (struct type
*t
)
1967 /* FIXME: Should we return true for references as well as
1972 && TYPE_CODE (t
) == TYPE_CODE_PTR
1973 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1977 is_integral_type (struct type
*t
)
1982 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
1983 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
1984 || (TYPE_CODE (t
) == TYPE_CODE_FLAGS
)
1985 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
1986 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
1987 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
1990 /* Return true if TYPE is scalar. */
1993 is_scalar_type (struct type
*type
)
1995 CHECK_TYPEDEF (type
);
1997 switch (TYPE_CODE (type
))
1999 case TYPE_CODE_ARRAY
:
2000 case TYPE_CODE_STRUCT
:
2001 case TYPE_CODE_UNION
:
2003 case TYPE_CODE_STRING
:
2004 case TYPE_CODE_BITSTRING
:
2011 /* Return true if T is scalar, or a composite type which in practice has
2012 the memory layout of a scalar type. E.g., an array or struct with only
2013 one scalar element inside it, or a union with only scalar elements. */
2016 is_scalar_type_recursive (struct type
*t
)
2020 if (is_scalar_type (t
))
2022 /* Are we dealing with an array or string of known dimensions? */
2023 else if ((TYPE_CODE (t
) == TYPE_CODE_ARRAY
2024 || TYPE_CODE (t
) == TYPE_CODE_STRING
) && TYPE_NFIELDS (t
) == 1
2025 && TYPE_CODE (TYPE_INDEX_TYPE (t
)) == TYPE_CODE_RANGE
)
2027 LONGEST low_bound
, high_bound
;
2028 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (t
));
2030 get_discrete_bounds (TYPE_INDEX_TYPE (t
), &low_bound
, &high_bound
);
2032 return high_bound
== low_bound
&& is_scalar_type_recursive (elt_type
);
2034 /* Are we dealing with a struct with one element? */
2035 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
&& TYPE_NFIELDS (t
) == 1)
2036 return is_scalar_type_recursive (TYPE_FIELD_TYPE (t
, 0));
2037 else if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
2039 int i
, n
= TYPE_NFIELDS (t
);
2041 /* If all elements of the union are scalar, then the union is scalar. */
2042 for (i
= 0; i
< n
; i
++)
2043 if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t
, i
)))
2052 /* A helper function which returns true if types A and B represent the
2053 "same" class type. This is true if the types have the same main
2054 type, or the same name. */
2057 class_types_same_p (const struct type
*a
, const struct type
*b
)
2059 return (TYPE_MAIN_TYPE (a
) == TYPE_MAIN_TYPE (b
)
2060 || (TYPE_NAME (a
) && TYPE_NAME (b
)
2061 && !strcmp (TYPE_NAME (a
), TYPE_NAME (b
))));
2064 /* If BASE is an ancestor of DCLASS return the distance between them.
2065 otherwise return -1;
2069 class B: public A {};
2070 class C: public B {};
2073 distance_to_ancestor (A, A, 0) = 0
2074 distance_to_ancestor (A, B, 0) = 1
2075 distance_to_ancestor (A, C, 0) = 2
2076 distance_to_ancestor (A, D, 0) = 3
2078 If PUBLIC is 1 then only public ancestors are considered,
2079 and the function returns the distance only if BASE is a public ancestor
2083 distance_to_ancestor (A, D, 1) = -1. */
2086 distance_to_ancestor (struct type
*base
, struct type
*dclass
, int public)
2091 CHECK_TYPEDEF (base
);
2092 CHECK_TYPEDEF (dclass
);
2094 if (class_types_same_p (base
, dclass
))
2097 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2099 if (public && ! BASETYPE_VIA_PUBLIC (dclass
, i
))
2102 d
= distance_to_ancestor (base
, TYPE_BASECLASS (dclass
, i
), public);
2110 /* Check whether BASE is an ancestor or base class or DCLASS
2111 Return 1 if so, and 0 if not.
2112 Note: If BASE and DCLASS are of the same type, this function
2113 will return 1. So for some class A, is_ancestor (A, A) will
2117 is_ancestor (struct type
*base
, struct type
*dclass
)
2119 return distance_to_ancestor (base
, dclass
, 0) >= 0;
2122 /* Like is_ancestor, but only returns true when BASE is a public
2123 ancestor of DCLASS. */
2126 is_public_ancestor (struct type
*base
, struct type
*dclass
)
2128 return distance_to_ancestor (base
, dclass
, 1) >= 0;
2131 /* A helper function for is_unique_ancestor. */
2134 is_unique_ancestor_worker (struct type
*base
, struct type
*dclass
,
2136 const gdb_byte
*valaddr
, int embedded_offset
,
2137 CORE_ADDR address
, struct value
*val
)
2141 CHECK_TYPEDEF (base
);
2142 CHECK_TYPEDEF (dclass
);
2144 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
) && count
< 2; ++i
)
2149 iter
= check_typedef (TYPE_BASECLASS (dclass
, i
));
2151 this_offset
= baseclass_offset (dclass
, i
, valaddr
, embedded_offset
,
2154 if (class_types_same_p (base
, iter
))
2156 /* If this is the first subclass, set *OFFSET and set count
2157 to 1. Otherwise, if this is at the same offset as
2158 previous instances, do nothing. Otherwise, increment
2162 *offset
= this_offset
;
2165 else if (this_offset
== *offset
)
2173 count
+= is_unique_ancestor_worker (base
, iter
, offset
,
2175 embedded_offset
+ this_offset
,
2182 /* Like is_ancestor, but only returns true if BASE is a unique base
2183 class of the type of VAL. */
2186 is_unique_ancestor (struct type
*base
, struct value
*val
)
2190 return is_unique_ancestor_worker (base
, value_type (val
), &offset
,
2191 value_contents_for_printing (val
),
2192 value_embedded_offset (val
),
2193 value_address (val
), val
) == 1;
2198 /* Return the sum of the rank of A with the rank of B. */
2201 sum_ranks (struct rank a
, struct rank b
)
2204 c
.rank
= a
.rank
+ b
.rank
;
2205 c
.subrank
= a
.subrank
+ b
.subrank
;
2209 /* Compare rank A and B and return:
2211 1 if a is better than b
2212 -1 if b is better than a. */
2215 compare_ranks (struct rank a
, struct rank b
)
2217 if (a
.rank
== b
.rank
)
2219 if (a
.subrank
== b
.subrank
)
2221 if (a
.subrank
< b
.subrank
)
2223 if (a
.subrank
> b
.subrank
)
2227 if (a
.rank
< b
.rank
)
2230 /* a.rank > b.rank */
2234 /* Functions for overload resolution begin here. */
2236 /* Compare two badness vectors A and B and return the result.
2237 0 => A and B are identical
2238 1 => A and B are incomparable
2239 2 => A is better than B
2240 3 => A is worse than B */
2243 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
2247 short found_pos
= 0; /* any positives in c? */
2248 short found_neg
= 0; /* any negatives in c? */
2250 /* differing lengths => incomparable */
2251 if (a
->length
!= b
->length
)
2254 /* Subtract b from a */
2255 for (i
= 0; i
< a
->length
; i
++)
2257 tmp
= compare_ranks (b
->rank
[i
], a
->rank
[i
]);
2267 return 1; /* incomparable */
2269 return 3; /* A > B */
2275 return 2; /* A < B */
2277 return 0; /* A == B */
2281 /* Rank a function by comparing its parameter types (PARMS, length
2282 NPARMS), to the types of an argument list (ARGS, length NARGS).
2283 Return a pointer to a badness vector. This has NARGS + 1
2286 struct badness_vector
*
2287 rank_function (struct type
**parms
, int nparms
,
2288 struct value
**args
, int nargs
)
2291 struct badness_vector
*bv
;
2292 int min_len
= nparms
< nargs
? nparms
: nargs
;
2294 bv
= xmalloc (sizeof (struct badness_vector
));
2295 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank. */
2296 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
2298 /* First compare the lengths of the supplied lists.
2299 If there is a mismatch, set it to a high value. */
2301 /* pai/1997-06-03 FIXME: when we have debug info about default
2302 arguments and ellipsis parameter lists, we should consider those
2303 and rank the length-match more finely. */
2305 LENGTH_MATCH (bv
) = (nargs
!= nparms
)
2306 ? LENGTH_MISMATCH_BADNESS
2307 : EXACT_MATCH_BADNESS
;
2309 /* Now rank all the parameters of the candidate function. */
2310 for (i
= 1; i
<= min_len
; i
++)
2311 bv
->rank
[i
] = rank_one_type (parms
[i
- 1], value_type (args
[i
- 1]),
2314 /* If more arguments than parameters, add dummy entries. */
2315 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2316 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2321 /* Compare the names of two integer types, assuming that any sign
2322 qualifiers have been checked already. We do it this way because
2323 there may be an "int" in the name of one of the types. */
2326 integer_types_same_name_p (const char *first
, const char *second
)
2328 int first_p
, second_p
;
2330 /* If both are shorts, return 1; if neither is a short, keep
2332 first_p
= (strstr (first
, "short") != NULL
);
2333 second_p
= (strstr (second
, "short") != NULL
);
2334 if (first_p
&& second_p
)
2336 if (first_p
|| second_p
)
2339 /* Likewise for long. */
2340 first_p
= (strstr (first
, "long") != NULL
);
2341 second_p
= (strstr (second
, "long") != NULL
);
2342 if (first_p
&& second_p
)
2344 if (first_p
|| second_p
)
2347 /* Likewise for char. */
2348 first_p
= (strstr (first
, "char") != NULL
);
2349 second_p
= (strstr (second
, "char") != NULL
);
2350 if (first_p
&& second_p
)
2352 if (first_p
|| second_p
)
2355 /* They must both be ints. */
2359 /* Compares type A to type B returns 1 if the represent the same type
2363 types_equal (struct type
*a
, struct type
*b
)
2365 /* Identical type pointers. */
2366 /* However, this still doesn't catch all cases of same type for b
2367 and a. The reason is that builtin types are different from
2368 the same ones constructed from the object. */
2372 /* Resolve typedefs */
2373 if (TYPE_CODE (a
) == TYPE_CODE_TYPEDEF
)
2374 a
= check_typedef (a
);
2375 if (TYPE_CODE (b
) == TYPE_CODE_TYPEDEF
)
2376 b
= check_typedef (b
);
2378 /* If after resolving typedefs a and b are not of the same type
2379 code then they are not equal. */
2380 if (TYPE_CODE (a
) != TYPE_CODE (b
))
2383 /* If a and b are both pointers types or both reference types then
2384 they are equal of the same type iff the objects they refer to are
2385 of the same type. */
2386 if (TYPE_CODE (a
) == TYPE_CODE_PTR
2387 || TYPE_CODE (a
) == TYPE_CODE_REF
)
2388 return types_equal (TYPE_TARGET_TYPE (a
),
2389 TYPE_TARGET_TYPE (b
));
2391 /* Well, damnit, if the names are exactly the same, I'll say they
2392 are exactly the same. This happens when we generate method
2393 stubs. The types won't point to the same address, but they
2394 really are the same. */
2396 if (TYPE_NAME (a
) && TYPE_NAME (b
)
2397 && strcmp (TYPE_NAME (a
), TYPE_NAME (b
)) == 0)
2400 /* Check if identical after resolving typedefs. */
2407 /* Compare one type (PARM) for compatibility with another (ARG).
2408 * PARM is intended to be the parameter type of a function; and
2409 * ARG is the supplied argument's type. This function tests if
2410 * the latter can be converted to the former.
2411 * VALUE is the argument's value or NULL if none (or called recursively)
2413 * Return 0 if they are identical types;
2414 * Otherwise, return an integer which corresponds to how compatible
2415 * PARM is to ARG. The higher the return value, the worse the match.
2416 * Generally the "bad" conversions are all uniformly assigned a 100. */
2419 rank_one_type (struct type
*parm
, struct type
*arg
, struct value
*value
)
2421 struct rank rank
= {0,0};
2423 if (types_equal (parm
, arg
))
2424 return EXACT_MATCH_BADNESS
;
2426 /* Resolve typedefs */
2427 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2428 parm
= check_typedef (parm
);
2429 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2430 arg
= check_typedef (arg
);
2432 /* See through references, since we can almost make non-references
2434 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2435 return (sum_ranks (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
),
2436 REFERENCE_CONVERSION_BADNESS
));
2437 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2438 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
),
2439 REFERENCE_CONVERSION_BADNESS
));
2441 /* Debugging only. */
2442 fprintf_filtered (gdb_stderr
,
2443 "------ Arg is %s [%d], parm is %s [%d]\n",
2444 TYPE_NAME (arg
), TYPE_CODE (arg
),
2445 TYPE_NAME (parm
), TYPE_CODE (parm
));
2447 /* x -> y means arg of type x being supplied for parameter of type y. */
2449 switch (TYPE_CODE (parm
))
2452 switch (TYPE_CODE (arg
))
2456 /* Allowed pointer conversions are:
2457 (a) pointer to void-pointer conversion. */
2458 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2459 return VOID_PTR_CONVERSION_BADNESS
;
2461 /* (b) pointer to ancestor-pointer conversion. */
2462 rank
.subrank
= distance_to_ancestor (TYPE_TARGET_TYPE (parm
),
2463 TYPE_TARGET_TYPE (arg
),
2465 if (rank
.subrank
>= 0)
2466 return sum_ranks (BASE_PTR_CONVERSION_BADNESS
, rank
);
2468 return INCOMPATIBLE_TYPE_BADNESS
;
2469 case TYPE_CODE_ARRAY
:
2470 if (types_equal (TYPE_TARGET_TYPE (parm
),
2471 TYPE_TARGET_TYPE (arg
)))
2472 return EXACT_MATCH_BADNESS
;
2473 return INCOMPATIBLE_TYPE_BADNESS
;
2474 case TYPE_CODE_FUNC
:
2475 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
);
2477 if (value
!= NULL
&& TYPE_CODE (value_type (value
)) == TYPE_CODE_INT
2478 && value_as_long (value
) == 0)
2480 /* Null pointer conversion: allow it to be cast to a pointer.
2481 [4.10.1 of C++ standard draft n3290] */
2482 return NULL_POINTER_CONVERSION_BADNESS
;
2485 case TYPE_CODE_ENUM
:
2486 case TYPE_CODE_FLAGS
:
2487 case TYPE_CODE_CHAR
:
2488 case TYPE_CODE_RANGE
:
2489 case TYPE_CODE_BOOL
:
2491 return INCOMPATIBLE_TYPE_BADNESS
;
2493 case TYPE_CODE_ARRAY
:
2494 switch (TYPE_CODE (arg
))
2497 case TYPE_CODE_ARRAY
:
2498 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2499 TYPE_TARGET_TYPE (arg
), NULL
);
2501 return INCOMPATIBLE_TYPE_BADNESS
;
2503 case TYPE_CODE_FUNC
:
2504 switch (TYPE_CODE (arg
))
2506 case TYPE_CODE_PTR
: /* funcptr -> func */
2507 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
);
2509 return INCOMPATIBLE_TYPE_BADNESS
;
2512 switch (TYPE_CODE (arg
))
2515 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2517 /* Deal with signed, unsigned, and plain chars and
2518 signed and unsigned ints. */
2519 if (TYPE_NOSIGN (parm
))
2521 /* This case only for character types. */
2522 if (TYPE_NOSIGN (arg
))
2523 return EXACT_MATCH_BADNESS
; /* plain char -> plain char */
2524 else /* signed/unsigned char -> plain char */
2525 return INTEGER_CONVERSION_BADNESS
;
2527 else if (TYPE_UNSIGNED (parm
))
2529 if (TYPE_UNSIGNED (arg
))
2531 /* unsigned int -> unsigned int, or
2532 unsigned long -> unsigned long */
2533 if (integer_types_same_name_p (TYPE_NAME (parm
),
2535 return EXACT_MATCH_BADNESS
;
2536 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2538 && integer_types_same_name_p (TYPE_NAME (parm
),
2540 /* unsigned int -> unsigned long */
2541 return INTEGER_PROMOTION_BADNESS
;
2543 /* unsigned long -> unsigned int */
2544 return INTEGER_CONVERSION_BADNESS
;
2548 if (integer_types_same_name_p (TYPE_NAME (arg
),
2550 && integer_types_same_name_p (TYPE_NAME (parm
),
2552 /* signed long -> unsigned int */
2553 return INTEGER_CONVERSION_BADNESS
;
2555 /* signed int/long -> unsigned int/long */
2556 return INTEGER_CONVERSION_BADNESS
;
2559 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2561 if (integer_types_same_name_p (TYPE_NAME (parm
),
2563 return EXACT_MATCH_BADNESS
;
2564 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2566 && integer_types_same_name_p (TYPE_NAME (parm
),
2568 return INTEGER_PROMOTION_BADNESS
;
2570 return INTEGER_CONVERSION_BADNESS
;
2573 return INTEGER_CONVERSION_BADNESS
;
2575 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2576 return INTEGER_PROMOTION_BADNESS
;
2578 return INTEGER_CONVERSION_BADNESS
;
2579 case TYPE_CODE_ENUM
:
2580 case TYPE_CODE_FLAGS
:
2581 case TYPE_CODE_CHAR
:
2582 case TYPE_CODE_RANGE
:
2583 case TYPE_CODE_BOOL
:
2584 return INTEGER_PROMOTION_BADNESS
;
2586 return INT_FLOAT_CONVERSION_BADNESS
;
2588 return NS_POINTER_CONVERSION_BADNESS
;
2590 return INCOMPATIBLE_TYPE_BADNESS
;
2593 case TYPE_CODE_ENUM
:
2594 switch (TYPE_CODE (arg
))
2597 case TYPE_CODE_CHAR
:
2598 case TYPE_CODE_RANGE
:
2599 case TYPE_CODE_BOOL
:
2600 case TYPE_CODE_ENUM
:
2601 return INTEGER_CONVERSION_BADNESS
;
2603 return INT_FLOAT_CONVERSION_BADNESS
;
2605 return INCOMPATIBLE_TYPE_BADNESS
;
2608 case TYPE_CODE_CHAR
:
2609 switch (TYPE_CODE (arg
))
2611 case TYPE_CODE_RANGE
:
2612 case TYPE_CODE_BOOL
:
2613 case TYPE_CODE_ENUM
:
2614 return INTEGER_CONVERSION_BADNESS
;
2616 return INT_FLOAT_CONVERSION_BADNESS
;
2618 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2619 return INTEGER_CONVERSION_BADNESS
;
2620 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2621 return INTEGER_PROMOTION_BADNESS
;
2622 /* >>> !! else fall through !! <<< */
2623 case TYPE_CODE_CHAR
:
2624 /* Deal with signed, unsigned, and plain chars for C++ and
2625 with int cases falling through from previous case. */
2626 if (TYPE_NOSIGN (parm
))
2628 if (TYPE_NOSIGN (arg
))
2629 return EXACT_MATCH_BADNESS
;
2631 return INTEGER_CONVERSION_BADNESS
;
2633 else if (TYPE_UNSIGNED (parm
))
2635 if (TYPE_UNSIGNED (arg
))
2636 return EXACT_MATCH_BADNESS
;
2638 return INTEGER_PROMOTION_BADNESS
;
2640 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2641 return EXACT_MATCH_BADNESS
;
2643 return INTEGER_CONVERSION_BADNESS
;
2645 return INCOMPATIBLE_TYPE_BADNESS
;
2648 case TYPE_CODE_RANGE
:
2649 switch (TYPE_CODE (arg
))
2652 case TYPE_CODE_CHAR
:
2653 case TYPE_CODE_RANGE
:
2654 case TYPE_CODE_BOOL
:
2655 case TYPE_CODE_ENUM
:
2656 return INTEGER_CONVERSION_BADNESS
;
2658 return INT_FLOAT_CONVERSION_BADNESS
;
2660 return INCOMPATIBLE_TYPE_BADNESS
;
2663 case TYPE_CODE_BOOL
:
2664 switch (TYPE_CODE (arg
))
2667 case TYPE_CODE_CHAR
:
2668 case TYPE_CODE_RANGE
:
2669 case TYPE_CODE_ENUM
:
2671 return INCOMPATIBLE_TYPE_BADNESS
;
2673 return BOOL_PTR_CONVERSION_BADNESS
;
2674 case TYPE_CODE_BOOL
:
2675 return EXACT_MATCH_BADNESS
;
2677 return INCOMPATIBLE_TYPE_BADNESS
;
2681 switch (TYPE_CODE (arg
))
2684 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2685 return FLOAT_PROMOTION_BADNESS
;
2686 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2687 return EXACT_MATCH_BADNESS
;
2689 return FLOAT_CONVERSION_BADNESS
;
2691 case TYPE_CODE_BOOL
:
2692 case TYPE_CODE_ENUM
:
2693 case TYPE_CODE_RANGE
:
2694 case TYPE_CODE_CHAR
:
2695 return INT_FLOAT_CONVERSION_BADNESS
;
2697 return INCOMPATIBLE_TYPE_BADNESS
;
2700 case TYPE_CODE_COMPLEX
:
2701 switch (TYPE_CODE (arg
))
2702 { /* Strictly not needed for C++, but... */
2704 return FLOAT_PROMOTION_BADNESS
;
2705 case TYPE_CODE_COMPLEX
:
2706 return EXACT_MATCH_BADNESS
;
2708 return INCOMPATIBLE_TYPE_BADNESS
;
2711 case TYPE_CODE_STRUCT
:
2712 /* currently same as TYPE_CODE_CLASS. */
2713 switch (TYPE_CODE (arg
))
2715 case TYPE_CODE_STRUCT
:
2716 /* Check for derivation */
2717 rank
.subrank
= distance_to_ancestor (parm
, arg
, 0);
2718 if (rank
.subrank
>= 0)
2719 return sum_ranks (BASE_CONVERSION_BADNESS
, rank
);
2720 /* else fall through */
2722 return INCOMPATIBLE_TYPE_BADNESS
;
2725 case TYPE_CODE_UNION
:
2726 switch (TYPE_CODE (arg
))
2728 case TYPE_CODE_UNION
:
2730 return INCOMPATIBLE_TYPE_BADNESS
;
2733 case TYPE_CODE_MEMBERPTR
:
2734 switch (TYPE_CODE (arg
))
2737 return INCOMPATIBLE_TYPE_BADNESS
;
2740 case TYPE_CODE_METHOD
:
2741 switch (TYPE_CODE (arg
))
2745 return INCOMPATIBLE_TYPE_BADNESS
;
2749 switch (TYPE_CODE (arg
))
2753 return INCOMPATIBLE_TYPE_BADNESS
;
2758 switch (TYPE_CODE (arg
))
2762 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0),
2763 TYPE_FIELD_TYPE (arg
, 0), NULL
);
2765 return INCOMPATIBLE_TYPE_BADNESS
;
2768 case TYPE_CODE_VOID
:
2770 return INCOMPATIBLE_TYPE_BADNESS
;
2771 } /* switch (TYPE_CODE (arg)) */
2775 /* End of functions for overload resolution. */
2778 print_bit_vector (B_TYPE
*bits
, int nbits
)
2782 for (bitno
= 0; bitno
< nbits
; bitno
++)
2784 if ((bitno
% 8) == 0)
2786 puts_filtered (" ");
2788 if (B_TST (bits
, bitno
))
2789 printf_filtered (("1"));
2791 printf_filtered (("0"));
2795 /* Note the first arg should be the "this" pointer, we may not want to
2796 include it since we may get into a infinitely recursive
2800 print_arg_types (struct field
*args
, int nargs
, int spaces
)
2806 for (i
= 0; i
< nargs
; i
++)
2807 recursive_dump_type (args
[i
].type
, spaces
+ 2);
2812 field_is_static (struct field
*f
)
2814 /* "static" fields are the fields whose location is not relative
2815 to the address of the enclosing struct. It would be nice to
2816 have a dedicated flag that would be set for static fields when
2817 the type is being created. But in practice, checking the field
2818 loc_kind should give us an accurate answer. */
2819 return (FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSNAME
2820 || FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSADDR
);
2824 dump_fn_fieldlists (struct type
*type
, int spaces
)
2830 printfi_filtered (spaces
, "fn_fieldlists ");
2831 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2832 printf_filtered ("\n");
2833 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2835 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2836 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2838 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2839 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2841 printf_filtered (_(") length %d\n"),
2842 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2843 for (overload_idx
= 0;
2844 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2847 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2849 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2850 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2852 printf_filtered (")\n");
2853 printfi_filtered (spaces
+ 8, "type ");
2854 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2856 printf_filtered ("\n");
2858 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2861 printfi_filtered (spaces
+ 8, "args ");
2862 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2864 printf_filtered ("\n");
2866 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2867 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
,
2870 printfi_filtered (spaces
+ 8, "fcontext ");
2871 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2873 printf_filtered ("\n");
2875 printfi_filtered (spaces
+ 8, "is_const %d\n",
2876 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2877 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2878 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2879 printfi_filtered (spaces
+ 8, "is_private %d\n",
2880 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2881 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2882 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2883 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2884 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2885 printfi_filtered (spaces
+ 8, "voffset %u\n",
2886 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2892 print_cplus_stuff (struct type
*type
, int spaces
)
2894 printfi_filtered (spaces
, "n_baseclasses %d\n",
2895 TYPE_N_BASECLASSES (type
));
2896 printfi_filtered (spaces
, "nfn_fields %d\n",
2897 TYPE_NFN_FIELDS (type
));
2898 if (TYPE_N_BASECLASSES (type
) > 0)
2900 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2901 TYPE_N_BASECLASSES (type
));
2902 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
2904 printf_filtered (")");
2906 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2907 TYPE_N_BASECLASSES (type
));
2908 puts_filtered ("\n");
2910 if (TYPE_NFIELDS (type
) > 0)
2912 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2914 printfi_filtered (spaces
,
2915 "private_field_bits (%d bits at *",
2916 TYPE_NFIELDS (type
));
2917 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
2919 printf_filtered (")");
2920 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2921 TYPE_NFIELDS (type
));
2922 puts_filtered ("\n");
2924 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2926 printfi_filtered (spaces
,
2927 "protected_field_bits (%d bits at *",
2928 TYPE_NFIELDS (type
));
2929 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
2931 printf_filtered (")");
2932 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2933 TYPE_NFIELDS (type
));
2934 puts_filtered ("\n");
2937 if (TYPE_NFN_FIELDS (type
) > 0)
2939 dump_fn_fieldlists (type
, spaces
);
2943 /* Print the contents of the TYPE's type_specific union, assuming that
2944 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
2947 print_gnat_stuff (struct type
*type
, int spaces
)
2949 struct type
*descriptive_type
= TYPE_DESCRIPTIVE_TYPE (type
);
2951 recursive_dump_type (descriptive_type
, spaces
+ 2);
2954 static struct obstack dont_print_type_obstack
;
2957 recursive_dump_type (struct type
*type
, int spaces
)
2962 obstack_begin (&dont_print_type_obstack
, 0);
2964 if (TYPE_NFIELDS (type
) > 0
2965 || (HAVE_CPLUS_STRUCT (type
) && TYPE_NFN_FIELDS (type
) > 0))
2967 struct type
**first_dont_print
2968 = (struct type
**) obstack_base (&dont_print_type_obstack
);
2970 int i
= (struct type
**)
2971 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
2975 if (type
== first_dont_print
[i
])
2977 printfi_filtered (spaces
, "type node ");
2978 gdb_print_host_address (type
, gdb_stdout
);
2979 printf_filtered (_(" <same as already seen type>\n"));
2984 obstack_ptr_grow (&dont_print_type_obstack
, type
);
2987 printfi_filtered (spaces
, "type node ");
2988 gdb_print_host_address (type
, gdb_stdout
);
2989 printf_filtered ("\n");
2990 printfi_filtered (spaces
, "name '%s' (",
2991 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
2992 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
2993 printf_filtered (")\n");
2994 printfi_filtered (spaces
, "tagname '%s' (",
2995 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
2996 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
2997 printf_filtered (")\n");
2998 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
2999 switch (TYPE_CODE (type
))
3001 case TYPE_CODE_UNDEF
:
3002 printf_filtered ("(TYPE_CODE_UNDEF)");
3005 printf_filtered ("(TYPE_CODE_PTR)");
3007 case TYPE_CODE_ARRAY
:
3008 printf_filtered ("(TYPE_CODE_ARRAY)");
3010 case TYPE_CODE_STRUCT
:
3011 printf_filtered ("(TYPE_CODE_STRUCT)");
3013 case TYPE_CODE_UNION
:
3014 printf_filtered ("(TYPE_CODE_UNION)");
3016 case TYPE_CODE_ENUM
:
3017 printf_filtered ("(TYPE_CODE_ENUM)");
3019 case TYPE_CODE_FLAGS
:
3020 printf_filtered ("(TYPE_CODE_FLAGS)");
3022 case TYPE_CODE_FUNC
:
3023 printf_filtered ("(TYPE_CODE_FUNC)");
3026 printf_filtered ("(TYPE_CODE_INT)");
3029 printf_filtered ("(TYPE_CODE_FLT)");
3031 case TYPE_CODE_VOID
:
3032 printf_filtered ("(TYPE_CODE_VOID)");
3035 printf_filtered ("(TYPE_CODE_SET)");
3037 case TYPE_CODE_RANGE
:
3038 printf_filtered ("(TYPE_CODE_RANGE)");
3040 case TYPE_CODE_STRING
:
3041 printf_filtered ("(TYPE_CODE_STRING)");
3043 case TYPE_CODE_BITSTRING
:
3044 printf_filtered ("(TYPE_CODE_BITSTRING)");
3046 case TYPE_CODE_ERROR
:
3047 printf_filtered ("(TYPE_CODE_ERROR)");
3049 case TYPE_CODE_MEMBERPTR
:
3050 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
3052 case TYPE_CODE_METHODPTR
:
3053 printf_filtered ("(TYPE_CODE_METHODPTR)");
3055 case TYPE_CODE_METHOD
:
3056 printf_filtered ("(TYPE_CODE_METHOD)");
3059 printf_filtered ("(TYPE_CODE_REF)");
3061 case TYPE_CODE_CHAR
:
3062 printf_filtered ("(TYPE_CODE_CHAR)");
3064 case TYPE_CODE_BOOL
:
3065 printf_filtered ("(TYPE_CODE_BOOL)");
3067 case TYPE_CODE_COMPLEX
:
3068 printf_filtered ("(TYPE_CODE_COMPLEX)");
3070 case TYPE_CODE_TYPEDEF
:
3071 printf_filtered ("(TYPE_CODE_TYPEDEF)");
3073 case TYPE_CODE_NAMESPACE
:
3074 printf_filtered ("(TYPE_CODE_NAMESPACE)");
3077 printf_filtered ("(UNKNOWN TYPE CODE)");
3080 puts_filtered ("\n");
3081 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
3082 if (TYPE_OBJFILE_OWNED (type
))
3084 printfi_filtered (spaces
, "objfile ");
3085 gdb_print_host_address (TYPE_OWNER (type
).objfile
, gdb_stdout
);
3089 printfi_filtered (spaces
, "gdbarch ");
3090 gdb_print_host_address (TYPE_OWNER (type
).gdbarch
, gdb_stdout
);
3092 printf_filtered ("\n");
3093 printfi_filtered (spaces
, "target_type ");
3094 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
3095 printf_filtered ("\n");
3096 if (TYPE_TARGET_TYPE (type
) != NULL
)
3098 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
3100 printfi_filtered (spaces
, "pointer_type ");
3101 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
3102 printf_filtered ("\n");
3103 printfi_filtered (spaces
, "reference_type ");
3104 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
3105 printf_filtered ("\n");
3106 printfi_filtered (spaces
, "type_chain ");
3107 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
3108 printf_filtered ("\n");
3109 printfi_filtered (spaces
, "instance_flags 0x%x",
3110 TYPE_INSTANCE_FLAGS (type
));
3111 if (TYPE_CONST (type
))
3113 puts_filtered (" TYPE_FLAG_CONST");
3115 if (TYPE_VOLATILE (type
))
3117 puts_filtered (" TYPE_FLAG_VOLATILE");
3119 if (TYPE_CODE_SPACE (type
))
3121 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3123 if (TYPE_DATA_SPACE (type
))
3125 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3127 if (TYPE_ADDRESS_CLASS_1 (type
))
3129 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3131 if (TYPE_ADDRESS_CLASS_2 (type
))
3133 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3135 puts_filtered ("\n");
3137 printfi_filtered (spaces
, "flags");
3138 if (TYPE_UNSIGNED (type
))
3140 puts_filtered (" TYPE_FLAG_UNSIGNED");
3142 if (TYPE_NOSIGN (type
))
3144 puts_filtered (" TYPE_FLAG_NOSIGN");
3146 if (TYPE_STUB (type
))
3148 puts_filtered (" TYPE_FLAG_STUB");
3150 if (TYPE_TARGET_STUB (type
))
3152 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3154 if (TYPE_STATIC (type
))
3156 puts_filtered (" TYPE_FLAG_STATIC");
3158 if (TYPE_PROTOTYPED (type
))
3160 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3162 if (TYPE_INCOMPLETE (type
))
3164 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3166 if (TYPE_VARARGS (type
))
3168 puts_filtered (" TYPE_FLAG_VARARGS");
3170 /* This is used for things like AltiVec registers on ppc. Gcc emits
3171 an attribute for the array type, which tells whether or not we
3172 have a vector, instead of a regular array. */
3173 if (TYPE_VECTOR (type
))
3175 puts_filtered (" TYPE_FLAG_VECTOR");
3177 if (TYPE_FIXED_INSTANCE (type
))
3179 puts_filtered (" TYPE_FIXED_INSTANCE");
3181 if (TYPE_STUB_SUPPORTED (type
))
3183 puts_filtered (" TYPE_STUB_SUPPORTED");
3185 if (TYPE_NOTTEXT (type
))
3187 puts_filtered (" TYPE_NOTTEXT");
3189 puts_filtered ("\n");
3190 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
3191 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
3192 puts_filtered ("\n");
3193 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
3195 printfi_filtered (spaces
+ 2,
3196 "[%d] bitpos %d bitsize %d type ",
3197 idx
, TYPE_FIELD_BITPOS (type
, idx
),
3198 TYPE_FIELD_BITSIZE (type
, idx
));
3199 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
3200 printf_filtered (" name '%s' (",
3201 TYPE_FIELD_NAME (type
, idx
) != NULL
3202 ? TYPE_FIELD_NAME (type
, idx
)
3204 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
3205 printf_filtered (")\n");
3206 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
3208 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
3211 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
3213 printfi_filtered (spaces
, "low %s%s high %s%s\n",
3214 plongest (TYPE_LOW_BOUND (type
)),
3215 TYPE_LOW_BOUND_UNDEFINED (type
) ? " (undefined)" : "",
3216 plongest (TYPE_HIGH_BOUND (type
)),
3217 TYPE_HIGH_BOUND_UNDEFINED (type
)
3218 ? " (undefined)" : "");
3220 printfi_filtered (spaces
, "vptr_basetype ");
3221 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
3222 puts_filtered ("\n");
3223 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
3225 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
3227 printfi_filtered (spaces
, "vptr_fieldno %d\n",
3228 TYPE_VPTR_FIELDNO (type
));
3230 switch (TYPE_SPECIFIC_FIELD (type
))
3232 case TYPE_SPECIFIC_CPLUS_STUFF
:
3233 printfi_filtered (spaces
, "cplus_stuff ");
3234 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
),
3236 puts_filtered ("\n");
3237 print_cplus_stuff (type
, spaces
);
3240 case TYPE_SPECIFIC_GNAT_STUFF
:
3241 printfi_filtered (spaces
, "gnat_stuff ");
3242 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type
), gdb_stdout
);
3243 puts_filtered ("\n");
3244 print_gnat_stuff (type
, spaces
);
3247 case TYPE_SPECIFIC_FLOATFORMAT
:
3248 printfi_filtered (spaces
, "floatformat ");
3249 if (TYPE_FLOATFORMAT (type
) == NULL
)
3250 puts_filtered ("(null)");
3253 puts_filtered ("{ ");
3254 if (TYPE_FLOATFORMAT (type
)[0] == NULL
3255 || TYPE_FLOATFORMAT (type
)[0]->name
== NULL
)
3256 puts_filtered ("(null)");
3258 puts_filtered (TYPE_FLOATFORMAT (type
)[0]->name
);
3260 puts_filtered (", ");
3261 if (TYPE_FLOATFORMAT (type
)[1] == NULL
3262 || TYPE_FLOATFORMAT (type
)[1]->name
== NULL
)
3263 puts_filtered ("(null)");
3265 puts_filtered (TYPE_FLOATFORMAT (type
)[1]->name
);
3267 puts_filtered (" }");
3269 puts_filtered ("\n");
3272 case TYPE_SPECIFIC_FUNC
:
3273 printfi_filtered (spaces
, "calling_convention %d\n",
3274 TYPE_CALLING_CONVENTION (type
));
3275 /* tail_call_list is not printed. */
3280 obstack_free (&dont_print_type_obstack
, NULL
);
3283 /* Trivial helpers for the libiberty hash table, for mapping one
3288 struct type
*old
, *new;
3292 type_pair_hash (const void *item
)
3294 const struct type_pair
*pair
= item
;
3296 return htab_hash_pointer (pair
->old
);
3300 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
3302 const struct type_pair
*lhs
= item_lhs
, *rhs
= item_rhs
;
3304 return lhs
->old
== rhs
->old
;
3307 /* Allocate the hash table used by copy_type_recursive to walk
3308 types without duplicates. We use OBJFILE's obstack, because
3309 OBJFILE is about to be deleted. */
3312 create_copied_types_hash (struct objfile
*objfile
)
3314 return htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
3315 NULL
, &objfile
->objfile_obstack
,
3316 hashtab_obstack_allocate
,
3317 dummy_obstack_deallocate
);
3320 /* Recursively copy (deep copy) TYPE, if it is associated with
3321 OBJFILE. Return a new type allocated using malloc, a saved type if
3322 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
3323 not associated with OBJFILE. */
3326 copy_type_recursive (struct objfile
*objfile
,
3328 htab_t copied_types
)
3330 struct type_pair
*stored
, pair
;
3332 struct type
*new_type
;
3334 if (! TYPE_OBJFILE_OWNED (type
))
3337 /* This type shouldn't be pointing to any types in other objfiles;
3338 if it did, the type might disappear unexpectedly. */
3339 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
3342 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
3344 return ((struct type_pair
*) *slot
)->new;
3346 new_type
= alloc_type_arch (get_type_arch (type
));
3348 /* We must add the new type to the hash table immediately, in case
3349 we encounter this type again during a recursive call below. */
3351 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct type_pair
));
3353 stored
->new = new_type
;
3356 /* Copy the common fields of types. For the main type, we simply
3357 copy the entire thing and then update specific fields as needed. */
3358 *TYPE_MAIN_TYPE (new_type
) = *TYPE_MAIN_TYPE (type
);
3359 TYPE_OBJFILE_OWNED (new_type
) = 0;
3360 TYPE_OWNER (new_type
).gdbarch
= get_type_arch (type
);
3362 if (TYPE_NAME (type
))
3363 TYPE_NAME (new_type
) = xstrdup (TYPE_NAME (type
));
3364 if (TYPE_TAG_NAME (type
))
3365 TYPE_TAG_NAME (new_type
) = xstrdup (TYPE_TAG_NAME (type
));
3367 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
3368 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
3370 /* Copy the fields. */
3371 if (TYPE_NFIELDS (type
))
3375 nfields
= TYPE_NFIELDS (type
);
3376 TYPE_FIELDS (new_type
) = XCALLOC (nfields
, struct field
);
3377 for (i
= 0; i
< nfields
; i
++)
3379 TYPE_FIELD_ARTIFICIAL (new_type
, i
) =
3380 TYPE_FIELD_ARTIFICIAL (type
, i
);
3381 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
3382 if (TYPE_FIELD_TYPE (type
, i
))
3383 TYPE_FIELD_TYPE (new_type
, i
)
3384 = copy_type_recursive (objfile
, TYPE_FIELD_TYPE (type
, i
),
3386 if (TYPE_FIELD_NAME (type
, i
))
3387 TYPE_FIELD_NAME (new_type
, i
) =
3388 xstrdup (TYPE_FIELD_NAME (type
, i
));
3389 switch (TYPE_FIELD_LOC_KIND (type
, i
))
3391 case FIELD_LOC_KIND_BITPOS
:
3392 SET_FIELD_BITPOS (TYPE_FIELD (new_type
, i
),
3393 TYPE_FIELD_BITPOS (type
, i
));
3395 case FIELD_LOC_KIND_PHYSADDR
:
3396 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type
, i
),
3397 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
3399 case FIELD_LOC_KIND_PHYSNAME
:
3400 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type
, i
),
3401 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
,
3405 internal_error (__FILE__
, __LINE__
,
3406 _("Unexpected type field location kind: %d"),
3407 TYPE_FIELD_LOC_KIND (type
, i
));
3412 /* For range types, copy the bounds information. */
3413 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
3415 TYPE_RANGE_DATA (new_type
) = xmalloc (sizeof (struct range_bounds
));
3416 *TYPE_RANGE_DATA (new_type
) = *TYPE_RANGE_DATA (type
);
3419 /* Copy pointers to other types. */
3420 if (TYPE_TARGET_TYPE (type
))
3421 TYPE_TARGET_TYPE (new_type
) =
3422 copy_type_recursive (objfile
,
3423 TYPE_TARGET_TYPE (type
),
3425 if (TYPE_VPTR_BASETYPE (type
))
3426 TYPE_VPTR_BASETYPE (new_type
) =
3427 copy_type_recursive (objfile
,
3428 TYPE_VPTR_BASETYPE (type
),
3430 /* Maybe copy the type_specific bits.
3432 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3433 base classes and methods. There's no fundamental reason why we
3434 can't, but at the moment it is not needed. */
3436 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
3437 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
3438 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3439 || TYPE_CODE (type
) == TYPE_CODE_UNION
3440 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
3441 INIT_CPLUS_SPECIFIC (new_type
);
3446 /* Make a copy of the given TYPE, except that the pointer & reference
3447 types are not preserved.
3449 This function assumes that the given type has an associated objfile.
3450 This objfile is used to allocate the new type. */
3453 copy_type (const struct type
*type
)
3455 struct type
*new_type
;
3457 gdb_assert (TYPE_OBJFILE_OWNED (type
));
3459 new_type
= alloc_type_copy (type
);
3460 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
3461 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
3462 memcpy (TYPE_MAIN_TYPE (new_type
), TYPE_MAIN_TYPE (type
),
3463 sizeof (struct main_type
));
3469 /* Helper functions to initialize architecture-specific types. */
3471 /* Allocate a type structure associated with GDBARCH and set its
3472 CODE, LENGTH, and NAME fields. */
3474 arch_type (struct gdbarch
*gdbarch
,
3475 enum type_code code
, int length
, char *name
)
3479 type
= alloc_type_arch (gdbarch
);
3480 TYPE_CODE (type
) = code
;
3481 TYPE_LENGTH (type
) = length
;
3484 TYPE_NAME (type
) = xstrdup (name
);
3489 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
3490 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3491 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3493 arch_integer_type (struct gdbarch
*gdbarch
,
3494 int bit
, int unsigned_p
, char *name
)
3498 t
= arch_type (gdbarch
, TYPE_CODE_INT
, bit
/ TARGET_CHAR_BIT
, name
);
3500 TYPE_UNSIGNED (t
) = 1;
3501 if (name
&& strcmp (name
, "char") == 0)
3502 TYPE_NOSIGN (t
) = 1;
3507 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
3508 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3509 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3511 arch_character_type (struct gdbarch
*gdbarch
,
3512 int bit
, int unsigned_p
, char *name
)
3516 t
= arch_type (gdbarch
, TYPE_CODE_CHAR
, bit
/ TARGET_CHAR_BIT
, name
);
3518 TYPE_UNSIGNED (t
) = 1;
3523 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
3524 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3525 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3527 arch_boolean_type (struct gdbarch
*gdbarch
,
3528 int bit
, int unsigned_p
, char *name
)
3532 t
= arch_type (gdbarch
, TYPE_CODE_BOOL
, bit
/ TARGET_CHAR_BIT
, name
);
3534 TYPE_UNSIGNED (t
) = 1;
3539 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
3540 BIT is the type size in bits; if BIT equals -1, the size is
3541 determined by the floatformat. NAME is the type name. Set the
3542 TYPE_FLOATFORMAT from FLOATFORMATS. */
3544 arch_float_type (struct gdbarch
*gdbarch
,
3545 int bit
, char *name
, const struct floatformat
**floatformats
)
3551 gdb_assert (floatformats
!= NULL
);
3552 gdb_assert (floatformats
[0] != NULL
&& floatformats
[1] != NULL
);
3553 bit
= floatformats
[0]->totalsize
;
3555 gdb_assert (bit
>= 0);
3557 t
= arch_type (gdbarch
, TYPE_CODE_FLT
, bit
/ TARGET_CHAR_BIT
, name
);
3558 TYPE_FLOATFORMAT (t
) = floatformats
;
3562 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
3563 NAME is the type name. TARGET_TYPE is the component float type. */
3565 arch_complex_type (struct gdbarch
*gdbarch
,
3566 char *name
, struct type
*target_type
)
3570 t
= arch_type (gdbarch
, TYPE_CODE_COMPLEX
,
3571 2 * TYPE_LENGTH (target_type
), name
);
3572 TYPE_TARGET_TYPE (t
) = target_type
;
3576 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
3577 NAME is the type name. LENGTH is the size of the flag word in bytes. */
3579 arch_flags_type (struct gdbarch
*gdbarch
, char *name
, int length
)
3581 int nfields
= length
* TARGET_CHAR_BIT
;
3584 type
= arch_type (gdbarch
, TYPE_CODE_FLAGS
, length
, name
);
3585 TYPE_UNSIGNED (type
) = 1;
3586 TYPE_NFIELDS (type
) = nfields
;
3587 TYPE_FIELDS (type
) = TYPE_ZALLOC (type
, nfields
* sizeof (struct field
));
3592 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
3593 position BITPOS is called NAME. */
3595 append_flags_type_flag (struct type
*type
, int bitpos
, char *name
)
3597 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLAGS
);
3598 gdb_assert (bitpos
< TYPE_NFIELDS (type
));
3599 gdb_assert (bitpos
>= 0);
3603 TYPE_FIELD_NAME (type
, bitpos
) = xstrdup (name
);
3604 TYPE_FIELD_BITPOS (type
, bitpos
) = bitpos
;
3608 /* Don't show this field to the user. */
3609 TYPE_FIELD_BITPOS (type
, bitpos
) = -1;
3613 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
3614 specified by CODE) associated with GDBARCH. NAME is the type name. */
3616 arch_composite_type (struct gdbarch
*gdbarch
, char *name
, enum type_code code
)
3620 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
3621 t
= arch_type (gdbarch
, code
, 0, NULL
);
3622 TYPE_TAG_NAME (t
) = name
;
3623 INIT_CPLUS_SPECIFIC (t
);
3627 /* Add new field with name NAME and type FIELD to composite type T.
3628 Do not set the field's position or adjust the type's length;
3629 the caller should do so. Return the new field. */
3631 append_composite_type_field_raw (struct type
*t
, char *name
,
3636 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
3637 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
3638 sizeof (struct field
) * TYPE_NFIELDS (t
));
3639 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
3640 memset (f
, 0, sizeof f
[0]);
3641 FIELD_TYPE (f
[0]) = field
;
3642 FIELD_NAME (f
[0]) = name
;
3646 /* Add new field with name NAME and type FIELD to composite type T.
3647 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
3649 append_composite_type_field_aligned (struct type
*t
, char *name
,
3650 struct type
*field
, int alignment
)
3652 struct field
*f
= append_composite_type_field_raw (t
, name
, field
);
3654 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
3656 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
3657 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
3659 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
3661 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
3662 if (TYPE_NFIELDS (t
) > 1)
3664 FIELD_BITPOS (f
[0]) = (FIELD_BITPOS (f
[-1])
3665 + (TYPE_LENGTH (FIELD_TYPE (f
[-1]))
3666 * TARGET_CHAR_BIT
));
3672 alignment
*= TARGET_CHAR_BIT
;
3673 left
= FIELD_BITPOS (f
[0]) % alignment
;
3677 FIELD_BITPOS (f
[0]) += (alignment
- left
);
3678 TYPE_LENGTH (t
) += (alignment
- left
) / TARGET_CHAR_BIT
;
3685 /* Add new field with name NAME and type FIELD to composite type T. */
3687 append_composite_type_field (struct type
*t
, char *name
,
3690 append_composite_type_field_aligned (t
, name
, field
, 0);
3694 static struct gdbarch_data
*gdbtypes_data
;
3696 const struct builtin_type
*
3697 builtin_type (struct gdbarch
*gdbarch
)
3699 return gdbarch_data (gdbarch
, gdbtypes_data
);
3703 gdbtypes_post_init (struct gdbarch
*gdbarch
)
3705 struct builtin_type
*builtin_type
3706 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
3709 builtin_type
->builtin_void
3710 = arch_type (gdbarch
, TYPE_CODE_VOID
, 1, "void");
3711 builtin_type
->builtin_char
3712 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3713 !gdbarch_char_signed (gdbarch
), "char");
3714 builtin_type
->builtin_signed_char
3715 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3717 builtin_type
->builtin_unsigned_char
3718 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3719 1, "unsigned char");
3720 builtin_type
->builtin_short
3721 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
3723 builtin_type
->builtin_unsigned_short
3724 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
3725 1, "unsigned short");
3726 builtin_type
->builtin_int
3727 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
3729 builtin_type
->builtin_unsigned_int
3730 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
3732 builtin_type
->builtin_long
3733 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
3735 builtin_type
->builtin_unsigned_long
3736 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
3737 1, "unsigned long");
3738 builtin_type
->builtin_long_long
3739 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
3741 builtin_type
->builtin_unsigned_long_long
3742 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
3743 1, "unsigned long long");
3744 builtin_type
->builtin_float
3745 = arch_float_type (gdbarch
, gdbarch_float_bit (gdbarch
),
3746 "float", gdbarch_float_format (gdbarch
));
3747 builtin_type
->builtin_double
3748 = arch_float_type (gdbarch
, gdbarch_double_bit (gdbarch
),
3749 "double", gdbarch_double_format (gdbarch
));
3750 builtin_type
->builtin_long_double
3751 = arch_float_type (gdbarch
, gdbarch_long_double_bit (gdbarch
),
3752 "long double", gdbarch_long_double_format (gdbarch
));
3753 builtin_type
->builtin_complex
3754 = arch_complex_type (gdbarch
, "complex",
3755 builtin_type
->builtin_float
);
3756 builtin_type
->builtin_double_complex
3757 = arch_complex_type (gdbarch
, "double complex",
3758 builtin_type
->builtin_double
);
3759 builtin_type
->builtin_string
3760 = arch_type (gdbarch
, TYPE_CODE_STRING
, 1, "string");
3761 builtin_type
->builtin_bool
3762 = arch_type (gdbarch
, TYPE_CODE_BOOL
, 1, "bool");
3764 /* The following three are about decimal floating point types, which
3765 are 32-bits, 64-bits and 128-bits respectively. */
3766 builtin_type
->builtin_decfloat
3767 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 32 / 8, "_Decimal32");
3768 builtin_type
->builtin_decdouble
3769 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 64 / 8, "_Decimal64");
3770 builtin_type
->builtin_declong
3771 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 128 / 8, "_Decimal128");
3773 /* "True" character types. */
3774 builtin_type
->builtin_true_char
3775 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 0, "true character");
3776 builtin_type
->builtin_true_unsigned_char
3777 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 1, "true character");
3779 /* Fixed-size integer types. */
3780 builtin_type
->builtin_int0
3781 = arch_integer_type (gdbarch
, 0, 0, "int0_t");
3782 builtin_type
->builtin_int8
3783 = arch_integer_type (gdbarch
, 8, 0, "int8_t");
3784 builtin_type
->builtin_uint8
3785 = arch_integer_type (gdbarch
, 8, 1, "uint8_t");
3786 builtin_type
->builtin_int16
3787 = arch_integer_type (gdbarch
, 16, 0, "int16_t");
3788 builtin_type
->builtin_uint16
3789 = arch_integer_type (gdbarch
, 16, 1, "uint16_t");
3790 builtin_type
->builtin_int32
3791 = arch_integer_type (gdbarch
, 32, 0, "int32_t");
3792 builtin_type
->builtin_uint32
3793 = arch_integer_type (gdbarch
, 32, 1, "uint32_t");
3794 builtin_type
->builtin_int64
3795 = arch_integer_type (gdbarch
, 64, 0, "int64_t");
3796 builtin_type
->builtin_uint64
3797 = arch_integer_type (gdbarch
, 64, 1, "uint64_t");
3798 builtin_type
->builtin_int128
3799 = arch_integer_type (gdbarch
, 128, 0, "int128_t");
3800 builtin_type
->builtin_uint128
3801 = arch_integer_type (gdbarch
, 128, 1, "uint128_t");
3802 TYPE_INSTANCE_FLAGS (builtin_type
->builtin_int8
) |=
3803 TYPE_INSTANCE_FLAG_NOTTEXT
;
3804 TYPE_INSTANCE_FLAGS (builtin_type
->builtin_uint8
) |=
3805 TYPE_INSTANCE_FLAG_NOTTEXT
;
3807 /* Wide character types. */
3808 builtin_type
->builtin_char16
3809 = arch_integer_type (gdbarch
, 16, 0, "char16_t");
3810 builtin_type
->builtin_char32
3811 = arch_integer_type (gdbarch
, 32, 0, "char32_t");
3814 /* Default data/code pointer types. */
3815 builtin_type
->builtin_data_ptr
3816 = lookup_pointer_type (builtin_type
->builtin_void
);
3817 builtin_type
->builtin_func_ptr
3818 = lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
3819 builtin_type
->builtin_func_func
3820 = lookup_function_type (builtin_type
->builtin_func_ptr
);
3822 /* This type represents a GDB internal function. */
3823 builtin_type
->internal_fn
3824 = arch_type (gdbarch
, TYPE_CODE_INTERNAL_FUNCTION
, 0,
3825 "<internal function>");
3827 return builtin_type
;
3831 /* This set of objfile-based types is intended to be used by symbol
3832 readers as basic types. */
3834 static const struct objfile_data
*objfile_type_data
;
3836 const struct objfile_type
*
3837 objfile_type (struct objfile
*objfile
)
3839 struct gdbarch
*gdbarch
;
3840 struct objfile_type
*objfile_type
3841 = objfile_data (objfile
, objfile_type_data
);
3844 return objfile_type
;
3846 objfile_type
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
3847 1, struct objfile_type
);
3849 /* Use the objfile architecture to determine basic type properties. */
3850 gdbarch
= get_objfile_arch (objfile
);
3853 objfile_type
->builtin_void
3854 = init_type (TYPE_CODE_VOID
, 1,
3858 objfile_type
->builtin_char
3859 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3861 | (gdbarch_char_signed (gdbarch
) ? 0 : TYPE_FLAG_UNSIGNED
)),
3863 objfile_type
->builtin_signed_char
3864 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3866 "signed char", objfile
);
3867 objfile_type
->builtin_unsigned_char
3868 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3870 "unsigned char", objfile
);
3871 objfile_type
->builtin_short
3872 = init_type (TYPE_CODE_INT
,
3873 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3874 0, "short", objfile
);
3875 objfile_type
->builtin_unsigned_short
3876 = init_type (TYPE_CODE_INT
,
3877 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3878 TYPE_FLAG_UNSIGNED
, "unsigned short", objfile
);
3879 objfile_type
->builtin_int
3880 = init_type (TYPE_CODE_INT
,
3881 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3883 objfile_type
->builtin_unsigned_int
3884 = init_type (TYPE_CODE_INT
,
3885 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3886 TYPE_FLAG_UNSIGNED
, "unsigned int", objfile
);
3887 objfile_type
->builtin_long
3888 = init_type (TYPE_CODE_INT
,
3889 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3890 0, "long", objfile
);
3891 objfile_type
->builtin_unsigned_long
3892 = init_type (TYPE_CODE_INT
,
3893 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3894 TYPE_FLAG_UNSIGNED
, "unsigned long", objfile
);
3895 objfile_type
->builtin_long_long
3896 = init_type (TYPE_CODE_INT
,
3897 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3898 0, "long long", objfile
);
3899 objfile_type
->builtin_unsigned_long_long
3900 = init_type (TYPE_CODE_INT
,
3901 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3902 TYPE_FLAG_UNSIGNED
, "unsigned long long", objfile
);
3904 objfile_type
->builtin_float
3905 = init_type (TYPE_CODE_FLT
,
3906 gdbarch_float_bit (gdbarch
) / TARGET_CHAR_BIT
,
3907 0, "float", objfile
);
3908 TYPE_FLOATFORMAT (objfile_type
->builtin_float
)
3909 = gdbarch_float_format (gdbarch
);
3910 objfile_type
->builtin_double
3911 = init_type (TYPE_CODE_FLT
,
3912 gdbarch_double_bit (gdbarch
) / TARGET_CHAR_BIT
,
3913 0, "double", objfile
);
3914 TYPE_FLOATFORMAT (objfile_type
->builtin_double
)
3915 = gdbarch_double_format (gdbarch
);
3916 objfile_type
->builtin_long_double
3917 = init_type (TYPE_CODE_FLT
,
3918 gdbarch_long_double_bit (gdbarch
) / TARGET_CHAR_BIT
,
3919 0, "long double", objfile
);
3920 TYPE_FLOATFORMAT (objfile_type
->builtin_long_double
)
3921 = gdbarch_long_double_format (gdbarch
);
3923 /* This type represents a type that was unrecognized in symbol read-in. */
3924 objfile_type
->builtin_error
3925 = init_type (TYPE_CODE_ERROR
, 0, 0, "<unknown type>", objfile
);
3927 /* The following set of types is used for symbols with no
3928 debug information. */
3929 objfile_type
->nodebug_text_symbol
3930 = init_type (TYPE_CODE_FUNC
, 1, 0,
3931 "<text variable, no debug info>", objfile
);
3932 TYPE_TARGET_TYPE (objfile_type
->nodebug_text_symbol
)
3933 = objfile_type
->builtin_int
;
3934 objfile_type
->nodebug_text_gnu_ifunc_symbol
3935 = init_type (TYPE_CODE_FUNC
, 1, TYPE_FLAG_GNU_IFUNC
,
3936 "<text gnu-indirect-function variable, no debug info>",
3938 TYPE_TARGET_TYPE (objfile_type
->nodebug_text_gnu_ifunc_symbol
)
3939 = objfile_type
->nodebug_text_symbol
;
3940 objfile_type
->nodebug_got_plt_symbol
3941 = init_type (TYPE_CODE_PTR
, gdbarch_addr_bit (gdbarch
) / 8, 0,
3942 "<text from jump slot in .got.plt, no debug info>",
3944 TYPE_TARGET_TYPE (objfile_type
->nodebug_got_plt_symbol
)
3945 = objfile_type
->nodebug_text_symbol
;
3946 objfile_type
->nodebug_data_symbol
3947 = init_type (TYPE_CODE_INT
,
3948 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3949 "<data variable, no debug info>", objfile
);
3950 objfile_type
->nodebug_unknown_symbol
3951 = init_type (TYPE_CODE_INT
, 1, 0,
3952 "<variable (not text or data), no debug info>", objfile
);
3953 objfile_type
->nodebug_tls_symbol
3954 = init_type (TYPE_CODE_INT
,
3955 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3956 "<thread local variable, no debug info>", objfile
);
3958 /* NOTE: on some targets, addresses and pointers are not necessarily
3959 the same --- for example, on the D10V, pointers are 16 bits long,
3960 but addresses are 32 bits long. See doc/gdbint.texinfo,
3961 ``Pointers Are Not Always Addresses''.
3964 - gdb's `struct type' always describes the target's
3966 - gdb's `struct value' objects should always hold values in
3968 - gdb's CORE_ADDR values are addresses in the unified virtual
3969 address space that the assembler and linker work with. Thus,
3970 since target_read_memory takes a CORE_ADDR as an argument, it
3971 can access any memory on the target, even if the processor has
3972 separate code and data address spaces.
3975 - If v is a value holding a D10V code pointer, its contents are
3976 in target form: a big-endian address left-shifted two bits.
3977 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3978 sizeof (void *) == 2 on the target.
3980 In this context, objfile_type->builtin_core_addr is a bit odd:
3981 it's a target type for a value the target will never see. It's
3982 only used to hold the values of (typeless) linker symbols, which
3983 are indeed in the unified virtual address space. */
3985 objfile_type
->builtin_core_addr
3986 = init_type (TYPE_CODE_INT
,
3987 gdbarch_addr_bit (gdbarch
) / 8,
3988 TYPE_FLAG_UNSIGNED
, "__CORE_ADDR", objfile
);
3990 set_objfile_data (objfile
, objfile_type_data
, objfile_type
);
3991 return objfile_type
;
3995 extern void _initialize_gdbtypes (void);
3997 _initialize_gdbtypes (void)
3999 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
4000 objfile_type_data
= register_objfile_data ();
4002 add_setshow_zinteger_cmd ("overload", no_class
, &overload_debug
,
4003 _("Set debugging of C++ overloading."),
4004 _("Show debugging of C++ overloading."),
4005 _("When enabled, ranking of the "
4006 "functions is displayed."),
4008 show_overload_debug
,
4009 &setdebuglist
, &showdebuglist
);
4011 /* Add user knob for controlling resolution of opaque types. */
4012 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
4013 &opaque_type_resolution
,
4014 _("Set resolution of opaque struct/class/union"
4015 " types (if set before loading symbols)."),
4016 _("Show resolution of opaque struct/class/union"
4017 " types (if set before loading symbols)."),
4019 show_opaque_type_resolution
,
4020 &setlist
, &showlist
);