1 /* Support routines for manipulating internal types for GDB.
3 Copyright (C) 1992-2014 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/>. */
28 #include "expression.h"
33 #include "complaints.h"
37 #include "exceptions.h"
38 #include "cp-support.h"
40 #include "dwarf2loc.h"
43 /* Initialize BADNESS constants. */
45 const struct rank LENGTH_MISMATCH_BADNESS
= {100,0};
47 const struct rank TOO_FEW_PARAMS_BADNESS
= {100,0};
48 const struct rank INCOMPATIBLE_TYPE_BADNESS
= {100,0};
50 const struct rank EXACT_MATCH_BADNESS
= {0,0};
52 const struct rank INTEGER_PROMOTION_BADNESS
= {1,0};
53 const struct rank FLOAT_PROMOTION_BADNESS
= {1,0};
54 const struct rank BASE_PTR_CONVERSION_BADNESS
= {1,0};
55 const struct rank INTEGER_CONVERSION_BADNESS
= {2,0};
56 const struct rank FLOAT_CONVERSION_BADNESS
= {2,0};
57 const struct rank INT_FLOAT_CONVERSION_BADNESS
= {2,0};
58 const struct rank VOID_PTR_CONVERSION_BADNESS
= {2,0};
59 const struct rank BOOL_CONVERSION_BADNESS
= {3,0};
60 const struct rank BASE_CONVERSION_BADNESS
= {2,0};
61 const struct rank REFERENCE_CONVERSION_BADNESS
= {2,0};
62 const struct rank NULL_POINTER_CONVERSION_BADNESS
= {2,0};
63 const struct rank NS_POINTER_CONVERSION_BADNESS
= {10,0};
64 const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS
= {3,0};
66 /* Floatformat pairs. */
67 const struct floatformat
*floatformats_ieee_half
[BFD_ENDIAN_UNKNOWN
] = {
68 &floatformat_ieee_half_big
,
69 &floatformat_ieee_half_little
71 const struct floatformat
*floatformats_ieee_single
[BFD_ENDIAN_UNKNOWN
] = {
72 &floatformat_ieee_single_big
,
73 &floatformat_ieee_single_little
75 const struct floatformat
*floatformats_ieee_double
[BFD_ENDIAN_UNKNOWN
] = {
76 &floatformat_ieee_double_big
,
77 &floatformat_ieee_double_little
79 const struct floatformat
*floatformats_ieee_double_littlebyte_bigword
[BFD_ENDIAN_UNKNOWN
] = {
80 &floatformat_ieee_double_big
,
81 &floatformat_ieee_double_littlebyte_bigword
83 const struct floatformat
*floatformats_i387_ext
[BFD_ENDIAN_UNKNOWN
] = {
84 &floatformat_i387_ext
,
87 const struct floatformat
*floatformats_m68881_ext
[BFD_ENDIAN_UNKNOWN
] = {
88 &floatformat_m68881_ext
,
89 &floatformat_m68881_ext
91 const struct floatformat
*floatformats_arm_ext
[BFD_ENDIAN_UNKNOWN
] = {
92 &floatformat_arm_ext_big
,
93 &floatformat_arm_ext_littlebyte_bigword
95 const struct floatformat
*floatformats_ia64_spill
[BFD_ENDIAN_UNKNOWN
] = {
96 &floatformat_ia64_spill_big
,
97 &floatformat_ia64_spill_little
99 const struct floatformat
*floatformats_ia64_quad
[BFD_ENDIAN_UNKNOWN
] = {
100 &floatformat_ia64_quad_big
,
101 &floatformat_ia64_quad_little
103 const struct floatformat
*floatformats_vax_f
[BFD_ENDIAN_UNKNOWN
] = {
107 const struct floatformat
*floatformats_vax_d
[BFD_ENDIAN_UNKNOWN
] = {
111 const struct floatformat
*floatformats_ibm_long_double
[BFD_ENDIAN_UNKNOWN
] = {
112 &floatformat_ibm_long_double_big
,
113 &floatformat_ibm_long_double_little
116 /* Should opaque types be resolved? */
118 static int opaque_type_resolution
= 1;
120 /* A flag to enable printing of debugging information of C++
123 unsigned int overload_debug
= 0;
125 /* A flag to enable strict type checking. */
127 static int strict_type_checking
= 1;
129 /* A function to show whether opaque types are resolved. */
132 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
133 struct cmd_list_element
*c
,
136 fprintf_filtered (file
, _("Resolution of opaque struct/class/union types "
137 "(if set before loading symbols) is %s.\n"),
141 /* A function to show whether C++ overload debugging is enabled. */
144 show_overload_debug (struct ui_file
*file
, int from_tty
,
145 struct cmd_list_element
*c
, const char *value
)
147 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"),
151 /* A function to show the status of strict type checking. */
154 show_strict_type_checking (struct ui_file
*file
, int from_tty
,
155 struct cmd_list_element
*c
, const char *value
)
157 fprintf_filtered (file
, _("Strict type checking is %s.\n"), value
);
161 /* Allocate a new OBJFILE-associated type structure and fill it
162 with some defaults. Space for the type structure is allocated
163 on the objfile's objfile_obstack. */
166 alloc_type (struct objfile
*objfile
)
170 gdb_assert (objfile
!= NULL
);
172 /* Alloc the structure and start off with all fields zeroed. */
173 type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct type
);
174 TYPE_MAIN_TYPE (type
) = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
176 OBJSTAT (objfile
, n_types
++);
178 TYPE_OBJFILE_OWNED (type
) = 1;
179 TYPE_OWNER (type
).objfile
= objfile
;
181 /* Initialize the fields that might not be zero. */
183 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
184 TYPE_VPTR_FIELDNO (type
) = -1;
185 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
190 /* Allocate a new GDBARCH-associated type structure and fill it
191 with some defaults. Space for the type structure is allocated
195 alloc_type_arch (struct gdbarch
*gdbarch
)
199 gdb_assert (gdbarch
!= NULL
);
201 /* Alloc the structure and start off with all fields zeroed. */
203 type
= XCNEW (struct type
);
204 TYPE_MAIN_TYPE (type
) = XCNEW (struct main_type
);
206 TYPE_OBJFILE_OWNED (type
) = 0;
207 TYPE_OWNER (type
).gdbarch
= gdbarch
;
209 /* Initialize the fields that might not be zero. */
211 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
212 TYPE_VPTR_FIELDNO (type
) = -1;
213 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
218 /* If TYPE is objfile-associated, allocate a new type structure
219 associated with the same objfile. If TYPE is gdbarch-associated,
220 allocate a new type structure associated with the same gdbarch. */
223 alloc_type_copy (const struct type
*type
)
225 if (TYPE_OBJFILE_OWNED (type
))
226 return alloc_type (TYPE_OWNER (type
).objfile
);
228 return alloc_type_arch (TYPE_OWNER (type
).gdbarch
);
231 /* If TYPE is gdbarch-associated, return that architecture.
232 If TYPE is objfile-associated, return that objfile's architecture. */
235 get_type_arch (const struct type
*type
)
237 if (TYPE_OBJFILE_OWNED (type
))
238 return get_objfile_arch (TYPE_OWNER (type
).objfile
);
240 return TYPE_OWNER (type
).gdbarch
;
243 /* See gdbtypes.h. */
246 get_target_type (struct type
*type
)
250 type
= TYPE_TARGET_TYPE (type
);
252 type
= check_typedef (type
);
258 /* Alloc a new type instance structure, fill it with some defaults,
259 and point it at OLDTYPE. Allocate the new type instance from the
260 same place as OLDTYPE. */
263 alloc_type_instance (struct type
*oldtype
)
267 /* Allocate the structure. */
269 if (! TYPE_OBJFILE_OWNED (oldtype
))
270 type
= XCNEW (struct type
);
272 type
= OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype
)->objfile_obstack
,
275 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
277 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
282 /* Clear all remnants of the previous type at TYPE, in preparation for
283 replacing it with something else. Preserve owner information. */
286 smash_type (struct type
*type
)
288 int objfile_owned
= TYPE_OBJFILE_OWNED (type
);
289 union type_owner owner
= TYPE_OWNER (type
);
291 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
293 /* Restore owner information. */
294 TYPE_OBJFILE_OWNED (type
) = objfile_owned
;
295 TYPE_OWNER (type
) = owner
;
297 /* For now, delete the rings. */
298 TYPE_CHAIN (type
) = type
;
300 /* For now, leave the pointer/reference types alone. */
303 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
304 to a pointer to memory where the pointer type should be stored.
305 If *TYPEPTR is zero, update it to point to the pointer type we return.
306 We allocate new memory if needed. */
309 make_pointer_type (struct type
*type
, struct type
**typeptr
)
311 struct type
*ntype
; /* New type */
314 ntype
= TYPE_POINTER_TYPE (type
);
319 return ntype
; /* Don't care about alloc,
320 and have new type. */
321 else if (*typeptr
== 0)
323 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
328 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
330 ntype
= alloc_type_copy (type
);
334 else /* We have storage, but need to reset it. */
337 chain
= TYPE_CHAIN (ntype
);
339 TYPE_CHAIN (ntype
) = chain
;
342 TYPE_TARGET_TYPE (ntype
) = type
;
343 TYPE_POINTER_TYPE (type
) = ntype
;
345 /* FIXME! Assumes the machine has only one representation for pointers! */
348 = gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
349 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
351 /* Mark pointers as unsigned. The target converts between pointers
352 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
353 gdbarch_address_to_pointer. */
354 TYPE_UNSIGNED (ntype
) = 1;
356 /* Update the length of all the other variants of this type. */
357 chain
= TYPE_CHAIN (ntype
);
358 while (chain
!= ntype
)
360 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
361 chain
= TYPE_CHAIN (chain
);
367 /* Given a type TYPE, return a type of pointers to that type.
368 May need to construct such a type if this is the first use. */
371 lookup_pointer_type (struct type
*type
)
373 return make_pointer_type (type
, (struct type
**) 0);
376 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
377 points to a pointer to memory where the reference type should be
378 stored. If *TYPEPTR is zero, update it to point to the reference
379 type we return. We allocate new memory if needed. */
382 make_reference_type (struct type
*type
, struct type
**typeptr
)
384 struct type
*ntype
; /* New type */
387 ntype
= TYPE_REFERENCE_TYPE (type
);
392 return ntype
; /* Don't care about alloc,
393 and have new type. */
394 else if (*typeptr
== 0)
396 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
401 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
403 ntype
= alloc_type_copy (type
);
407 else /* We have storage, but need to reset it. */
410 chain
= TYPE_CHAIN (ntype
);
412 TYPE_CHAIN (ntype
) = chain
;
415 TYPE_TARGET_TYPE (ntype
) = type
;
416 TYPE_REFERENCE_TYPE (type
) = ntype
;
418 /* FIXME! Assume the machine has only one representation for
419 references, and that it matches the (only) representation for
422 TYPE_LENGTH (ntype
) =
423 gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
424 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
426 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
427 TYPE_REFERENCE_TYPE (type
) = ntype
;
429 /* Update the length of all the other variants of this type. */
430 chain
= TYPE_CHAIN (ntype
);
431 while (chain
!= ntype
)
433 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
434 chain
= TYPE_CHAIN (chain
);
440 /* Same as above, but caller doesn't care about memory allocation
444 lookup_reference_type (struct type
*type
)
446 return make_reference_type (type
, (struct type
**) 0);
449 /* Lookup a function type that returns type TYPE. TYPEPTR, if
450 nonzero, points to a pointer to memory where the function type
451 should be stored. If *TYPEPTR is zero, update it to point to the
452 function type we return. We allocate new memory if needed. */
455 make_function_type (struct type
*type
, struct type
**typeptr
)
457 struct type
*ntype
; /* New type */
459 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
461 ntype
= alloc_type_copy (type
);
465 else /* We have storage, but need to reset it. */
471 TYPE_TARGET_TYPE (ntype
) = type
;
473 TYPE_LENGTH (ntype
) = 1;
474 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
476 INIT_FUNC_SPECIFIC (ntype
);
481 /* Given a type TYPE, return a type of functions that return that type.
482 May need to construct such a type if this is the first use. */
485 lookup_function_type (struct type
*type
)
487 return make_function_type (type
, (struct type
**) 0);
490 /* Given a type TYPE and argument types, return the appropriate
491 function type. If the final type in PARAM_TYPES is NULL, make a
495 lookup_function_type_with_arguments (struct type
*type
,
497 struct type
**param_types
)
499 struct type
*fn
= make_function_type (type
, (struct type
**) 0);
504 if (param_types
[nparams
- 1] == NULL
)
507 TYPE_VARARGS (fn
) = 1;
509 else if (TYPE_CODE (check_typedef (param_types
[nparams
- 1]))
513 /* Caller should have ensured this. */
514 gdb_assert (nparams
== 0);
515 TYPE_PROTOTYPED (fn
) = 1;
519 TYPE_NFIELDS (fn
) = nparams
;
520 TYPE_FIELDS (fn
) = TYPE_ZALLOC (fn
, nparams
* sizeof (struct field
));
521 for (i
= 0; i
< nparams
; ++i
)
522 TYPE_FIELD_TYPE (fn
, i
) = param_types
[i
];
527 /* Identify address space identifier by name --
528 return the integer flag defined in gdbtypes.h. */
531 address_space_name_to_int (struct gdbarch
*gdbarch
, char *space_identifier
)
535 /* Check for known address space delimiters. */
536 if (!strcmp (space_identifier
, "code"))
537 return TYPE_INSTANCE_FLAG_CODE_SPACE
;
538 else if (!strcmp (space_identifier
, "data"))
539 return TYPE_INSTANCE_FLAG_DATA_SPACE
;
540 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
541 && gdbarch_address_class_name_to_type_flags (gdbarch
,
546 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
549 /* Identify address space identifier by integer flag as defined in
550 gdbtypes.h -- return the string version of the adress space name. */
553 address_space_int_to_name (struct gdbarch
*gdbarch
, int space_flag
)
555 if (space_flag
& TYPE_INSTANCE_FLAG_CODE_SPACE
)
557 else if (space_flag
& TYPE_INSTANCE_FLAG_DATA_SPACE
)
559 else if ((space_flag
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
560 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
561 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
566 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
568 If STORAGE is non-NULL, create the new type instance there.
569 STORAGE must be in the same obstack as TYPE. */
572 make_qualified_type (struct type
*type
, int new_flags
,
573 struct type
*storage
)
580 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
582 ntype
= TYPE_CHAIN (ntype
);
584 while (ntype
!= type
);
586 /* Create a new type instance. */
588 ntype
= alloc_type_instance (type
);
591 /* If STORAGE was provided, it had better be in the same objfile
592 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
593 if one objfile is freed and the other kept, we'd have
594 dangling pointers. */
595 gdb_assert (TYPE_OBJFILE (type
) == TYPE_OBJFILE (storage
));
598 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
599 TYPE_CHAIN (ntype
) = ntype
;
602 /* Pointers or references to the original type are not relevant to
604 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
605 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
607 /* Chain the new qualified type to the old type. */
608 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
609 TYPE_CHAIN (type
) = ntype
;
611 /* Now set the instance flags and return the new type. */
612 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
614 /* Set length of new type to that of the original type. */
615 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
620 /* Make an address-space-delimited variant of a type -- a type that
621 is identical to the one supplied except that it has an address
622 space attribute attached to it (such as "code" or "data").
624 The space attributes "code" and "data" are for Harvard
625 architectures. The address space attributes are for architectures
626 which have alternately sized pointers or pointers with alternate
630 make_type_with_address_space (struct type
*type
, int space_flag
)
632 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
633 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
634 | TYPE_INSTANCE_FLAG_DATA_SPACE
635 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
))
638 return make_qualified_type (type
, new_flags
, NULL
);
641 /* Make a "c-v" variant of a type -- a type that is identical to the
642 one supplied except that it may have const or volatile attributes
643 CNST is a flag for setting the const attribute
644 VOLTL is a flag for setting the volatile attribute
645 TYPE is the base type whose variant we are creating.
647 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
648 storage to hold the new qualified type; *TYPEPTR and TYPE must be
649 in the same objfile. Otherwise, allocate fresh memory for the new
650 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
651 new type we construct. */
654 make_cv_type (int cnst
, int voltl
,
656 struct type
**typeptr
)
658 struct type
*ntype
; /* New type */
660 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
661 & ~(TYPE_INSTANCE_FLAG_CONST
662 | TYPE_INSTANCE_FLAG_VOLATILE
));
665 new_flags
|= TYPE_INSTANCE_FLAG_CONST
;
668 new_flags
|= TYPE_INSTANCE_FLAG_VOLATILE
;
670 if (typeptr
&& *typeptr
!= NULL
)
672 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
673 a C-V variant chain that threads across objfiles: if one
674 objfile gets freed, then the other has a broken C-V chain.
676 This code used to try to copy over the main type from TYPE to
677 *TYPEPTR if they were in different objfiles, but that's
678 wrong, too: TYPE may have a field list or member function
679 lists, which refer to types of their own, etc. etc. The
680 whole shebang would need to be copied over recursively; you
681 can't have inter-objfile pointers. The only thing to do is
682 to leave stub types as stub types, and look them up afresh by
683 name each time you encounter them. */
684 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
));
687 ntype
= make_qualified_type (type
, new_flags
,
688 typeptr
? *typeptr
: NULL
);
696 /* Make a 'restrict'-qualified version of TYPE. */
699 make_restrict_type (struct type
*type
)
701 return make_qualified_type (type
,
702 (TYPE_INSTANCE_FLAGS (type
)
703 | TYPE_INSTANCE_FLAG_RESTRICT
),
707 /* Replace the contents of ntype with the type *type. This changes the
708 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
709 the changes are propogated to all types in the TYPE_CHAIN.
711 In order to build recursive types, it's inevitable that we'll need
712 to update types in place --- but this sort of indiscriminate
713 smashing is ugly, and needs to be replaced with something more
714 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
715 clear if more steps are needed. */
718 replace_type (struct type
*ntype
, struct type
*type
)
722 /* These two types had better be in the same objfile. Otherwise,
723 the assignment of one type's main type structure to the other
724 will produce a type with references to objects (names; field
725 lists; etc.) allocated on an objfile other than its own. */
726 gdb_assert (TYPE_OBJFILE (ntype
) == TYPE_OBJFILE (ntype
));
728 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
730 /* The type length is not a part of the main type. Update it for
731 each type on the variant chain. */
735 /* Assert that this element of the chain has no address-class bits
736 set in its flags. Such type variants might have type lengths
737 which are supposed to be different from the non-address-class
738 variants. This assertion shouldn't ever be triggered because
739 symbol readers which do construct address-class variants don't
740 call replace_type(). */
741 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
743 TYPE_LENGTH (chain
) = TYPE_LENGTH (type
);
744 chain
= TYPE_CHAIN (chain
);
746 while (ntype
!= chain
);
748 /* Assert that the two types have equivalent instance qualifiers.
749 This should be true for at least all of our debug readers. */
750 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
753 /* Implement direct support for MEMBER_TYPE in GNU C++.
754 May need to construct such a type if this is the first use.
755 The TYPE is the type of the member. The DOMAIN is the type
756 of the aggregate that the member belongs to. */
759 lookup_memberptr_type (struct type
*type
, struct type
*domain
)
763 mtype
= alloc_type_copy (type
);
764 smash_to_memberptr_type (mtype
, domain
, type
);
768 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
771 lookup_methodptr_type (struct type
*to_type
)
775 mtype
= alloc_type_copy (to_type
);
776 smash_to_methodptr_type (mtype
, to_type
);
780 /* Allocate a stub method whose return type is TYPE. This apparently
781 happens for speed of symbol reading, since parsing out the
782 arguments to the method is cpu-intensive, the way we are doing it.
783 So, we will fill in arguments later. This always returns a fresh
787 allocate_stub_method (struct type
*type
)
791 mtype
= alloc_type_copy (type
);
792 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
793 TYPE_LENGTH (mtype
) = 1;
794 TYPE_STUB (mtype
) = 1;
795 TYPE_TARGET_TYPE (mtype
) = type
;
796 /* _DOMAIN_TYPE (mtype) = unknown yet */
800 /* Create a range type with a dynamic range from LOW_BOUND to
801 HIGH_BOUND, inclusive. See create_range_type for further details. */
804 create_range_type (struct type
*result_type
, struct type
*index_type
,
805 const struct dynamic_prop
*low_bound
,
806 const struct dynamic_prop
*high_bound
)
808 if (result_type
== NULL
)
809 result_type
= alloc_type_copy (index_type
);
810 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
811 TYPE_TARGET_TYPE (result_type
) = index_type
;
812 if (TYPE_STUB (index_type
))
813 TYPE_TARGET_STUB (result_type
) = 1;
815 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
817 TYPE_RANGE_DATA (result_type
) = (struct range_bounds
*)
818 TYPE_ZALLOC (result_type
, sizeof (struct range_bounds
));
819 TYPE_RANGE_DATA (result_type
)->low
= *low_bound
;
820 TYPE_RANGE_DATA (result_type
)->high
= *high_bound
;
822 if (low_bound
->kind
== PROP_CONST
&& low_bound
->data
.const_val
>= 0)
823 TYPE_UNSIGNED (result_type
) = 1;
828 /* Create a range type using either a blank type supplied in
829 RESULT_TYPE, or creating a new type, inheriting the objfile from
832 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
833 to HIGH_BOUND, inclusive.
835 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
836 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
839 create_static_range_type (struct type
*result_type
, struct type
*index_type
,
840 LONGEST low_bound
, LONGEST high_bound
)
842 struct dynamic_prop low
, high
;
844 low
.kind
= PROP_CONST
;
845 low
.data
.const_val
= low_bound
;
847 high
.kind
= PROP_CONST
;
848 high
.data
.const_val
= high_bound
;
850 result_type
= create_range_type (result_type
, index_type
, &low
, &high
);
855 /* Predicate tests whether BOUNDS are static. Returns 1 if all bounds values
856 are static, otherwise returns 0. */
859 has_static_range (const struct range_bounds
*bounds
)
861 return (bounds
->low
.kind
== PROP_CONST
862 && bounds
->high
.kind
== PROP_CONST
);
866 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
867 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
868 bounds will fit in LONGEST), or -1 otherwise. */
871 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
873 CHECK_TYPEDEF (type
);
874 switch (TYPE_CODE (type
))
876 case TYPE_CODE_RANGE
:
877 *lowp
= TYPE_LOW_BOUND (type
);
878 *highp
= TYPE_HIGH_BOUND (type
);
881 if (TYPE_NFIELDS (type
) > 0)
883 /* The enums may not be sorted by value, so search all
887 *lowp
= *highp
= TYPE_FIELD_ENUMVAL (type
, 0);
888 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
890 if (TYPE_FIELD_ENUMVAL (type
, i
) < *lowp
)
891 *lowp
= TYPE_FIELD_ENUMVAL (type
, i
);
892 if (TYPE_FIELD_ENUMVAL (type
, i
) > *highp
)
893 *highp
= TYPE_FIELD_ENUMVAL (type
, i
);
896 /* Set unsigned indicator if warranted. */
899 TYPE_UNSIGNED (type
) = 1;
913 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
915 if (!TYPE_UNSIGNED (type
))
917 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
921 /* ... fall through for unsigned ints ... */
924 /* This round-about calculation is to avoid shifting by
925 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
926 if TYPE_LENGTH (type) == sizeof (LONGEST). */
927 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
928 *highp
= (*highp
- 1) | *highp
;
935 /* Assuming TYPE is a simple, non-empty array type, compute its upper
936 and lower bound. Save the low bound into LOW_BOUND if not NULL.
937 Save the high bound into HIGH_BOUND if not NULL.
939 Return 1 if the operation was successful. Return zero otherwise,
940 in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
942 We now simply use get_discrete_bounds call to get the values
943 of the low and high bounds.
944 get_discrete_bounds can return three values:
945 1, meaning that index is a range,
946 0, meaning that index is a discrete type,
947 or -1 for failure. */
950 get_array_bounds (struct type
*type
, LONGEST
*low_bound
, LONGEST
*high_bound
)
952 struct type
*index
= TYPE_INDEX_TYPE (type
);
960 res
= get_discrete_bounds (index
, &low
, &high
);
964 /* Check if the array bounds are undefined. */
966 && ((low_bound
&& TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type
))
967 || (high_bound
&& TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))))
979 /* Create an array type using either a blank type supplied in
980 RESULT_TYPE, or creating a new type, inheriting the objfile from
983 Elements will be of type ELEMENT_TYPE, the indices will be of type
986 If BIT_STRIDE is not zero, build a packed array type whose element
987 size is BIT_STRIDE. Otherwise, ignore this parameter.
989 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
990 sure it is TYPE_CODE_UNDEF before we bash it into an array
994 create_array_type_with_stride (struct type
*result_type
,
995 struct type
*element_type
,
996 struct type
*range_type
,
997 unsigned int bit_stride
)
999 if (result_type
== NULL
)
1000 result_type
= alloc_type_copy (range_type
);
1002 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
1003 TYPE_TARGET_TYPE (result_type
) = element_type
;
1004 if (has_static_range (TYPE_RANGE_DATA (range_type
)))
1006 LONGEST low_bound
, high_bound
;
1008 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
1009 low_bound
= high_bound
= 0;
1010 CHECK_TYPEDEF (element_type
);
1011 /* Be careful when setting the array length. Ada arrays can be
1012 empty arrays with the high_bound being smaller than the low_bound.
1013 In such cases, the array length should be zero. */
1014 if (high_bound
< low_bound
)
1015 TYPE_LENGTH (result_type
) = 0;
1016 else if (bit_stride
> 0)
1017 TYPE_LENGTH (result_type
) =
1018 (bit_stride
* (high_bound
- low_bound
+ 1) + 7) / 8;
1020 TYPE_LENGTH (result_type
) =
1021 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
1025 /* This type is dynamic and its length needs to be computed
1026 on demand. In the meantime, avoid leaving the TYPE_LENGTH
1027 undefined by setting it to zero. Although we are not expected
1028 to trust TYPE_LENGTH in this case, setting the size to zero
1029 allows us to avoid allocating objects of random sizes in case
1030 we accidently do. */
1031 TYPE_LENGTH (result_type
) = 0;
1034 TYPE_NFIELDS (result_type
) = 1;
1035 TYPE_FIELDS (result_type
) =
1036 (struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
));
1037 TYPE_INDEX_TYPE (result_type
) = range_type
;
1038 TYPE_VPTR_FIELDNO (result_type
) = -1;
1040 TYPE_FIELD_BITSIZE (result_type
, 0) = bit_stride
;
1042 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays. */
1043 if (TYPE_LENGTH (result_type
) == 0)
1044 TYPE_TARGET_STUB (result_type
) = 1;
1049 /* Same as create_array_type_with_stride but with no bit_stride
1050 (BIT_STRIDE = 0), thus building an unpacked array. */
1053 create_array_type (struct type
*result_type
,
1054 struct type
*element_type
,
1055 struct type
*range_type
)
1057 return create_array_type_with_stride (result_type
, element_type
,
1062 lookup_array_range_type (struct type
*element_type
,
1063 LONGEST low_bound
, LONGEST high_bound
)
1065 struct gdbarch
*gdbarch
= get_type_arch (element_type
);
1066 struct type
*index_type
= builtin_type (gdbarch
)->builtin_int
;
1067 struct type
*range_type
1068 = create_static_range_type (NULL
, index_type
, low_bound
, high_bound
);
1070 return create_array_type (NULL
, element_type
, range_type
);
1073 /* Create a string type using either a blank type supplied in
1074 RESULT_TYPE, or creating a new type. String types are similar
1075 enough to array of char types that we can use create_array_type to
1076 build the basic type and then bash it into a string type.
1078 For fixed length strings, the range type contains 0 as the lower
1079 bound and the length of the string minus one as the upper bound.
1081 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1082 sure it is TYPE_CODE_UNDEF before we bash it into a string
1086 create_string_type (struct type
*result_type
,
1087 struct type
*string_char_type
,
1088 struct type
*range_type
)
1090 result_type
= create_array_type (result_type
,
1093 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
1098 lookup_string_range_type (struct type
*string_char_type
,
1099 LONGEST low_bound
, LONGEST high_bound
)
1101 struct type
*result_type
;
1103 result_type
= lookup_array_range_type (string_char_type
,
1104 low_bound
, high_bound
);
1105 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
1110 create_set_type (struct type
*result_type
, struct type
*domain_type
)
1112 if (result_type
== NULL
)
1113 result_type
= alloc_type_copy (domain_type
);
1115 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
1116 TYPE_NFIELDS (result_type
) = 1;
1117 TYPE_FIELDS (result_type
) = TYPE_ZALLOC (result_type
, sizeof (struct field
));
1119 if (!TYPE_STUB (domain_type
))
1121 LONGEST low_bound
, high_bound
, bit_length
;
1123 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
1124 low_bound
= high_bound
= 0;
1125 bit_length
= high_bound
- low_bound
+ 1;
1126 TYPE_LENGTH (result_type
)
1127 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
1129 TYPE_UNSIGNED (result_type
) = 1;
1131 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
1136 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
1137 and any array types nested inside it. */
1140 make_vector_type (struct type
*array_type
)
1142 struct type
*inner_array
, *elt_type
;
1145 /* Find the innermost array type, in case the array is
1146 multi-dimensional. */
1147 inner_array
= array_type
;
1148 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
1149 inner_array
= TYPE_TARGET_TYPE (inner_array
);
1151 elt_type
= TYPE_TARGET_TYPE (inner_array
);
1152 if (TYPE_CODE (elt_type
) == TYPE_CODE_INT
)
1154 flags
= TYPE_INSTANCE_FLAGS (elt_type
) | TYPE_INSTANCE_FLAG_NOTTEXT
;
1155 elt_type
= make_qualified_type (elt_type
, flags
, NULL
);
1156 TYPE_TARGET_TYPE (inner_array
) = elt_type
;
1159 TYPE_VECTOR (array_type
) = 1;
1163 init_vector_type (struct type
*elt_type
, int n
)
1165 struct type
*array_type
;
1167 array_type
= lookup_array_range_type (elt_type
, 0, n
- 1);
1168 make_vector_type (array_type
);
1172 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
1173 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1174 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1175 TYPE doesn't include the offset (that's the value of the MEMBER
1176 itself), but does include the structure type into which it points
1179 When "smashing" the type, we preserve the objfile that the old type
1180 pointed to, since we aren't changing where the type is actually
1184 smash_to_memberptr_type (struct type
*type
, struct type
*domain
,
1185 struct type
*to_type
)
1188 TYPE_TARGET_TYPE (type
) = to_type
;
1189 TYPE_DOMAIN_TYPE (type
) = domain
;
1190 /* Assume that a data member pointer is the same size as a normal
1193 = gdbarch_ptr_bit (get_type_arch (to_type
)) / TARGET_CHAR_BIT
;
1194 TYPE_CODE (type
) = TYPE_CODE_MEMBERPTR
;
1197 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1199 When "smashing" the type, we preserve the objfile that the old type
1200 pointed to, since we aren't changing where the type is actually
1204 smash_to_methodptr_type (struct type
*type
, struct type
*to_type
)
1207 TYPE_TARGET_TYPE (type
) = to_type
;
1208 TYPE_DOMAIN_TYPE (type
) = TYPE_DOMAIN_TYPE (to_type
);
1209 TYPE_LENGTH (type
) = cplus_method_ptr_size (to_type
);
1210 TYPE_CODE (type
) = TYPE_CODE_METHODPTR
;
1213 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
1214 METHOD just means `function that gets an extra "this" argument'.
1216 When "smashing" the type, we preserve the objfile that the old type
1217 pointed to, since we aren't changing where the type is actually
1221 smash_to_method_type (struct type
*type
, struct type
*domain
,
1222 struct type
*to_type
, struct field
*args
,
1223 int nargs
, int varargs
)
1226 TYPE_TARGET_TYPE (type
) = to_type
;
1227 TYPE_DOMAIN_TYPE (type
) = domain
;
1228 TYPE_FIELDS (type
) = args
;
1229 TYPE_NFIELDS (type
) = nargs
;
1231 TYPE_VARARGS (type
) = 1;
1232 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1233 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
1236 /* Return a typename for a struct/union/enum type without "struct ",
1237 "union ", or "enum ". If the type has a NULL name, return NULL. */
1240 type_name_no_tag (const struct type
*type
)
1242 if (TYPE_TAG_NAME (type
) != NULL
)
1243 return TYPE_TAG_NAME (type
);
1245 /* Is there code which expects this to return the name if there is
1246 no tag name? My guess is that this is mainly used for C++ in
1247 cases where the two will always be the same. */
1248 return TYPE_NAME (type
);
1251 /* A wrapper of type_name_no_tag which calls error if the type is anonymous.
1252 Since GCC PR debug/47510 DWARF provides associated information to detect the
1253 anonymous class linkage name from its typedef.
1255 Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
1259 type_name_no_tag_or_error (struct type
*type
)
1261 struct type
*saved_type
= type
;
1263 struct objfile
*objfile
;
1265 CHECK_TYPEDEF (type
);
1267 name
= type_name_no_tag (type
);
1271 name
= type_name_no_tag (saved_type
);
1272 objfile
= TYPE_OBJFILE (saved_type
);
1273 error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
1274 name
? name
: "<anonymous>",
1275 objfile
? objfile_name (objfile
) : "<arch>");
1278 /* Lookup a typedef or primitive type named NAME, visible in lexical
1279 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1280 suitably defined. */
1283 lookup_typename (const struct language_defn
*language
,
1284 struct gdbarch
*gdbarch
, const char *name
,
1285 const struct block
*block
, int noerr
)
1290 sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, 0);
1291 if (sym
!= NULL
&& SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
1292 return SYMBOL_TYPE (sym
);
1294 type
= language_lookup_primitive_type_by_name (language
, gdbarch
, name
);
1300 error (_("No type named %s."), name
);
1304 lookup_unsigned_typename (const struct language_defn
*language
,
1305 struct gdbarch
*gdbarch
, const char *name
)
1307 char *uns
= alloca (strlen (name
) + 10);
1309 strcpy (uns
, "unsigned ");
1310 strcpy (uns
+ 9, name
);
1311 return lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 0);
1315 lookup_signed_typename (const struct language_defn
*language
,
1316 struct gdbarch
*gdbarch
, const char *name
)
1319 char *uns
= alloca (strlen (name
) + 8);
1321 strcpy (uns
, "signed ");
1322 strcpy (uns
+ 7, name
);
1323 t
= lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 1);
1324 /* If we don't find "signed FOO" just try again with plain "FOO". */
1327 return lookup_typename (language
, gdbarch
, name
, (struct block
*) NULL
, 0);
1330 /* Lookup a structure type named "struct NAME",
1331 visible in lexical block BLOCK. */
1334 lookup_struct (const char *name
, const struct block
*block
)
1338 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1342 error (_("No struct type named %s."), name
);
1344 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1346 error (_("This context has class, union or enum %s, not a struct."),
1349 return (SYMBOL_TYPE (sym
));
1352 /* Lookup a union type named "union NAME",
1353 visible in lexical block BLOCK. */
1356 lookup_union (const char *name
, const struct block
*block
)
1361 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1364 error (_("No union type named %s."), name
);
1366 t
= SYMBOL_TYPE (sym
);
1368 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1371 /* If we get here, it's not a union. */
1372 error (_("This context has class, struct or enum %s, not a union."),
1376 /* Lookup an enum type named "enum NAME",
1377 visible in lexical block BLOCK. */
1380 lookup_enum (const char *name
, const struct block
*block
)
1384 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1387 error (_("No enum type named %s."), name
);
1389 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1391 error (_("This context has class, struct or union %s, not an enum."),
1394 return (SYMBOL_TYPE (sym
));
1397 /* Lookup a template type named "template NAME<TYPE>",
1398 visible in lexical block BLOCK. */
1401 lookup_template_type (char *name
, struct type
*type
,
1402 const struct block
*block
)
1405 char *nam
= (char *)
1406 alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1410 strcat (nam
, TYPE_NAME (type
));
1411 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1413 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0);
1417 error (_("No template type named %s."), name
);
1419 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1421 error (_("This context has class, union or enum %s, not a struct."),
1424 return (SYMBOL_TYPE (sym
));
1427 /* Given a type TYPE, lookup the type of the component of type named
1430 TYPE can be either a struct or union, or a pointer or reference to
1431 a struct or union. If it is a pointer or reference, its target
1432 type is automatically used. Thus '.' and '->' are interchangable,
1433 as specified for the definitions of the expression element types
1434 STRUCTOP_STRUCT and STRUCTOP_PTR.
1436 If NOERR is nonzero, return zero if NAME is not suitably defined.
1437 If NAME is the name of a baseclass type, return that type. */
1440 lookup_struct_elt_type (struct type
*type
, const char *name
, int noerr
)
1447 CHECK_TYPEDEF (type
);
1448 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1449 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1451 type
= TYPE_TARGET_TYPE (type
);
1454 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1455 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1457 typename
= type_to_string (type
);
1458 make_cleanup (xfree
, typename
);
1459 error (_("Type %s is not a structure or union type."), typename
);
1463 /* FIXME: This change put in by Michael seems incorrect for the case
1464 where the structure tag name is the same as the member name.
1465 I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
1466 foo; } bell;" Disabled by fnf. */
1470 typename
= type_name_no_tag (type
);
1471 if (typename
!= NULL
&& strcmp (typename
, name
) == 0)
1476 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1478 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1480 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1482 return TYPE_FIELD_TYPE (type
, i
);
1484 else if (!t_field_name
|| *t_field_name
== '\0')
1486 struct type
*subtype
1487 = lookup_struct_elt_type (TYPE_FIELD_TYPE (type
, i
), name
, 1);
1489 if (subtype
!= NULL
)
1494 /* OK, it's not in this class. Recursively check the baseclasses. */
1495 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1499 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, 1);
1511 typename
= type_to_string (type
);
1512 make_cleanup (xfree
, typename
);
1513 error (_("Type %s has no component named %s."), typename
, name
);
1516 /* Store in *MAX the largest number representable by unsigned integer type
1520 get_unsigned_type_max (struct type
*type
, ULONGEST
*max
)
1524 CHECK_TYPEDEF (type
);
1525 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_INT
&& TYPE_UNSIGNED (type
));
1526 gdb_assert (TYPE_LENGTH (type
) <= sizeof (ULONGEST
));
1528 /* Written this way to avoid overflow. */
1529 n
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
1530 *max
= ((((ULONGEST
) 1 << (n
- 1)) - 1) << 1) | 1;
1533 /* Store in *MIN, *MAX the smallest and largest numbers representable by
1534 signed integer type TYPE. */
1537 get_signed_type_minmax (struct type
*type
, LONGEST
*min
, LONGEST
*max
)
1541 CHECK_TYPEDEF (type
);
1542 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_INT
&& !TYPE_UNSIGNED (type
));
1543 gdb_assert (TYPE_LENGTH (type
) <= sizeof (LONGEST
));
1545 n
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
1546 *min
= -((ULONGEST
) 1 << (n
- 1));
1547 *max
= ((ULONGEST
) 1 << (n
- 1)) - 1;
1550 /* Lookup the vptr basetype/fieldno values for TYPE.
1551 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1552 vptr_fieldno. Also, if found and basetype is from the same objfile,
1554 If not found, return -1 and ignore BASETYPEP.
1555 Callers should be aware that in some cases (for example,
1556 the type or one of its baseclasses is a stub type and we are
1557 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1558 this function will not be able to find the
1559 virtual function table pointer, and vptr_fieldno will remain -1 and
1560 vptr_basetype will remain NULL or incomplete. */
1563 get_vptr_fieldno (struct type
*type
, struct type
**basetypep
)
1565 CHECK_TYPEDEF (type
);
1567 if (TYPE_VPTR_FIELDNO (type
) < 0)
1571 /* We must start at zero in case the first (and only) baseclass
1572 is virtual (and hence we cannot share the table pointer). */
1573 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1575 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1577 struct type
*basetype
;
1579 fieldno
= get_vptr_fieldno (baseclass
, &basetype
);
1582 /* If the type comes from a different objfile we can't cache
1583 it, it may have a different lifetime. PR 2384 */
1584 if (TYPE_OBJFILE (type
) == TYPE_OBJFILE (basetype
))
1586 TYPE_VPTR_FIELDNO (type
) = fieldno
;
1587 TYPE_VPTR_BASETYPE (type
) = basetype
;
1590 *basetypep
= basetype
;
1601 *basetypep
= TYPE_VPTR_BASETYPE (type
);
1602 return TYPE_VPTR_FIELDNO (type
);
1607 stub_noname_complaint (void)
1609 complaint (&symfile_complaints
, _("stub type has NULL name"));
1612 /* Worker for is_dynamic_type. */
1615 is_dynamic_type_internal (struct type
*type
, int top_level
)
1617 type
= check_typedef (type
);
1619 /* We only want to recognize references at the outermost level. */
1620 if (top_level
&& TYPE_CODE (type
) == TYPE_CODE_REF
)
1621 type
= check_typedef (TYPE_TARGET_TYPE (type
));
1623 /* Types that have a dynamic TYPE_DATA_LOCATION are considered
1624 dynamic, even if the type itself is statically defined.
1625 From a user's point of view, this may appear counter-intuitive;
1626 but it makes sense in this context, because the point is to determine
1627 whether any part of the type needs to be resolved before it can
1629 if (TYPE_DATA_LOCATION (type
) != NULL
1630 && (TYPE_DATA_LOCATION_KIND (type
) == PROP_LOCEXPR
1631 || TYPE_DATA_LOCATION_KIND (type
) == PROP_LOCLIST
))
1634 switch (TYPE_CODE (type
))
1636 case TYPE_CODE_RANGE
:
1637 return !has_static_range (TYPE_RANGE_DATA (type
));
1639 case TYPE_CODE_ARRAY
:
1641 gdb_assert (TYPE_NFIELDS (type
) == 1);
1643 /* The array is dynamic if either the bounds are dynamic,
1644 or the elements it contains have a dynamic contents. */
1645 if (is_dynamic_type_internal (TYPE_INDEX_TYPE (type
), 0))
1647 return is_dynamic_type_internal (TYPE_TARGET_TYPE (type
), 0);
1650 case TYPE_CODE_STRUCT
:
1651 case TYPE_CODE_UNION
:
1655 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
1656 if (!field_is_static (&TYPE_FIELD (type
, i
))
1657 && is_dynamic_type_internal (TYPE_FIELD_TYPE (type
, i
), 0))
1666 /* See gdbtypes.h. */
1669 is_dynamic_type (struct type
*type
)
1671 return is_dynamic_type_internal (type
, 1);
1674 static struct type
*resolve_dynamic_type_internal (struct type
*type
,
1678 /* Given a dynamic range type (dyn_range_type) and address,
1679 return a static version of that type. */
1681 static struct type
*
1682 resolve_dynamic_range (struct type
*dyn_range_type
, CORE_ADDR addr
)
1685 struct type
*static_range_type
;
1686 const struct dynamic_prop
*prop
;
1687 const struct dwarf2_locexpr_baton
*baton
;
1688 struct dynamic_prop low_bound
, high_bound
;
1690 gdb_assert (TYPE_CODE (dyn_range_type
) == TYPE_CODE_RANGE
);
1692 prop
= &TYPE_RANGE_DATA (dyn_range_type
)->low
;
1693 if (dwarf2_evaluate_property (prop
, addr
, &value
))
1695 low_bound
.kind
= PROP_CONST
;
1696 low_bound
.data
.const_val
= value
;
1700 low_bound
.kind
= PROP_UNDEFINED
;
1701 low_bound
.data
.const_val
= 0;
1704 prop
= &TYPE_RANGE_DATA (dyn_range_type
)->high
;
1705 if (dwarf2_evaluate_property (prop
, addr
, &value
))
1707 high_bound
.kind
= PROP_CONST
;
1708 high_bound
.data
.const_val
= value
;
1710 if (TYPE_RANGE_DATA (dyn_range_type
)->flag_upper_bound_is_count
)
1711 high_bound
.data
.const_val
1712 = low_bound
.data
.const_val
+ high_bound
.data
.const_val
- 1;
1716 high_bound
.kind
= PROP_UNDEFINED
;
1717 high_bound
.data
.const_val
= 0;
1720 static_range_type
= create_range_type (copy_type (dyn_range_type
),
1721 TYPE_TARGET_TYPE (dyn_range_type
),
1722 &low_bound
, &high_bound
);
1723 TYPE_RANGE_DATA (static_range_type
)->flag_bound_evaluated
= 1;
1724 return static_range_type
;
1727 /* Resolves dynamic bound values of an array type TYPE to static ones.
1728 ADDRESS might be needed to resolve the subrange bounds, it is the location
1729 of the associated array. */
1731 static struct type
*
1732 resolve_dynamic_array (struct type
*type
, CORE_ADDR addr
)
1735 struct type
*elt_type
;
1736 struct type
*range_type
;
1737 struct type
*ary_dim
;
1739 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_ARRAY
);
1742 range_type
= check_typedef (TYPE_INDEX_TYPE (elt_type
));
1743 range_type
= resolve_dynamic_range (range_type
, addr
);
1745 ary_dim
= check_typedef (TYPE_TARGET_TYPE (elt_type
));
1747 if (ary_dim
!= NULL
&& TYPE_CODE (ary_dim
) == TYPE_CODE_ARRAY
)
1748 elt_type
= resolve_dynamic_array (TYPE_TARGET_TYPE (type
), addr
);
1750 elt_type
= TYPE_TARGET_TYPE (type
);
1752 return create_array_type (copy_type (type
),
1757 /* Resolve dynamic bounds of members of the union TYPE to static
1760 static struct type
*
1761 resolve_dynamic_union (struct type
*type
, CORE_ADDR addr
)
1763 struct type
*resolved_type
;
1765 unsigned int max_len
= 0;
1767 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_UNION
);
1769 resolved_type
= copy_type (type
);
1770 TYPE_FIELDS (resolved_type
)
1771 = TYPE_ALLOC (resolved_type
,
1772 TYPE_NFIELDS (resolved_type
) * sizeof (struct field
));
1773 memcpy (TYPE_FIELDS (resolved_type
),
1775 TYPE_NFIELDS (resolved_type
) * sizeof (struct field
));
1776 for (i
= 0; i
< TYPE_NFIELDS (resolved_type
); ++i
)
1780 if (field_is_static (&TYPE_FIELD (type
, i
)))
1783 t
= resolve_dynamic_type_internal (TYPE_FIELD_TYPE (resolved_type
, i
),
1785 TYPE_FIELD_TYPE (resolved_type
, i
) = t
;
1786 if (TYPE_LENGTH (t
) > max_len
)
1787 max_len
= TYPE_LENGTH (t
);
1790 TYPE_LENGTH (resolved_type
) = max_len
;
1791 return resolved_type
;
1794 /* Resolve dynamic bounds of members of the struct TYPE to static
1797 static struct type
*
1798 resolve_dynamic_struct (struct type
*type
, CORE_ADDR addr
)
1800 struct type
*resolved_type
;
1802 unsigned resolved_type_bit_length
= 0;
1804 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
);
1805 gdb_assert (TYPE_NFIELDS (type
) > 0);
1807 resolved_type
= copy_type (type
);
1808 TYPE_FIELDS (resolved_type
)
1809 = TYPE_ALLOC (resolved_type
,
1810 TYPE_NFIELDS (resolved_type
) * sizeof (struct field
));
1811 memcpy (TYPE_FIELDS (resolved_type
),
1813 TYPE_NFIELDS (resolved_type
) * sizeof (struct field
));
1814 for (i
= 0; i
< TYPE_NFIELDS (resolved_type
); ++i
)
1816 unsigned new_bit_length
;
1818 if (field_is_static (&TYPE_FIELD (type
, i
)))
1821 TYPE_FIELD_TYPE (resolved_type
, i
)
1822 = resolve_dynamic_type_internal (TYPE_FIELD_TYPE (resolved_type
, i
),
1825 /* As we know this field is not a static field, the field's
1826 field_loc_kind should be FIELD_LOC_KIND_BITPOS. Verify
1827 this is the case, but only trigger a simple error rather
1828 than an internal error if that fails. While failing
1829 that verification indicates a bug in our code, the error
1830 is not severe enough to suggest to the user he stops
1831 his debugging session because of it. */
1832 if (TYPE_FIELD_LOC_KIND (resolved_type
, i
) != FIELD_LOC_KIND_BITPOS
)
1833 error (_("Cannot determine struct field location"
1834 " (invalid location kind)"));
1835 new_bit_length
= TYPE_FIELD_BITPOS (resolved_type
, i
);
1836 if (TYPE_FIELD_BITSIZE (resolved_type
, i
) != 0)
1837 new_bit_length
+= TYPE_FIELD_BITSIZE (resolved_type
, i
);
1839 new_bit_length
+= (TYPE_LENGTH (TYPE_FIELD_TYPE (resolved_type
, i
))
1842 /* Normally, we would use the position and size of the last field
1843 to determine the size of the enclosing structure. But GCC seems
1844 to be encoding the position of some fields incorrectly when
1845 the struct contains a dynamic field that is not placed last.
1846 So we compute the struct size based on the field that has
1847 the highest position + size - probably the best we can do. */
1848 if (new_bit_length
> resolved_type_bit_length
)
1849 resolved_type_bit_length
= new_bit_length
;
1852 TYPE_LENGTH (resolved_type
)
1853 = (resolved_type_bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
1855 return resolved_type
;
1858 /* Worker for resolved_dynamic_type. */
1860 static struct type
*
1861 resolve_dynamic_type_internal (struct type
*type
, CORE_ADDR addr
,
1864 struct type
*real_type
= check_typedef (type
);
1865 struct type
*resolved_type
= type
;
1866 const struct dynamic_prop
*prop
;
1869 if (!is_dynamic_type_internal (real_type
, top_level
))
1872 switch (TYPE_CODE (type
))
1874 case TYPE_CODE_TYPEDEF
:
1875 resolved_type
= copy_type (type
);
1876 TYPE_TARGET_TYPE (resolved_type
)
1877 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type
), addr
,
1883 CORE_ADDR target_addr
= read_memory_typed_address (addr
, type
);
1885 resolved_type
= copy_type (type
);
1886 TYPE_TARGET_TYPE (resolved_type
)
1887 = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type
),
1888 target_addr
, top_level
);
1892 case TYPE_CODE_ARRAY
:
1893 resolved_type
= resolve_dynamic_array (type
, addr
);
1896 case TYPE_CODE_RANGE
:
1897 resolved_type
= resolve_dynamic_range (type
, addr
);
1900 case TYPE_CODE_UNION
:
1901 resolved_type
= resolve_dynamic_union (type
, addr
);
1904 case TYPE_CODE_STRUCT
:
1905 resolved_type
= resolve_dynamic_struct (type
, addr
);
1909 /* Resolve data_location attribute. */
1910 prop
= TYPE_DATA_LOCATION (resolved_type
);
1911 if (dwarf2_evaluate_property (prop
, addr
, &value
))
1913 TYPE_DATA_LOCATION_ADDR (resolved_type
) = value
;
1914 TYPE_DATA_LOCATION_KIND (resolved_type
) = PROP_CONST
;
1917 TYPE_DATA_LOCATION (resolved_type
) = NULL
;
1919 return resolved_type
;
1922 /* See gdbtypes.h */
1925 resolve_dynamic_type (struct type
*type
, CORE_ADDR addr
)
1927 return resolve_dynamic_type_internal (type
, addr
, 1);
1930 /* Find the real type of TYPE. This function returns the real type,
1931 after removing all layers of typedefs, and completing opaque or stub
1932 types. Completion changes the TYPE argument, but stripping of
1935 Instance flags (e.g. const/volatile) are preserved as typedefs are
1936 stripped. If necessary a new qualified form of the underlying type
1939 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
1940 not been computed and we're either in the middle of reading symbols, or
1941 there was no name for the typedef in the debug info.
1943 NOTE: Lookup of opaque types can throw errors for invalid symbol files.
1944 QUITs in the symbol reading code can also throw.
1945 Thus this function can throw an exception.
1947 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
1950 If this is a stubbed struct (i.e. declared as struct foo *), see if
1951 we can find a full definition in some other file. If so, copy this
1952 definition, so we can use it in future. There used to be a comment
1953 (but not any code) that if we don't find a full definition, we'd
1954 set a flag so we don't spend time in the future checking the same
1955 type. That would be a mistake, though--we might load in more
1956 symbols which contain a full definition for the type. */
1959 check_typedef (struct type
*type
)
1961 struct type
*orig_type
= type
;
1962 /* While we're removing typedefs, we don't want to lose qualifiers.
1963 E.g., const/volatile. */
1964 int instance_flags
= TYPE_INSTANCE_FLAGS (type
);
1968 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1970 if (!TYPE_TARGET_TYPE (type
))
1975 /* It is dangerous to call lookup_symbol if we are currently
1976 reading a symtab. Infinite recursion is one danger. */
1977 if (currently_reading_symtab
)
1978 return make_qualified_type (type
, instance_flags
, NULL
);
1980 name
= type_name_no_tag (type
);
1981 /* FIXME: shouldn't we separately check the TYPE_NAME and
1982 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1983 VAR_DOMAIN as appropriate? (this code was written before
1984 TYPE_NAME and TYPE_TAG_NAME were separate). */
1987 stub_noname_complaint ();
1988 return make_qualified_type (type
, instance_flags
, NULL
);
1990 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1992 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1993 else /* TYPE_CODE_UNDEF */
1994 TYPE_TARGET_TYPE (type
) = alloc_type_arch (get_type_arch (type
));
1996 type
= TYPE_TARGET_TYPE (type
);
1998 /* Preserve the instance flags as we traverse down the typedef chain.
2000 Handling address spaces/classes is nasty, what do we do if there's a
2002 E.g., what if an outer typedef marks the type as class_1 and an inner
2003 typedef marks the type as class_2?
2004 This is the wrong place to do such error checking. We leave it to
2005 the code that created the typedef in the first place to flag the
2006 error. We just pick the outer address space (akin to letting the
2007 outer cast in a chain of casting win), instead of assuming
2008 "it can't happen". */
2010 const int ALL_SPACES
= (TYPE_INSTANCE_FLAG_CODE_SPACE
2011 | TYPE_INSTANCE_FLAG_DATA_SPACE
);
2012 const int ALL_CLASSES
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
;
2013 int new_instance_flags
= TYPE_INSTANCE_FLAGS (type
);
2015 /* Treat code vs data spaces and address classes separately. */
2016 if ((instance_flags
& ALL_SPACES
) != 0)
2017 new_instance_flags
&= ~ALL_SPACES
;
2018 if ((instance_flags
& ALL_CLASSES
) != 0)
2019 new_instance_flags
&= ~ALL_CLASSES
;
2021 instance_flags
|= new_instance_flags
;
2025 /* If this is a struct/class/union with no fields, then check
2026 whether a full definition exists somewhere else. This is for
2027 systems where a type definition with no fields is issued for such
2028 types, instead of identifying them as stub types in the first
2031 if (TYPE_IS_OPAQUE (type
)
2032 && opaque_type_resolution
2033 && !currently_reading_symtab
)
2035 const char *name
= type_name_no_tag (type
);
2036 struct type
*newtype
;
2040 stub_noname_complaint ();
2041 return make_qualified_type (type
, instance_flags
, NULL
);
2043 newtype
= lookup_transparent_type (name
);
2047 /* If the resolved type and the stub are in the same
2048 objfile, then replace the stub type with the real deal.
2049 But if they're in separate objfiles, leave the stub
2050 alone; we'll just look up the transparent type every time
2051 we call check_typedef. We can't create pointers between
2052 types allocated to different objfiles, since they may
2053 have different lifetimes. Trying to copy NEWTYPE over to
2054 TYPE's objfile is pointless, too, since you'll have to
2055 move over any other types NEWTYPE refers to, which could
2056 be an unbounded amount of stuff. */
2057 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
2058 type
= make_qualified_type (newtype
,
2059 TYPE_INSTANCE_FLAGS (type
),
2065 /* Otherwise, rely on the stub flag being set for opaque/stubbed
2067 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
2069 const char *name
= type_name_no_tag (type
);
2070 /* FIXME: shouldn't we separately check the TYPE_NAME and the
2071 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
2072 as appropriate? (this code was written before TYPE_NAME and
2073 TYPE_TAG_NAME were separate). */
2078 stub_noname_complaint ();
2079 return make_qualified_type (type
, instance_flags
, NULL
);
2081 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
2084 /* Same as above for opaque types, we can replace the stub
2085 with the complete type only if they are in the same
2087 if (TYPE_OBJFILE (SYMBOL_TYPE(sym
)) == TYPE_OBJFILE (type
))
2088 type
= make_qualified_type (SYMBOL_TYPE (sym
),
2089 TYPE_INSTANCE_FLAGS (type
),
2092 type
= SYMBOL_TYPE (sym
);
2096 if (TYPE_TARGET_STUB (type
))
2098 struct type
*range_type
;
2099 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
2101 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
2103 /* Nothing we can do. */
2105 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
2107 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
2108 TYPE_TARGET_STUB (type
) = 0;
2112 type
= make_qualified_type (type
, instance_flags
, NULL
);
2114 /* Cache TYPE_LENGTH for future use. */
2115 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
2120 /* Parse a type expression in the string [P..P+LENGTH). If an error
2121 occurs, silently return a void type. */
2123 static struct type
*
2124 safe_parse_type (struct gdbarch
*gdbarch
, char *p
, int length
)
2126 struct ui_file
*saved_gdb_stderr
;
2127 struct type
*type
= NULL
; /* Initialize to keep gcc happy. */
2128 volatile struct gdb_exception except
;
2130 /* Suppress error messages. */
2131 saved_gdb_stderr
= gdb_stderr
;
2132 gdb_stderr
= ui_file_new ();
2134 /* Call parse_and_eval_type() without fear of longjmp()s. */
2135 TRY_CATCH (except
, RETURN_MASK_ERROR
)
2137 type
= parse_and_eval_type (p
, length
);
2140 if (except
.reason
< 0)
2141 type
= builtin_type (gdbarch
)->builtin_void
;
2143 /* Stop suppressing error messages. */
2144 ui_file_delete (gdb_stderr
);
2145 gdb_stderr
= saved_gdb_stderr
;
2150 /* Ugly hack to convert method stubs into method types.
2152 He ain't kiddin'. This demangles the name of the method into a
2153 string including argument types, parses out each argument type,
2154 generates a string casting a zero to that type, evaluates the
2155 string, and stuffs the resulting type into an argtype vector!!!
2156 Then it knows the type of the whole function (including argument
2157 types for overloading), which info used to be in the stab's but was
2158 removed to hack back the space required for them. */
2161 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
2163 struct gdbarch
*gdbarch
= get_type_arch (type
);
2165 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
2166 char *demangled_name
= gdb_demangle (mangled_name
,
2167 DMGL_PARAMS
| DMGL_ANSI
);
2168 char *argtypetext
, *p
;
2169 int depth
= 0, argcount
= 1;
2170 struct field
*argtypes
;
2173 /* Make sure we got back a function string that we can use. */
2175 p
= strchr (demangled_name
, '(');
2179 if (demangled_name
== NULL
|| p
== NULL
)
2180 error (_("Internal: Cannot demangle mangled name `%s'."),
2183 /* Now, read in the parameters that define this type. */
2188 if (*p
== '(' || *p
== '<')
2192 else if (*p
== ')' || *p
== '>')
2196 else if (*p
== ',' && depth
== 0)
2204 /* If we read one argument and it was ``void'', don't count it. */
2205 if (strncmp (argtypetext
, "(void)", 6) == 0)
2208 /* We need one extra slot, for the THIS pointer. */
2210 argtypes
= (struct field
*)
2211 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
2214 /* Add THIS pointer for non-static methods. */
2215 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
2216 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
2220 argtypes
[0].type
= lookup_pointer_type (type
);
2224 if (*p
!= ')') /* () means no args, skip while. */
2229 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
2231 /* Avoid parsing of ellipsis, they will be handled below.
2232 Also avoid ``void'' as above. */
2233 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
2234 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
2236 argtypes
[argcount
].type
=
2237 safe_parse_type (gdbarch
, argtypetext
, p
- argtypetext
);
2240 argtypetext
= p
+ 1;
2243 if (*p
== '(' || *p
== '<')
2247 else if (*p
== ')' || *p
== '>')
2256 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
2258 /* Now update the old "stub" type into a real type. */
2259 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
2260 TYPE_DOMAIN_TYPE (mtype
) = type
;
2261 TYPE_FIELDS (mtype
) = argtypes
;
2262 TYPE_NFIELDS (mtype
) = argcount
;
2263 TYPE_STUB (mtype
) = 0;
2264 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
2266 TYPE_VARARGS (mtype
) = 1;
2268 xfree (demangled_name
);
2271 /* This is the external interface to check_stub_method, above. This
2272 function unstubs all of the signatures for TYPE's METHOD_ID method
2273 name. After calling this function TYPE_FN_FIELD_STUB will be
2274 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
2277 This function unfortunately can not die until stabs do. */
2280 check_stub_method_group (struct type
*type
, int method_id
)
2282 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
2283 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
2284 int j
, found_stub
= 0;
2286 for (j
= 0; j
< len
; j
++)
2287 if (TYPE_FN_FIELD_STUB (f
, j
))
2290 check_stub_method (type
, method_id
, j
);
2293 /* GNU v3 methods with incorrect names were corrected when we read
2294 in type information, because it was cheaper to do it then. The
2295 only GNU v2 methods with incorrect method names are operators and
2296 destructors; destructors were also corrected when we read in type
2299 Therefore the only thing we need to handle here are v2 operator
2301 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
2304 char dem_opname
[256];
2306 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
2308 dem_opname
, DMGL_ANSI
);
2310 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
2314 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
2318 /* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */
2319 const struct cplus_struct_type cplus_struct_default
= { };
2322 allocate_cplus_struct_type (struct type
*type
)
2324 if (HAVE_CPLUS_STRUCT (type
))
2325 /* Structure was already allocated. Nothing more to do. */
2328 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_CPLUS_STUFF
;
2329 TYPE_RAW_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
2330 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
2331 *(TYPE_RAW_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
2334 const struct gnat_aux_type gnat_aux_default
=
2337 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
2338 and allocate the associated gnat-specific data. The gnat-specific
2339 data is also initialized to gnat_aux_default. */
2342 allocate_gnat_aux_type (struct type
*type
)
2344 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_GNAT_STUFF
;
2345 TYPE_GNAT_SPECIFIC (type
) = (struct gnat_aux_type
*)
2346 TYPE_ALLOC (type
, sizeof (struct gnat_aux_type
));
2347 *(TYPE_GNAT_SPECIFIC (type
)) = gnat_aux_default
;
2350 /* Helper function to initialize the standard scalar types.
2352 If NAME is non-NULL, then it is used to initialize the type name.
2353 Note that NAME is not copied; it is required to have a lifetime at
2354 least as long as OBJFILE. */
2357 init_type (enum type_code code
, int length
, int flags
,
2358 const char *name
, struct objfile
*objfile
)
2362 type
= alloc_type (objfile
);
2363 TYPE_CODE (type
) = code
;
2364 TYPE_LENGTH (type
) = length
;
2366 gdb_assert (!(flags
& (TYPE_FLAG_MIN
- 1)));
2367 if (flags
& TYPE_FLAG_UNSIGNED
)
2368 TYPE_UNSIGNED (type
) = 1;
2369 if (flags
& TYPE_FLAG_NOSIGN
)
2370 TYPE_NOSIGN (type
) = 1;
2371 if (flags
& TYPE_FLAG_STUB
)
2372 TYPE_STUB (type
) = 1;
2373 if (flags
& TYPE_FLAG_TARGET_STUB
)
2374 TYPE_TARGET_STUB (type
) = 1;
2375 if (flags
& TYPE_FLAG_STATIC
)
2376 TYPE_STATIC (type
) = 1;
2377 if (flags
& TYPE_FLAG_PROTOTYPED
)
2378 TYPE_PROTOTYPED (type
) = 1;
2379 if (flags
& TYPE_FLAG_INCOMPLETE
)
2380 TYPE_INCOMPLETE (type
) = 1;
2381 if (flags
& TYPE_FLAG_VARARGS
)
2382 TYPE_VARARGS (type
) = 1;
2383 if (flags
& TYPE_FLAG_VECTOR
)
2384 TYPE_VECTOR (type
) = 1;
2385 if (flags
& TYPE_FLAG_STUB_SUPPORTED
)
2386 TYPE_STUB_SUPPORTED (type
) = 1;
2387 if (flags
& TYPE_FLAG_FIXED_INSTANCE
)
2388 TYPE_FIXED_INSTANCE (type
) = 1;
2389 if (flags
& TYPE_FLAG_GNU_IFUNC
)
2390 TYPE_GNU_IFUNC (type
) = 1;
2392 TYPE_NAME (type
) = name
;
2396 if (name
&& strcmp (name
, "char") == 0)
2397 TYPE_NOSIGN (type
) = 1;
2401 case TYPE_CODE_STRUCT
:
2402 case TYPE_CODE_UNION
:
2403 case TYPE_CODE_NAMESPACE
:
2404 INIT_CPLUS_SPECIFIC (type
);
2407 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_FLOATFORMAT
;
2409 case TYPE_CODE_FUNC
:
2410 INIT_FUNC_SPECIFIC (type
);
2416 /* Queries on types. */
2419 can_dereference (struct type
*t
)
2421 /* FIXME: Should we return true for references as well as
2426 && TYPE_CODE (t
) == TYPE_CODE_PTR
2427 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
2431 is_integral_type (struct type
*t
)
2436 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
2437 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
2438 || (TYPE_CODE (t
) == TYPE_CODE_FLAGS
)
2439 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
2440 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
2441 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
2444 /* Return true if TYPE is scalar. */
2447 is_scalar_type (struct type
*type
)
2449 CHECK_TYPEDEF (type
);
2451 switch (TYPE_CODE (type
))
2453 case TYPE_CODE_ARRAY
:
2454 case TYPE_CODE_STRUCT
:
2455 case TYPE_CODE_UNION
:
2457 case TYPE_CODE_STRING
:
2464 /* Return true if T is scalar, or a composite type which in practice has
2465 the memory layout of a scalar type. E.g., an array or struct with only
2466 one scalar element inside it, or a union with only scalar elements. */
2469 is_scalar_type_recursive (struct type
*t
)
2473 if (is_scalar_type (t
))
2475 /* Are we dealing with an array or string of known dimensions? */
2476 else if ((TYPE_CODE (t
) == TYPE_CODE_ARRAY
2477 || TYPE_CODE (t
) == TYPE_CODE_STRING
) && TYPE_NFIELDS (t
) == 1
2478 && TYPE_CODE (TYPE_INDEX_TYPE (t
)) == TYPE_CODE_RANGE
)
2480 LONGEST low_bound
, high_bound
;
2481 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (t
));
2483 get_discrete_bounds (TYPE_INDEX_TYPE (t
), &low_bound
, &high_bound
);
2485 return high_bound
== low_bound
&& is_scalar_type_recursive (elt_type
);
2487 /* Are we dealing with a struct with one element? */
2488 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
&& TYPE_NFIELDS (t
) == 1)
2489 return is_scalar_type_recursive (TYPE_FIELD_TYPE (t
, 0));
2490 else if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
2492 int i
, n
= TYPE_NFIELDS (t
);
2494 /* If all elements of the union are scalar, then the union is scalar. */
2495 for (i
= 0; i
< n
; i
++)
2496 if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t
, i
)))
2505 /* A helper function which returns true if types A and B represent the
2506 "same" class type. This is true if the types have the same main
2507 type, or the same name. */
2510 class_types_same_p (const struct type
*a
, const struct type
*b
)
2512 return (TYPE_MAIN_TYPE (a
) == TYPE_MAIN_TYPE (b
)
2513 || (TYPE_NAME (a
) && TYPE_NAME (b
)
2514 && !strcmp (TYPE_NAME (a
), TYPE_NAME (b
))));
2517 /* If BASE is an ancestor of DCLASS return the distance between them.
2518 otherwise return -1;
2522 class B: public A {};
2523 class C: public B {};
2526 distance_to_ancestor (A, A, 0) = 0
2527 distance_to_ancestor (A, B, 0) = 1
2528 distance_to_ancestor (A, C, 0) = 2
2529 distance_to_ancestor (A, D, 0) = 3
2531 If PUBLIC is 1 then only public ancestors are considered,
2532 and the function returns the distance only if BASE is a public ancestor
2536 distance_to_ancestor (A, D, 1) = -1. */
2539 distance_to_ancestor (struct type
*base
, struct type
*dclass
, int public)
2544 CHECK_TYPEDEF (base
);
2545 CHECK_TYPEDEF (dclass
);
2547 if (class_types_same_p (base
, dclass
))
2550 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2552 if (public && ! BASETYPE_VIA_PUBLIC (dclass
, i
))
2555 d
= distance_to_ancestor (base
, TYPE_BASECLASS (dclass
, i
), public);
2563 /* Check whether BASE is an ancestor or base class or DCLASS
2564 Return 1 if so, and 0 if not.
2565 Note: If BASE and DCLASS are of the same type, this function
2566 will return 1. So for some class A, is_ancestor (A, A) will
2570 is_ancestor (struct type
*base
, struct type
*dclass
)
2572 return distance_to_ancestor (base
, dclass
, 0) >= 0;
2575 /* Like is_ancestor, but only returns true when BASE is a public
2576 ancestor of DCLASS. */
2579 is_public_ancestor (struct type
*base
, struct type
*dclass
)
2581 return distance_to_ancestor (base
, dclass
, 1) >= 0;
2584 /* A helper function for is_unique_ancestor. */
2587 is_unique_ancestor_worker (struct type
*base
, struct type
*dclass
,
2589 const gdb_byte
*valaddr
, int embedded_offset
,
2590 CORE_ADDR address
, struct value
*val
)
2594 CHECK_TYPEDEF (base
);
2595 CHECK_TYPEDEF (dclass
);
2597 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
) && count
< 2; ++i
)
2602 iter
= check_typedef (TYPE_BASECLASS (dclass
, i
));
2604 this_offset
= baseclass_offset (dclass
, i
, valaddr
, embedded_offset
,
2607 if (class_types_same_p (base
, iter
))
2609 /* If this is the first subclass, set *OFFSET and set count
2610 to 1. Otherwise, if this is at the same offset as
2611 previous instances, do nothing. Otherwise, increment
2615 *offset
= this_offset
;
2618 else if (this_offset
== *offset
)
2626 count
+= is_unique_ancestor_worker (base
, iter
, offset
,
2628 embedded_offset
+ this_offset
,
2635 /* Like is_ancestor, but only returns true if BASE is a unique base
2636 class of the type of VAL. */
2639 is_unique_ancestor (struct type
*base
, struct value
*val
)
2643 return is_unique_ancestor_worker (base
, value_type (val
), &offset
,
2644 value_contents_for_printing (val
),
2645 value_embedded_offset (val
),
2646 value_address (val
), val
) == 1;
2650 /* Overload resolution. */
2652 /* Return the sum of the rank of A with the rank of B. */
2655 sum_ranks (struct rank a
, struct rank b
)
2658 c
.rank
= a
.rank
+ b
.rank
;
2659 c
.subrank
= a
.subrank
+ b
.subrank
;
2663 /* Compare rank A and B and return:
2665 1 if a is better than b
2666 -1 if b is better than a. */
2669 compare_ranks (struct rank a
, struct rank b
)
2671 if (a
.rank
== b
.rank
)
2673 if (a
.subrank
== b
.subrank
)
2675 if (a
.subrank
< b
.subrank
)
2677 if (a
.subrank
> b
.subrank
)
2681 if (a
.rank
< b
.rank
)
2684 /* a.rank > b.rank */
2688 /* Functions for overload resolution begin here. */
2690 /* Compare two badness vectors A and B and return the result.
2691 0 => A and B are identical
2692 1 => A and B are incomparable
2693 2 => A is better than B
2694 3 => A is worse than B */
2697 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
2701 short found_pos
= 0; /* any positives in c? */
2702 short found_neg
= 0; /* any negatives in c? */
2704 /* differing lengths => incomparable */
2705 if (a
->length
!= b
->length
)
2708 /* Subtract b from a */
2709 for (i
= 0; i
< a
->length
; i
++)
2711 tmp
= compare_ranks (b
->rank
[i
], a
->rank
[i
]);
2721 return 1; /* incomparable */
2723 return 3; /* A > B */
2729 return 2; /* A < B */
2731 return 0; /* A == B */
2735 /* Rank a function by comparing its parameter types (PARMS, length
2736 NPARMS), to the types of an argument list (ARGS, length NARGS).
2737 Return a pointer to a badness vector. This has NARGS + 1
2740 struct badness_vector
*
2741 rank_function (struct type
**parms
, int nparms
,
2742 struct value
**args
, int nargs
)
2745 struct badness_vector
*bv
;
2746 int min_len
= nparms
< nargs
? nparms
: nargs
;
2748 bv
= xmalloc (sizeof (struct badness_vector
));
2749 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank. */
2750 bv
->rank
= XNEWVEC (struct rank
, nargs
+ 1);
2752 /* First compare the lengths of the supplied lists.
2753 If there is a mismatch, set it to a high value. */
2755 /* pai/1997-06-03 FIXME: when we have debug info about default
2756 arguments and ellipsis parameter lists, we should consider those
2757 and rank the length-match more finely. */
2759 LENGTH_MATCH (bv
) = (nargs
!= nparms
)
2760 ? LENGTH_MISMATCH_BADNESS
2761 : EXACT_MATCH_BADNESS
;
2763 /* Now rank all the parameters of the candidate function. */
2764 for (i
= 1; i
<= min_len
; i
++)
2765 bv
->rank
[i
] = rank_one_type (parms
[i
- 1], value_type (args
[i
- 1]),
2768 /* If more arguments than parameters, add dummy entries. */
2769 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2770 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2775 /* Compare the names of two integer types, assuming that any sign
2776 qualifiers have been checked already. We do it this way because
2777 there may be an "int" in the name of one of the types. */
2780 integer_types_same_name_p (const char *first
, const char *second
)
2782 int first_p
, second_p
;
2784 /* If both are shorts, return 1; if neither is a short, keep
2786 first_p
= (strstr (first
, "short") != NULL
);
2787 second_p
= (strstr (second
, "short") != NULL
);
2788 if (first_p
&& second_p
)
2790 if (first_p
|| second_p
)
2793 /* Likewise for long. */
2794 first_p
= (strstr (first
, "long") != NULL
);
2795 second_p
= (strstr (second
, "long") != NULL
);
2796 if (first_p
&& second_p
)
2798 if (first_p
|| second_p
)
2801 /* Likewise for char. */
2802 first_p
= (strstr (first
, "char") != NULL
);
2803 second_p
= (strstr (second
, "char") != NULL
);
2804 if (first_p
&& second_p
)
2806 if (first_p
|| second_p
)
2809 /* They must both be ints. */
2813 /* Compares type A to type B returns 1 if the represent the same type
2817 types_equal (struct type
*a
, struct type
*b
)
2819 /* Identical type pointers. */
2820 /* However, this still doesn't catch all cases of same type for b
2821 and a. The reason is that builtin types are different from
2822 the same ones constructed from the object. */
2826 /* Resolve typedefs */
2827 if (TYPE_CODE (a
) == TYPE_CODE_TYPEDEF
)
2828 a
= check_typedef (a
);
2829 if (TYPE_CODE (b
) == TYPE_CODE_TYPEDEF
)
2830 b
= check_typedef (b
);
2832 /* If after resolving typedefs a and b are not of the same type
2833 code then they are not equal. */
2834 if (TYPE_CODE (a
) != TYPE_CODE (b
))
2837 /* If a and b are both pointers types or both reference types then
2838 they are equal of the same type iff the objects they refer to are
2839 of the same type. */
2840 if (TYPE_CODE (a
) == TYPE_CODE_PTR
2841 || TYPE_CODE (a
) == TYPE_CODE_REF
)
2842 return types_equal (TYPE_TARGET_TYPE (a
),
2843 TYPE_TARGET_TYPE (b
));
2845 /* Well, damnit, if the names are exactly the same, I'll say they
2846 are exactly the same. This happens when we generate method
2847 stubs. The types won't point to the same address, but they
2848 really are the same. */
2850 if (TYPE_NAME (a
) && TYPE_NAME (b
)
2851 && strcmp (TYPE_NAME (a
), TYPE_NAME (b
)) == 0)
2854 /* Check if identical after resolving typedefs. */
2858 /* Two function types are equal if their argument and return types
2860 if (TYPE_CODE (a
) == TYPE_CODE_FUNC
)
2864 if (TYPE_NFIELDS (a
) != TYPE_NFIELDS (b
))
2867 if (!types_equal (TYPE_TARGET_TYPE (a
), TYPE_TARGET_TYPE (b
)))
2870 for (i
= 0; i
< TYPE_NFIELDS (a
); ++i
)
2871 if (!types_equal (TYPE_FIELD_TYPE (a
, i
), TYPE_FIELD_TYPE (b
, i
)))
2880 /* Deep comparison of types. */
2882 /* An entry in the type-equality bcache. */
2884 typedef struct type_equality_entry
2886 struct type
*type1
, *type2
;
2887 } type_equality_entry_d
;
2889 DEF_VEC_O (type_equality_entry_d
);
2891 /* A helper function to compare two strings. Returns 1 if they are
2892 the same, 0 otherwise. Handles NULLs properly. */
2895 compare_maybe_null_strings (const char *s
, const char *t
)
2897 if (s
== NULL
&& t
!= NULL
)
2899 else if (s
!= NULL
&& t
== NULL
)
2901 else if (s
== NULL
&& t
== NULL
)
2903 return strcmp (s
, t
) == 0;
2906 /* A helper function for check_types_worklist that checks two types for
2907 "deep" equality. Returns non-zero if the types are considered the
2908 same, zero otherwise. */
2911 check_types_equal (struct type
*type1
, struct type
*type2
,
2912 VEC (type_equality_entry_d
) **worklist
)
2914 CHECK_TYPEDEF (type1
);
2915 CHECK_TYPEDEF (type2
);
2920 if (TYPE_CODE (type1
) != TYPE_CODE (type2
)
2921 || TYPE_LENGTH (type1
) != TYPE_LENGTH (type2
)
2922 || TYPE_UNSIGNED (type1
) != TYPE_UNSIGNED (type2
)
2923 || TYPE_NOSIGN (type1
) != TYPE_NOSIGN (type2
)
2924 || TYPE_VARARGS (type1
) != TYPE_VARARGS (type2
)
2925 || TYPE_VECTOR (type1
) != TYPE_VECTOR (type2
)
2926 || TYPE_NOTTEXT (type1
) != TYPE_NOTTEXT (type2
)
2927 || TYPE_INSTANCE_FLAGS (type1
) != TYPE_INSTANCE_FLAGS (type2
)
2928 || TYPE_NFIELDS (type1
) != TYPE_NFIELDS (type2
))
2931 if (!compare_maybe_null_strings (TYPE_TAG_NAME (type1
),
2932 TYPE_TAG_NAME (type2
)))
2934 if (!compare_maybe_null_strings (TYPE_NAME (type1
), TYPE_NAME (type2
)))
2937 if (TYPE_CODE (type1
) == TYPE_CODE_RANGE
)
2939 if (memcmp (TYPE_RANGE_DATA (type1
), TYPE_RANGE_DATA (type2
),
2940 sizeof (*TYPE_RANGE_DATA (type1
))) != 0)
2947 for (i
= 0; i
< TYPE_NFIELDS (type1
); ++i
)
2949 const struct field
*field1
= &TYPE_FIELD (type1
, i
);
2950 const struct field
*field2
= &TYPE_FIELD (type2
, i
);
2951 struct type_equality_entry entry
;
2953 if (FIELD_ARTIFICIAL (*field1
) != FIELD_ARTIFICIAL (*field2
)
2954 || FIELD_BITSIZE (*field1
) != FIELD_BITSIZE (*field2
)
2955 || FIELD_LOC_KIND (*field1
) != FIELD_LOC_KIND (*field2
))
2957 if (!compare_maybe_null_strings (FIELD_NAME (*field1
),
2958 FIELD_NAME (*field2
)))
2960 switch (FIELD_LOC_KIND (*field1
))
2962 case FIELD_LOC_KIND_BITPOS
:
2963 if (FIELD_BITPOS (*field1
) != FIELD_BITPOS (*field2
))
2966 case FIELD_LOC_KIND_ENUMVAL
:
2967 if (FIELD_ENUMVAL (*field1
) != FIELD_ENUMVAL (*field2
))
2970 case FIELD_LOC_KIND_PHYSADDR
:
2971 if (FIELD_STATIC_PHYSADDR (*field1
)
2972 != FIELD_STATIC_PHYSADDR (*field2
))
2975 case FIELD_LOC_KIND_PHYSNAME
:
2976 if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1
),
2977 FIELD_STATIC_PHYSNAME (*field2
)))
2980 case FIELD_LOC_KIND_DWARF_BLOCK
:
2982 struct dwarf2_locexpr_baton
*block1
, *block2
;
2984 block1
= FIELD_DWARF_BLOCK (*field1
);
2985 block2
= FIELD_DWARF_BLOCK (*field2
);
2986 if (block1
->per_cu
!= block2
->per_cu
2987 || block1
->size
!= block2
->size
2988 || memcmp (block1
->data
, block2
->data
, block1
->size
) != 0)
2993 internal_error (__FILE__
, __LINE__
, _("Unsupported field kind "
2994 "%d by check_types_equal"),
2995 FIELD_LOC_KIND (*field1
));
2998 entry
.type1
= FIELD_TYPE (*field1
);
2999 entry
.type2
= FIELD_TYPE (*field2
);
3000 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
3004 if (TYPE_TARGET_TYPE (type1
) != NULL
)
3006 struct type_equality_entry entry
;
3008 if (TYPE_TARGET_TYPE (type2
) == NULL
)
3011 entry
.type1
= TYPE_TARGET_TYPE (type1
);
3012 entry
.type2
= TYPE_TARGET_TYPE (type2
);
3013 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
3015 else if (TYPE_TARGET_TYPE (type2
) != NULL
)
3021 /* Check types on a worklist for equality. Returns zero if any pair
3022 is not equal, non-zero if they are all considered equal. */
3025 check_types_worklist (VEC (type_equality_entry_d
) **worklist
,
3026 struct bcache
*cache
)
3028 while (!VEC_empty (type_equality_entry_d
, *worklist
))
3030 struct type_equality_entry entry
;
3033 entry
= *VEC_last (type_equality_entry_d
, *worklist
);
3034 VEC_pop (type_equality_entry_d
, *worklist
);
3036 /* If the type pair has already been visited, we know it is
3038 bcache_full (&entry
, sizeof (entry
), cache
, &added
);
3042 if (check_types_equal (entry
.type1
, entry
.type2
, worklist
) == 0)
3049 /* Return non-zero if types TYPE1 and TYPE2 are equal, as determined by a
3050 "deep comparison". Otherwise return zero. */
3053 types_deeply_equal (struct type
*type1
, struct type
*type2
)
3055 volatile struct gdb_exception except
;
3057 struct bcache
*cache
;
3058 VEC (type_equality_entry_d
) *worklist
= NULL
;
3059 struct type_equality_entry entry
;
3061 gdb_assert (type1
!= NULL
&& type2
!= NULL
);
3063 /* Early exit for the simple case. */
3067 cache
= bcache_xmalloc (NULL
, NULL
);
3069 entry
.type1
= type1
;
3070 entry
.type2
= type2
;
3071 VEC_safe_push (type_equality_entry_d
, worklist
, &entry
);
3073 TRY_CATCH (except
, RETURN_MASK_ALL
)
3075 result
= check_types_worklist (&worklist
, cache
);
3077 /* check_types_worklist calls several nested helper functions,
3078 some of which can raise a GDB Exception, so we just check
3079 and rethrow here. If there is a GDB exception, a comparison
3080 is not capable (or trusted), so exit. */
3081 bcache_xfree (cache
);
3082 VEC_free (type_equality_entry_d
, worklist
);
3083 /* Rethrow if there was a problem. */
3084 if (except
.reason
< 0)
3085 throw_exception (except
);
3090 /* Compare one type (PARM) for compatibility with another (ARG).
3091 * PARM is intended to be the parameter type of a function; and
3092 * ARG is the supplied argument's type. This function tests if
3093 * the latter can be converted to the former.
3094 * VALUE is the argument's value or NULL if none (or called recursively)
3096 * Return 0 if they are identical types;
3097 * Otherwise, return an integer which corresponds to how compatible
3098 * PARM is to ARG. The higher the return value, the worse the match.
3099 * Generally the "bad" conversions are all uniformly assigned a 100. */
3102 rank_one_type (struct type
*parm
, struct type
*arg
, struct value
*value
)
3104 struct rank rank
= {0,0};
3106 if (types_equal (parm
, arg
))
3107 return EXACT_MATCH_BADNESS
;
3109 /* Resolve typedefs */
3110 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
3111 parm
= check_typedef (parm
);
3112 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
3113 arg
= check_typedef (arg
);
3115 /* See through references, since we can almost make non-references
3117 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
3118 return (sum_ranks (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
),
3119 REFERENCE_CONVERSION_BADNESS
));
3120 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
3121 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
),
3122 REFERENCE_CONVERSION_BADNESS
));
3124 /* Debugging only. */
3125 fprintf_filtered (gdb_stderr
,
3126 "------ Arg is %s [%d], parm is %s [%d]\n",
3127 TYPE_NAME (arg
), TYPE_CODE (arg
),
3128 TYPE_NAME (parm
), TYPE_CODE (parm
));
3130 /* x -> y means arg of type x being supplied for parameter of type y. */
3132 switch (TYPE_CODE (parm
))
3135 switch (TYPE_CODE (arg
))
3139 /* Allowed pointer conversions are:
3140 (a) pointer to void-pointer conversion. */
3141 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
3142 return VOID_PTR_CONVERSION_BADNESS
;
3144 /* (b) pointer to ancestor-pointer conversion. */
3145 rank
.subrank
= distance_to_ancestor (TYPE_TARGET_TYPE (parm
),
3146 TYPE_TARGET_TYPE (arg
),
3148 if (rank
.subrank
>= 0)
3149 return sum_ranks (BASE_PTR_CONVERSION_BADNESS
, rank
);
3151 return INCOMPATIBLE_TYPE_BADNESS
;
3152 case TYPE_CODE_ARRAY
:
3153 if (types_equal (TYPE_TARGET_TYPE (parm
),
3154 TYPE_TARGET_TYPE (arg
)))
3155 return EXACT_MATCH_BADNESS
;
3156 return INCOMPATIBLE_TYPE_BADNESS
;
3157 case TYPE_CODE_FUNC
:
3158 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
);
3160 if (value
!= NULL
&& TYPE_CODE (value_type (value
)) == TYPE_CODE_INT
)
3162 if (value_as_long (value
) == 0)
3164 /* Null pointer conversion: allow it to be cast to a pointer.
3165 [4.10.1 of C++ standard draft n3290] */
3166 return NULL_POINTER_CONVERSION_BADNESS
;
3170 /* If type checking is disabled, allow the conversion. */
3171 if (!strict_type_checking
)
3172 return NS_INTEGER_POINTER_CONVERSION_BADNESS
;
3176 case TYPE_CODE_ENUM
:
3177 case TYPE_CODE_FLAGS
:
3178 case TYPE_CODE_CHAR
:
3179 case TYPE_CODE_RANGE
:
3180 case TYPE_CODE_BOOL
:
3182 return INCOMPATIBLE_TYPE_BADNESS
;
3184 case TYPE_CODE_ARRAY
:
3185 switch (TYPE_CODE (arg
))
3188 case TYPE_CODE_ARRAY
:
3189 return rank_one_type (TYPE_TARGET_TYPE (parm
),
3190 TYPE_TARGET_TYPE (arg
), NULL
);
3192 return INCOMPATIBLE_TYPE_BADNESS
;
3194 case TYPE_CODE_FUNC
:
3195 switch (TYPE_CODE (arg
))
3197 case TYPE_CODE_PTR
: /* funcptr -> func */
3198 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
);
3200 return INCOMPATIBLE_TYPE_BADNESS
;
3203 switch (TYPE_CODE (arg
))
3206 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
3208 /* Deal with signed, unsigned, and plain chars and
3209 signed and unsigned ints. */
3210 if (TYPE_NOSIGN (parm
))
3212 /* This case only for character types. */
3213 if (TYPE_NOSIGN (arg
))
3214 return EXACT_MATCH_BADNESS
; /* plain char -> plain char */
3215 else /* signed/unsigned char -> plain char */
3216 return INTEGER_CONVERSION_BADNESS
;
3218 else if (TYPE_UNSIGNED (parm
))
3220 if (TYPE_UNSIGNED (arg
))
3222 /* unsigned int -> unsigned int, or
3223 unsigned long -> unsigned long */
3224 if (integer_types_same_name_p (TYPE_NAME (parm
),
3226 return EXACT_MATCH_BADNESS
;
3227 else if (integer_types_same_name_p (TYPE_NAME (arg
),
3229 && integer_types_same_name_p (TYPE_NAME (parm
),
3231 /* unsigned int -> unsigned long */
3232 return INTEGER_PROMOTION_BADNESS
;
3234 /* unsigned long -> unsigned int */
3235 return INTEGER_CONVERSION_BADNESS
;
3239 if (integer_types_same_name_p (TYPE_NAME (arg
),
3241 && integer_types_same_name_p (TYPE_NAME (parm
),
3243 /* signed long -> unsigned int */
3244 return INTEGER_CONVERSION_BADNESS
;
3246 /* signed int/long -> unsigned int/long */
3247 return INTEGER_CONVERSION_BADNESS
;
3250 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
3252 if (integer_types_same_name_p (TYPE_NAME (parm
),
3254 return EXACT_MATCH_BADNESS
;
3255 else if (integer_types_same_name_p (TYPE_NAME (arg
),
3257 && integer_types_same_name_p (TYPE_NAME (parm
),
3259 return INTEGER_PROMOTION_BADNESS
;
3261 return INTEGER_CONVERSION_BADNESS
;
3264 return INTEGER_CONVERSION_BADNESS
;
3266 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
3267 return INTEGER_PROMOTION_BADNESS
;
3269 return INTEGER_CONVERSION_BADNESS
;
3270 case TYPE_CODE_ENUM
:
3271 case TYPE_CODE_FLAGS
:
3272 case TYPE_CODE_CHAR
:
3273 case TYPE_CODE_RANGE
:
3274 case TYPE_CODE_BOOL
:
3275 if (TYPE_DECLARED_CLASS (arg
))
3276 return INCOMPATIBLE_TYPE_BADNESS
;
3277 return INTEGER_PROMOTION_BADNESS
;
3279 return INT_FLOAT_CONVERSION_BADNESS
;
3281 return NS_POINTER_CONVERSION_BADNESS
;
3283 return INCOMPATIBLE_TYPE_BADNESS
;
3286 case TYPE_CODE_ENUM
:
3287 switch (TYPE_CODE (arg
))
3290 case TYPE_CODE_CHAR
:
3291 case TYPE_CODE_RANGE
:
3292 case TYPE_CODE_BOOL
:
3293 case TYPE_CODE_ENUM
:
3294 if (TYPE_DECLARED_CLASS (parm
) || TYPE_DECLARED_CLASS (arg
))
3295 return INCOMPATIBLE_TYPE_BADNESS
;
3296 return INTEGER_CONVERSION_BADNESS
;
3298 return INT_FLOAT_CONVERSION_BADNESS
;
3300 return INCOMPATIBLE_TYPE_BADNESS
;
3303 case TYPE_CODE_CHAR
:
3304 switch (TYPE_CODE (arg
))
3306 case TYPE_CODE_RANGE
:
3307 case TYPE_CODE_BOOL
:
3308 case TYPE_CODE_ENUM
:
3309 if (TYPE_DECLARED_CLASS (arg
))
3310 return INCOMPATIBLE_TYPE_BADNESS
;
3311 return INTEGER_CONVERSION_BADNESS
;
3313 return INT_FLOAT_CONVERSION_BADNESS
;
3315 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
3316 return INTEGER_CONVERSION_BADNESS
;
3317 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
3318 return INTEGER_PROMOTION_BADNESS
;
3319 /* >>> !! else fall through !! <<< */
3320 case TYPE_CODE_CHAR
:
3321 /* Deal with signed, unsigned, and plain chars for C++ and
3322 with int cases falling through from previous case. */
3323 if (TYPE_NOSIGN (parm
))
3325 if (TYPE_NOSIGN (arg
))
3326 return EXACT_MATCH_BADNESS
;
3328 return INTEGER_CONVERSION_BADNESS
;
3330 else if (TYPE_UNSIGNED (parm
))
3332 if (TYPE_UNSIGNED (arg
))
3333 return EXACT_MATCH_BADNESS
;
3335 return INTEGER_PROMOTION_BADNESS
;
3337 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
3338 return EXACT_MATCH_BADNESS
;
3340 return INTEGER_CONVERSION_BADNESS
;
3342 return INCOMPATIBLE_TYPE_BADNESS
;
3345 case TYPE_CODE_RANGE
:
3346 switch (TYPE_CODE (arg
))
3349 case TYPE_CODE_CHAR
:
3350 case TYPE_CODE_RANGE
:
3351 case TYPE_CODE_BOOL
:
3352 case TYPE_CODE_ENUM
:
3353 return INTEGER_CONVERSION_BADNESS
;
3355 return INT_FLOAT_CONVERSION_BADNESS
;
3357 return INCOMPATIBLE_TYPE_BADNESS
;
3360 case TYPE_CODE_BOOL
:
3361 switch (TYPE_CODE (arg
))
3363 /* n3290 draft, section 4.12.1 (conv.bool):
3365 "A prvalue of arithmetic, unscoped enumeration, pointer, or
3366 pointer to member type can be converted to a prvalue of type
3367 bool. A zero value, null pointer value, or null member pointer
3368 value is converted to false; any other value is converted to
3369 true. A prvalue of type std::nullptr_t can be converted to a
3370 prvalue of type bool; the resulting value is false." */
3372 case TYPE_CODE_CHAR
:
3373 case TYPE_CODE_ENUM
:
3375 case TYPE_CODE_MEMBERPTR
:
3377 return BOOL_CONVERSION_BADNESS
;
3378 case TYPE_CODE_RANGE
:
3379 return INCOMPATIBLE_TYPE_BADNESS
;
3380 case TYPE_CODE_BOOL
:
3381 return EXACT_MATCH_BADNESS
;
3383 return INCOMPATIBLE_TYPE_BADNESS
;
3387 switch (TYPE_CODE (arg
))
3390 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
3391 return FLOAT_PROMOTION_BADNESS
;
3392 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
3393 return EXACT_MATCH_BADNESS
;
3395 return FLOAT_CONVERSION_BADNESS
;
3397 case TYPE_CODE_BOOL
:
3398 case TYPE_CODE_ENUM
:
3399 case TYPE_CODE_RANGE
:
3400 case TYPE_CODE_CHAR
:
3401 return INT_FLOAT_CONVERSION_BADNESS
;
3403 return INCOMPATIBLE_TYPE_BADNESS
;
3406 case TYPE_CODE_COMPLEX
:
3407 switch (TYPE_CODE (arg
))
3408 { /* Strictly not needed for C++, but... */
3410 return FLOAT_PROMOTION_BADNESS
;
3411 case TYPE_CODE_COMPLEX
:
3412 return EXACT_MATCH_BADNESS
;
3414 return INCOMPATIBLE_TYPE_BADNESS
;
3417 case TYPE_CODE_STRUCT
:
3418 /* currently same as TYPE_CODE_CLASS. */
3419 switch (TYPE_CODE (arg
))
3421 case TYPE_CODE_STRUCT
:
3422 /* Check for derivation */
3423 rank
.subrank
= distance_to_ancestor (parm
, arg
, 0);
3424 if (rank
.subrank
>= 0)
3425 return sum_ranks (BASE_CONVERSION_BADNESS
, rank
);
3426 /* else fall through */
3428 return INCOMPATIBLE_TYPE_BADNESS
;
3431 case TYPE_CODE_UNION
:
3432 switch (TYPE_CODE (arg
))
3434 case TYPE_CODE_UNION
:
3436 return INCOMPATIBLE_TYPE_BADNESS
;
3439 case TYPE_CODE_MEMBERPTR
:
3440 switch (TYPE_CODE (arg
))
3443 return INCOMPATIBLE_TYPE_BADNESS
;
3446 case TYPE_CODE_METHOD
:
3447 switch (TYPE_CODE (arg
))
3451 return INCOMPATIBLE_TYPE_BADNESS
;
3455 switch (TYPE_CODE (arg
))
3459 return INCOMPATIBLE_TYPE_BADNESS
;
3464 switch (TYPE_CODE (arg
))
3468 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0),
3469 TYPE_FIELD_TYPE (arg
, 0), NULL
);
3471 return INCOMPATIBLE_TYPE_BADNESS
;
3474 case TYPE_CODE_VOID
:
3476 return INCOMPATIBLE_TYPE_BADNESS
;
3477 } /* switch (TYPE_CODE (arg)) */
3480 /* End of functions for overload resolution. */
3482 /* Routines to pretty-print types. */
3485 print_bit_vector (B_TYPE
*bits
, int nbits
)
3489 for (bitno
= 0; bitno
< nbits
; bitno
++)
3491 if ((bitno
% 8) == 0)
3493 puts_filtered (" ");
3495 if (B_TST (bits
, bitno
))
3496 printf_filtered (("1"));
3498 printf_filtered (("0"));
3502 /* Note the first arg should be the "this" pointer, we may not want to
3503 include it since we may get into a infinitely recursive
3507 print_arg_types (struct field
*args
, int nargs
, int spaces
)
3513 for (i
= 0; i
< nargs
; i
++)
3514 recursive_dump_type (args
[i
].type
, spaces
+ 2);
3519 field_is_static (struct field
*f
)
3521 /* "static" fields are the fields whose location is not relative
3522 to the address of the enclosing struct. It would be nice to
3523 have a dedicated flag that would be set for static fields when
3524 the type is being created. But in practice, checking the field
3525 loc_kind should give us an accurate answer. */
3526 return (FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSNAME
3527 || FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSADDR
);
3531 dump_fn_fieldlists (struct type
*type
, int spaces
)
3537 printfi_filtered (spaces
, "fn_fieldlists ");
3538 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
3539 printf_filtered ("\n");
3540 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
3542 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
3543 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
3545 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
3546 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
3548 printf_filtered (_(") length %d\n"),
3549 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
3550 for (overload_idx
= 0;
3551 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
3554 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
3556 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
3557 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
3559 printf_filtered (")\n");
3560 printfi_filtered (spaces
+ 8, "type ");
3561 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
3563 printf_filtered ("\n");
3565 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
3568 printfi_filtered (spaces
+ 8, "args ");
3569 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
3571 printf_filtered ("\n");
3573 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
3574 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
,
3577 printfi_filtered (spaces
+ 8, "fcontext ");
3578 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
3580 printf_filtered ("\n");
3582 printfi_filtered (spaces
+ 8, "is_const %d\n",
3583 TYPE_FN_FIELD_CONST (f
, overload_idx
));
3584 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
3585 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
3586 printfi_filtered (spaces
+ 8, "is_private %d\n",
3587 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
3588 printfi_filtered (spaces
+ 8, "is_protected %d\n",
3589 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
3590 printfi_filtered (spaces
+ 8, "is_stub %d\n",
3591 TYPE_FN_FIELD_STUB (f
, overload_idx
));
3592 printfi_filtered (spaces
+ 8, "voffset %u\n",
3593 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
3599 print_cplus_stuff (struct type
*type
, int spaces
)
3601 printfi_filtered (spaces
, "n_baseclasses %d\n",
3602 TYPE_N_BASECLASSES (type
));
3603 printfi_filtered (spaces
, "nfn_fields %d\n",
3604 TYPE_NFN_FIELDS (type
));
3605 if (TYPE_N_BASECLASSES (type
) > 0)
3607 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
3608 TYPE_N_BASECLASSES (type
));
3609 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
3611 printf_filtered (")");
3613 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
3614 TYPE_N_BASECLASSES (type
));
3615 puts_filtered ("\n");
3617 if (TYPE_NFIELDS (type
) > 0)
3619 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
3621 printfi_filtered (spaces
,
3622 "private_field_bits (%d bits at *",
3623 TYPE_NFIELDS (type
));
3624 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
3626 printf_filtered (")");
3627 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
3628 TYPE_NFIELDS (type
));
3629 puts_filtered ("\n");
3631 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
3633 printfi_filtered (spaces
,
3634 "protected_field_bits (%d bits at *",
3635 TYPE_NFIELDS (type
));
3636 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
3638 printf_filtered (")");
3639 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
3640 TYPE_NFIELDS (type
));
3641 puts_filtered ("\n");
3644 if (TYPE_NFN_FIELDS (type
) > 0)
3646 dump_fn_fieldlists (type
, spaces
);
3650 /* Print the contents of the TYPE's type_specific union, assuming that
3651 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
3654 print_gnat_stuff (struct type
*type
, int spaces
)
3656 struct type
*descriptive_type
= TYPE_DESCRIPTIVE_TYPE (type
);
3658 recursive_dump_type (descriptive_type
, spaces
+ 2);
3661 static struct obstack dont_print_type_obstack
;
3664 recursive_dump_type (struct type
*type
, int spaces
)
3669 obstack_begin (&dont_print_type_obstack
, 0);
3671 if (TYPE_NFIELDS (type
) > 0
3672 || (HAVE_CPLUS_STRUCT (type
) && TYPE_NFN_FIELDS (type
) > 0))
3674 struct type
**first_dont_print
3675 = (struct type
**) obstack_base (&dont_print_type_obstack
);
3677 int i
= (struct type
**)
3678 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
3682 if (type
== first_dont_print
[i
])
3684 printfi_filtered (spaces
, "type node ");
3685 gdb_print_host_address (type
, gdb_stdout
);
3686 printf_filtered (_(" <same as already seen type>\n"));
3691 obstack_ptr_grow (&dont_print_type_obstack
, type
);
3694 printfi_filtered (spaces
, "type node ");
3695 gdb_print_host_address (type
, gdb_stdout
);
3696 printf_filtered ("\n");
3697 printfi_filtered (spaces
, "name '%s' (",
3698 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
3699 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
3700 printf_filtered (")\n");
3701 printfi_filtered (spaces
, "tagname '%s' (",
3702 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
3703 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
3704 printf_filtered (")\n");
3705 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
3706 switch (TYPE_CODE (type
))
3708 case TYPE_CODE_UNDEF
:
3709 printf_filtered ("(TYPE_CODE_UNDEF)");
3712 printf_filtered ("(TYPE_CODE_PTR)");
3714 case TYPE_CODE_ARRAY
:
3715 printf_filtered ("(TYPE_CODE_ARRAY)");
3717 case TYPE_CODE_STRUCT
:
3718 printf_filtered ("(TYPE_CODE_STRUCT)");
3720 case TYPE_CODE_UNION
:
3721 printf_filtered ("(TYPE_CODE_UNION)");
3723 case TYPE_CODE_ENUM
:
3724 printf_filtered ("(TYPE_CODE_ENUM)");
3726 case TYPE_CODE_FLAGS
:
3727 printf_filtered ("(TYPE_CODE_FLAGS)");
3729 case TYPE_CODE_FUNC
:
3730 printf_filtered ("(TYPE_CODE_FUNC)");
3733 printf_filtered ("(TYPE_CODE_INT)");
3736 printf_filtered ("(TYPE_CODE_FLT)");
3738 case TYPE_CODE_VOID
:
3739 printf_filtered ("(TYPE_CODE_VOID)");
3742 printf_filtered ("(TYPE_CODE_SET)");
3744 case TYPE_CODE_RANGE
:
3745 printf_filtered ("(TYPE_CODE_RANGE)");
3747 case TYPE_CODE_STRING
:
3748 printf_filtered ("(TYPE_CODE_STRING)");
3750 case TYPE_CODE_ERROR
:
3751 printf_filtered ("(TYPE_CODE_ERROR)");
3753 case TYPE_CODE_MEMBERPTR
:
3754 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
3756 case TYPE_CODE_METHODPTR
:
3757 printf_filtered ("(TYPE_CODE_METHODPTR)");
3759 case TYPE_CODE_METHOD
:
3760 printf_filtered ("(TYPE_CODE_METHOD)");
3763 printf_filtered ("(TYPE_CODE_REF)");
3765 case TYPE_CODE_CHAR
:
3766 printf_filtered ("(TYPE_CODE_CHAR)");
3768 case TYPE_CODE_BOOL
:
3769 printf_filtered ("(TYPE_CODE_BOOL)");
3771 case TYPE_CODE_COMPLEX
:
3772 printf_filtered ("(TYPE_CODE_COMPLEX)");
3774 case TYPE_CODE_TYPEDEF
:
3775 printf_filtered ("(TYPE_CODE_TYPEDEF)");
3777 case TYPE_CODE_NAMESPACE
:
3778 printf_filtered ("(TYPE_CODE_NAMESPACE)");
3781 printf_filtered ("(UNKNOWN TYPE CODE)");
3784 puts_filtered ("\n");
3785 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
3786 if (TYPE_OBJFILE_OWNED (type
))
3788 printfi_filtered (spaces
, "objfile ");
3789 gdb_print_host_address (TYPE_OWNER (type
).objfile
, gdb_stdout
);
3793 printfi_filtered (spaces
, "gdbarch ");
3794 gdb_print_host_address (TYPE_OWNER (type
).gdbarch
, gdb_stdout
);
3796 printf_filtered ("\n");
3797 printfi_filtered (spaces
, "target_type ");
3798 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
3799 printf_filtered ("\n");
3800 if (TYPE_TARGET_TYPE (type
) != NULL
)
3802 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
3804 printfi_filtered (spaces
, "pointer_type ");
3805 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
3806 printf_filtered ("\n");
3807 printfi_filtered (spaces
, "reference_type ");
3808 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
3809 printf_filtered ("\n");
3810 printfi_filtered (spaces
, "type_chain ");
3811 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
3812 printf_filtered ("\n");
3813 printfi_filtered (spaces
, "instance_flags 0x%x",
3814 TYPE_INSTANCE_FLAGS (type
));
3815 if (TYPE_CONST (type
))
3817 puts_filtered (" TYPE_FLAG_CONST");
3819 if (TYPE_VOLATILE (type
))
3821 puts_filtered (" TYPE_FLAG_VOLATILE");
3823 if (TYPE_CODE_SPACE (type
))
3825 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3827 if (TYPE_DATA_SPACE (type
))
3829 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3831 if (TYPE_ADDRESS_CLASS_1 (type
))
3833 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3835 if (TYPE_ADDRESS_CLASS_2 (type
))
3837 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3839 if (TYPE_RESTRICT (type
))
3841 puts_filtered (" TYPE_FLAG_RESTRICT");
3843 puts_filtered ("\n");
3845 printfi_filtered (spaces
, "flags");
3846 if (TYPE_UNSIGNED (type
))
3848 puts_filtered (" TYPE_FLAG_UNSIGNED");
3850 if (TYPE_NOSIGN (type
))
3852 puts_filtered (" TYPE_FLAG_NOSIGN");
3854 if (TYPE_STUB (type
))
3856 puts_filtered (" TYPE_FLAG_STUB");
3858 if (TYPE_TARGET_STUB (type
))
3860 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3862 if (TYPE_STATIC (type
))
3864 puts_filtered (" TYPE_FLAG_STATIC");
3866 if (TYPE_PROTOTYPED (type
))
3868 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3870 if (TYPE_INCOMPLETE (type
))
3872 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3874 if (TYPE_VARARGS (type
))
3876 puts_filtered (" TYPE_FLAG_VARARGS");
3878 /* This is used for things like AltiVec registers on ppc. Gcc emits
3879 an attribute for the array type, which tells whether or not we
3880 have a vector, instead of a regular array. */
3881 if (TYPE_VECTOR (type
))
3883 puts_filtered (" TYPE_FLAG_VECTOR");
3885 if (TYPE_FIXED_INSTANCE (type
))
3887 puts_filtered (" TYPE_FIXED_INSTANCE");
3889 if (TYPE_STUB_SUPPORTED (type
))
3891 puts_filtered (" TYPE_STUB_SUPPORTED");
3893 if (TYPE_NOTTEXT (type
))
3895 puts_filtered (" TYPE_NOTTEXT");
3897 puts_filtered ("\n");
3898 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
3899 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
3900 puts_filtered ("\n");
3901 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
3903 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
3904 printfi_filtered (spaces
+ 2,
3905 "[%d] enumval %s type ",
3906 idx
, plongest (TYPE_FIELD_ENUMVAL (type
, idx
)));
3908 printfi_filtered (spaces
+ 2,
3909 "[%d] bitpos %d bitsize %d type ",
3910 idx
, TYPE_FIELD_BITPOS (type
, idx
),
3911 TYPE_FIELD_BITSIZE (type
, idx
));
3912 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
3913 printf_filtered (" name '%s' (",
3914 TYPE_FIELD_NAME (type
, idx
) != NULL
3915 ? TYPE_FIELD_NAME (type
, idx
)
3917 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
3918 printf_filtered (")\n");
3919 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
3921 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
3924 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
3926 printfi_filtered (spaces
, "low %s%s high %s%s\n",
3927 plongest (TYPE_LOW_BOUND (type
)),
3928 TYPE_LOW_BOUND_UNDEFINED (type
) ? " (undefined)" : "",
3929 plongest (TYPE_HIGH_BOUND (type
)),
3930 TYPE_HIGH_BOUND_UNDEFINED (type
)
3931 ? " (undefined)" : "");
3933 printfi_filtered (spaces
, "vptr_basetype ");
3934 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
3935 puts_filtered ("\n");
3936 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
3938 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
3940 printfi_filtered (spaces
, "vptr_fieldno %d\n",
3941 TYPE_VPTR_FIELDNO (type
));
3943 switch (TYPE_SPECIFIC_FIELD (type
))
3945 case TYPE_SPECIFIC_CPLUS_STUFF
:
3946 printfi_filtered (spaces
, "cplus_stuff ");
3947 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
),
3949 puts_filtered ("\n");
3950 print_cplus_stuff (type
, spaces
);
3953 case TYPE_SPECIFIC_GNAT_STUFF
:
3954 printfi_filtered (spaces
, "gnat_stuff ");
3955 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type
), gdb_stdout
);
3956 puts_filtered ("\n");
3957 print_gnat_stuff (type
, spaces
);
3960 case TYPE_SPECIFIC_FLOATFORMAT
:
3961 printfi_filtered (spaces
, "floatformat ");
3962 if (TYPE_FLOATFORMAT (type
) == NULL
)
3963 puts_filtered ("(null)");
3966 puts_filtered ("{ ");
3967 if (TYPE_FLOATFORMAT (type
)[0] == NULL
3968 || TYPE_FLOATFORMAT (type
)[0]->name
== NULL
)
3969 puts_filtered ("(null)");
3971 puts_filtered (TYPE_FLOATFORMAT (type
)[0]->name
);
3973 puts_filtered (", ");
3974 if (TYPE_FLOATFORMAT (type
)[1] == NULL
3975 || TYPE_FLOATFORMAT (type
)[1]->name
== NULL
)
3976 puts_filtered ("(null)");
3978 puts_filtered (TYPE_FLOATFORMAT (type
)[1]->name
);
3980 puts_filtered (" }");
3982 puts_filtered ("\n");
3985 case TYPE_SPECIFIC_FUNC
:
3986 printfi_filtered (spaces
, "calling_convention %d\n",
3987 TYPE_CALLING_CONVENTION (type
));
3988 /* tail_call_list is not printed. */
3993 obstack_free (&dont_print_type_obstack
, NULL
);
3996 /* Trivial helpers for the libiberty hash table, for mapping one
4001 struct type
*old
, *new;
4005 type_pair_hash (const void *item
)
4007 const struct type_pair
*pair
= item
;
4009 return htab_hash_pointer (pair
->old
);
4013 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
4015 const struct type_pair
*lhs
= item_lhs
, *rhs
= item_rhs
;
4017 return lhs
->old
== rhs
->old
;
4020 /* Allocate the hash table used by copy_type_recursive to walk
4021 types without duplicates. We use OBJFILE's obstack, because
4022 OBJFILE is about to be deleted. */
4025 create_copied_types_hash (struct objfile
*objfile
)
4027 return htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
4028 NULL
, &objfile
->objfile_obstack
,
4029 hashtab_obstack_allocate
,
4030 dummy_obstack_deallocate
);
4033 /* Recursively copy (deep copy) TYPE, if it is associated with
4034 OBJFILE. Return a new type allocated using malloc, a saved type if
4035 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
4036 not associated with OBJFILE. */
4039 copy_type_recursive (struct objfile
*objfile
,
4041 htab_t copied_types
)
4043 struct type_pair
*stored
, pair
;
4045 struct type
*new_type
;
4047 if (! TYPE_OBJFILE_OWNED (type
))
4050 /* This type shouldn't be pointing to any types in other objfiles;
4051 if it did, the type might disappear unexpectedly. */
4052 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
4055 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
4057 return ((struct type_pair
*) *slot
)->new;
4059 new_type
= alloc_type_arch (get_type_arch (type
));
4061 /* We must add the new type to the hash table immediately, in case
4062 we encounter this type again during a recursive call below. */
4064 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct type_pair
));
4066 stored
->new = new_type
;
4069 /* Copy the common fields of types. For the main type, we simply
4070 copy the entire thing and then update specific fields as needed. */
4071 *TYPE_MAIN_TYPE (new_type
) = *TYPE_MAIN_TYPE (type
);
4072 TYPE_OBJFILE_OWNED (new_type
) = 0;
4073 TYPE_OWNER (new_type
).gdbarch
= get_type_arch (type
);
4075 if (TYPE_NAME (type
))
4076 TYPE_NAME (new_type
) = xstrdup (TYPE_NAME (type
));
4077 if (TYPE_TAG_NAME (type
))
4078 TYPE_TAG_NAME (new_type
) = xstrdup (TYPE_TAG_NAME (type
));
4080 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
4081 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
4083 /* Copy the fields. */
4084 if (TYPE_NFIELDS (type
))
4088 nfields
= TYPE_NFIELDS (type
);
4089 TYPE_FIELDS (new_type
) = XCNEWVEC (struct field
, nfields
);
4090 for (i
= 0; i
< nfields
; i
++)
4092 TYPE_FIELD_ARTIFICIAL (new_type
, i
) =
4093 TYPE_FIELD_ARTIFICIAL (type
, i
);
4094 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
4095 if (TYPE_FIELD_TYPE (type
, i
))
4096 TYPE_FIELD_TYPE (new_type
, i
)
4097 = copy_type_recursive (objfile
, TYPE_FIELD_TYPE (type
, i
),
4099 if (TYPE_FIELD_NAME (type
, i
))
4100 TYPE_FIELD_NAME (new_type
, i
) =
4101 xstrdup (TYPE_FIELD_NAME (type
, i
));
4102 switch (TYPE_FIELD_LOC_KIND (type
, i
))
4104 case FIELD_LOC_KIND_BITPOS
:
4105 SET_FIELD_BITPOS (TYPE_FIELD (new_type
, i
),
4106 TYPE_FIELD_BITPOS (type
, i
));
4108 case FIELD_LOC_KIND_ENUMVAL
:
4109 SET_FIELD_ENUMVAL (TYPE_FIELD (new_type
, i
),
4110 TYPE_FIELD_ENUMVAL (type
, i
));
4112 case FIELD_LOC_KIND_PHYSADDR
:
4113 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type
, i
),
4114 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
4116 case FIELD_LOC_KIND_PHYSNAME
:
4117 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type
, i
),
4118 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
,
4122 internal_error (__FILE__
, __LINE__
,
4123 _("Unexpected type field location kind: %d"),
4124 TYPE_FIELD_LOC_KIND (type
, i
));
4129 /* For range types, copy the bounds information. */
4130 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
4132 TYPE_RANGE_DATA (new_type
) = xmalloc (sizeof (struct range_bounds
));
4133 *TYPE_RANGE_DATA (new_type
) = *TYPE_RANGE_DATA (type
);
4136 /* Copy the data location information. */
4137 if (TYPE_DATA_LOCATION (type
) != NULL
)
4139 TYPE_DATA_LOCATION (new_type
)
4140 = TYPE_ALLOC (new_type
, sizeof (struct dynamic_prop
));
4141 memcpy (TYPE_DATA_LOCATION (new_type
), TYPE_DATA_LOCATION (type
),
4142 sizeof (struct dynamic_prop
));
4145 /* Copy pointers to other types. */
4146 if (TYPE_TARGET_TYPE (type
))
4147 TYPE_TARGET_TYPE (new_type
) =
4148 copy_type_recursive (objfile
,
4149 TYPE_TARGET_TYPE (type
),
4151 if (TYPE_VPTR_BASETYPE (type
))
4152 TYPE_VPTR_BASETYPE (new_type
) =
4153 copy_type_recursive (objfile
,
4154 TYPE_VPTR_BASETYPE (type
),
4156 /* Maybe copy the type_specific bits.
4158 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
4159 base classes and methods. There's no fundamental reason why we
4160 can't, but at the moment it is not needed. */
4162 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
4163 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
4164 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
4165 || TYPE_CODE (type
) == TYPE_CODE_UNION
4166 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
4167 INIT_CPLUS_SPECIFIC (new_type
);
4172 /* Make a copy of the given TYPE, except that the pointer & reference
4173 types are not preserved.
4175 This function assumes that the given type has an associated objfile.
4176 This objfile is used to allocate the new type. */
4179 copy_type (const struct type
*type
)
4181 struct type
*new_type
;
4183 gdb_assert (TYPE_OBJFILE_OWNED (type
));
4185 new_type
= alloc_type_copy (type
);
4186 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
4187 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
4188 memcpy (TYPE_MAIN_TYPE (new_type
), TYPE_MAIN_TYPE (type
),
4189 sizeof (struct main_type
));
4190 if (TYPE_DATA_LOCATION (type
) != NULL
)
4192 TYPE_DATA_LOCATION (new_type
)
4193 = TYPE_ALLOC (new_type
, sizeof (struct dynamic_prop
));
4194 memcpy (TYPE_DATA_LOCATION (new_type
), TYPE_DATA_LOCATION (type
),
4195 sizeof (struct dynamic_prop
));
4201 /* Helper functions to initialize architecture-specific types. */
4203 /* Allocate a type structure associated with GDBARCH and set its
4204 CODE, LENGTH, and NAME fields. */
4207 arch_type (struct gdbarch
*gdbarch
,
4208 enum type_code code
, int length
, char *name
)
4212 type
= alloc_type_arch (gdbarch
);
4213 TYPE_CODE (type
) = code
;
4214 TYPE_LENGTH (type
) = length
;
4217 TYPE_NAME (type
) = xstrdup (name
);
4222 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
4223 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
4224 the type's TYPE_UNSIGNED flag. NAME is the type name. */
4227 arch_integer_type (struct gdbarch
*gdbarch
,
4228 int bit
, int unsigned_p
, char *name
)
4232 t
= arch_type (gdbarch
, TYPE_CODE_INT
, bit
/ TARGET_CHAR_BIT
, name
);
4234 TYPE_UNSIGNED (t
) = 1;
4235 if (name
&& strcmp (name
, "char") == 0)
4236 TYPE_NOSIGN (t
) = 1;
4241 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
4242 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
4243 the type's TYPE_UNSIGNED flag. NAME is the type name. */
4246 arch_character_type (struct gdbarch
*gdbarch
,
4247 int bit
, int unsigned_p
, char *name
)
4251 t
= arch_type (gdbarch
, TYPE_CODE_CHAR
, bit
/ TARGET_CHAR_BIT
, name
);
4253 TYPE_UNSIGNED (t
) = 1;
4258 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
4259 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
4260 the type's TYPE_UNSIGNED flag. NAME is the type name. */
4263 arch_boolean_type (struct gdbarch
*gdbarch
,
4264 int bit
, int unsigned_p
, char *name
)
4268 t
= arch_type (gdbarch
, TYPE_CODE_BOOL
, bit
/ TARGET_CHAR_BIT
, name
);
4270 TYPE_UNSIGNED (t
) = 1;
4275 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
4276 BIT is the type size in bits; if BIT equals -1, the size is
4277 determined by the floatformat. NAME is the type name. Set the
4278 TYPE_FLOATFORMAT from FLOATFORMATS. */
4281 arch_float_type (struct gdbarch
*gdbarch
,
4282 int bit
, char *name
, const struct floatformat
**floatformats
)
4288 gdb_assert (floatformats
!= NULL
);
4289 gdb_assert (floatformats
[0] != NULL
&& floatformats
[1] != NULL
);
4290 bit
= floatformats
[0]->totalsize
;
4292 gdb_assert (bit
>= 0);
4294 t
= arch_type (gdbarch
, TYPE_CODE_FLT
, bit
/ TARGET_CHAR_BIT
, name
);
4295 TYPE_FLOATFORMAT (t
) = floatformats
;
4299 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
4300 NAME is the type name. TARGET_TYPE is the component float type. */
4303 arch_complex_type (struct gdbarch
*gdbarch
,
4304 char *name
, struct type
*target_type
)
4308 t
= arch_type (gdbarch
, TYPE_CODE_COMPLEX
,
4309 2 * TYPE_LENGTH (target_type
), name
);
4310 TYPE_TARGET_TYPE (t
) = target_type
;
4314 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
4315 NAME is the type name. LENGTH is the size of the flag word in bytes. */
4318 arch_flags_type (struct gdbarch
*gdbarch
, char *name
, int length
)
4320 int nfields
= length
* TARGET_CHAR_BIT
;
4323 type
= arch_type (gdbarch
, TYPE_CODE_FLAGS
, length
, name
);
4324 TYPE_UNSIGNED (type
) = 1;
4325 TYPE_NFIELDS (type
) = nfields
;
4326 TYPE_FIELDS (type
) = TYPE_ZALLOC (type
, nfields
* sizeof (struct field
));
4331 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
4332 position BITPOS is called NAME. */
4335 append_flags_type_flag (struct type
*type
, int bitpos
, char *name
)
4337 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLAGS
);
4338 gdb_assert (bitpos
< TYPE_NFIELDS (type
));
4339 gdb_assert (bitpos
>= 0);
4343 TYPE_FIELD_NAME (type
, bitpos
) = xstrdup (name
);
4344 SET_FIELD_BITPOS (TYPE_FIELD (type
, bitpos
), bitpos
);
4348 /* Don't show this field to the user. */
4349 SET_FIELD_BITPOS (TYPE_FIELD (type
, bitpos
), -1);
4353 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
4354 specified by CODE) associated with GDBARCH. NAME is the type name. */
4357 arch_composite_type (struct gdbarch
*gdbarch
, char *name
, enum type_code code
)
4361 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
4362 t
= arch_type (gdbarch
, code
, 0, NULL
);
4363 TYPE_TAG_NAME (t
) = name
;
4364 INIT_CPLUS_SPECIFIC (t
);
4368 /* Add new field with name NAME and type FIELD to composite type T.
4369 Do not set the field's position or adjust the type's length;
4370 the caller should do so. Return the new field. */
4373 append_composite_type_field_raw (struct type
*t
, char *name
,
4378 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
4379 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
4380 sizeof (struct field
) * TYPE_NFIELDS (t
));
4381 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
4382 memset (f
, 0, sizeof f
[0]);
4383 FIELD_TYPE (f
[0]) = field
;
4384 FIELD_NAME (f
[0]) = name
;
4388 /* Add new field with name NAME and type FIELD to composite type T.
4389 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
4392 append_composite_type_field_aligned (struct type
*t
, char *name
,
4393 struct type
*field
, int alignment
)
4395 struct field
*f
= append_composite_type_field_raw (t
, name
, field
);
4397 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
4399 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
4400 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
4402 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
4404 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
4405 if (TYPE_NFIELDS (t
) > 1)
4407 SET_FIELD_BITPOS (f
[0],
4408 (FIELD_BITPOS (f
[-1])
4409 + (TYPE_LENGTH (FIELD_TYPE (f
[-1]))
4410 * TARGET_CHAR_BIT
)));
4416 alignment
*= TARGET_CHAR_BIT
;
4417 left
= FIELD_BITPOS (f
[0]) % alignment
;
4421 SET_FIELD_BITPOS (f
[0], FIELD_BITPOS (f
[0]) + (alignment
- left
));
4422 TYPE_LENGTH (t
) += (alignment
- left
) / TARGET_CHAR_BIT
;
4429 /* Add new field with name NAME and type FIELD to composite type T. */
4432 append_composite_type_field (struct type
*t
, char *name
,
4435 append_composite_type_field_aligned (t
, name
, field
, 0);
4438 static struct gdbarch_data
*gdbtypes_data
;
4440 const struct builtin_type
*
4441 builtin_type (struct gdbarch
*gdbarch
)
4443 return gdbarch_data (gdbarch
, gdbtypes_data
);
4447 gdbtypes_post_init (struct gdbarch
*gdbarch
)
4449 struct builtin_type
*builtin_type
4450 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
4453 builtin_type
->builtin_void
4454 = arch_type (gdbarch
, TYPE_CODE_VOID
, 1, "void");
4455 builtin_type
->builtin_char
4456 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
4457 !gdbarch_char_signed (gdbarch
), "char");
4458 builtin_type
->builtin_signed_char
4459 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
4461 builtin_type
->builtin_unsigned_char
4462 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
4463 1, "unsigned char");
4464 builtin_type
->builtin_short
4465 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
4467 builtin_type
->builtin_unsigned_short
4468 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
4469 1, "unsigned short");
4470 builtin_type
->builtin_int
4471 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
4473 builtin_type
->builtin_unsigned_int
4474 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
4476 builtin_type
->builtin_long
4477 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
4479 builtin_type
->builtin_unsigned_long
4480 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
4481 1, "unsigned long");
4482 builtin_type
->builtin_long_long
4483 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
4485 builtin_type
->builtin_unsigned_long_long
4486 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
4487 1, "unsigned long long");
4488 builtin_type
->builtin_float
4489 = arch_float_type (gdbarch
, gdbarch_float_bit (gdbarch
),
4490 "float", gdbarch_float_format (gdbarch
));
4491 builtin_type
->builtin_double
4492 = arch_float_type (gdbarch
, gdbarch_double_bit (gdbarch
),
4493 "double", gdbarch_double_format (gdbarch
));
4494 builtin_type
->builtin_long_double
4495 = arch_float_type (gdbarch
, gdbarch_long_double_bit (gdbarch
),
4496 "long double", gdbarch_long_double_format (gdbarch
));
4497 builtin_type
->builtin_complex
4498 = arch_complex_type (gdbarch
, "complex",
4499 builtin_type
->builtin_float
);
4500 builtin_type
->builtin_double_complex
4501 = arch_complex_type (gdbarch
, "double complex",
4502 builtin_type
->builtin_double
);
4503 builtin_type
->builtin_string
4504 = arch_type (gdbarch
, TYPE_CODE_STRING
, 1, "string");
4505 builtin_type
->builtin_bool
4506 = arch_type (gdbarch
, TYPE_CODE_BOOL
, 1, "bool");
4508 /* The following three are about decimal floating point types, which
4509 are 32-bits, 64-bits and 128-bits respectively. */
4510 builtin_type
->builtin_decfloat
4511 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 32 / 8, "_Decimal32");
4512 builtin_type
->builtin_decdouble
4513 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 64 / 8, "_Decimal64");
4514 builtin_type
->builtin_declong
4515 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 128 / 8, "_Decimal128");
4517 /* "True" character types. */
4518 builtin_type
->builtin_true_char
4519 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 0, "true character");
4520 builtin_type
->builtin_true_unsigned_char
4521 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 1, "true character");
4523 /* Fixed-size integer types. */
4524 builtin_type
->builtin_int0
4525 = arch_integer_type (gdbarch
, 0, 0, "int0_t");
4526 builtin_type
->builtin_int8
4527 = arch_integer_type (gdbarch
, 8, 0, "int8_t");
4528 builtin_type
->builtin_uint8
4529 = arch_integer_type (gdbarch
, 8, 1, "uint8_t");
4530 builtin_type
->builtin_int16
4531 = arch_integer_type (gdbarch
, 16, 0, "int16_t");
4532 builtin_type
->builtin_uint16
4533 = arch_integer_type (gdbarch
, 16, 1, "uint16_t");
4534 builtin_type
->builtin_int32
4535 = arch_integer_type (gdbarch
, 32, 0, "int32_t");
4536 builtin_type
->builtin_uint32
4537 = arch_integer_type (gdbarch
, 32, 1, "uint32_t");
4538 builtin_type
->builtin_int64
4539 = arch_integer_type (gdbarch
, 64, 0, "int64_t");
4540 builtin_type
->builtin_uint64
4541 = arch_integer_type (gdbarch
, 64, 1, "uint64_t");
4542 builtin_type
->builtin_int128
4543 = arch_integer_type (gdbarch
, 128, 0, "int128_t");
4544 builtin_type
->builtin_uint128
4545 = arch_integer_type (gdbarch
, 128, 1, "uint128_t");
4546 TYPE_INSTANCE_FLAGS (builtin_type
->builtin_int8
) |=
4547 TYPE_INSTANCE_FLAG_NOTTEXT
;
4548 TYPE_INSTANCE_FLAGS (builtin_type
->builtin_uint8
) |=
4549 TYPE_INSTANCE_FLAG_NOTTEXT
;
4551 /* Wide character types. */
4552 builtin_type
->builtin_char16
4553 = arch_integer_type (gdbarch
, 16, 0, "char16_t");
4554 builtin_type
->builtin_char32
4555 = arch_integer_type (gdbarch
, 32, 0, "char32_t");
4558 /* Default data/code pointer types. */
4559 builtin_type
->builtin_data_ptr
4560 = lookup_pointer_type (builtin_type
->builtin_void
);
4561 builtin_type
->builtin_func_ptr
4562 = lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
4563 builtin_type
->builtin_func_func
4564 = lookup_function_type (builtin_type
->builtin_func_ptr
);
4566 /* This type represents a GDB internal function. */
4567 builtin_type
->internal_fn
4568 = arch_type (gdbarch
, TYPE_CODE_INTERNAL_FUNCTION
, 0,
4569 "<internal function>");
4571 /* This type represents an xmethod. */
4572 builtin_type
->xmethod
4573 = arch_type (gdbarch
, TYPE_CODE_XMETHOD
, 0, "<xmethod>");
4575 return builtin_type
;
4578 /* This set of objfile-based types is intended to be used by symbol
4579 readers as basic types. */
4581 static const struct objfile_data
*objfile_type_data
;
4583 const struct objfile_type
*
4584 objfile_type (struct objfile
*objfile
)
4586 struct gdbarch
*gdbarch
;
4587 struct objfile_type
*objfile_type
4588 = objfile_data (objfile
, objfile_type_data
);
4591 return objfile_type
;
4593 objfile_type
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
4594 1, struct objfile_type
);
4596 /* Use the objfile architecture to determine basic type properties. */
4597 gdbarch
= get_objfile_arch (objfile
);
4600 objfile_type
->builtin_void
4601 = init_type (TYPE_CODE_VOID
, 1,
4605 objfile_type
->builtin_char
4606 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
4608 | (gdbarch_char_signed (gdbarch
) ? 0 : TYPE_FLAG_UNSIGNED
)),
4610 objfile_type
->builtin_signed_char
4611 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
4613 "signed char", objfile
);
4614 objfile_type
->builtin_unsigned_char
4615 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
4617 "unsigned char", objfile
);
4618 objfile_type
->builtin_short
4619 = init_type (TYPE_CODE_INT
,
4620 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
4621 0, "short", objfile
);
4622 objfile_type
->builtin_unsigned_short
4623 = init_type (TYPE_CODE_INT
,
4624 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
4625 TYPE_FLAG_UNSIGNED
, "unsigned short", objfile
);
4626 objfile_type
->builtin_int
4627 = init_type (TYPE_CODE_INT
,
4628 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
4630 objfile_type
->builtin_unsigned_int
4631 = init_type (TYPE_CODE_INT
,
4632 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
4633 TYPE_FLAG_UNSIGNED
, "unsigned int", objfile
);
4634 objfile_type
->builtin_long
4635 = init_type (TYPE_CODE_INT
,
4636 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
4637 0, "long", objfile
);
4638 objfile_type
->builtin_unsigned_long
4639 = init_type (TYPE_CODE_INT
,
4640 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
4641 TYPE_FLAG_UNSIGNED
, "unsigned long", objfile
);
4642 objfile_type
->builtin_long_long
4643 = init_type (TYPE_CODE_INT
,
4644 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
4645 0, "long long", objfile
);
4646 objfile_type
->builtin_unsigned_long_long
4647 = init_type (TYPE_CODE_INT
,
4648 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
4649 TYPE_FLAG_UNSIGNED
, "unsigned long long", objfile
);
4651 objfile_type
->builtin_float
4652 = init_type (TYPE_CODE_FLT
,
4653 gdbarch_float_bit (gdbarch
) / TARGET_CHAR_BIT
,
4654 0, "float", objfile
);
4655 TYPE_FLOATFORMAT (objfile_type
->builtin_float
)
4656 = gdbarch_float_format (gdbarch
);
4657 objfile_type
->builtin_double
4658 = init_type (TYPE_CODE_FLT
,
4659 gdbarch_double_bit (gdbarch
) / TARGET_CHAR_BIT
,
4660 0, "double", objfile
);
4661 TYPE_FLOATFORMAT (objfile_type
->builtin_double
)
4662 = gdbarch_double_format (gdbarch
);
4663 objfile_type
->builtin_long_double
4664 = init_type (TYPE_CODE_FLT
,
4665 gdbarch_long_double_bit (gdbarch
) / TARGET_CHAR_BIT
,
4666 0, "long double", objfile
);
4667 TYPE_FLOATFORMAT (objfile_type
->builtin_long_double
)
4668 = gdbarch_long_double_format (gdbarch
);
4670 /* This type represents a type that was unrecognized in symbol read-in. */
4671 objfile_type
->builtin_error
4672 = init_type (TYPE_CODE_ERROR
, 0, 0, "<unknown type>", objfile
);
4674 /* The following set of types is used for symbols with no
4675 debug information. */
4676 objfile_type
->nodebug_text_symbol
4677 = init_type (TYPE_CODE_FUNC
, 1, 0,
4678 "<text variable, no debug info>", objfile
);
4679 TYPE_TARGET_TYPE (objfile_type
->nodebug_text_symbol
)
4680 = objfile_type
->builtin_int
;
4681 objfile_type
->nodebug_text_gnu_ifunc_symbol
4682 = init_type (TYPE_CODE_FUNC
, 1, TYPE_FLAG_GNU_IFUNC
,
4683 "<text gnu-indirect-function variable, no debug info>",
4685 TYPE_TARGET_TYPE (objfile_type
->nodebug_text_gnu_ifunc_symbol
)
4686 = objfile_type
->nodebug_text_symbol
;
4687 objfile_type
->nodebug_got_plt_symbol
4688 = init_type (TYPE_CODE_PTR
, gdbarch_addr_bit (gdbarch
) / 8, 0,
4689 "<text from jump slot in .got.plt, no debug info>",
4691 TYPE_TARGET_TYPE (objfile_type
->nodebug_got_plt_symbol
)
4692 = objfile_type
->nodebug_text_symbol
;
4693 objfile_type
->nodebug_data_symbol
4694 = init_type (TYPE_CODE_INT
,
4695 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
4696 "<data variable, no debug info>", objfile
);
4697 objfile_type
->nodebug_unknown_symbol
4698 = init_type (TYPE_CODE_INT
, 1, 0,
4699 "<variable (not text or data), no debug info>", objfile
);
4700 objfile_type
->nodebug_tls_symbol
4701 = init_type (TYPE_CODE_INT
,
4702 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
4703 "<thread local variable, no debug info>", objfile
);
4705 /* NOTE: on some targets, addresses and pointers are not necessarily
4709 - gdb's `struct type' always describes the target's
4711 - gdb's `struct value' objects should always hold values in
4713 - gdb's CORE_ADDR values are addresses in the unified virtual
4714 address space that the assembler and linker work with. Thus,
4715 since target_read_memory takes a CORE_ADDR as an argument, it
4716 can access any memory on the target, even if the processor has
4717 separate code and data address spaces.
4719 In this context, objfile_type->builtin_core_addr is a bit odd:
4720 it's a target type for a value the target will never see. It's
4721 only used to hold the values of (typeless) linker symbols, which
4722 are indeed in the unified virtual address space. */
4724 objfile_type
->builtin_core_addr
4725 = init_type (TYPE_CODE_INT
,
4726 gdbarch_addr_bit (gdbarch
) / 8,
4727 TYPE_FLAG_UNSIGNED
, "__CORE_ADDR", objfile
);
4729 set_objfile_data (objfile
, objfile_type_data
, objfile_type
);
4730 return objfile_type
;
4733 extern initialize_file_ftype _initialize_gdbtypes
;
4736 _initialize_gdbtypes (void)
4738 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
4739 objfile_type_data
= register_objfile_data ();
4741 add_setshow_zuinteger_cmd ("overload", no_class
, &overload_debug
,
4742 _("Set debugging of C++ overloading."),
4743 _("Show debugging of C++ overloading."),
4744 _("When enabled, ranking of the "
4745 "functions is displayed."),
4747 show_overload_debug
,
4748 &setdebuglist
, &showdebuglist
);
4750 /* Add user knob for controlling resolution of opaque types. */
4751 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
4752 &opaque_type_resolution
,
4753 _("Set resolution of opaque struct/class/union"
4754 " types (if set before loading symbols)."),
4755 _("Show resolution of opaque struct/class/union"
4756 " types (if set before loading symbols)."),
4758 show_opaque_type_resolution
,
4759 &setlist
, &showlist
);
4761 /* Add an option to permit non-strict type checking. */
4762 add_setshow_boolean_cmd ("type", class_support
,
4763 &strict_type_checking
,
4764 _("Set strict type checking."),
4765 _("Show strict type checking."),
4767 show_strict_type_checking
,
4768 &setchecklist
, &showchecklist
);