1 /* Support routines for manipulating internal types for GDB.
3 Copyright (C) 1992-2013 Free Software Foundation, Inc.
5 Contributed by Cygnus Support, using pieces from other GDB modules.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_string.h"
29 #include "expression.h"
34 #include "complaints.h"
37 #include "gdb_assert.h"
39 #include "exceptions.h"
41 /* Initialize BADNESS constants. */
43 const struct rank LENGTH_MISMATCH_BADNESS
= {100,0};
45 const struct rank TOO_FEW_PARAMS_BADNESS
= {100,0};
46 const struct rank INCOMPATIBLE_TYPE_BADNESS
= {100,0};
48 const struct rank EXACT_MATCH_BADNESS
= {0,0};
50 const struct rank INTEGER_PROMOTION_BADNESS
= {1,0};
51 const struct rank FLOAT_PROMOTION_BADNESS
= {1,0};
52 const struct rank BASE_PTR_CONVERSION_BADNESS
= {1,0};
53 const struct rank INTEGER_CONVERSION_BADNESS
= {2,0};
54 const struct rank FLOAT_CONVERSION_BADNESS
= {2,0};
55 const struct rank INT_FLOAT_CONVERSION_BADNESS
= {2,0};
56 const struct rank VOID_PTR_CONVERSION_BADNESS
= {2,0};
57 const struct rank BOOL_CONVERSION_BADNESS
= {3,0};
58 const struct rank BASE_CONVERSION_BADNESS
= {2,0};
59 const struct rank REFERENCE_CONVERSION_BADNESS
= {2,0};
60 const struct rank NULL_POINTER_CONVERSION_BADNESS
= {2,0};
61 const struct rank NS_POINTER_CONVERSION_BADNESS
= {10,0};
62 const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS
= {3,0};
64 /* Floatformat pairs. */
65 const struct floatformat
*floatformats_ieee_half
[BFD_ENDIAN_UNKNOWN
] = {
66 &floatformat_ieee_half_big
,
67 &floatformat_ieee_half_little
69 const struct floatformat
*floatformats_ieee_single
[BFD_ENDIAN_UNKNOWN
] = {
70 &floatformat_ieee_single_big
,
71 &floatformat_ieee_single_little
73 const struct floatformat
*floatformats_ieee_double
[BFD_ENDIAN_UNKNOWN
] = {
74 &floatformat_ieee_double_big
,
75 &floatformat_ieee_double_little
77 const struct floatformat
*floatformats_ieee_double_littlebyte_bigword
[BFD_ENDIAN_UNKNOWN
] = {
78 &floatformat_ieee_double_big
,
79 &floatformat_ieee_double_littlebyte_bigword
81 const struct floatformat
*floatformats_i387_ext
[BFD_ENDIAN_UNKNOWN
] = {
82 &floatformat_i387_ext
,
85 const struct floatformat
*floatformats_m68881_ext
[BFD_ENDIAN_UNKNOWN
] = {
86 &floatformat_m68881_ext
,
87 &floatformat_m68881_ext
89 const struct floatformat
*floatformats_arm_ext
[BFD_ENDIAN_UNKNOWN
] = {
90 &floatformat_arm_ext_big
,
91 &floatformat_arm_ext_littlebyte_bigword
93 const struct floatformat
*floatformats_ia64_spill
[BFD_ENDIAN_UNKNOWN
] = {
94 &floatformat_ia64_spill_big
,
95 &floatformat_ia64_spill_little
97 const struct floatformat
*floatformats_ia64_quad
[BFD_ENDIAN_UNKNOWN
] = {
98 &floatformat_ia64_quad_big
,
99 &floatformat_ia64_quad_little
101 const struct floatformat
*floatformats_vax_f
[BFD_ENDIAN_UNKNOWN
] = {
105 const struct floatformat
*floatformats_vax_d
[BFD_ENDIAN_UNKNOWN
] = {
109 const struct floatformat
*floatformats_ibm_long_double
[BFD_ENDIAN_UNKNOWN
] = {
110 &floatformat_ibm_long_double
,
111 &floatformat_ibm_long_double
114 /* Should opaque types be resolved? */
116 static int opaque_type_resolution
= 1;
118 /* A flag to enable printing of debugging information of C++
121 unsigned int overload_debug
= 0;
123 /* A flag to enable strict type checking. */
125 static int strict_type_checking
= 1;
127 /* A function to show whether opaque types are resolved. */
130 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
131 struct cmd_list_element
*c
,
134 fprintf_filtered (file
, _("Resolution of opaque struct/class/union types "
135 "(if set before loading symbols) is %s.\n"),
139 /* A function to show whether C++ overload debugging is enabled. */
142 show_overload_debug (struct ui_file
*file
, int from_tty
,
143 struct cmd_list_element
*c
, const char *value
)
145 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"),
149 /* A function to show the status of strict type checking. */
152 show_strict_type_checking (struct ui_file
*file
, int from_tty
,
153 struct cmd_list_element
*c
, const char *value
)
155 fprintf_filtered (file
, _("Strict type checking is %s.\n"), value
);
159 /* Allocate a new OBJFILE-associated type structure and fill it
160 with some defaults. Space for the type structure is allocated
161 on the objfile's objfile_obstack. */
164 alloc_type (struct objfile
*objfile
)
168 gdb_assert (objfile
!= NULL
);
170 /* Alloc the structure and start off with all fields zeroed. */
171 type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct type
);
172 TYPE_MAIN_TYPE (type
) = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
174 OBJSTAT (objfile
, n_types
++);
176 TYPE_OBJFILE_OWNED (type
) = 1;
177 TYPE_OWNER (type
).objfile
= objfile
;
179 /* Initialize the fields that might not be zero. */
181 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
182 TYPE_VPTR_FIELDNO (type
) = -1;
183 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
188 /* Allocate a new GDBARCH-associated type structure and fill it
189 with some defaults. Space for the type structure is allocated
193 alloc_type_arch (struct gdbarch
*gdbarch
)
197 gdb_assert (gdbarch
!= NULL
);
199 /* Alloc the structure and start off with all fields zeroed. */
201 type
= XZALLOC (struct type
);
202 TYPE_MAIN_TYPE (type
) = XZALLOC (struct main_type
);
204 TYPE_OBJFILE_OWNED (type
) = 0;
205 TYPE_OWNER (type
).gdbarch
= gdbarch
;
207 /* Initialize the fields that might not be zero. */
209 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
210 TYPE_VPTR_FIELDNO (type
) = -1;
211 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
216 /* If TYPE is objfile-associated, allocate a new type structure
217 associated with the same objfile. If TYPE is gdbarch-associated,
218 allocate a new type structure associated with the same gdbarch. */
221 alloc_type_copy (const struct type
*type
)
223 if (TYPE_OBJFILE_OWNED (type
))
224 return alloc_type (TYPE_OWNER (type
).objfile
);
226 return alloc_type_arch (TYPE_OWNER (type
).gdbarch
);
229 /* If TYPE is gdbarch-associated, return that architecture.
230 If TYPE is objfile-associated, return that objfile's architecture. */
233 get_type_arch (const struct type
*type
)
235 if (TYPE_OBJFILE_OWNED (type
))
236 return get_objfile_arch (TYPE_OWNER (type
).objfile
);
238 return TYPE_OWNER (type
).gdbarch
;
241 /* Alloc a new type instance structure, fill it with some defaults,
242 and point it at OLDTYPE. Allocate the new type instance from the
243 same place as OLDTYPE. */
246 alloc_type_instance (struct type
*oldtype
)
250 /* Allocate the structure. */
252 if (! TYPE_OBJFILE_OWNED (oldtype
))
253 type
= XZALLOC (struct type
);
255 type
= OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype
)->objfile_obstack
,
258 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
260 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
265 /* Clear all remnants of the previous type at TYPE, in preparation for
266 replacing it with something else. Preserve owner information. */
269 smash_type (struct type
*type
)
271 int objfile_owned
= TYPE_OBJFILE_OWNED (type
);
272 union type_owner owner
= TYPE_OWNER (type
);
274 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
276 /* Restore owner information. */
277 TYPE_OBJFILE_OWNED (type
) = objfile_owned
;
278 TYPE_OWNER (type
) = owner
;
280 /* For now, delete the rings. */
281 TYPE_CHAIN (type
) = type
;
283 /* For now, leave the pointer/reference types alone. */
286 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
287 to a pointer to memory where the pointer type should be stored.
288 If *TYPEPTR is zero, update it to point to the pointer type we return.
289 We allocate new memory if needed. */
292 make_pointer_type (struct type
*type
, struct type
**typeptr
)
294 struct type
*ntype
; /* New type */
297 ntype
= TYPE_POINTER_TYPE (type
);
302 return ntype
; /* Don't care about alloc,
303 and have new type. */
304 else if (*typeptr
== 0)
306 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
311 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
313 ntype
= alloc_type_copy (type
);
317 else /* We have storage, but need to reset it. */
320 chain
= TYPE_CHAIN (ntype
);
322 TYPE_CHAIN (ntype
) = chain
;
325 TYPE_TARGET_TYPE (ntype
) = type
;
326 TYPE_POINTER_TYPE (type
) = ntype
;
328 /* FIXME! Assumes the machine has only one representation for pointers! */
331 = gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
332 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
334 /* Mark pointers as unsigned. The target converts between pointers
335 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
336 gdbarch_address_to_pointer. */
337 TYPE_UNSIGNED (ntype
) = 1;
339 /* Update the length of all the other variants of this type. */
340 chain
= TYPE_CHAIN (ntype
);
341 while (chain
!= ntype
)
343 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
344 chain
= TYPE_CHAIN (chain
);
350 /* Given a type TYPE, return a type of pointers to that type.
351 May need to construct such a type if this is the first use. */
354 lookup_pointer_type (struct type
*type
)
356 return make_pointer_type (type
, (struct type
**) 0);
359 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
360 points to a pointer to memory where the reference type should be
361 stored. If *TYPEPTR is zero, update it to point to the reference
362 type we return. We allocate new memory if needed. */
365 make_reference_type (struct type
*type
, struct type
**typeptr
)
367 struct type
*ntype
; /* New type */
370 ntype
= TYPE_REFERENCE_TYPE (type
);
375 return ntype
; /* Don't care about alloc,
376 and have new type. */
377 else if (*typeptr
== 0)
379 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
384 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
386 ntype
= alloc_type_copy (type
);
390 else /* We have storage, but need to reset it. */
393 chain
= TYPE_CHAIN (ntype
);
395 TYPE_CHAIN (ntype
) = chain
;
398 TYPE_TARGET_TYPE (ntype
) = type
;
399 TYPE_REFERENCE_TYPE (type
) = ntype
;
401 /* FIXME! Assume the machine has only one representation for
402 references, and that it matches the (only) representation for
405 TYPE_LENGTH (ntype
) =
406 gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
407 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
409 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
410 TYPE_REFERENCE_TYPE (type
) = ntype
;
412 /* Update the length of all the other variants of this type. */
413 chain
= TYPE_CHAIN (ntype
);
414 while (chain
!= ntype
)
416 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
417 chain
= TYPE_CHAIN (chain
);
423 /* Same as above, but caller doesn't care about memory allocation
427 lookup_reference_type (struct type
*type
)
429 return make_reference_type (type
, (struct type
**) 0);
432 /* Lookup a function type that returns type TYPE. TYPEPTR, if
433 nonzero, points to a pointer to memory where the function type
434 should be stored. If *TYPEPTR is zero, update it to point to the
435 function type we return. We allocate new memory if needed. */
438 make_function_type (struct type
*type
, struct type
**typeptr
)
440 struct type
*ntype
; /* New type */
442 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
444 ntype
= alloc_type_copy (type
);
448 else /* We have storage, but need to reset it. */
454 TYPE_TARGET_TYPE (ntype
) = type
;
456 TYPE_LENGTH (ntype
) = 1;
457 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
459 INIT_FUNC_SPECIFIC (ntype
);
464 /* Given a type TYPE, return a type of functions that return that type.
465 May need to construct such a type if this is the first use. */
468 lookup_function_type (struct type
*type
)
470 return make_function_type (type
, (struct type
**) 0);
473 /* Given a type TYPE and argument types, return the appropriate
474 function type. If the final type in PARAM_TYPES is NULL, make a
478 lookup_function_type_with_arguments (struct type
*type
,
480 struct type
**param_types
)
482 struct type
*fn
= make_function_type (type
, (struct type
**) 0);
487 if (param_types
[nparams
- 1] == NULL
)
490 TYPE_VARARGS (fn
) = 1;
492 else if (TYPE_CODE (check_typedef (param_types
[nparams
- 1]))
496 /* Caller should have ensured this. */
497 gdb_assert (nparams
== 0);
498 TYPE_PROTOTYPED (fn
) = 1;
502 TYPE_NFIELDS (fn
) = nparams
;
503 TYPE_FIELDS (fn
) = TYPE_ZALLOC (fn
, nparams
* sizeof (struct field
));
504 for (i
= 0; i
< nparams
; ++i
)
505 TYPE_FIELD_TYPE (fn
, i
) = param_types
[i
];
510 /* Identify address space identifier by name --
511 return the integer flag defined in gdbtypes.h. */
514 address_space_name_to_int (struct gdbarch
*gdbarch
, char *space_identifier
)
518 /* Check for known address space delimiters. */
519 if (!strcmp (space_identifier
, "code"))
520 return TYPE_INSTANCE_FLAG_CODE_SPACE
;
521 else if (!strcmp (space_identifier
, "data"))
522 return TYPE_INSTANCE_FLAG_DATA_SPACE
;
523 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
524 && gdbarch_address_class_name_to_type_flags (gdbarch
,
529 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
532 /* Identify address space identifier by integer flag as defined in
533 gdbtypes.h -- return the string version of the adress space name. */
536 address_space_int_to_name (struct gdbarch
*gdbarch
, int space_flag
)
538 if (space_flag
& TYPE_INSTANCE_FLAG_CODE_SPACE
)
540 else if (space_flag
& TYPE_INSTANCE_FLAG_DATA_SPACE
)
542 else if ((space_flag
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
543 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
544 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
549 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
551 If STORAGE is non-NULL, create the new type instance there.
552 STORAGE must be in the same obstack as TYPE. */
555 make_qualified_type (struct type
*type
, int new_flags
,
556 struct type
*storage
)
563 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
565 ntype
= TYPE_CHAIN (ntype
);
567 while (ntype
!= type
);
569 /* Create a new type instance. */
571 ntype
= alloc_type_instance (type
);
574 /* If STORAGE was provided, it had better be in the same objfile
575 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
576 if one objfile is freed and the other kept, we'd have
577 dangling pointers. */
578 gdb_assert (TYPE_OBJFILE (type
) == TYPE_OBJFILE (storage
));
581 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
582 TYPE_CHAIN (ntype
) = ntype
;
585 /* Pointers or references to the original type are not relevant to
587 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
588 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
590 /* Chain the new qualified type to the old type. */
591 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
592 TYPE_CHAIN (type
) = ntype
;
594 /* Now set the instance flags and return the new type. */
595 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
597 /* Set length of new type to that of the original type. */
598 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
603 /* Make an address-space-delimited variant of a type -- a type that
604 is identical to the one supplied except that it has an address
605 space attribute attached to it (such as "code" or "data").
607 The space attributes "code" and "data" are for Harvard
608 architectures. The address space attributes are for architectures
609 which have alternately sized pointers or pointers with alternate
613 make_type_with_address_space (struct type
*type
, int space_flag
)
615 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
616 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
617 | TYPE_INSTANCE_FLAG_DATA_SPACE
618 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
))
621 return make_qualified_type (type
, new_flags
, NULL
);
624 /* Make a "c-v" variant of a type -- a type that is identical to the
625 one supplied except that it may have const or volatile attributes
626 CNST is a flag for setting the const attribute
627 VOLTL is a flag for setting the volatile attribute
628 TYPE is the base type whose variant we are creating.
630 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
631 storage to hold the new qualified type; *TYPEPTR and TYPE must be
632 in the same objfile. Otherwise, allocate fresh memory for the new
633 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
634 new type we construct. */
637 make_cv_type (int cnst
, int voltl
,
639 struct type
**typeptr
)
641 struct type
*ntype
; /* New type */
643 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
644 & ~(TYPE_INSTANCE_FLAG_CONST
645 | TYPE_INSTANCE_FLAG_VOLATILE
));
648 new_flags
|= TYPE_INSTANCE_FLAG_CONST
;
651 new_flags
|= TYPE_INSTANCE_FLAG_VOLATILE
;
653 if (typeptr
&& *typeptr
!= NULL
)
655 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
656 a C-V variant chain that threads across objfiles: if one
657 objfile gets freed, then the other has a broken C-V chain.
659 This code used to try to copy over the main type from TYPE to
660 *TYPEPTR if they were in different objfiles, but that's
661 wrong, too: TYPE may have a field list or member function
662 lists, which refer to types of their own, etc. etc. The
663 whole shebang would need to be copied over recursively; you
664 can't have inter-objfile pointers. The only thing to do is
665 to leave stub types as stub types, and look them up afresh by
666 name each time you encounter them. */
667 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
));
670 ntype
= make_qualified_type (type
, new_flags
,
671 typeptr
? *typeptr
: NULL
);
679 /* Make a 'restrict'-qualified version of TYPE. */
682 make_restrict_type (struct type
*type
)
684 return make_qualified_type (type
,
685 (TYPE_INSTANCE_FLAGS (type
)
686 | TYPE_INSTANCE_FLAG_RESTRICT
),
690 /* Replace the contents of ntype with the type *type. This changes the
691 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
692 the changes are propogated to all types in the TYPE_CHAIN.
694 In order to build recursive types, it's inevitable that we'll need
695 to update types in place --- but this sort of indiscriminate
696 smashing is ugly, and needs to be replaced with something more
697 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
698 clear if more steps are needed. */
701 replace_type (struct type
*ntype
, struct type
*type
)
705 /* These two types had better be in the same objfile. Otherwise,
706 the assignment of one type's main type structure to the other
707 will produce a type with references to objects (names; field
708 lists; etc.) allocated on an objfile other than its own. */
709 gdb_assert (TYPE_OBJFILE (ntype
) == TYPE_OBJFILE (ntype
));
711 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
713 /* The type length is not a part of the main type. Update it for
714 each type on the variant chain. */
718 /* Assert that this element of the chain has no address-class bits
719 set in its flags. Such type variants might have type lengths
720 which are supposed to be different from the non-address-class
721 variants. This assertion shouldn't ever be triggered because
722 symbol readers which do construct address-class variants don't
723 call replace_type(). */
724 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
726 TYPE_LENGTH (chain
) = TYPE_LENGTH (type
);
727 chain
= TYPE_CHAIN (chain
);
729 while (ntype
!= chain
);
731 /* Assert that the two types have equivalent instance qualifiers.
732 This should be true for at least all of our debug readers. */
733 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
736 /* Implement direct support for MEMBER_TYPE in GNU C++.
737 May need to construct such a type if this is the first use.
738 The TYPE is the type of the member. The DOMAIN is the type
739 of the aggregate that the member belongs to. */
742 lookup_memberptr_type (struct type
*type
, struct type
*domain
)
746 mtype
= alloc_type_copy (type
);
747 smash_to_memberptr_type (mtype
, domain
, type
);
751 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
754 lookup_methodptr_type (struct type
*to_type
)
758 mtype
= alloc_type_copy (to_type
);
759 smash_to_methodptr_type (mtype
, to_type
);
763 /* Allocate a stub method whose return type is TYPE. This apparently
764 happens for speed of symbol reading, since parsing out the
765 arguments to the method is cpu-intensive, the way we are doing it.
766 So, we will fill in arguments later. This always returns a fresh
770 allocate_stub_method (struct type
*type
)
774 mtype
= alloc_type_copy (type
);
775 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
776 TYPE_LENGTH (mtype
) = 1;
777 TYPE_STUB (mtype
) = 1;
778 TYPE_TARGET_TYPE (mtype
) = type
;
779 /* _DOMAIN_TYPE (mtype) = unknown yet */
783 /* Create a range type using either a blank type supplied in
784 RESULT_TYPE, or creating a new type, inheriting the objfile from
787 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
788 to HIGH_BOUND, inclusive.
790 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
791 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
794 create_range_type (struct type
*result_type
, struct type
*index_type
,
795 LONGEST low_bound
, LONGEST high_bound
)
797 if (result_type
== NULL
)
798 result_type
= alloc_type_copy (index_type
);
799 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
800 TYPE_TARGET_TYPE (result_type
) = index_type
;
801 if (TYPE_STUB (index_type
))
802 TYPE_TARGET_STUB (result_type
) = 1;
804 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
805 TYPE_RANGE_DATA (result_type
) = (struct range_bounds
*)
806 TYPE_ZALLOC (result_type
, sizeof (struct range_bounds
));
807 TYPE_LOW_BOUND (result_type
) = low_bound
;
808 TYPE_HIGH_BOUND (result_type
) = high_bound
;
811 TYPE_UNSIGNED (result_type
) = 1;
816 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
817 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
818 bounds will fit in LONGEST), or -1 otherwise. */
821 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
823 CHECK_TYPEDEF (type
);
824 switch (TYPE_CODE (type
))
826 case TYPE_CODE_RANGE
:
827 *lowp
= TYPE_LOW_BOUND (type
);
828 *highp
= TYPE_HIGH_BOUND (type
);
831 if (TYPE_NFIELDS (type
) > 0)
833 /* The enums may not be sorted by value, so search all
837 *lowp
= *highp
= TYPE_FIELD_ENUMVAL (type
, 0);
838 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
840 if (TYPE_FIELD_ENUMVAL (type
, i
) < *lowp
)
841 *lowp
= TYPE_FIELD_ENUMVAL (type
, i
);
842 if (TYPE_FIELD_ENUMVAL (type
, i
) > *highp
)
843 *highp
= TYPE_FIELD_ENUMVAL (type
, i
);
846 /* Set unsigned indicator if warranted. */
849 TYPE_UNSIGNED (type
) = 1;
863 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
865 if (!TYPE_UNSIGNED (type
))
867 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
871 /* ... fall through for unsigned ints ... */
874 /* This round-about calculation is to avoid shifting by
875 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
876 if TYPE_LENGTH (type) == sizeof (LONGEST). */
877 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
878 *highp
= (*highp
- 1) | *highp
;
885 /* Assuming TYPE is a simple, non-empty array type, compute its upper
886 and lower bound. Save the low bound into LOW_BOUND if not NULL.
887 Save the high bound into HIGH_BOUND if not NULL.
889 Return 1 if the operation was successful. Return zero otherwise,
890 in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
892 We now simply use get_discrete_bounds call to get the values
893 of the low and high bounds.
894 get_discrete_bounds can return three values:
895 1, meaning that index is a range,
896 0, meaning that index is a discrete type,
897 or -1 for failure. */
900 get_array_bounds (struct type
*type
, LONGEST
*low_bound
, LONGEST
*high_bound
)
902 struct type
*index
= TYPE_INDEX_TYPE (type
);
910 res
= get_discrete_bounds (index
, &low
, &high
);
914 /* Check if the array bounds are undefined. */
916 && ((low_bound
&& TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type
))
917 || (high_bound
&& TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))))
929 /* Create an array type using either a blank type supplied in
930 RESULT_TYPE, or creating a new type, inheriting the objfile from
933 Elements will be of type ELEMENT_TYPE, the indices will be of type
936 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
937 sure it is TYPE_CODE_UNDEF before we bash it into an array
941 create_array_type (struct type
*result_type
,
942 struct type
*element_type
,
943 struct type
*range_type
)
945 LONGEST low_bound
, high_bound
;
947 if (result_type
== NULL
)
948 result_type
= alloc_type_copy (range_type
);
950 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
951 TYPE_TARGET_TYPE (result_type
) = element_type
;
952 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
953 low_bound
= high_bound
= 0;
954 CHECK_TYPEDEF (element_type
);
955 /* Be careful when setting the array length. Ada arrays can be
956 empty arrays with the high_bound being smaller than the low_bound.
957 In such cases, the array length should be zero. */
958 if (high_bound
< low_bound
)
959 TYPE_LENGTH (result_type
) = 0;
961 TYPE_LENGTH (result_type
) =
962 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
963 TYPE_NFIELDS (result_type
) = 1;
964 TYPE_FIELDS (result_type
) =
965 (struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
));
966 TYPE_INDEX_TYPE (result_type
) = range_type
;
967 TYPE_VPTR_FIELDNO (result_type
) = -1;
969 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays. */
970 if (TYPE_LENGTH (result_type
) == 0)
971 TYPE_TARGET_STUB (result_type
) = 1;
977 lookup_array_range_type (struct type
*element_type
,
978 LONGEST low_bound
, LONGEST high_bound
)
980 struct gdbarch
*gdbarch
= get_type_arch (element_type
);
981 struct type
*index_type
= builtin_type (gdbarch
)->builtin_int
;
982 struct type
*range_type
983 = create_range_type (NULL
, index_type
, low_bound
, high_bound
);
985 return create_array_type (NULL
, element_type
, range_type
);
988 /* Create a string type using either a blank type supplied in
989 RESULT_TYPE, or creating a new type. String types are similar
990 enough to array of char types that we can use create_array_type to
991 build the basic type and then bash it into a string type.
993 For fixed length strings, the range type contains 0 as the lower
994 bound and the length of the string minus one as the upper bound.
996 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
997 sure it is TYPE_CODE_UNDEF before we bash it into a string
1001 create_string_type (struct type
*result_type
,
1002 struct type
*string_char_type
,
1003 struct type
*range_type
)
1005 result_type
= create_array_type (result_type
,
1008 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
1013 lookup_string_range_type (struct type
*string_char_type
,
1014 LONGEST low_bound
, LONGEST high_bound
)
1016 struct type
*result_type
;
1018 result_type
= lookup_array_range_type (string_char_type
,
1019 low_bound
, high_bound
);
1020 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
1025 create_set_type (struct type
*result_type
, struct type
*domain_type
)
1027 if (result_type
== NULL
)
1028 result_type
= alloc_type_copy (domain_type
);
1030 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
1031 TYPE_NFIELDS (result_type
) = 1;
1032 TYPE_FIELDS (result_type
) = TYPE_ZALLOC (result_type
, sizeof (struct field
));
1034 if (!TYPE_STUB (domain_type
))
1036 LONGEST low_bound
, high_bound
, bit_length
;
1038 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
1039 low_bound
= high_bound
= 0;
1040 bit_length
= high_bound
- low_bound
+ 1;
1041 TYPE_LENGTH (result_type
)
1042 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
1044 TYPE_UNSIGNED (result_type
) = 1;
1046 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
1051 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
1052 and any array types nested inside it. */
1055 make_vector_type (struct type
*array_type
)
1057 struct type
*inner_array
, *elt_type
;
1060 /* Find the innermost array type, in case the array is
1061 multi-dimensional. */
1062 inner_array
= array_type
;
1063 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
1064 inner_array
= TYPE_TARGET_TYPE (inner_array
);
1066 elt_type
= TYPE_TARGET_TYPE (inner_array
);
1067 if (TYPE_CODE (elt_type
) == TYPE_CODE_INT
)
1069 flags
= TYPE_INSTANCE_FLAGS (elt_type
) | TYPE_INSTANCE_FLAG_NOTTEXT
;
1070 elt_type
= make_qualified_type (elt_type
, flags
, NULL
);
1071 TYPE_TARGET_TYPE (inner_array
) = elt_type
;
1074 TYPE_VECTOR (array_type
) = 1;
1078 init_vector_type (struct type
*elt_type
, int n
)
1080 struct type
*array_type
;
1082 array_type
= lookup_array_range_type (elt_type
, 0, n
- 1);
1083 make_vector_type (array_type
);
1087 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
1088 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1089 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1090 TYPE doesn't include the offset (that's the value of the MEMBER
1091 itself), but does include the structure type into which it points
1094 When "smashing" the type, we preserve the objfile that the old type
1095 pointed to, since we aren't changing where the type is actually
1099 smash_to_memberptr_type (struct type
*type
, struct type
*domain
,
1100 struct type
*to_type
)
1103 TYPE_TARGET_TYPE (type
) = to_type
;
1104 TYPE_DOMAIN_TYPE (type
) = domain
;
1105 /* Assume that a data member pointer is the same size as a normal
1108 = gdbarch_ptr_bit (get_type_arch (to_type
)) / TARGET_CHAR_BIT
;
1109 TYPE_CODE (type
) = TYPE_CODE_MEMBERPTR
;
1112 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1114 When "smashing" the type, we preserve the objfile that the old type
1115 pointed to, since we aren't changing where the type is actually
1119 smash_to_methodptr_type (struct type
*type
, struct type
*to_type
)
1122 TYPE_TARGET_TYPE (type
) = to_type
;
1123 TYPE_DOMAIN_TYPE (type
) = TYPE_DOMAIN_TYPE (to_type
);
1124 TYPE_LENGTH (type
) = cplus_method_ptr_size (to_type
);
1125 TYPE_CODE (type
) = TYPE_CODE_METHODPTR
;
1128 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
1129 METHOD just means `function that gets an extra "this" argument'.
1131 When "smashing" the type, we preserve the objfile that the old type
1132 pointed to, since we aren't changing where the type is actually
1136 smash_to_method_type (struct type
*type
, struct type
*domain
,
1137 struct type
*to_type
, struct field
*args
,
1138 int nargs
, int varargs
)
1141 TYPE_TARGET_TYPE (type
) = to_type
;
1142 TYPE_DOMAIN_TYPE (type
) = domain
;
1143 TYPE_FIELDS (type
) = args
;
1144 TYPE_NFIELDS (type
) = nargs
;
1146 TYPE_VARARGS (type
) = 1;
1147 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1148 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
1151 /* Return a typename for a struct/union/enum type without "struct ",
1152 "union ", or "enum ". If the type has a NULL name, return NULL. */
1155 type_name_no_tag (const struct type
*type
)
1157 if (TYPE_TAG_NAME (type
) != NULL
)
1158 return TYPE_TAG_NAME (type
);
1160 /* Is there code which expects this to return the name if there is
1161 no tag name? My guess is that this is mainly used for C++ in
1162 cases where the two will always be the same. */
1163 return TYPE_NAME (type
);
1166 /* A wrapper of type_name_no_tag which calls error if the type is anonymous.
1167 Since GCC PR debug/47510 DWARF provides associated information to detect the
1168 anonymous class linkage name from its typedef.
1170 Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
1174 type_name_no_tag_or_error (struct type
*type
)
1176 struct type
*saved_type
= type
;
1178 struct objfile
*objfile
;
1180 CHECK_TYPEDEF (type
);
1182 name
= type_name_no_tag (type
);
1186 name
= type_name_no_tag (saved_type
);
1187 objfile
= TYPE_OBJFILE (saved_type
);
1188 error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
1189 name
? name
: "<anonymous>", objfile
? objfile
->name
: "<arch>");
1192 /* Lookup a typedef or primitive type named NAME, visible in lexical
1193 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1194 suitably defined. */
1197 lookup_typename (const struct language_defn
*language
,
1198 struct gdbarch
*gdbarch
, const char *name
,
1199 const struct block
*block
, int noerr
)
1204 sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, 0);
1205 if (sym
!= NULL
&& SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
1206 return SYMBOL_TYPE (sym
);
1208 type
= language_lookup_primitive_type_by_name (language
, gdbarch
, name
);
1214 error (_("No type named %s."), name
);
1218 lookup_unsigned_typename (const struct language_defn
*language
,
1219 struct gdbarch
*gdbarch
, const char *name
)
1221 char *uns
= alloca (strlen (name
) + 10);
1223 strcpy (uns
, "unsigned ");
1224 strcpy (uns
+ 9, name
);
1225 return lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 0);
1229 lookup_signed_typename (const struct language_defn
*language
,
1230 struct gdbarch
*gdbarch
, const char *name
)
1233 char *uns
= alloca (strlen (name
) + 8);
1235 strcpy (uns
, "signed ");
1236 strcpy (uns
+ 7, name
);
1237 t
= lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 1);
1238 /* If we don't find "signed FOO" just try again with plain "FOO". */
1241 return lookup_typename (language
, gdbarch
, name
, (struct block
*) NULL
, 0);
1244 /* Lookup a structure type named "struct NAME",
1245 visible in lexical block BLOCK. */
1248 lookup_struct (const char *name
, const struct block
*block
)
1252 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1256 error (_("No struct type named %s."), name
);
1258 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1260 error (_("This context has class, union or enum %s, not a struct."),
1263 return (SYMBOL_TYPE (sym
));
1266 /* Lookup a union type named "union NAME",
1267 visible in lexical block BLOCK. */
1270 lookup_union (const char *name
, const struct block
*block
)
1275 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1278 error (_("No union type named %s."), name
);
1280 t
= SYMBOL_TYPE (sym
);
1282 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1285 /* If we get here, it's not a union. */
1286 error (_("This context has class, struct or enum %s, not a union."),
1290 /* Lookup an enum type named "enum NAME",
1291 visible in lexical block BLOCK. */
1294 lookup_enum (const char *name
, const struct block
*block
)
1298 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1301 error (_("No enum type named %s."), name
);
1303 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1305 error (_("This context has class, struct or union %s, not an enum."),
1308 return (SYMBOL_TYPE (sym
));
1311 /* Lookup a template type named "template NAME<TYPE>",
1312 visible in lexical block BLOCK. */
1315 lookup_template_type (char *name
, struct type
*type
,
1316 const struct block
*block
)
1319 char *nam
= (char *)
1320 alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1324 strcat (nam
, TYPE_NAME (type
));
1325 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1327 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0);
1331 error (_("No template type named %s."), name
);
1333 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1335 error (_("This context has class, union or enum %s, not a struct."),
1338 return (SYMBOL_TYPE (sym
));
1341 /* Given a type TYPE, lookup the type of the component of type named
1344 TYPE can be either a struct or union, or a pointer or reference to
1345 a struct or union. If it is a pointer or reference, its target
1346 type is automatically used. Thus '.' and '->' are interchangable,
1347 as specified for the definitions of the expression element types
1348 STRUCTOP_STRUCT and STRUCTOP_PTR.
1350 If NOERR is nonzero, return zero if NAME is not suitably defined.
1351 If NAME is the name of a baseclass type, return that type. */
1354 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
1361 CHECK_TYPEDEF (type
);
1362 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1363 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1365 type
= TYPE_TARGET_TYPE (type
);
1368 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1369 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1371 typename
= type_to_string (type
);
1372 make_cleanup (xfree
, typename
);
1373 error (_("Type %s is not a structure or union type."), typename
);
1377 /* FIXME: This change put in by Michael seems incorrect for the case
1378 where the structure tag name is the same as the member name.
1379 I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
1380 foo; } bell;" Disabled by fnf. */
1384 typename
= type_name_no_tag (type
);
1385 if (typename
!= NULL
&& strcmp (typename
, name
) == 0)
1390 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1392 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1394 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1396 return TYPE_FIELD_TYPE (type
, i
);
1398 else if (!t_field_name
|| *t_field_name
== '\0')
1400 struct type
*subtype
1401 = lookup_struct_elt_type (TYPE_FIELD_TYPE (type
, i
), name
, 1);
1403 if (subtype
!= NULL
)
1408 /* OK, it's not in this class. Recursively check the baseclasses. */
1409 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1413 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, 1);
1425 typename
= type_to_string (type
);
1426 make_cleanup (xfree
, typename
);
1427 error (_("Type %s has no component named %s."), typename
, name
);
1430 /* Lookup the vptr basetype/fieldno values for TYPE.
1431 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1432 vptr_fieldno. Also, if found and basetype is from the same objfile,
1434 If not found, return -1 and ignore BASETYPEP.
1435 Callers should be aware that in some cases (for example,
1436 the type or one of its baseclasses is a stub type and we are
1437 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1438 this function will not be able to find the
1439 virtual function table pointer, and vptr_fieldno will remain -1 and
1440 vptr_basetype will remain NULL or incomplete. */
1443 get_vptr_fieldno (struct type
*type
, struct type
**basetypep
)
1445 CHECK_TYPEDEF (type
);
1447 if (TYPE_VPTR_FIELDNO (type
) < 0)
1451 /* We must start at zero in case the first (and only) baseclass
1452 is virtual (and hence we cannot share the table pointer). */
1453 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1455 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1457 struct type
*basetype
;
1459 fieldno
= get_vptr_fieldno (baseclass
, &basetype
);
1462 /* If the type comes from a different objfile we can't cache
1463 it, it may have a different lifetime. PR 2384 */
1464 if (TYPE_OBJFILE (type
) == TYPE_OBJFILE (basetype
))
1466 TYPE_VPTR_FIELDNO (type
) = fieldno
;
1467 TYPE_VPTR_BASETYPE (type
) = basetype
;
1470 *basetypep
= basetype
;
1481 *basetypep
= TYPE_VPTR_BASETYPE (type
);
1482 return TYPE_VPTR_FIELDNO (type
);
1487 stub_noname_complaint (void)
1489 complaint (&symfile_complaints
, _("stub type has NULL name"));
1492 /* Find the real type of TYPE. This function returns the real type,
1493 after removing all layers of typedefs, and completing opaque or stub
1494 types. Completion changes the TYPE argument, but stripping of
1497 Instance flags (e.g. const/volatile) are preserved as typedefs are
1498 stripped. If necessary a new qualified form of the underlying type
1501 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
1502 not been computed and we're either in the middle of reading symbols, or
1503 there was no name for the typedef in the debug info.
1505 NOTE: Lookup of opaque types can throw errors for invalid symbol files.
1506 QUITs in the symbol reading code can also throw.
1507 Thus this function can throw an exception.
1509 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
1512 If this is a stubbed struct (i.e. declared as struct foo *), see if
1513 we can find a full definition in some other file. If so, copy this
1514 definition, so we can use it in future. There used to be a comment
1515 (but not any code) that if we don't find a full definition, we'd
1516 set a flag so we don't spend time in the future checking the same
1517 type. That would be a mistake, though--we might load in more
1518 symbols which contain a full definition for the type. */
1521 check_typedef (struct type
*type
)
1523 struct type
*orig_type
= type
;
1524 /* While we're removing typedefs, we don't want to lose qualifiers.
1525 E.g., const/volatile. */
1526 int instance_flags
= TYPE_INSTANCE_FLAGS (type
);
1530 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1532 if (!TYPE_TARGET_TYPE (type
))
1537 /* It is dangerous to call lookup_symbol if we are currently
1538 reading a symtab. Infinite recursion is one danger. */
1539 if (currently_reading_symtab
)
1540 return make_qualified_type (type
, instance_flags
, NULL
);
1542 name
= type_name_no_tag (type
);
1543 /* FIXME: shouldn't we separately check the TYPE_NAME and
1544 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1545 VAR_DOMAIN as appropriate? (this code was written before
1546 TYPE_NAME and TYPE_TAG_NAME were separate). */
1549 stub_noname_complaint ();
1550 return make_qualified_type (type
, instance_flags
, NULL
);
1552 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1554 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1555 else /* TYPE_CODE_UNDEF */
1556 TYPE_TARGET_TYPE (type
) = alloc_type_arch (get_type_arch (type
));
1558 type
= TYPE_TARGET_TYPE (type
);
1560 /* Preserve the instance flags as we traverse down the typedef chain.
1562 Handling address spaces/classes is nasty, what do we do if there's a
1564 E.g., what if an outer typedef marks the type as class_1 and an inner
1565 typedef marks the type as class_2?
1566 This is the wrong place to do such error checking. We leave it to
1567 the code that created the typedef in the first place to flag the
1568 error. We just pick the outer address space (akin to letting the
1569 outer cast in a chain of casting win), instead of assuming
1570 "it can't happen". */
1572 const int ALL_SPACES
= (TYPE_INSTANCE_FLAG_CODE_SPACE
1573 | TYPE_INSTANCE_FLAG_DATA_SPACE
);
1574 const int ALL_CLASSES
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
;
1575 int new_instance_flags
= TYPE_INSTANCE_FLAGS (type
);
1577 /* Treat code vs data spaces and address classes separately. */
1578 if ((instance_flags
& ALL_SPACES
) != 0)
1579 new_instance_flags
&= ~ALL_SPACES
;
1580 if ((instance_flags
& ALL_CLASSES
) != 0)
1581 new_instance_flags
&= ~ALL_CLASSES
;
1583 instance_flags
|= new_instance_flags
;
1587 /* If this is a struct/class/union with no fields, then check
1588 whether a full definition exists somewhere else. This is for
1589 systems where a type definition with no fields is issued for such
1590 types, instead of identifying them as stub types in the first
1593 if (TYPE_IS_OPAQUE (type
)
1594 && opaque_type_resolution
1595 && !currently_reading_symtab
)
1597 const char *name
= type_name_no_tag (type
);
1598 struct type
*newtype
;
1602 stub_noname_complaint ();
1603 return make_qualified_type (type
, instance_flags
, NULL
);
1605 newtype
= lookup_transparent_type (name
);
1609 /* If the resolved type and the stub are in the same
1610 objfile, then replace the stub type with the real deal.
1611 But if they're in separate objfiles, leave the stub
1612 alone; we'll just look up the transparent type every time
1613 we call check_typedef. We can't create pointers between
1614 types allocated to different objfiles, since they may
1615 have different lifetimes. Trying to copy NEWTYPE over to
1616 TYPE's objfile is pointless, too, since you'll have to
1617 move over any other types NEWTYPE refers to, which could
1618 be an unbounded amount of stuff. */
1619 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
1620 type
= make_qualified_type (newtype
,
1621 TYPE_INSTANCE_FLAGS (type
),
1627 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1629 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1631 const char *name
= type_name_no_tag (type
);
1632 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1633 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1634 as appropriate? (this code was written before TYPE_NAME and
1635 TYPE_TAG_NAME were separate). */
1640 stub_noname_complaint ();
1641 return make_qualified_type (type
, instance_flags
, NULL
);
1643 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1646 /* Same as above for opaque types, we can replace the stub
1647 with the complete type only if they are in the same
1649 if (TYPE_OBJFILE (SYMBOL_TYPE(sym
)) == TYPE_OBJFILE (type
))
1650 type
= make_qualified_type (SYMBOL_TYPE (sym
),
1651 TYPE_INSTANCE_FLAGS (type
),
1654 type
= SYMBOL_TYPE (sym
);
1658 if (TYPE_TARGET_STUB (type
))
1660 struct type
*range_type
;
1661 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1663 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1665 /* Nothing we can do. */
1667 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1668 && TYPE_NFIELDS (type
) == 1
1669 && (TYPE_CODE (range_type
= TYPE_INDEX_TYPE (type
))
1670 == TYPE_CODE_RANGE
))
1672 /* Now recompute the length of the array type, based on its
1673 number of elements and the target type's length.
1674 Watch out for Ada null Ada arrays where the high bound
1675 is smaller than the low bound. */
1676 const LONGEST low_bound
= TYPE_LOW_BOUND (range_type
);
1677 const LONGEST high_bound
= TYPE_HIGH_BOUND (range_type
);
1680 if (high_bound
< low_bound
)
1684 /* For now, we conservatively take the array length to be 0
1685 if its length exceeds UINT_MAX. The code below assumes
1686 that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
1687 which is technically not guaranteed by C, but is usually true
1688 (because it would be true if x were unsigned with its
1689 high-order bit on). It uses the fact that
1690 high_bound-low_bound is always representable in
1691 ULONGEST and that if high_bound-low_bound+1 overflows,
1692 it overflows to 0. We must change these tests if we
1693 decide to increase the representation of TYPE_LENGTH
1694 from unsigned int to ULONGEST. */
1695 ULONGEST ulow
= low_bound
, uhigh
= high_bound
;
1696 ULONGEST tlen
= TYPE_LENGTH (target_type
);
1698 len
= tlen
* (uhigh
- ulow
+ 1);
1699 if (tlen
== 0 || (len
/ tlen
- 1 + ulow
) != uhigh
1703 TYPE_LENGTH (type
) = len
;
1704 TYPE_TARGET_STUB (type
) = 0;
1706 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1708 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1709 TYPE_TARGET_STUB (type
) = 0;
1713 type
= make_qualified_type (type
, instance_flags
, NULL
);
1715 /* Cache TYPE_LENGTH for future use. */
1716 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1721 /* Parse a type expression in the string [P..P+LENGTH). If an error
1722 occurs, silently return a void type. */
1724 static struct type
*
1725 safe_parse_type (struct gdbarch
*gdbarch
, char *p
, int length
)
1727 struct ui_file
*saved_gdb_stderr
;
1728 struct type
*type
= NULL
; /* Initialize to keep gcc happy. */
1729 volatile struct gdb_exception except
;
1731 /* Suppress error messages. */
1732 saved_gdb_stderr
= gdb_stderr
;
1733 gdb_stderr
= ui_file_new ();
1735 /* Call parse_and_eval_type() without fear of longjmp()s. */
1736 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1738 type
= parse_and_eval_type (p
, length
);
1741 if (except
.reason
< 0)
1742 type
= builtin_type (gdbarch
)->builtin_void
;
1744 /* Stop suppressing error messages. */
1745 ui_file_delete (gdb_stderr
);
1746 gdb_stderr
= saved_gdb_stderr
;
1751 /* Ugly hack to convert method stubs into method types.
1753 He ain't kiddin'. This demangles the name of the method into a
1754 string including argument types, parses out each argument type,
1755 generates a string casting a zero to that type, evaluates the
1756 string, and stuffs the resulting type into an argtype vector!!!
1757 Then it knows the type of the whole function (including argument
1758 types for overloading), which info used to be in the stab's but was
1759 removed to hack back the space required for them. */
1762 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1764 struct gdbarch
*gdbarch
= get_type_arch (type
);
1766 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1767 char *demangled_name
= cplus_demangle (mangled_name
,
1768 DMGL_PARAMS
| DMGL_ANSI
);
1769 char *argtypetext
, *p
;
1770 int depth
= 0, argcount
= 1;
1771 struct field
*argtypes
;
1774 /* Make sure we got back a function string that we can use. */
1776 p
= strchr (demangled_name
, '(');
1780 if (demangled_name
== NULL
|| p
== NULL
)
1781 error (_("Internal: Cannot demangle mangled name `%s'."),
1784 /* Now, read in the parameters that define this type. */
1789 if (*p
== '(' || *p
== '<')
1793 else if (*p
== ')' || *p
== '>')
1797 else if (*p
== ',' && depth
== 0)
1805 /* If we read one argument and it was ``void'', don't count it. */
1806 if (strncmp (argtypetext
, "(void)", 6) == 0)
1809 /* We need one extra slot, for the THIS pointer. */
1811 argtypes
= (struct field
*)
1812 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
1815 /* Add THIS pointer for non-static methods. */
1816 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1817 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
1821 argtypes
[0].type
= lookup_pointer_type (type
);
1825 if (*p
!= ')') /* () means no args, skip while. */
1830 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1832 /* Avoid parsing of ellipsis, they will be handled below.
1833 Also avoid ``void'' as above. */
1834 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
1835 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
1837 argtypes
[argcount
].type
=
1838 safe_parse_type (gdbarch
, argtypetext
, p
- argtypetext
);
1841 argtypetext
= p
+ 1;
1844 if (*p
== '(' || *p
== '<')
1848 else if (*p
== ')' || *p
== '>')
1857 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1859 /* Now update the old "stub" type into a real type. */
1860 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1861 TYPE_DOMAIN_TYPE (mtype
) = type
;
1862 TYPE_FIELDS (mtype
) = argtypes
;
1863 TYPE_NFIELDS (mtype
) = argcount
;
1864 TYPE_STUB (mtype
) = 0;
1865 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1867 TYPE_VARARGS (mtype
) = 1;
1869 xfree (demangled_name
);
1872 /* This is the external interface to check_stub_method, above. This
1873 function unstubs all of the signatures for TYPE's METHOD_ID method
1874 name. After calling this function TYPE_FN_FIELD_STUB will be
1875 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1878 This function unfortunately can not die until stabs do. */
1881 check_stub_method_group (struct type
*type
, int method_id
)
1883 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
1884 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1885 int j
, found_stub
= 0;
1887 for (j
= 0; j
< len
; j
++)
1888 if (TYPE_FN_FIELD_STUB (f
, j
))
1891 check_stub_method (type
, method_id
, j
);
1894 /* GNU v3 methods with incorrect names were corrected when we read
1895 in type information, because it was cheaper to do it then. The
1896 only GNU v2 methods with incorrect method names are operators and
1897 destructors; destructors were also corrected when we read in type
1900 Therefore the only thing we need to handle here are v2 operator
1902 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
1905 char dem_opname
[256];
1907 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1909 dem_opname
, DMGL_ANSI
);
1911 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1915 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
1919 /* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */
1920 const struct cplus_struct_type cplus_struct_default
= { };
1923 allocate_cplus_struct_type (struct type
*type
)
1925 if (HAVE_CPLUS_STRUCT (type
))
1926 /* Structure was already allocated. Nothing more to do. */
1929 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_CPLUS_STUFF
;
1930 TYPE_RAW_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1931 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1932 *(TYPE_RAW_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1935 const struct gnat_aux_type gnat_aux_default
=
1938 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
1939 and allocate the associated gnat-specific data. The gnat-specific
1940 data is also initialized to gnat_aux_default. */
1943 allocate_gnat_aux_type (struct type
*type
)
1945 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_GNAT_STUFF
;
1946 TYPE_GNAT_SPECIFIC (type
) = (struct gnat_aux_type
*)
1947 TYPE_ALLOC (type
, sizeof (struct gnat_aux_type
));
1948 *(TYPE_GNAT_SPECIFIC (type
)) = gnat_aux_default
;
1951 /* Helper function to initialize the standard scalar types.
1953 If NAME is non-NULL, then we make a copy of the string pointed
1954 to by name in the objfile_obstack for that objfile, and initialize
1955 the type name to that copy. There are places (mipsread.c in particular),
1956 where init_type is called with a NULL value for NAME). */
1959 init_type (enum type_code code
, int length
, int flags
,
1960 const char *name
, struct objfile
*objfile
)
1964 type
= alloc_type (objfile
);
1965 TYPE_CODE (type
) = code
;
1966 TYPE_LENGTH (type
) = length
;
1968 gdb_assert (!(flags
& (TYPE_FLAG_MIN
- 1)));
1969 if (flags
& TYPE_FLAG_UNSIGNED
)
1970 TYPE_UNSIGNED (type
) = 1;
1971 if (flags
& TYPE_FLAG_NOSIGN
)
1972 TYPE_NOSIGN (type
) = 1;
1973 if (flags
& TYPE_FLAG_STUB
)
1974 TYPE_STUB (type
) = 1;
1975 if (flags
& TYPE_FLAG_TARGET_STUB
)
1976 TYPE_TARGET_STUB (type
) = 1;
1977 if (flags
& TYPE_FLAG_STATIC
)
1978 TYPE_STATIC (type
) = 1;
1979 if (flags
& TYPE_FLAG_PROTOTYPED
)
1980 TYPE_PROTOTYPED (type
) = 1;
1981 if (flags
& TYPE_FLAG_INCOMPLETE
)
1982 TYPE_INCOMPLETE (type
) = 1;
1983 if (flags
& TYPE_FLAG_VARARGS
)
1984 TYPE_VARARGS (type
) = 1;
1985 if (flags
& TYPE_FLAG_VECTOR
)
1986 TYPE_VECTOR (type
) = 1;
1987 if (flags
& TYPE_FLAG_STUB_SUPPORTED
)
1988 TYPE_STUB_SUPPORTED (type
) = 1;
1989 if (flags
& TYPE_FLAG_FIXED_INSTANCE
)
1990 TYPE_FIXED_INSTANCE (type
) = 1;
1991 if (flags
& TYPE_FLAG_GNU_IFUNC
)
1992 TYPE_GNU_IFUNC (type
) = 1;
1995 TYPE_NAME (type
) = obsavestring (name
, strlen (name
),
1996 &objfile
->objfile_obstack
);
2000 if (name
&& strcmp (name
, "char") == 0)
2001 TYPE_NOSIGN (type
) = 1;
2005 case TYPE_CODE_STRUCT
:
2006 case TYPE_CODE_UNION
:
2007 case TYPE_CODE_NAMESPACE
:
2008 INIT_CPLUS_SPECIFIC (type
);
2011 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_FLOATFORMAT
;
2013 case TYPE_CODE_FUNC
:
2014 INIT_FUNC_SPECIFIC (type
);
2020 /* Queries on types. */
2023 can_dereference (struct type
*t
)
2025 /* FIXME: Should we return true for references as well as
2030 && TYPE_CODE (t
) == TYPE_CODE_PTR
2031 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
2035 is_integral_type (struct type
*t
)
2040 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
2041 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
2042 || (TYPE_CODE (t
) == TYPE_CODE_FLAGS
)
2043 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
2044 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
2045 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
2048 /* Return true if TYPE is scalar. */
2051 is_scalar_type (struct type
*type
)
2053 CHECK_TYPEDEF (type
);
2055 switch (TYPE_CODE (type
))
2057 case TYPE_CODE_ARRAY
:
2058 case TYPE_CODE_STRUCT
:
2059 case TYPE_CODE_UNION
:
2061 case TYPE_CODE_STRING
:
2068 /* Return true if T is scalar, or a composite type which in practice has
2069 the memory layout of a scalar type. E.g., an array or struct with only
2070 one scalar element inside it, or a union with only scalar elements. */
2073 is_scalar_type_recursive (struct type
*t
)
2077 if (is_scalar_type (t
))
2079 /* Are we dealing with an array or string of known dimensions? */
2080 else if ((TYPE_CODE (t
) == TYPE_CODE_ARRAY
2081 || TYPE_CODE (t
) == TYPE_CODE_STRING
) && TYPE_NFIELDS (t
) == 1
2082 && TYPE_CODE (TYPE_INDEX_TYPE (t
)) == TYPE_CODE_RANGE
)
2084 LONGEST low_bound
, high_bound
;
2085 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (t
));
2087 get_discrete_bounds (TYPE_INDEX_TYPE (t
), &low_bound
, &high_bound
);
2089 return high_bound
== low_bound
&& is_scalar_type_recursive (elt_type
);
2091 /* Are we dealing with a struct with one element? */
2092 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
&& TYPE_NFIELDS (t
) == 1)
2093 return is_scalar_type_recursive (TYPE_FIELD_TYPE (t
, 0));
2094 else if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
2096 int i
, n
= TYPE_NFIELDS (t
);
2098 /* If all elements of the union are scalar, then the union is scalar. */
2099 for (i
= 0; i
< n
; i
++)
2100 if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t
, i
)))
2109 /* A helper function which returns true if types A and B represent the
2110 "same" class type. This is true if the types have the same main
2111 type, or the same name. */
2114 class_types_same_p (const struct type
*a
, const struct type
*b
)
2116 return (TYPE_MAIN_TYPE (a
) == TYPE_MAIN_TYPE (b
)
2117 || (TYPE_NAME (a
) && TYPE_NAME (b
)
2118 && !strcmp (TYPE_NAME (a
), TYPE_NAME (b
))));
2121 /* If BASE is an ancestor of DCLASS return the distance between them.
2122 otherwise return -1;
2126 class B: public A {};
2127 class C: public B {};
2130 distance_to_ancestor (A, A, 0) = 0
2131 distance_to_ancestor (A, B, 0) = 1
2132 distance_to_ancestor (A, C, 0) = 2
2133 distance_to_ancestor (A, D, 0) = 3
2135 If PUBLIC is 1 then only public ancestors are considered,
2136 and the function returns the distance only if BASE is a public ancestor
2140 distance_to_ancestor (A, D, 1) = -1. */
2143 distance_to_ancestor (struct type
*base
, struct type
*dclass
, int public)
2148 CHECK_TYPEDEF (base
);
2149 CHECK_TYPEDEF (dclass
);
2151 if (class_types_same_p (base
, dclass
))
2154 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
2156 if (public && ! BASETYPE_VIA_PUBLIC (dclass
, i
))
2159 d
= distance_to_ancestor (base
, TYPE_BASECLASS (dclass
, i
), public);
2167 /* Check whether BASE is an ancestor or base class or DCLASS
2168 Return 1 if so, and 0 if not.
2169 Note: If BASE and DCLASS are of the same type, this function
2170 will return 1. So for some class A, is_ancestor (A, A) will
2174 is_ancestor (struct type
*base
, struct type
*dclass
)
2176 return distance_to_ancestor (base
, dclass
, 0) >= 0;
2179 /* Like is_ancestor, but only returns true when BASE is a public
2180 ancestor of DCLASS. */
2183 is_public_ancestor (struct type
*base
, struct type
*dclass
)
2185 return distance_to_ancestor (base
, dclass
, 1) >= 0;
2188 /* A helper function for is_unique_ancestor. */
2191 is_unique_ancestor_worker (struct type
*base
, struct type
*dclass
,
2193 const gdb_byte
*valaddr
, int embedded_offset
,
2194 CORE_ADDR address
, struct value
*val
)
2198 CHECK_TYPEDEF (base
);
2199 CHECK_TYPEDEF (dclass
);
2201 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
) && count
< 2; ++i
)
2206 iter
= check_typedef (TYPE_BASECLASS (dclass
, i
));
2208 this_offset
= baseclass_offset (dclass
, i
, valaddr
, embedded_offset
,
2211 if (class_types_same_p (base
, iter
))
2213 /* If this is the first subclass, set *OFFSET and set count
2214 to 1. Otherwise, if this is at the same offset as
2215 previous instances, do nothing. Otherwise, increment
2219 *offset
= this_offset
;
2222 else if (this_offset
== *offset
)
2230 count
+= is_unique_ancestor_worker (base
, iter
, offset
,
2232 embedded_offset
+ this_offset
,
2239 /* Like is_ancestor, but only returns true if BASE is a unique base
2240 class of the type of VAL. */
2243 is_unique_ancestor (struct type
*base
, struct value
*val
)
2247 return is_unique_ancestor_worker (base
, value_type (val
), &offset
,
2248 value_contents_for_printing (val
),
2249 value_embedded_offset (val
),
2250 value_address (val
), val
) == 1;
2254 /* Overload resolution. */
2256 /* Return the sum of the rank of A with the rank of B. */
2259 sum_ranks (struct rank a
, struct rank b
)
2262 c
.rank
= a
.rank
+ b
.rank
;
2263 c
.subrank
= a
.subrank
+ b
.subrank
;
2267 /* Compare rank A and B and return:
2269 1 if a is better than b
2270 -1 if b is better than a. */
2273 compare_ranks (struct rank a
, struct rank b
)
2275 if (a
.rank
== b
.rank
)
2277 if (a
.subrank
== b
.subrank
)
2279 if (a
.subrank
< b
.subrank
)
2281 if (a
.subrank
> b
.subrank
)
2285 if (a
.rank
< b
.rank
)
2288 /* a.rank > b.rank */
2292 /* Functions for overload resolution begin here. */
2294 /* Compare two badness vectors A and B and return the result.
2295 0 => A and B are identical
2296 1 => A and B are incomparable
2297 2 => A is better than B
2298 3 => A is worse than B */
2301 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
2305 short found_pos
= 0; /* any positives in c? */
2306 short found_neg
= 0; /* any negatives in c? */
2308 /* differing lengths => incomparable */
2309 if (a
->length
!= b
->length
)
2312 /* Subtract b from a */
2313 for (i
= 0; i
< a
->length
; i
++)
2315 tmp
= compare_ranks (b
->rank
[i
], a
->rank
[i
]);
2325 return 1; /* incomparable */
2327 return 3; /* A > B */
2333 return 2; /* A < B */
2335 return 0; /* A == B */
2339 /* Rank a function by comparing its parameter types (PARMS, length
2340 NPARMS), to the types of an argument list (ARGS, length NARGS).
2341 Return a pointer to a badness vector. This has NARGS + 1
2344 struct badness_vector
*
2345 rank_function (struct type
**parms
, int nparms
,
2346 struct value
**args
, int nargs
)
2349 struct badness_vector
*bv
;
2350 int min_len
= nparms
< nargs
? nparms
: nargs
;
2352 bv
= xmalloc (sizeof (struct badness_vector
));
2353 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank. */
2354 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
2356 /* First compare the lengths of the supplied lists.
2357 If there is a mismatch, set it to a high value. */
2359 /* pai/1997-06-03 FIXME: when we have debug info about default
2360 arguments and ellipsis parameter lists, we should consider those
2361 and rank the length-match more finely. */
2363 LENGTH_MATCH (bv
) = (nargs
!= nparms
)
2364 ? LENGTH_MISMATCH_BADNESS
2365 : EXACT_MATCH_BADNESS
;
2367 /* Now rank all the parameters of the candidate function. */
2368 for (i
= 1; i
<= min_len
; i
++)
2369 bv
->rank
[i
] = rank_one_type (parms
[i
- 1], value_type (args
[i
- 1]),
2372 /* If more arguments than parameters, add dummy entries. */
2373 for (i
= min_len
+ 1; i
<= nargs
; i
++)
2374 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
2379 /* Compare the names of two integer types, assuming that any sign
2380 qualifiers have been checked already. We do it this way because
2381 there may be an "int" in the name of one of the types. */
2384 integer_types_same_name_p (const char *first
, const char *second
)
2386 int first_p
, second_p
;
2388 /* If both are shorts, return 1; if neither is a short, keep
2390 first_p
= (strstr (first
, "short") != NULL
);
2391 second_p
= (strstr (second
, "short") != NULL
);
2392 if (first_p
&& second_p
)
2394 if (first_p
|| second_p
)
2397 /* Likewise for long. */
2398 first_p
= (strstr (first
, "long") != NULL
);
2399 second_p
= (strstr (second
, "long") != NULL
);
2400 if (first_p
&& second_p
)
2402 if (first_p
|| second_p
)
2405 /* Likewise for char. */
2406 first_p
= (strstr (first
, "char") != NULL
);
2407 second_p
= (strstr (second
, "char") != NULL
);
2408 if (first_p
&& second_p
)
2410 if (first_p
|| second_p
)
2413 /* They must both be ints. */
2417 /* Compares type A to type B returns 1 if the represent the same type
2421 types_equal (struct type
*a
, struct type
*b
)
2423 /* Identical type pointers. */
2424 /* However, this still doesn't catch all cases of same type for b
2425 and a. The reason is that builtin types are different from
2426 the same ones constructed from the object. */
2430 /* Resolve typedefs */
2431 if (TYPE_CODE (a
) == TYPE_CODE_TYPEDEF
)
2432 a
= check_typedef (a
);
2433 if (TYPE_CODE (b
) == TYPE_CODE_TYPEDEF
)
2434 b
= check_typedef (b
);
2436 /* If after resolving typedefs a and b are not of the same type
2437 code then they are not equal. */
2438 if (TYPE_CODE (a
) != TYPE_CODE (b
))
2441 /* If a and b are both pointers types or both reference types then
2442 they are equal of the same type iff the objects they refer to are
2443 of the same type. */
2444 if (TYPE_CODE (a
) == TYPE_CODE_PTR
2445 || TYPE_CODE (a
) == TYPE_CODE_REF
)
2446 return types_equal (TYPE_TARGET_TYPE (a
),
2447 TYPE_TARGET_TYPE (b
));
2449 /* Well, damnit, if the names are exactly the same, I'll say they
2450 are exactly the same. This happens when we generate method
2451 stubs. The types won't point to the same address, but they
2452 really are the same. */
2454 if (TYPE_NAME (a
) && TYPE_NAME (b
)
2455 && strcmp (TYPE_NAME (a
), TYPE_NAME (b
)) == 0)
2458 /* Check if identical after resolving typedefs. */
2465 /* Compare one type (PARM) for compatibility with another (ARG).
2466 * PARM is intended to be the parameter type of a function; and
2467 * ARG is the supplied argument's type. This function tests if
2468 * the latter can be converted to the former.
2469 * VALUE is the argument's value or NULL if none (or called recursively)
2471 * Return 0 if they are identical types;
2472 * Otherwise, return an integer which corresponds to how compatible
2473 * PARM is to ARG. The higher the return value, the worse the match.
2474 * Generally the "bad" conversions are all uniformly assigned a 100. */
2477 rank_one_type (struct type
*parm
, struct type
*arg
, struct value
*value
)
2479 struct rank rank
= {0,0};
2481 if (types_equal (parm
, arg
))
2482 return EXACT_MATCH_BADNESS
;
2484 /* Resolve typedefs */
2485 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2486 parm
= check_typedef (parm
);
2487 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2488 arg
= check_typedef (arg
);
2490 /* See through references, since we can almost make non-references
2492 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2493 return (sum_ranks (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
),
2494 REFERENCE_CONVERSION_BADNESS
));
2495 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2496 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
),
2497 REFERENCE_CONVERSION_BADNESS
));
2499 /* Debugging only. */
2500 fprintf_filtered (gdb_stderr
,
2501 "------ Arg is %s [%d], parm is %s [%d]\n",
2502 TYPE_NAME (arg
), TYPE_CODE (arg
),
2503 TYPE_NAME (parm
), TYPE_CODE (parm
));
2505 /* x -> y means arg of type x being supplied for parameter of type y. */
2507 switch (TYPE_CODE (parm
))
2510 switch (TYPE_CODE (arg
))
2514 /* Allowed pointer conversions are:
2515 (a) pointer to void-pointer conversion. */
2516 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
)
2517 return VOID_PTR_CONVERSION_BADNESS
;
2519 /* (b) pointer to ancestor-pointer conversion. */
2520 rank
.subrank
= distance_to_ancestor (TYPE_TARGET_TYPE (parm
),
2521 TYPE_TARGET_TYPE (arg
),
2523 if (rank
.subrank
>= 0)
2524 return sum_ranks (BASE_PTR_CONVERSION_BADNESS
, rank
);
2526 return INCOMPATIBLE_TYPE_BADNESS
;
2527 case TYPE_CODE_ARRAY
:
2528 if (types_equal (TYPE_TARGET_TYPE (parm
),
2529 TYPE_TARGET_TYPE (arg
)))
2530 return EXACT_MATCH_BADNESS
;
2531 return INCOMPATIBLE_TYPE_BADNESS
;
2532 case TYPE_CODE_FUNC
:
2533 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
, NULL
);
2535 if (value
!= NULL
&& TYPE_CODE (value_type (value
)) == TYPE_CODE_INT
)
2537 if (value_as_long (value
) == 0)
2539 /* Null pointer conversion: allow it to be cast to a pointer.
2540 [4.10.1 of C++ standard draft n3290] */
2541 return NULL_POINTER_CONVERSION_BADNESS
;
2545 /* If type checking is disabled, allow the conversion. */
2546 if (!strict_type_checking
)
2547 return NS_INTEGER_POINTER_CONVERSION_BADNESS
;
2551 case TYPE_CODE_ENUM
:
2552 case TYPE_CODE_FLAGS
:
2553 case TYPE_CODE_CHAR
:
2554 case TYPE_CODE_RANGE
:
2555 case TYPE_CODE_BOOL
:
2557 return INCOMPATIBLE_TYPE_BADNESS
;
2559 case TYPE_CODE_ARRAY
:
2560 switch (TYPE_CODE (arg
))
2563 case TYPE_CODE_ARRAY
:
2564 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2565 TYPE_TARGET_TYPE (arg
), NULL
);
2567 return INCOMPATIBLE_TYPE_BADNESS
;
2569 case TYPE_CODE_FUNC
:
2570 switch (TYPE_CODE (arg
))
2572 case TYPE_CODE_PTR
: /* funcptr -> func */
2573 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
), NULL
);
2575 return INCOMPATIBLE_TYPE_BADNESS
;
2578 switch (TYPE_CODE (arg
))
2581 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2583 /* Deal with signed, unsigned, and plain chars and
2584 signed and unsigned ints. */
2585 if (TYPE_NOSIGN (parm
))
2587 /* This case only for character types. */
2588 if (TYPE_NOSIGN (arg
))
2589 return EXACT_MATCH_BADNESS
; /* plain char -> plain char */
2590 else /* signed/unsigned char -> plain char */
2591 return INTEGER_CONVERSION_BADNESS
;
2593 else if (TYPE_UNSIGNED (parm
))
2595 if (TYPE_UNSIGNED (arg
))
2597 /* unsigned int -> unsigned int, or
2598 unsigned long -> unsigned long */
2599 if (integer_types_same_name_p (TYPE_NAME (parm
),
2601 return EXACT_MATCH_BADNESS
;
2602 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2604 && integer_types_same_name_p (TYPE_NAME (parm
),
2606 /* unsigned int -> unsigned long */
2607 return INTEGER_PROMOTION_BADNESS
;
2609 /* unsigned long -> unsigned int */
2610 return INTEGER_CONVERSION_BADNESS
;
2614 if (integer_types_same_name_p (TYPE_NAME (arg
),
2616 && integer_types_same_name_p (TYPE_NAME (parm
),
2618 /* signed long -> unsigned int */
2619 return INTEGER_CONVERSION_BADNESS
;
2621 /* signed int/long -> unsigned int/long */
2622 return INTEGER_CONVERSION_BADNESS
;
2625 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2627 if (integer_types_same_name_p (TYPE_NAME (parm
),
2629 return EXACT_MATCH_BADNESS
;
2630 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2632 && integer_types_same_name_p (TYPE_NAME (parm
),
2634 return INTEGER_PROMOTION_BADNESS
;
2636 return INTEGER_CONVERSION_BADNESS
;
2639 return INTEGER_CONVERSION_BADNESS
;
2641 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2642 return INTEGER_PROMOTION_BADNESS
;
2644 return INTEGER_CONVERSION_BADNESS
;
2645 case TYPE_CODE_ENUM
:
2646 case TYPE_CODE_FLAGS
:
2647 case TYPE_CODE_CHAR
:
2648 case TYPE_CODE_RANGE
:
2649 case TYPE_CODE_BOOL
:
2650 return INTEGER_PROMOTION_BADNESS
;
2652 return INT_FLOAT_CONVERSION_BADNESS
;
2654 return NS_POINTER_CONVERSION_BADNESS
;
2656 return INCOMPATIBLE_TYPE_BADNESS
;
2659 case TYPE_CODE_ENUM
:
2660 switch (TYPE_CODE (arg
))
2663 case TYPE_CODE_CHAR
:
2664 case TYPE_CODE_RANGE
:
2665 case TYPE_CODE_BOOL
:
2666 case TYPE_CODE_ENUM
:
2667 return INTEGER_CONVERSION_BADNESS
;
2669 return INT_FLOAT_CONVERSION_BADNESS
;
2671 return INCOMPATIBLE_TYPE_BADNESS
;
2674 case TYPE_CODE_CHAR
:
2675 switch (TYPE_CODE (arg
))
2677 case TYPE_CODE_RANGE
:
2678 case TYPE_CODE_BOOL
:
2679 case TYPE_CODE_ENUM
:
2680 return INTEGER_CONVERSION_BADNESS
;
2682 return INT_FLOAT_CONVERSION_BADNESS
;
2684 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2685 return INTEGER_CONVERSION_BADNESS
;
2686 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2687 return INTEGER_PROMOTION_BADNESS
;
2688 /* >>> !! else fall through !! <<< */
2689 case TYPE_CODE_CHAR
:
2690 /* Deal with signed, unsigned, and plain chars for C++ and
2691 with int cases falling through from previous case. */
2692 if (TYPE_NOSIGN (parm
))
2694 if (TYPE_NOSIGN (arg
))
2695 return EXACT_MATCH_BADNESS
;
2697 return INTEGER_CONVERSION_BADNESS
;
2699 else if (TYPE_UNSIGNED (parm
))
2701 if (TYPE_UNSIGNED (arg
))
2702 return EXACT_MATCH_BADNESS
;
2704 return INTEGER_PROMOTION_BADNESS
;
2706 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2707 return EXACT_MATCH_BADNESS
;
2709 return INTEGER_CONVERSION_BADNESS
;
2711 return INCOMPATIBLE_TYPE_BADNESS
;
2714 case TYPE_CODE_RANGE
:
2715 switch (TYPE_CODE (arg
))
2718 case TYPE_CODE_CHAR
:
2719 case TYPE_CODE_RANGE
:
2720 case TYPE_CODE_BOOL
:
2721 case TYPE_CODE_ENUM
:
2722 return INTEGER_CONVERSION_BADNESS
;
2724 return INT_FLOAT_CONVERSION_BADNESS
;
2726 return INCOMPATIBLE_TYPE_BADNESS
;
2729 case TYPE_CODE_BOOL
:
2730 switch (TYPE_CODE (arg
))
2732 /* n3290 draft, section 4.12.1 (conv.bool):
2734 "A prvalue of arithmetic, unscoped enumeration, pointer, or
2735 pointer to member type can be converted to a prvalue of type
2736 bool. A zero value, null pointer value, or null member pointer
2737 value is converted to false; any other value is converted to
2738 true. A prvalue of type std::nullptr_t can be converted to a
2739 prvalue of type bool; the resulting value is false." */
2741 case TYPE_CODE_CHAR
:
2742 case TYPE_CODE_ENUM
:
2744 case TYPE_CODE_MEMBERPTR
:
2746 return BOOL_CONVERSION_BADNESS
;
2747 case TYPE_CODE_RANGE
:
2748 return INCOMPATIBLE_TYPE_BADNESS
;
2749 case TYPE_CODE_BOOL
:
2750 return EXACT_MATCH_BADNESS
;
2752 return INCOMPATIBLE_TYPE_BADNESS
;
2756 switch (TYPE_CODE (arg
))
2759 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2760 return FLOAT_PROMOTION_BADNESS
;
2761 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2762 return EXACT_MATCH_BADNESS
;
2764 return FLOAT_CONVERSION_BADNESS
;
2766 case TYPE_CODE_BOOL
:
2767 case TYPE_CODE_ENUM
:
2768 case TYPE_CODE_RANGE
:
2769 case TYPE_CODE_CHAR
:
2770 return INT_FLOAT_CONVERSION_BADNESS
;
2772 return INCOMPATIBLE_TYPE_BADNESS
;
2775 case TYPE_CODE_COMPLEX
:
2776 switch (TYPE_CODE (arg
))
2777 { /* Strictly not needed for C++, but... */
2779 return FLOAT_PROMOTION_BADNESS
;
2780 case TYPE_CODE_COMPLEX
:
2781 return EXACT_MATCH_BADNESS
;
2783 return INCOMPATIBLE_TYPE_BADNESS
;
2786 case TYPE_CODE_STRUCT
:
2787 /* currently same as TYPE_CODE_CLASS. */
2788 switch (TYPE_CODE (arg
))
2790 case TYPE_CODE_STRUCT
:
2791 /* Check for derivation */
2792 rank
.subrank
= distance_to_ancestor (parm
, arg
, 0);
2793 if (rank
.subrank
>= 0)
2794 return sum_ranks (BASE_CONVERSION_BADNESS
, rank
);
2795 /* else fall through */
2797 return INCOMPATIBLE_TYPE_BADNESS
;
2800 case TYPE_CODE_UNION
:
2801 switch (TYPE_CODE (arg
))
2803 case TYPE_CODE_UNION
:
2805 return INCOMPATIBLE_TYPE_BADNESS
;
2808 case TYPE_CODE_MEMBERPTR
:
2809 switch (TYPE_CODE (arg
))
2812 return INCOMPATIBLE_TYPE_BADNESS
;
2815 case TYPE_CODE_METHOD
:
2816 switch (TYPE_CODE (arg
))
2820 return INCOMPATIBLE_TYPE_BADNESS
;
2824 switch (TYPE_CODE (arg
))
2828 return INCOMPATIBLE_TYPE_BADNESS
;
2833 switch (TYPE_CODE (arg
))
2837 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0),
2838 TYPE_FIELD_TYPE (arg
, 0), NULL
);
2840 return INCOMPATIBLE_TYPE_BADNESS
;
2843 case TYPE_CODE_VOID
:
2845 return INCOMPATIBLE_TYPE_BADNESS
;
2846 } /* switch (TYPE_CODE (arg)) */
2849 /* End of functions for overload resolution. */
2851 /* Routines to pretty-print types. */
2854 print_bit_vector (B_TYPE
*bits
, int nbits
)
2858 for (bitno
= 0; bitno
< nbits
; bitno
++)
2860 if ((bitno
% 8) == 0)
2862 puts_filtered (" ");
2864 if (B_TST (bits
, bitno
))
2865 printf_filtered (("1"));
2867 printf_filtered (("0"));
2871 /* Note the first arg should be the "this" pointer, we may not want to
2872 include it since we may get into a infinitely recursive
2876 print_arg_types (struct field
*args
, int nargs
, int spaces
)
2882 for (i
= 0; i
< nargs
; i
++)
2883 recursive_dump_type (args
[i
].type
, spaces
+ 2);
2888 field_is_static (struct field
*f
)
2890 /* "static" fields are the fields whose location is not relative
2891 to the address of the enclosing struct. It would be nice to
2892 have a dedicated flag that would be set for static fields when
2893 the type is being created. But in practice, checking the field
2894 loc_kind should give us an accurate answer. */
2895 return (FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSNAME
2896 || FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSADDR
);
2900 dump_fn_fieldlists (struct type
*type
, int spaces
)
2906 printfi_filtered (spaces
, "fn_fieldlists ");
2907 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2908 printf_filtered ("\n");
2909 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2911 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2912 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2914 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2915 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2917 printf_filtered (_(") length %d\n"),
2918 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2919 for (overload_idx
= 0;
2920 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2923 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2925 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2926 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2928 printf_filtered (")\n");
2929 printfi_filtered (spaces
+ 8, "type ");
2930 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2932 printf_filtered ("\n");
2934 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2937 printfi_filtered (spaces
+ 8, "args ");
2938 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2940 printf_filtered ("\n");
2942 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2943 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
,
2946 printfi_filtered (spaces
+ 8, "fcontext ");
2947 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2949 printf_filtered ("\n");
2951 printfi_filtered (spaces
+ 8, "is_const %d\n",
2952 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2953 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2954 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2955 printfi_filtered (spaces
+ 8, "is_private %d\n",
2956 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2957 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2958 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2959 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2960 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2961 printfi_filtered (spaces
+ 8, "voffset %u\n",
2962 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2968 print_cplus_stuff (struct type
*type
, int spaces
)
2970 printfi_filtered (spaces
, "n_baseclasses %d\n",
2971 TYPE_N_BASECLASSES (type
));
2972 printfi_filtered (spaces
, "nfn_fields %d\n",
2973 TYPE_NFN_FIELDS (type
));
2974 if (TYPE_N_BASECLASSES (type
) > 0)
2976 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2977 TYPE_N_BASECLASSES (type
));
2978 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
2980 printf_filtered (")");
2982 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2983 TYPE_N_BASECLASSES (type
));
2984 puts_filtered ("\n");
2986 if (TYPE_NFIELDS (type
) > 0)
2988 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2990 printfi_filtered (spaces
,
2991 "private_field_bits (%d bits at *",
2992 TYPE_NFIELDS (type
));
2993 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
2995 printf_filtered (")");
2996 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2997 TYPE_NFIELDS (type
));
2998 puts_filtered ("\n");
3000 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
3002 printfi_filtered (spaces
,
3003 "protected_field_bits (%d bits at *",
3004 TYPE_NFIELDS (type
));
3005 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
3007 printf_filtered (")");
3008 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
3009 TYPE_NFIELDS (type
));
3010 puts_filtered ("\n");
3013 if (TYPE_NFN_FIELDS (type
) > 0)
3015 dump_fn_fieldlists (type
, spaces
);
3019 /* Print the contents of the TYPE's type_specific union, assuming that
3020 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
3023 print_gnat_stuff (struct type
*type
, int spaces
)
3025 struct type
*descriptive_type
= TYPE_DESCRIPTIVE_TYPE (type
);
3027 recursive_dump_type (descriptive_type
, spaces
+ 2);
3030 static struct obstack dont_print_type_obstack
;
3033 recursive_dump_type (struct type
*type
, int spaces
)
3038 obstack_begin (&dont_print_type_obstack
, 0);
3040 if (TYPE_NFIELDS (type
) > 0
3041 || (HAVE_CPLUS_STRUCT (type
) && TYPE_NFN_FIELDS (type
) > 0))
3043 struct type
**first_dont_print
3044 = (struct type
**) obstack_base (&dont_print_type_obstack
);
3046 int i
= (struct type
**)
3047 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
3051 if (type
== first_dont_print
[i
])
3053 printfi_filtered (spaces
, "type node ");
3054 gdb_print_host_address (type
, gdb_stdout
);
3055 printf_filtered (_(" <same as already seen type>\n"));
3060 obstack_ptr_grow (&dont_print_type_obstack
, type
);
3063 printfi_filtered (spaces
, "type node ");
3064 gdb_print_host_address (type
, gdb_stdout
);
3065 printf_filtered ("\n");
3066 printfi_filtered (spaces
, "name '%s' (",
3067 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
3068 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
3069 printf_filtered (")\n");
3070 printfi_filtered (spaces
, "tagname '%s' (",
3071 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
3072 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
3073 printf_filtered (")\n");
3074 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
3075 switch (TYPE_CODE (type
))
3077 case TYPE_CODE_UNDEF
:
3078 printf_filtered ("(TYPE_CODE_UNDEF)");
3081 printf_filtered ("(TYPE_CODE_PTR)");
3083 case TYPE_CODE_ARRAY
:
3084 printf_filtered ("(TYPE_CODE_ARRAY)");
3086 case TYPE_CODE_STRUCT
:
3087 printf_filtered ("(TYPE_CODE_STRUCT)");
3089 case TYPE_CODE_UNION
:
3090 printf_filtered ("(TYPE_CODE_UNION)");
3092 case TYPE_CODE_ENUM
:
3093 printf_filtered ("(TYPE_CODE_ENUM)");
3095 case TYPE_CODE_FLAGS
:
3096 printf_filtered ("(TYPE_CODE_FLAGS)");
3098 case TYPE_CODE_FUNC
:
3099 printf_filtered ("(TYPE_CODE_FUNC)");
3102 printf_filtered ("(TYPE_CODE_INT)");
3105 printf_filtered ("(TYPE_CODE_FLT)");
3107 case TYPE_CODE_VOID
:
3108 printf_filtered ("(TYPE_CODE_VOID)");
3111 printf_filtered ("(TYPE_CODE_SET)");
3113 case TYPE_CODE_RANGE
:
3114 printf_filtered ("(TYPE_CODE_RANGE)");
3116 case TYPE_CODE_STRING
:
3117 printf_filtered ("(TYPE_CODE_STRING)");
3119 case TYPE_CODE_ERROR
:
3120 printf_filtered ("(TYPE_CODE_ERROR)");
3122 case TYPE_CODE_MEMBERPTR
:
3123 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
3125 case TYPE_CODE_METHODPTR
:
3126 printf_filtered ("(TYPE_CODE_METHODPTR)");
3128 case TYPE_CODE_METHOD
:
3129 printf_filtered ("(TYPE_CODE_METHOD)");
3132 printf_filtered ("(TYPE_CODE_REF)");
3134 case TYPE_CODE_CHAR
:
3135 printf_filtered ("(TYPE_CODE_CHAR)");
3137 case TYPE_CODE_BOOL
:
3138 printf_filtered ("(TYPE_CODE_BOOL)");
3140 case TYPE_CODE_COMPLEX
:
3141 printf_filtered ("(TYPE_CODE_COMPLEX)");
3143 case TYPE_CODE_TYPEDEF
:
3144 printf_filtered ("(TYPE_CODE_TYPEDEF)");
3146 case TYPE_CODE_NAMESPACE
:
3147 printf_filtered ("(TYPE_CODE_NAMESPACE)");
3150 printf_filtered ("(UNKNOWN TYPE CODE)");
3153 puts_filtered ("\n");
3154 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
3155 if (TYPE_OBJFILE_OWNED (type
))
3157 printfi_filtered (spaces
, "objfile ");
3158 gdb_print_host_address (TYPE_OWNER (type
).objfile
, gdb_stdout
);
3162 printfi_filtered (spaces
, "gdbarch ");
3163 gdb_print_host_address (TYPE_OWNER (type
).gdbarch
, gdb_stdout
);
3165 printf_filtered ("\n");
3166 printfi_filtered (spaces
, "target_type ");
3167 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
3168 printf_filtered ("\n");
3169 if (TYPE_TARGET_TYPE (type
) != NULL
)
3171 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
3173 printfi_filtered (spaces
, "pointer_type ");
3174 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
3175 printf_filtered ("\n");
3176 printfi_filtered (spaces
, "reference_type ");
3177 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
3178 printf_filtered ("\n");
3179 printfi_filtered (spaces
, "type_chain ");
3180 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
3181 printf_filtered ("\n");
3182 printfi_filtered (spaces
, "instance_flags 0x%x",
3183 TYPE_INSTANCE_FLAGS (type
));
3184 if (TYPE_CONST (type
))
3186 puts_filtered (" TYPE_FLAG_CONST");
3188 if (TYPE_VOLATILE (type
))
3190 puts_filtered (" TYPE_FLAG_VOLATILE");
3192 if (TYPE_CODE_SPACE (type
))
3194 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3196 if (TYPE_DATA_SPACE (type
))
3198 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3200 if (TYPE_ADDRESS_CLASS_1 (type
))
3202 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3204 if (TYPE_ADDRESS_CLASS_2 (type
))
3206 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3208 if (TYPE_RESTRICT (type
))
3210 puts_filtered (" TYPE_FLAG_RESTRICT");
3212 puts_filtered ("\n");
3214 printfi_filtered (spaces
, "flags");
3215 if (TYPE_UNSIGNED (type
))
3217 puts_filtered (" TYPE_FLAG_UNSIGNED");
3219 if (TYPE_NOSIGN (type
))
3221 puts_filtered (" TYPE_FLAG_NOSIGN");
3223 if (TYPE_STUB (type
))
3225 puts_filtered (" TYPE_FLAG_STUB");
3227 if (TYPE_TARGET_STUB (type
))
3229 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3231 if (TYPE_STATIC (type
))
3233 puts_filtered (" TYPE_FLAG_STATIC");
3235 if (TYPE_PROTOTYPED (type
))
3237 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3239 if (TYPE_INCOMPLETE (type
))
3241 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3243 if (TYPE_VARARGS (type
))
3245 puts_filtered (" TYPE_FLAG_VARARGS");
3247 /* This is used for things like AltiVec registers on ppc. Gcc emits
3248 an attribute for the array type, which tells whether or not we
3249 have a vector, instead of a regular array. */
3250 if (TYPE_VECTOR (type
))
3252 puts_filtered (" TYPE_FLAG_VECTOR");
3254 if (TYPE_FIXED_INSTANCE (type
))
3256 puts_filtered (" TYPE_FIXED_INSTANCE");
3258 if (TYPE_STUB_SUPPORTED (type
))
3260 puts_filtered (" TYPE_STUB_SUPPORTED");
3262 if (TYPE_NOTTEXT (type
))
3264 puts_filtered (" TYPE_NOTTEXT");
3266 puts_filtered ("\n");
3267 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
3268 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
3269 puts_filtered ("\n");
3270 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
3272 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
3273 printfi_filtered (spaces
+ 2,
3274 "[%d] enumval %s type ",
3275 idx
, plongest (TYPE_FIELD_ENUMVAL (type
, idx
)));
3277 printfi_filtered (spaces
+ 2,
3278 "[%d] bitpos %d bitsize %d type ",
3279 idx
, TYPE_FIELD_BITPOS (type
, idx
),
3280 TYPE_FIELD_BITSIZE (type
, idx
));
3281 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
3282 printf_filtered (" name '%s' (",
3283 TYPE_FIELD_NAME (type
, idx
) != NULL
3284 ? TYPE_FIELD_NAME (type
, idx
)
3286 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
3287 printf_filtered (")\n");
3288 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
3290 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
3293 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
3295 printfi_filtered (spaces
, "low %s%s high %s%s\n",
3296 plongest (TYPE_LOW_BOUND (type
)),
3297 TYPE_LOW_BOUND_UNDEFINED (type
) ? " (undefined)" : "",
3298 plongest (TYPE_HIGH_BOUND (type
)),
3299 TYPE_HIGH_BOUND_UNDEFINED (type
)
3300 ? " (undefined)" : "");
3302 printfi_filtered (spaces
, "vptr_basetype ");
3303 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
3304 puts_filtered ("\n");
3305 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
3307 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
3309 printfi_filtered (spaces
, "vptr_fieldno %d\n",
3310 TYPE_VPTR_FIELDNO (type
));
3312 switch (TYPE_SPECIFIC_FIELD (type
))
3314 case TYPE_SPECIFIC_CPLUS_STUFF
:
3315 printfi_filtered (spaces
, "cplus_stuff ");
3316 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
),
3318 puts_filtered ("\n");
3319 print_cplus_stuff (type
, spaces
);
3322 case TYPE_SPECIFIC_GNAT_STUFF
:
3323 printfi_filtered (spaces
, "gnat_stuff ");
3324 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type
), gdb_stdout
);
3325 puts_filtered ("\n");
3326 print_gnat_stuff (type
, spaces
);
3329 case TYPE_SPECIFIC_FLOATFORMAT
:
3330 printfi_filtered (spaces
, "floatformat ");
3331 if (TYPE_FLOATFORMAT (type
) == NULL
)
3332 puts_filtered ("(null)");
3335 puts_filtered ("{ ");
3336 if (TYPE_FLOATFORMAT (type
)[0] == NULL
3337 || TYPE_FLOATFORMAT (type
)[0]->name
== NULL
)
3338 puts_filtered ("(null)");
3340 puts_filtered (TYPE_FLOATFORMAT (type
)[0]->name
);
3342 puts_filtered (", ");
3343 if (TYPE_FLOATFORMAT (type
)[1] == NULL
3344 || TYPE_FLOATFORMAT (type
)[1]->name
== NULL
)
3345 puts_filtered ("(null)");
3347 puts_filtered (TYPE_FLOATFORMAT (type
)[1]->name
);
3349 puts_filtered (" }");
3351 puts_filtered ("\n");
3354 case TYPE_SPECIFIC_FUNC
:
3355 printfi_filtered (spaces
, "calling_convention %d\n",
3356 TYPE_CALLING_CONVENTION (type
));
3357 /* tail_call_list is not printed. */
3362 obstack_free (&dont_print_type_obstack
, NULL
);
3365 /* Trivial helpers for the libiberty hash table, for mapping one
3370 struct type
*old
, *new;
3374 type_pair_hash (const void *item
)
3376 const struct type_pair
*pair
= item
;
3378 return htab_hash_pointer (pair
->old
);
3382 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
3384 const struct type_pair
*lhs
= item_lhs
, *rhs
= item_rhs
;
3386 return lhs
->old
== rhs
->old
;
3389 /* Allocate the hash table used by copy_type_recursive to walk
3390 types without duplicates. We use OBJFILE's obstack, because
3391 OBJFILE is about to be deleted. */
3394 create_copied_types_hash (struct objfile
*objfile
)
3396 return htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
3397 NULL
, &objfile
->objfile_obstack
,
3398 hashtab_obstack_allocate
,
3399 dummy_obstack_deallocate
);
3402 /* Recursively copy (deep copy) TYPE, if it is associated with
3403 OBJFILE. Return a new type allocated using malloc, a saved type if
3404 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
3405 not associated with OBJFILE. */
3408 copy_type_recursive (struct objfile
*objfile
,
3410 htab_t copied_types
)
3412 struct type_pair
*stored
, pair
;
3414 struct type
*new_type
;
3416 if (! TYPE_OBJFILE_OWNED (type
))
3419 /* This type shouldn't be pointing to any types in other objfiles;
3420 if it did, the type might disappear unexpectedly. */
3421 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
3424 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
3426 return ((struct type_pair
*) *slot
)->new;
3428 new_type
= alloc_type_arch (get_type_arch (type
));
3430 /* We must add the new type to the hash table immediately, in case
3431 we encounter this type again during a recursive call below. */
3433 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct type_pair
));
3435 stored
->new = new_type
;
3438 /* Copy the common fields of types. For the main type, we simply
3439 copy the entire thing and then update specific fields as needed. */
3440 *TYPE_MAIN_TYPE (new_type
) = *TYPE_MAIN_TYPE (type
);
3441 TYPE_OBJFILE_OWNED (new_type
) = 0;
3442 TYPE_OWNER (new_type
).gdbarch
= get_type_arch (type
);
3444 if (TYPE_NAME (type
))
3445 TYPE_NAME (new_type
) = xstrdup (TYPE_NAME (type
));
3446 if (TYPE_TAG_NAME (type
))
3447 TYPE_TAG_NAME (new_type
) = xstrdup (TYPE_TAG_NAME (type
));
3449 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
3450 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
3452 /* Copy the fields. */
3453 if (TYPE_NFIELDS (type
))
3457 nfields
= TYPE_NFIELDS (type
);
3458 TYPE_FIELDS (new_type
) = XCALLOC (nfields
, struct field
);
3459 for (i
= 0; i
< nfields
; i
++)
3461 TYPE_FIELD_ARTIFICIAL (new_type
, i
) =
3462 TYPE_FIELD_ARTIFICIAL (type
, i
);
3463 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
3464 if (TYPE_FIELD_TYPE (type
, i
))
3465 TYPE_FIELD_TYPE (new_type
, i
)
3466 = copy_type_recursive (objfile
, TYPE_FIELD_TYPE (type
, i
),
3468 if (TYPE_FIELD_NAME (type
, i
))
3469 TYPE_FIELD_NAME (new_type
, i
) =
3470 xstrdup (TYPE_FIELD_NAME (type
, i
));
3471 switch (TYPE_FIELD_LOC_KIND (type
, i
))
3473 case FIELD_LOC_KIND_BITPOS
:
3474 SET_FIELD_BITPOS (TYPE_FIELD (new_type
, i
),
3475 TYPE_FIELD_BITPOS (type
, i
));
3477 case FIELD_LOC_KIND_ENUMVAL
:
3478 SET_FIELD_ENUMVAL (TYPE_FIELD (new_type
, i
),
3479 TYPE_FIELD_ENUMVAL (type
, i
));
3481 case FIELD_LOC_KIND_PHYSADDR
:
3482 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type
, i
),
3483 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
3485 case FIELD_LOC_KIND_PHYSNAME
:
3486 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type
, i
),
3487 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
,
3491 internal_error (__FILE__
, __LINE__
,
3492 _("Unexpected type field location kind: %d"),
3493 TYPE_FIELD_LOC_KIND (type
, i
));
3498 /* For range types, copy the bounds information. */
3499 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
3501 TYPE_RANGE_DATA (new_type
) = xmalloc (sizeof (struct range_bounds
));
3502 *TYPE_RANGE_DATA (new_type
) = *TYPE_RANGE_DATA (type
);
3505 /* Copy pointers to other types. */
3506 if (TYPE_TARGET_TYPE (type
))
3507 TYPE_TARGET_TYPE (new_type
) =
3508 copy_type_recursive (objfile
,
3509 TYPE_TARGET_TYPE (type
),
3511 if (TYPE_VPTR_BASETYPE (type
))
3512 TYPE_VPTR_BASETYPE (new_type
) =
3513 copy_type_recursive (objfile
,
3514 TYPE_VPTR_BASETYPE (type
),
3516 /* Maybe copy the type_specific bits.
3518 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3519 base classes and methods. There's no fundamental reason why we
3520 can't, but at the moment it is not needed. */
3522 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
3523 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
3524 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3525 || TYPE_CODE (type
) == TYPE_CODE_UNION
3526 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
3527 INIT_CPLUS_SPECIFIC (new_type
);
3532 /* Make a copy of the given TYPE, except that the pointer & reference
3533 types are not preserved.
3535 This function assumes that the given type has an associated objfile.
3536 This objfile is used to allocate the new type. */
3539 copy_type (const struct type
*type
)
3541 struct type
*new_type
;
3543 gdb_assert (TYPE_OBJFILE_OWNED (type
));
3545 new_type
= alloc_type_copy (type
);
3546 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
3547 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
3548 memcpy (TYPE_MAIN_TYPE (new_type
), TYPE_MAIN_TYPE (type
),
3549 sizeof (struct main_type
));
3554 /* Helper functions to initialize architecture-specific types. */
3556 /* Allocate a type structure associated with GDBARCH and set its
3557 CODE, LENGTH, and NAME fields. */
3560 arch_type (struct gdbarch
*gdbarch
,
3561 enum type_code code
, int length
, char *name
)
3565 type
= alloc_type_arch (gdbarch
);
3566 TYPE_CODE (type
) = code
;
3567 TYPE_LENGTH (type
) = length
;
3570 TYPE_NAME (type
) = xstrdup (name
);
3575 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
3576 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3577 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3580 arch_integer_type (struct gdbarch
*gdbarch
,
3581 int bit
, int unsigned_p
, char *name
)
3585 t
= arch_type (gdbarch
, TYPE_CODE_INT
, bit
/ TARGET_CHAR_BIT
, name
);
3587 TYPE_UNSIGNED (t
) = 1;
3588 if (name
&& strcmp (name
, "char") == 0)
3589 TYPE_NOSIGN (t
) = 1;
3594 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
3595 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3596 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3599 arch_character_type (struct gdbarch
*gdbarch
,
3600 int bit
, int unsigned_p
, char *name
)
3604 t
= arch_type (gdbarch
, TYPE_CODE_CHAR
, bit
/ TARGET_CHAR_BIT
, name
);
3606 TYPE_UNSIGNED (t
) = 1;
3611 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
3612 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3613 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3616 arch_boolean_type (struct gdbarch
*gdbarch
,
3617 int bit
, int unsigned_p
, char *name
)
3621 t
= arch_type (gdbarch
, TYPE_CODE_BOOL
, bit
/ TARGET_CHAR_BIT
, name
);
3623 TYPE_UNSIGNED (t
) = 1;
3628 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
3629 BIT is the type size in bits; if BIT equals -1, the size is
3630 determined by the floatformat. NAME is the type name. Set the
3631 TYPE_FLOATFORMAT from FLOATFORMATS. */
3634 arch_float_type (struct gdbarch
*gdbarch
,
3635 int bit
, char *name
, const struct floatformat
**floatformats
)
3641 gdb_assert (floatformats
!= NULL
);
3642 gdb_assert (floatformats
[0] != NULL
&& floatformats
[1] != NULL
);
3643 bit
= floatformats
[0]->totalsize
;
3645 gdb_assert (bit
>= 0);
3647 t
= arch_type (gdbarch
, TYPE_CODE_FLT
, bit
/ TARGET_CHAR_BIT
, name
);
3648 TYPE_FLOATFORMAT (t
) = floatformats
;
3652 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
3653 NAME is the type name. TARGET_TYPE is the component float type. */
3656 arch_complex_type (struct gdbarch
*gdbarch
,
3657 char *name
, struct type
*target_type
)
3661 t
= arch_type (gdbarch
, TYPE_CODE_COMPLEX
,
3662 2 * TYPE_LENGTH (target_type
), name
);
3663 TYPE_TARGET_TYPE (t
) = target_type
;
3667 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
3668 NAME is the type name. LENGTH is the size of the flag word in bytes. */
3671 arch_flags_type (struct gdbarch
*gdbarch
, char *name
, int length
)
3673 int nfields
= length
* TARGET_CHAR_BIT
;
3676 type
= arch_type (gdbarch
, TYPE_CODE_FLAGS
, length
, name
);
3677 TYPE_UNSIGNED (type
) = 1;
3678 TYPE_NFIELDS (type
) = nfields
;
3679 TYPE_FIELDS (type
) = TYPE_ZALLOC (type
, nfields
* sizeof (struct field
));
3684 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
3685 position BITPOS is called NAME. */
3688 append_flags_type_flag (struct type
*type
, int bitpos
, char *name
)
3690 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLAGS
);
3691 gdb_assert (bitpos
< TYPE_NFIELDS (type
));
3692 gdb_assert (bitpos
>= 0);
3696 TYPE_FIELD_NAME (type
, bitpos
) = xstrdup (name
);
3697 SET_FIELD_BITPOS (TYPE_FIELD (type
, bitpos
), bitpos
);
3701 /* Don't show this field to the user. */
3702 SET_FIELD_BITPOS (TYPE_FIELD (type
, bitpos
), -1);
3706 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
3707 specified by CODE) associated with GDBARCH. NAME is the type name. */
3710 arch_composite_type (struct gdbarch
*gdbarch
, char *name
, enum type_code code
)
3714 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
3715 t
= arch_type (gdbarch
, code
, 0, NULL
);
3716 TYPE_TAG_NAME (t
) = name
;
3717 INIT_CPLUS_SPECIFIC (t
);
3721 /* Add new field with name NAME and type FIELD to composite type T.
3722 Do not set the field's position or adjust the type's length;
3723 the caller should do so. Return the new field. */
3726 append_composite_type_field_raw (struct type
*t
, char *name
,
3731 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
3732 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
3733 sizeof (struct field
) * TYPE_NFIELDS (t
));
3734 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
3735 memset (f
, 0, sizeof f
[0]);
3736 FIELD_TYPE (f
[0]) = field
;
3737 FIELD_NAME (f
[0]) = name
;
3741 /* Add new field with name NAME and type FIELD to composite type T.
3742 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
3745 append_composite_type_field_aligned (struct type
*t
, char *name
,
3746 struct type
*field
, int alignment
)
3748 struct field
*f
= append_composite_type_field_raw (t
, name
, field
);
3750 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
3752 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
3753 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
3755 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
3757 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
3758 if (TYPE_NFIELDS (t
) > 1)
3760 SET_FIELD_BITPOS (f
[0],
3761 (FIELD_BITPOS (f
[-1])
3762 + (TYPE_LENGTH (FIELD_TYPE (f
[-1]))
3763 * TARGET_CHAR_BIT
)));
3769 alignment
*= TARGET_CHAR_BIT
;
3770 left
= FIELD_BITPOS (f
[0]) % alignment
;
3774 SET_FIELD_BITPOS (f
[0], FIELD_BITPOS (f
[0]) + (alignment
- left
));
3775 TYPE_LENGTH (t
) += (alignment
- left
) / TARGET_CHAR_BIT
;
3782 /* Add new field with name NAME and type FIELD to composite type T. */
3785 append_composite_type_field (struct type
*t
, char *name
,
3788 append_composite_type_field_aligned (t
, name
, field
, 0);
3791 static struct gdbarch_data
*gdbtypes_data
;
3793 const struct builtin_type
*
3794 builtin_type (struct gdbarch
*gdbarch
)
3796 return gdbarch_data (gdbarch
, gdbtypes_data
);
3800 gdbtypes_post_init (struct gdbarch
*gdbarch
)
3802 struct builtin_type
*builtin_type
3803 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
3806 builtin_type
->builtin_void
3807 = arch_type (gdbarch
, TYPE_CODE_VOID
, 1, "void");
3808 builtin_type
->builtin_char
3809 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3810 !gdbarch_char_signed (gdbarch
), "char");
3811 builtin_type
->builtin_signed_char
3812 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3814 builtin_type
->builtin_unsigned_char
3815 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3816 1, "unsigned char");
3817 builtin_type
->builtin_short
3818 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
3820 builtin_type
->builtin_unsigned_short
3821 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
3822 1, "unsigned short");
3823 builtin_type
->builtin_int
3824 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
3826 builtin_type
->builtin_unsigned_int
3827 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
3829 builtin_type
->builtin_long
3830 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
3832 builtin_type
->builtin_unsigned_long
3833 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
3834 1, "unsigned long");
3835 builtin_type
->builtin_long_long
3836 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
3838 builtin_type
->builtin_unsigned_long_long
3839 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
3840 1, "unsigned long long");
3841 builtin_type
->builtin_float
3842 = arch_float_type (gdbarch
, gdbarch_float_bit (gdbarch
),
3843 "float", gdbarch_float_format (gdbarch
));
3844 builtin_type
->builtin_double
3845 = arch_float_type (gdbarch
, gdbarch_double_bit (gdbarch
),
3846 "double", gdbarch_double_format (gdbarch
));
3847 builtin_type
->builtin_long_double
3848 = arch_float_type (gdbarch
, gdbarch_long_double_bit (gdbarch
),
3849 "long double", gdbarch_long_double_format (gdbarch
));
3850 builtin_type
->builtin_complex
3851 = arch_complex_type (gdbarch
, "complex",
3852 builtin_type
->builtin_float
);
3853 builtin_type
->builtin_double_complex
3854 = arch_complex_type (gdbarch
, "double complex",
3855 builtin_type
->builtin_double
);
3856 builtin_type
->builtin_string
3857 = arch_type (gdbarch
, TYPE_CODE_STRING
, 1, "string");
3858 builtin_type
->builtin_bool
3859 = arch_type (gdbarch
, TYPE_CODE_BOOL
, 1, "bool");
3861 /* The following three are about decimal floating point types, which
3862 are 32-bits, 64-bits and 128-bits respectively. */
3863 builtin_type
->builtin_decfloat
3864 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 32 / 8, "_Decimal32");
3865 builtin_type
->builtin_decdouble
3866 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 64 / 8, "_Decimal64");
3867 builtin_type
->builtin_declong
3868 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 128 / 8, "_Decimal128");
3870 /* "True" character types. */
3871 builtin_type
->builtin_true_char
3872 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 0, "true character");
3873 builtin_type
->builtin_true_unsigned_char
3874 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 1, "true character");
3876 /* Fixed-size integer types. */
3877 builtin_type
->builtin_int0
3878 = arch_integer_type (gdbarch
, 0, 0, "int0_t");
3879 builtin_type
->builtin_int8
3880 = arch_integer_type (gdbarch
, 8, 0, "int8_t");
3881 builtin_type
->builtin_uint8
3882 = arch_integer_type (gdbarch
, 8, 1, "uint8_t");
3883 builtin_type
->builtin_int16
3884 = arch_integer_type (gdbarch
, 16, 0, "int16_t");
3885 builtin_type
->builtin_uint16
3886 = arch_integer_type (gdbarch
, 16, 1, "uint16_t");
3887 builtin_type
->builtin_int32
3888 = arch_integer_type (gdbarch
, 32, 0, "int32_t");
3889 builtin_type
->builtin_uint32
3890 = arch_integer_type (gdbarch
, 32, 1, "uint32_t");
3891 builtin_type
->builtin_int64
3892 = arch_integer_type (gdbarch
, 64, 0, "int64_t");
3893 builtin_type
->builtin_uint64
3894 = arch_integer_type (gdbarch
, 64, 1, "uint64_t");
3895 builtin_type
->builtin_int128
3896 = arch_integer_type (gdbarch
, 128, 0, "int128_t");
3897 builtin_type
->builtin_uint128
3898 = arch_integer_type (gdbarch
, 128, 1, "uint128_t");
3899 TYPE_INSTANCE_FLAGS (builtin_type
->builtin_int8
) |=
3900 TYPE_INSTANCE_FLAG_NOTTEXT
;
3901 TYPE_INSTANCE_FLAGS (builtin_type
->builtin_uint8
) |=
3902 TYPE_INSTANCE_FLAG_NOTTEXT
;
3904 /* Wide character types. */
3905 builtin_type
->builtin_char16
3906 = arch_integer_type (gdbarch
, 16, 0, "char16_t");
3907 builtin_type
->builtin_char32
3908 = arch_integer_type (gdbarch
, 32, 0, "char32_t");
3911 /* Default data/code pointer types. */
3912 builtin_type
->builtin_data_ptr
3913 = lookup_pointer_type (builtin_type
->builtin_void
);
3914 builtin_type
->builtin_func_ptr
3915 = lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
3916 builtin_type
->builtin_func_func
3917 = lookup_function_type (builtin_type
->builtin_func_ptr
);
3919 /* This type represents a GDB internal function. */
3920 builtin_type
->internal_fn
3921 = arch_type (gdbarch
, TYPE_CODE_INTERNAL_FUNCTION
, 0,
3922 "<internal function>");
3924 return builtin_type
;
3927 /* This set of objfile-based types is intended to be used by symbol
3928 readers as basic types. */
3930 static const struct objfile_data
*objfile_type_data
;
3932 const struct objfile_type
*
3933 objfile_type (struct objfile
*objfile
)
3935 struct gdbarch
*gdbarch
;
3936 struct objfile_type
*objfile_type
3937 = objfile_data (objfile
, objfile_type_data
);
3940 return objfile_type
;
3942 objfile_type
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
3943 1, struct objfile_type
);
3945 /* Use the objfile architecture to determine basic type properties. */
3946 gdbarch
= get_objfile_arch (objfile
);
3949 objfile_type
->builtin_void
3950 = init_type (TYPE_CODE_VOID
, 1,
3954 objfile_type
->builtin_char
3955 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3957 | (gdbarch_char_signed (gdbarch
) ? 0 : TYPE_FLAG_UNSIGNED
)),
3959 objfile_type
->builtin_signed_char
3960 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3962 "signed char", objfile
);
3963 objfile_type
->builtin_unsigned_char
3964 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3966 "unsigned char", objfile
);
3967 objfile_type
->builtin_short
3968 = init_type (TYPE_CODE_INT
,
3969 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3970 0, "short", objfile
);
3971 objfile_type
->builtin_unsigned_short
3972 = init_type (TYPE_CODE_INT
,
3973 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3974 TYPE_FLAG_UNSIGNED
, "unsigned short", objfile
);
3975 objfile_type
->builtin_int
3976 = init_type (TYPE_CODE_INT
,
3977 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3979 objfile_type
->builtin_unsigned_int
3980 = init_type (TYPE_CODE_INT
,
3981 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3982 TYPE_FLAG_UNSIGNED
, "unsigned int", objfile
);
3983 objfile_type
->builtin_long
3984 = init_type (TYPE_CODE_INT
,
3985 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3986 0, "long", objfile
);
3987 objfile_type
->builtin_unsigned_long
3988 = init_type (TYPE_CODE_INT
,
3989 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3990 TYPE_FLAG_UNSIGNED
, "unsigned long", objfile
);
3991 objfile_type
->builtin_long_long
3992 = init_type (TYPE_CODE_INT
,
3993 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3994 0, "long long", objfile
);
3995 objfile_type
->builtin_unsigned_long_long
3996 = init_type (TYPE_CODE_INT
,
3997 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3998 TYPE_FLAG_UNSIGNED
, "unsigned long long", objfile
);
4000 objfile_type
->builtin_float
4001 = init_type (TYPE_CODE_FLT
,
4002 gdbarch_float_bit (gdbarch
) / TARGET_CHAR_BIT
,
4003 0, "float", objfile
);
4004 TYPE_FLOATFORMAT (objfile_type
->builtin_float
)
4005 = gdbarch_float_format (gdbarch
);
4006 objfile_type
->builtin_double
4007 = init_type (TYPE_CODE_FLT
,
4008 gdbarch_double_bit (gdbarch
) / TARGET_CHAR_BIT
,
4009 0, "double", objfile
);
4010 TYPE_FLOATFORMAT (objfile_type
->builtin_double
)
4011 = gdbarch_double_format (gdbarch
);
4012 objfile_type
->builtin_long_double
4013 = init_type (TYPE_CODE_FLT
,
4014 gdbarch_long_double_bit (gdbarch
) / TARGET_CHAR_BIT
,
4015 0, "long double", objfile
);
4016 TYPE_FLOATFORMAT (objfile_type
->builtin_long_double
)
4017 = gdbarch_long_double_format (gdbarch
);
4019 /* This type represents a type that was unrecognized in symbol read-in. */
4020 objfile_type
->builtin_error
4021 = init_type (TYPE_CODE_ERROR
, 0, 0, "<unknown type>", objfile
);
4023 /* The following set of types is used for symbols with no
4024 debug information. */
4025 objfile_type
->nodebug_text_symbol
4026 = init_type (TYPE_CODE_FUNC
, 1, 0,
4027 "<text variable, no debug info>", objfile
);
4028 TYPE_TARGET_TYPE (objfile_type
->nodebug_text_symbol
)
4029 = objfile_type
->builtin_int
;
4030 objfile_type
->nodebug_text_gnu_ifunc_symbol
4031 = init_type (TYPE_CODE_FUNC
, 1, TYPE_FLAG_GNU_IFUNC
,
4032 "<text gnu-indirect-function variable, no debug info>",
4034 TYPE_TARGET_TYPE (objfile_type
->nodebug_text_gnu_ifunc_symbol
)
4035 = objfile_type
->nodebug_text_symbol
;
4036 objfile_type
->nodebug_got_plt_symbol
4037 = init_type (TYPE_CODE_PTR
, gdbarch_addr_bit (gdbarch
) / 8, 0,
4038 "<text from jump slot in .got.plt, no debug info>",
4040 TYPE_TARGET_TYPE (objfile_type
->nodebug_got_plt_symbol
)
4041 = objfile_type
->nodebug_text_symbol
;
4042 objfile_type
->nodebug_data_symbol
4043 = init_type (TYPE_CODE_INT
,
4044 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
4045 "<data variable, no debug info>", objfile
);
4046 objfile_type
->nodebug_unknown_symbol
4047 = init_type (TYPE_CODE_INT
, 1, 0,
4048 "<variable (not text or data), no debug info>", objfile
);
4049 objfile_type
->nodebug_tls_symbol
4050 = init_type (TYPE_CODE_INT
,
4051 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
4052 "<thread local variable, no debug info>", objfile
);
4054 /* NOTE: on some targets, addresses and pointers are not necessarily
4055 the same --- for example, on the D10V, pointers are 16 bits long,
4056 but addresses are 32 bits long. See doc/gdbint.texinfo,
4057 ``Pointers Are Not Always Addresses''.
4060 - gdb's `struct type' always describes the target's
4062 - gdb's `struct value' objects should always hold values in
4064 - gdb's CORE_ADDR values are addresses in the unified virtual
4065 address space that the assembler and linker work with. Thus,
4066 since target_read_memory takes a CORE_ADDR as an argument, it
4067 can access any memory on the target, even if the processor has
4068 separate code and data address spaces.
4071 - If v is a value holding a D10V code pointer, its contents are
4072 in target form: a big-endian address left-shifted two bits.
4073 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
4074 sizeof (void *) == 2 on the target.
4076 In this context, objfile_type->builtin_core_addr is a bit odd:
4077 it's a target type for a value the target will never see. It's
4078 only used to hold the values of (typeless) linker symbols, which
4079 are indeed in the unified virtual address space. */
4081 objfile_type
->builtin_core_addr
4082 = init_type (TYPE_CODE_INT
,
4083 gdbarch_addr_bit (gdbarch
) / 8,
4084 TYPE_FLAG_UNSIGNED
, "__CORE_ADDR", objfile
);
4086 set_objfile_data (objfile
, objfile_type_data
, objfile_type
);
4087 return objfile_type
;
4090 extern initialize_file_ftype _initialize_gdbtypes
;
4093 _initialize_gdbtypes (void)
4095 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
4096 objfile_type_data
= register_objfile_data ();
4098 add_setshow_zuinteger_cmd ("overload", no_class
, &overload_debug
,
4099 _("Set debugging of C++ overloading."),
4100 _("Show debugging of C++ overloading."),
4101 _("When enabled, ranking of the "
4102 "functions is displayed."),
4104 show_overload_debug
,
4105 &setdebuglist
, &showdebuglist
);
4107 /* Add user knob for controlling resolution of opaque types. */
4108 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
4109 &opaque_type_resolution
,
4110 _("Set resolution of opaque struct/class/union"
4111 " types (if set before loading symbols)."),
4112 _("Show resolution of opaque struct/class/union"
4113 " types (if set before loading symbols)."),
4115 show_opaque_type_resolution
,
4116 &setlist
, &showlist
);
4118 /* Add an option to permit non-strict type checking. */
4119 add_setshow_boolean_cmd ("type", class_support
,
4120 &strict_type_checking
,
4121 _("Set strict type checking."),
4122 _("Show strict type checking."),
4124 show_strict_type_checking
,
4125 &setchecklist
, &showchecklist
);