1 /* Support routines for manipulating internal types for GDB.
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
4 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
7 Contributed by Cygnus Support, using pieces from other GDB modules.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "gdb_string.h"
31 #include "expression.h"
36 #include "complaints.h"
40 #include "gdb_assert.h"
44 /* Floatformat pairs. */
45 const struct floatformat
*floatformats_ieee_single
[BFD_ENDIAN_UNKNOWN
] = {
46 &floatformat_ieee_single_big
,
47 &floatformat_ieee_single_little
49 const struct floatformat
*floatformats_ieee_double
[BFD_ENDIAN_UNKNOWN
] = {
50 &floatformat_ieee_double_big
,
51 &floatformat_ieee_double_little
53 const struct floatformat
*floatformats_ieee_double_littlebyte_bigword
[BFD_ENDIAN_UNKNOWN
] = {
54 &floatformat_ieee_double_big
,
55 &floatformat_ieee_double_littlebyte_bigword
57 const struct floatformat
*floatformats_i387_ext
[BFD_ENDIAN_UNKNOWN
] = {
58 &floatformat_i387_ext
,
61 const struct floatformat
*floatformats_m68881_ext
[BFD_ENDIAN_UNKNOWN
] = {
62 &floatformat_m68881_ext
,
63 &floatformat_m68881_ext
65 const struct floatformat
*floatformats_arm_ext
[BFD_ENDIAN_UNKNOWN
] = {
66 &floatformat_arm_ext_big
,
67 &floatformat_arm_ext_littlebyte_bigword
69 const struct floatformat
*floatformats_ia64_spill
[BFD_ENDIAN_UNKNOWN
] = {
70 &floatformat_ia64_spill_big
,
71 &floatformat_ia64_spill_little
73 const struct floatformat
*floatformats_ia64_quad
[BFD_ENDIAN_UNKNOWN
] = {
74 &floatformat_ia64_quad_big
,
75 &floatformat_ia64_quad_little
77 const struct floatformat
*floatformats_vax_f
[BFD_ENDIAN_UNKNOWN
] = {
81 const struct floatformat
*floatformats_vax_d
[BFD_ENDIAN_UNKNOWN
] = {
85 const struct floatformat
*floatformats_ibm_long_double
[BFD_ENDIAN_UNKNOWN
] = {
86 &floatformat_ibm_long_double
,
87 &floatformat_ibm_long_double
91 int opaque_type_resolution
= 1;
93 show_opaque_type_resolution (struct ui_file
*file
, int from_tty
,
94 struct cmd_list_element
*c
,
97 fprintf_filtered (file
, _("\
98 Resolution of opaque struct/class/union types (if set before loading symbols) is %s.\n"),
102 int overload_debug
= 0;
104 show_overload_debug (struct ui_file
*file
, int from_tty
,
105 struct cmd_list_element
*c
, const char *value
)
107 fprintf_filtered (file
, _("Debugging of C++ overloading is %s.\n"),
115 }; /* Maximum extension is 128! FIXME */
117 static void print_bit_vector (B_TYPE
*, int);
118 static void print_arg_types (struct field
*, int, int);
119 static void dump_fn_fieldlists (struct type
*, int);
120 static void print_cplus_stuff (struct type
*, int);
123 /* Allocate a new OBJFILE-associated type structure and fill it
124 with some defaults. Space for the type structure is allocated
125 on the objfile's objfile_obstack. */
128 alloc_type (struct objfile
*objfile
)
132 gdb_assert (objfile
!= NULL
);
134 /* Alloc the structure and start off with all fields zeroed. */
135 type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct type
);
136 TYPE_MAIN_TYPE (type
) = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
138 OBJSTAT (objfile
, n_types
++);
140 TYPE_OBJFILE_OWNED (type
) = 1;
141 TYPE_OWNER (type
).objfile
= objfile
;
143 /* Initialize the fields that might not be zero. */
145 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
146 TYPE_VPTR_FIELDNO (type
) = -1;
147 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
152 /* Allocate a new GDBARCH-associated type structure and fill it
153 with some defaults. Space for the type structure is allocated
157 alloc_type_arch (struct gdbarch
*gdbarch
)
161 gdb_assert (gdbarch
!= NULL
);
163 /* Alloc the structure and start off with all fields zeroed. */
165 type
= XZALLOC (struct type
);
166 TYPE_MAIN_TYPE (type
) = XZALLOC (struct main_type
);
168 TYPE_OBJFILE_OWNED (type
) = 0;
169 TYPE_OWNER (type
).gdbarch
= gdbarch
;
171 /* Initialize the fields that might not be zero. */
173 TYPE_CODE (type
) = TYPE_CODE_UNDEF
;
174 TYPE_VPTR_FIELDNO (type
) = -1;
175 TYPE_CHAIN (type
) = type
; /* Chain back to itself. */
180 /* If TYPE is objfile-associated, allocate a new type structure
181 associated with the same objfile. If TYPE is gdbarch-associated,
182 allocate a new type structure associated with the same gdbarch. */
185 alloc_type_copy (const struct type
*type
)
187 if (TYPE_OBJFILE_OWNED (type
))
188 return alloc_type (TYPE_OWNER (type
).objfile
);
190 return alloc_type_arch (TYPE_OWNER (type
).gdbarch
);
193 /* If TYPE is gdbarch-associated, return that architecture.
194 If TYPE is objfile-associated, return that objfile's architecture. */
197 get_type_arch (const struct type
*type
)
199 if (TYPE_OBJFILE_OWNED (type
))
200 return get_objfile_arch (TYPE_OWNER (type
).objfile
);
202 return TYPE_OWNER (type
).gdbarch
;
206 /* Alloc a new type instance structure, fill it with some defaults,
207 and point it at OLDTYPE. Allocate the new type instance from the
208 same place as OLDTYPE. */
211 alloc_type_instance (struct type
*oldtype
)
215 /* Allocate the structure. */
217 if (! TYPE_OBJFILE_OWNED (oldtype
))
218 type
= XZALLOC (struct type
);
220 type
= OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype
)->objfile_obstack
,
223 TYPE_MAIN_TYPE (type
) = TYPE_MAIN_TYPE (oldtype
);
225 TYPE_CHAIN (type
) = type
; /* Chain back to itself for now. */
230 /* Clear all remnants of the previous type at TYPE, in preparation for
231 replacing it with something else. Preserve owner information. */
233 smash_type (struct type
*type
)
235 int objfile_owned
= TYPE_OBJFILE_OWNED (type
);
236 union type_owner owner
= TYPE_OWNER (type
);
238 memset (TYPE_MAIN_TYPE (type
), 0, sizeof (struct main_type
));
240 /* Restore owner information. */
241 TYPE_OBJFILE_OWNED (type
) = objfile_owned
;
242 TYPE_OWNER (type
) = owner
;
244 /* For now, delete the rings. */
245 TYPE_CHAIN (type
) = type
;
247 /* For now, leave the pointer/reference types alone. */
250 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
251 to a pointer to memory where the pointer type should be stored.
252 If *TYPEPTR is zero, update it to point to the pointer type we return.
253 We allocate new memory if needed. */
256 make_pointer_type (struct type
*type
, struct type
**typeptr
)
258 struct type
*ntype
; /* New type */
261 ntype
= TYPE_POINTER_TYPE (type
);
266 return ntype
; /* Don't care about alloc,
267 and have new type. */
268 else if (*typeptr
== 0)
270 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
275 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
277 ntype
= alloc_type_copy (type
);
281 else /* We have storage, but need to reset it. */
284 chain
= TYPE_CHAIN (ntype
);
286 TYPE_CHAIN (ntype
) = chain
;
289 TYPE_TARGET_TYPE (ntype
) = type
;
290 TYPE_POINTER_TYPE (type
) = ntype
;
292 /* FIXME! Assume the machine has only one representation for
296 = gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
297 TYPE_CODE (ntype
) = TYPE_CODE_PTR
;
299 /* Mark pointers as unsigned. The target converts between pointers
300 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
301 gdbarch_address_to_pointer. */
302 TYPE_UNSIGNED (ntype
) = 1;
304 if (!TYPE_POINTER_TYPE (type
)) /* Remember it, if don't have one. */
305 TYPE_POINTER_TYPE (type
) = ntype
;
307 /* Update the length of all the other variants of this type. */
308 chain
= TYPE_CHAIN (ntype
);
309 while (chain
!= ntype
)
311 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
312 chain
= TYPE_CHAIN (chain
);
318 /* Given a type TYPE, return a type of pointers to that type.
319 May need to construct such a type if this is the first use. */
322 lookup_pointer_type (struct type
*type
)
324 return make_pointer_type (type
, (struct type
**) 0);
327 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
328 points to a pointer to memory where the reference type should be
329 stored. If *TYPEPTR is zero, update it to point to the reference
330 type we return. We allocate new memory if needed. */
333 make_reference_type (struct type
*type
, struct type
**typeptr
)
335 struct type
*ntype
; /* New type */
338 ntype
= TYPE_REFERENCE_TYPE (type
);
343 return ntype
; /* Don't care about alloc,
344 and have new type. */
345 else if (*typeptr
== 0)
347 *typeptr
= ntype
; /* Tracking alloc, and have new type. */
352 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
354 ntype
= alloc_type_copy (type
);
358 else /* We have storage, but need to reset it. */
361 chain
= TYPE_CHAIN (ntype
);
363 TYPE_CHAIN (ntype
) = chain
;
366 TYPE_TARGET_TYPE (ntype
) = type
;
367 TYPE_REFERENCE_TYPE (type
) = ntype
;
369 /* FIXME! Assume the machine has only one representation for
370 references, and that it matches the (only) representation for
373 TYPE_LENGTH (ntype
) =
374 gdbarch_ptr_bit (get_type_arch (type
)) / TARGET_CHAR_BIT
;
375 TYPE_CODE (ntype
) = TYPE_CODE_REF
;
377 if (!TYPE_REFERENCE_TYPE (type
)) /* Remember it, if don't have one. */
378 TYPE_REFERENCE_TYPE (type
) = ntype
;
380 /* Update the length of all the other variants of this type. */
381 chain
= TYPE_CHAIN (ntype
);
382 while (chain
!= ntype
)
384 TYPE_LENGTH (chain
) = TYPE_LENGTH (ntype
);
385 chain
= TYPE_CHAIN (chain
);
391 /* Same as above, but caller doesn't care about memory allocation
395 lookup_reference_type (struct type
*type
)
397 return make_reference_type (type
, (struct type
**) 0);
400 /* Lookup a function type that returns type TYPE. TYPEPTR, if
401 nonzero, points to a pointer to memory where the function type
402 should be stored. If *TYPEPTR is zero, update it to point to the
403 function type we return. We allocate new memory if needed. */
406 make_function_type (struct type
*type
, struct type
**typeptr
)
408 struct type
*ntype
; /* New type */
410 if (typeptr
== 0 || *typeptr
== 0) /* We'll need to allocate one. */
412 ntype
= alloc_type_copy (type
);
416 else /* We have storage, but need to reset it. */
422 TYPE_TARGET_TYPE (ntype
) = type
;
424 TYPE_LENGTH (ntype
) = 1;
425 TYPE_CODE (ntype
) = TYPE_CODE_FUNC
;
431 /* Given a type TYPE, return a type of functions that return that type.
432 May need to construct such a type if this is the first use. */
435 lookup_function_type (struct type
*type
)
437 return make_function_type (type
, (struct type
**) 0);
440 /* Identify address space identifier by name --
441 return the integer flag defined in gdbtypes.h. */
443 address_space_name_to_int (struct gdbarch
*gdbarch
, char *space_identifier
)
446 /* Check for known address space delimiters. */
447 if (!strcmp (space_identifier
, "code"))
448 return TYPE_INSTANCE_FLAG_CODE_SPACE
;
449 else if (!strcmp (space_identifier
, "data"))
450 return TYPE_INSTANCE_FLAG_DATA_SPACE
;
451 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch
)
452 && gdbarch_address_class_name_to_type_flags (gdbarch
,
457 error (_("Unknown address space specifier: \"%s\""), space_identifier
);
460 /* Identify address space identifier by integer flag as defined in
461 gdbtypes.h -- return the string version of the adress space name. */
464 address_space_int_to_name (struct gdbarch
*gdbarch
, int space_flag
)
466 if (space_flag
& TYPE_INSTANCE_FLAG_CODE_SPACE
)
468 else if (space_flag
& TYPE_INSTANCE_FLAG_DATA_SPACE
)
470 else if ((space_flag
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
471 && gdbarch_address_class_type_flags_to_name_p (gdbarch
))
472 return gdbarch_address_class_type_flags_to_name (gdbarch
, space_flag
);
477 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
479 If STORAGE is non-NULL, create the new type instance there.
480 STORAGE must be in the same obstack as TYPE. */
483 make_qualified_type (struct type
*type
, int new_flags
,
484 struct type
*storage
)
491 if (TYPE_INSTANCE_FLAGS (ntype
) == new_flags
)
493 ntype
= TYPE_CHAIN (ntype
);
495 while (ntype
!= type
);
497 /* Create a new type instance. */
499 ntype
= alloc_type_instance (type
);
502 /* If STORAGE was provided, it had better be in the same objfile
503 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
504 if one objfile is freed and the other kept, we'd have
505 dangling pointers. */
506 gdb_assert (TYPE_OBJFILE (type
) == TYPE_OBJFILE (storage
));
509 TYPE_MAIN_TYPE (ntype
) = TYPE_MAIN_TYPE (type
);
510 TYPE_CHAIN (ntype
) = ntype
;
513 /* Pointers or references to the original type are not relevant to
515 TYPE_POINTER_TYPE (ntype
) = (struct type
*) 0;
516 TYPE_REFERENCE_TYPE (ntype
) = (struct type
*) 0;
518 /* Chain the new qualified type to the old type. */
519 TYPE_CHAIN (ntype
) = TYPE_CHAIN (type
);
520 TYPE_CHAIN (type
) = ntype
;
522 /* Now set the instance flags and return the new type. */
523 TYPE_INSTANCE_FLAGS (ntype
) = new_flags
;
525 /* Set length of new type to that of the original type. */
526 TYPE_LENGTH (ntype
) = TYPE_LENGTH (type
);
531 /* Make an address-space-delimited variant of a type -- a type that
532 is identical to the one supplied except that it has an address
533 space attribute attached to it (such as "code" or "data").
535 The space attributes "code" and "data" are for Harvard
536 architectures. The address space attributes are for architectures
537 which have alternately sized pointers or pointers with alternate
541 make_type_with_address_space (struct type
*type
, int space_flag
)
544 int new_flags
= ((TYPE_INSTANCE_FLAGS (type
)
545 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
546 | TYPE_INSTANCE_FLAG_DATA_SPACE
547 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
))
550 return make_qualified_type (type
, new_flags
, NULL
);
553 /* Make a "c-v" variant of a type -- a type that is identical to the
554 one supplied except that it may have const or volatile attributes
555 CNST is a flag for setting the const attribute
556 VOLTL is a flag for setting the volatile attribute
557 TYPE is the base type whose variant we are creating.
559 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
560 storage to hold the new qualified type; *TYPEPTR and TYPE must be
561 in the same objfile. Otherwise, allocate fresh memory for the new
562 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
563 new type we construct. */
565 make_cv_type (int cnst
, int voltl
,
567 struct type
**typeptr
)
569 struct type
*ntype
; /* New type */
570 struct type
*tmp_type
= type
; /* tmp type */
571 struct objfile
*objfile
;
573 int new_flags
= (TYPE_INSTANCE_FLAGS (type
)
574 & ~(TYPE_INSTANCE_FLAG_CONST
| TYPE_INSTANCE_FLAG_VOLATILE
));
577 new_flags
|= TYPE_INSTANCE_FLAG_CONST
;
580 new_flags
|= TYPE_INSTANCE_FLAG_VOLATILE
;
582 if (typeptr
&& *typeptr
!= NULL
)
584 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
585 a C-V variant chain that threads across objfiles: if one
586 objfile gets freed, then the other has a broken C-V chain.
588 This code used to try to copy over the main type from TYPE to
589 *TYPEPTR if they were in different objfiles, but that's
590 wrong, too: TYPE may have a field list or member function
591 lists, which refer to types of their own, etc. etc. The
592 whole shebang would need to be copied over recursively; you
593 can't have inter-objfile pointers. The only thing to do is
594 to leave stub types as stub types, and look them up afresh by
595 name each time you encounter them. */
596 gdb_assert (TYPE_OBJFILE (*typeptr
) == TYPE_OBJFILE (type
));
599 ntype
= make_qualified_type (type
, new_flags
,
600 typeptr
? *typeptr
: NULL
);
608 /* Replace the contents of ntype with the type *type. This changes the
609 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
610 the changes are propogated to all types in the TYPE_CHAIN.
612 In order to build recursive types, it's inevitable that we'll need
613 to update types in place --- but this sort of indiscriminate
614 smashing is ugly, and needs to be replaced with something more
615 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
616 clear if more steps are needed. */
618 replace_type (struct type
*ntype
, struct type
*type
)
622 /* These two types had better be in the same objfile. Otherwise,
623 the assignment of one type's main type structure to the other
624 will produce a type with references to objects (names; field
625 lists; etc.) allocated on an objfile other than its own. */
626 gdb_assert (TYPE_OBJFILE (ntype
) == TYPE_OBJFILE (ntype
));
628 *TYPE_MAIN_TYPE (ntype
) = *TYPE_MAIN_TYPE (type
);
630 /* The type length is not a part of the main type. Update it for
631 each type on the variant chain. */
635 /* Assert that this element of the chain has no address-class bits
636 set in its flags. Such type variants might have type lengths
637 which are supposed to be different from the non-address-class
638 variants. This assertion shouldn't ever be triggered because
639 symbol readers which do construct address-class variants don't
640 call replace_type(). */
641 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain
) == 0);
643 TYPE_LENGTH (chain
) = TYPE_LENGTH (type
);
644 chain
= TYPE_CHAIN (chain
);
646 while (ntype
!= chain
);
648 /* Assert that the two types have equivalent instance qualifiers.
649 This should be true for at least all of our debug readers. */
650 gdb_assert (TYPE_INSTANCE_FLAGS (ntype
) == TYPE_INSTANCE_FLAGS (type
));
653 /* Implement direct support for MEMBER_TYPE in GNU C++.
654 May need to construct such a type if this is the first use.
655 The TYPE is the type of the member. The DOMAIN is the type
656 of the aggregate that the member belongs to. */
659 lookup_memberptr_type (struct type
*type
, struct type
*domain
)
663 mtype
= alloc_type_copy (type
);
664 smash_to_memberptr_type (mtype
, domain
, type
);
668 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
671 lookup_methodptr_type (struct type
*to_type
)
675 mtype
= alloc_type_copy (to_type
);
676 TYPE_TARGET_TYPE (mtype
) = to_type
;
677 TYPE_DOMAIN_TYPE (mtype
) = TYPE_DOMAIN_TYPE (to_type
);
678 TYPE_LENGTH (mtype
) = cplus_method_ptr_size (to_type
);
679 TYPE_CODE (mtype
) = TYPE_CODE_METHODPTR
;
683 /* Allocate a stub method whose return type is TYPE. This apparently
684 happens for speed of symbol reading, since parsing out the
685 arguments to the method is cpu-intensive, the way we are doing it.
686 So, we will fill in arguments later. This always returns a fresh
690 allocate_stub_method (struct type
*type
)
694 mtype
= alloc_type_copy (type
);
695 TYPE_CODE (mtype
) = TYPE_CODE_METHOD
;
696 TYPE_LENGTH (mtype
) = 1;
697 TYPE_STUB (mtype
) = 1;
698 TYPE_TARGET_TYPE (mtype
) = type
;
699 /* _DOMAIN_TYPE (mtype) = unknown yet */
703 /* Create a range type using either a blank type supplied in
704 RESULT_TYPE, or creating a new type, inheriting the objfile from
707 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
708 to HIGH_BOUND, inclusive.
710 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
711 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
714 create_range_type (struct type
*result_type
, struct type
*index_type
,
715 LONGEST low_bound
, LONGEST high_bound
)
717 if (result_type
== NULL
)
718 result_type
= alloc_type_copy (index_type
);
719 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
720 TYPE_TARGET_TYPE (result_type
) = index_type
;
721 if (TYPE_STUB (index_type
))
722 TYPE_TARGET_STUB (result_type
) = 1;
724 TYPE_LENGTH (result_type
) = TYPE_LENGTH (check_typedef (index_type
));
725 TYPE_RANGE_DATA (result_type
) = (struct range_bounds
*)
726 TYPE_ZALLOC (result_type
, sizeof (struct range_bounds
));
727 TYPE_LOW_BOUND (result_type
) = low_bound
;
728 TYPE_HIGH_BOUND (result_type
) = high_bound
;
731 TYPE_UNSIGNED (result_type
) = 1;
736 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
737 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
738 bounds will fit in LONGEST), or -1 otherwise. */
741 get_discrete_bounds (struct type
*type
, LONGEST
*lowp
, LONGEST
*highp
)
743 CHECK_TYPEDEF (type
);
744 switch (TYPE_CODE (type
))
746 case TYPE_CODE_RANGE
:
747 *lowp
= TYPE_LOW_BOUND (type
);
748 *highp
= TYPE_HIGH_BOUND (type
);
751 if (TYPE_NFIELDS (type
) > 0)
753 /* The enums may not be sorted by value, so search all
757 *lowp
= *highp
= TYPE_FIELD_BITPOS (type
, 0);
758 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
760 if (TYPE_FIELD_BITPOS (type
, i
) < *lowp
)
761 *lowp
= TYPE_FIELD_BITPOS (type
, i
);
762 if (TYPE_FIELD_BITPOS (type
, i
) > *highp
)
763 *highp
= TYPE_FIELD_BITPOS (type
, i
);
766 /* Set unsigned indicator if warranted. */
769 TYPE_UNSIGNED (type
) = 1;
783 if (TYPE_LENGTH (type
) > sizeof (LONGEST
)) /* Too big */
785 if (!TYPE_UNSIGNED (type
))
787 *lowp
= -(1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1));
791 /* ... fall through for unsigned ints ... */
794 /* This round-about calculation is to avoid shifting by
795 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
796 if TYPE_LENGTH (type) == sizeof (LONGEST). */
797 *highp
= 1 << (TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1);
798 *highp
= (*highp
- 1) | *highp
;
805 /* Create an array type using either a blank type supplied in
806 RESULT_TYPE, or creating a new type, inheriting the objfile from
809 Elements will be of type ELEMENT_TYPE, the indices will be of type
812 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
813 sure it is TYPE_CODE_UNDEF before we bash it into an array
817 create_array_type (struct type
*result_type
,
818 struct type
*element_type
,
819 struct type
*range_type
)
821 LONGEST low_bound
, high_bound
;
823 if (result_type
== NULL
)
824 result_type
= alloc_type_copy (range_type
);
826 TYPE_CODE (result_type
) = TYPE_CODE_ARRAY
;
827 TYPE_TARGET_TYPE (result_type
) = element_type
;
828 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
829 low_bound
= high_bound
= 0;
830 CHECK_TYPEDEF (element_type
);
831 /* Be careful when setting the array length. Ada arrays can be
832 empty arrays with the high_bound being smaller than the low_bound.
833 In such cases, the array length should be zero. */
834 if (high_bound
< low_bound
)
835 TYPE_LENGTH (result_type
) = 0;
837 TYPE_LENGTH (result_type
) =
838 TYPE_LENGTH (element_type
) * (high_bound
- low_bound
+ 1);
839 TYPE_NFIELDS (result_type
) = 1;
840 TYPE_FIELDS (result_type
) =
841 (struct field
*) TYPE_ZALLOC (result_type
, sizeof (struct field
));
842 TYPE_INDEX_TYPE (result_type
) = range_type
;
843 TYPE_VPTR_FIELDNO (result_type
) = -1;
845 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
846 if (TYPE_LENGTH (result_type
) == 0)
847 TYPE_TARGET_STUB (result_type
) = 1;
853 lookup_array_range_type (struct type
*element_type
,
854 int low_bound
, int high_bound
)
856 struct gdbarch
*gdbarch
= get_type_arch (element_type
);
857 struct type
*index_type
= builtin_type (gdbarch
)->builtin_int
;
858 struct type
*range_type
859 = create_range_type (NULL
, index_type
, low_bound
, high_bound
);
860 return create_array_type (NULL
, element_type
, range_type
);
863 /* Create a string type using either a blank type supplied in
864 RESULT_TYPE, or creating a new type. String types are similar
865 enough to array of char types that we can use create_array_type to
866 build the basic type and then bash it into a string type.
868 For fixed length strings, the range type contains 0 as the lower
869 bound and the length of the string minus one as the upper bound.
871 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
872 sure it is TYPE_CODE_UNDEF before we bash it into a string
876 create_string_type (struct type
*result_type
,
877 struct type
*string_char_type
,
878 struct type
*range_type
)
880 result_type
= create_array_type (result_type
,
883 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
888 lookup_string_range_type (struct type
*string_char_type
,
889 int low_bound
, int high_bound
)
891 struct type
*result_type
;
892 result_type
= lookup_array_range_type (string_char_type
,
893 low_bound
, high_bound
);
894 TYPE_CODE (result_type
) = TYPE_CODE_STRING
;
899 create_set_type (struct type
*result_type
, struct type
*domain_type
)
901 if (result_type
== NULL
)
902 result_type
= alloc_type_copy (domain_type
);
904 TYPE_CODE (result_type
) = TYPE_CODE_SET
;
905 TYPE_NFIELDS (result_type
) = 1;
906 TYPE_FIELDS (result_type
) = TYPE_ZALLOC (result_type
, sizeof (struct field
));
908 if (!TYPE_STUB (domain_type
))
910 LONGEST low_bound
, high_bound
, bit_length
;
911 if (get_discrete_bounds (domain_type
, &low_bound
, &high_bound
) < 0)
912 low_bound
= high_bound
= 0;
913 bit_length
= high_bound
- low_bound
+ 1;
914 TYPE_LENGTH (result_type
)
915 = (bit_length
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
917 TYPE_UNSIGNED (result_type
) = 1;
919 TYPE_FIELD_TYPE (result_type
, 0) = domain_type
;
924 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
925 and any array types nested inside it. */
928 make_vector_type (struct type
*array_type
)
930 struct type
*inner_array
, *elt_type
;
933 /* Find the innermost array type, in case the array is
934 multi-dimensional. */
935 inner_array
= array_type
;
936 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
937 inner_array
= TYPE_TARGET_TYPE (inner_array
);
939 elt_type
= TYPE_TARGET_TYPE (inner_array
);
940 if (TYPE_CODE (elt_type
) == TYPE_CODE_INT
)
942 flags
= TYPE_INSTANCE_FLAGS (elt_type
) | TYPE_FLAG_NOTTEXT
;
943 elt_type
= make_qualified_type (elt_type
, flags
, NULL
);
944 TYPE_TARGET_TYPE (inner_array
) = elt_type
;
947 TYPE_VECTOR (array_type
) = 1;
951 init_vector_type (struct type
*elt_type
, int n
)
953 struct type
*array_type
;
954 array_type
= lookup_array_range_type (elt_type
, 0, n
- 1);
955 make_vector_type (array_type
);
959 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
960 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
961 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
962 TYPE doesn't include the offset (that's the value of the MEMBER
963 itself), but does include the structure type into which it points
966 When "smashing" the type, we preserve the objfile that the old type
967 pointed to, since we aren't changing where the type is actually
971 smash_to_memberptr_type (struct type
*type
, struct type
*domain
,
972 struct type
*to_type
)
975 TYPE_TARGET_TYPE (type
) = to_type
;
976 TYPE_DOMAIN_TYPE (type
) = domain
;
977 /* Assume that a data member pointer is the same size as a normal
980 = gdbarch_ptr_bit (get_type_arch (to_type
)) / TARGET_CHAR_BIT
;
981 TYPE_CODE (type
) = TYPE_CODE_MEMBERPTR
;
984 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
985 METHOD just means `function that gets an extra "this" argument'.
987 When "smashing" the type, we preserve the objfile that the old type
988 pointed to, since we aren't changing where the type is actually
992 smash_to_method_type (struct type
*type
, struct type
*domain
,
993 struct type
*to_type
, struct field
*args
,
994 int nargs
, int varargs
)
997 TYPE_TARGET_TYPE (type
) = to_type
;
998 TYPE_DOMAIN_TYPE (type
) = domain
;
999 TYPE_FIELDS (type
) = args
;
1000 TYPE_NFIELDS (type
) = nargs
;
1002 TYPE_VARARGS (type
) = 1;
1003 TYPE_LENGTH (type
) = 1; /* In practice, this is never needed. */
1004 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
1007 /* Return a typename for a struct/union/enum type without "struct ",
1008 "union ", or "enum ". If the type has a NULL name, return NULL. */
1011 type_name_no_tag (const struct type
*type
)
1013 if (TYPE_TAG_NAME (type
) != NULL
)
1014 return TYPE_TAG_NAME (type
);
1016 /* Is there code which expects this to return the name if there is
1017 no tag name? My guess is that this is mainly used for C++ in
1018 cases where the two will always be the same. */
1019 return TYPE_NAME (type
);
1022 /* Lookup a typedef or primitive type named NAME, visible in lexical
1023 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1024 suitably defined. */
1027 lookup_typename (const struct language_defn
*language
,
1028 struct gdbarch
*gdbarch
, char *name
,
1029 struct block
*block
, int noerr
)
1034 sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, 0);
1035 if (sym
== NULL
|| SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
1037 tmp
= language_lookup_primitive_type_by_name (language
, gdbarch
, name
);
1042 else if (!tmp
&& noerr
)
1048 error (_("No type named %s."), name
);
1051 return (SYMBOL_TYPE (sym
));
1055 lookup_unsigned_typename (const struct language_defn
*language
,
1056 struct gdbarch
*gdbarch
, char *name
)
1058 char *uns
= alloca (strlen (name
) + 10);
1060 strcpy (uns
, "unsigned ");
1061 strcpy (uns
+ 9, name
);
1062 return lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 0);
1066 lookup_signed_typename (const struct language_defn
*language
,
1067 struct gdbarch
*gdbarch
, char *name
)
1070 char *uns
= alloca (strlen (name
) + 8);
1072 strcpy (uns
, "signed ");
1073 strcpy (uns
+ 7, name
);
1074 t
= lookup_typename (language
, gdbarch
, uns
, (struct block
*) NULL
, 1);
1075 /* If we don't find "signed FOO" just try again with plain "FOO". */
1078 return lookup_typename (language
, gdbarch
, name
, (struct block
*) NULL
, 0);
1081 /* Lookup a structure type named "struct NAME",
1082 visible in lexical block BLOCK. */
1085 lookup_struct (char *name
, struct block
*block
)
1089 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1093 error (_("No struct type named %s."), name
);
1095 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1097 error (_("This context has class, union or enum %s, not a struct."),
1100 return (SYMBOL_TYPE (sym
));
1103 /* Lookup a union type named "union NAME",
1104 visible in lexical block BLOCK. */
1107 lookup_union (char *name
, struct block
*block
)
1112 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1115 error (_("No union type named %s."), name
);
1117 t
= SYMBOL_TYPE (sym
);
1119 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
1122 /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
1123 * a further "declared_type" field to discover it is really a union.
1125 if (HAVE_CPLUS_STRUCT (t
))
1126 if (TYPE_DECLARED_TYPE (t
) == DECLARED_TYPE_UNION
)
1129 /* If we get here, it's not a union. */
1130 error (_("This context has class, struct or enum %s, not a union."),
1135 /* Lookup an enum type named "enum NAME",
1136 visible in lexical block BLOCK. */
1139 lookup_enum (char *name
, struct block
*block
)
1143 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
1146 error (_("No enum type named %s."), name
);
1148 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_ENUM
)
1150 error (_("This context has class, struct or union %s, not an enum."),
1153 return (SYMBOL_TYPE (sym
));
1156 /* Lookup a template type named "template NAME<TYPE>",
1157 visible in lexical block BLOCK. */
1160 lookup_template_type (char *name
, struct type
*type
,
1161 struct block
*block
)
1164 char *nam
= (char *)
1165 alloca (strlen (name
) + strlen (TYPE_NAME (type
)) + 4);
1168 strcat (nam
, TYPE_NAME (type
));
1169 strcat (nam
, " >"); /* FIXME, extra space still introduced in gcc? */
1171 sym
= lookup_symbol (nam
, block
, VAR_DOMAIN
, 0);
1175 error (_("No template type named %s."), name
);
1177 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
1179 error (_("This context has class, union or enum %s, not a struct."),
1182 return (SYMBOL_TYPE (sym
));
1185 /* Given a type TYPE, lookup the type of the component of type named
1188 TYPE can be either a struct or union, or a pointer or reference to
1189 a struct or union. If it is a pointer or reference, its target
1190 type is automatically used. Thus '.' and '->' are interchangable,
1191 as specified for the definitions of the expression element types
1192 STRUCTOP_STRUCT and STRUCTOP_PTR.
1194 If NOERR is nonzero, return zero if NAME is not suitably defined.
1195 If NAME is the name of a baseclass type, return that type. */
1198 lookup_struct_elt_type (struct type
*type
, char *name
, int noerr
)
1204 CHECK_TYPEDEF (type
);
1205 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1206 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1208 type
= TYPE_TARGET_TYPE (type
);
1211 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1212 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1214 target_terminal_ours ();
1215 gdb_flush (gdb_stdout
);
1216 fprintf_unfiltered (gdb_stderr
, "Type ");
1217 type_print (type
, "", gdb_stderr
, -1);
1218 error (_(" is not a structure or union type."));
1222 /* FIXME: This change put in by Michael seems incorrect for the case
1223 where the structure tag name is the same as the member name.
1224 I.E. when doing "ptype bell->bar" for "struct foo { int bar; int
1225 foo; } bell;" Disabled by fnf. */
1229 typename
= type_name_no_tag (type
);
1230 if (typename
!= NULL
&& strcmp (typename
, name
) == 0)
1235 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1237 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1239 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1241 return TYPE_FIELD_TYPE (type
, i
);
1245 /* OK, it's not in this class. Recursively check the baseclasses. */
1246 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1250 t
= lookup_struct_elt_type (TYPE_BASECLASS (type
, i
), name
, 1);
1262 target_terminal_ours ();
1263 gdb_flush (gdb_stdout
);
1264 fprintf_unfiltered (gdb_stderr
, "Type ");
1265 type_print (type
, "", gdb_stderr
, -1);
1266 fprintf_unfiltered (gdb_stderr
, " has no component named ");
1267 fputs_filtered (name
, gdb_stderr
);
1269 return (struct type
*) -1; /* For lint */
1272 /* Lookup the vptr basetype/fieldno values for TYPE.
1273 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1274 vptr_fieldno. Also, if found and basetype is from the same objfile,
1276 If not found, return -1 and ignore BASETYPEP.
1277 Callers should be aware that in some cases (for example,
1278 the type or one of its baseclasses is a stub type and we are
1279 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1280 this function will not be able to find the
1281 virtual function table pointer, and vptr_fieldno will remain -1 and
1282 vptr_basetype will remain NULL or incomplete. */
1285 get_vptr_fieldno (struct type
*type
, struct type
**basetypep
)
1287 CHECK_TYPEDEF (type
);
1289 if (TYPE_VPTR_FIELDNO (type
) < 0)
1293 /* We must start at zero in case the first (and only) baseclass
1294 is virtual (and hence we cannot share the table pointer). */
1295 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1297 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1299 struct type
*basetype
;
1301 fieldno
= get_vptr_fieldno (baseclass
, &basetype
);
1304 /* If the type comes from a different objfile we can't cache
1305 it, it may have a different lifetime. PR 2384 */
1306 if (TYPE_OBJFILE (type
) == TYPE_OBJFILE (basetype
))
1308 TYPE_VPTR_FIELDNO (type
) = fieldno
;
1309 TYPE_VPTR_BASETYPE (type
) = basetype
;
1312 *basetypep
= basetype
;
1323 *basetypep
= TYPE_VPTR_BASETYPE (type
);
1324 return TYPE_VPTR_FIELDNO (type
);
1329 stub_noname_complaint (void)
1331 complaint (&symfile_complaints
, _("stub type has NULL name"));
1334 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1336 If this is a stubbed struct (i.e. declared as struct foo *), see if
1337 we can find a full definition in some other file. If so, copy this
1338 definition, so we can use it in future. There used to be a comment
1339 (but not any code) that if we don't find a full definition, we'd
1340 set a flag so we don't spend time in the future checking the same
1341 type. That would be a mistake, though--we might load in more
1342 symbols which contain a full definition for the type.
1344 This used to be coded as a macro, but I don't think it is called
1345 often enough to merit such treatment.
1347 Find the real type of TYPE. This function returns the real type,
1348 after removing all layers of typedefs and completing opaque or stub
1349 types. Completion changes the TYPE argument, but stripping of
1352 If TYPE is a TYPE_CODE_TYPEDEF, its length is (also) set to the length of
1353 the target type instead of zero. However, in the case of TYPE_CODE_TYPEDEF
1354 check_typedef can still return different type than the original TYPE
1358 check_typedef (struct type
*type
)
1360 struct type
*orig_type
= type
;
1361 int is_const
, is_volatile
;
1365 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1367 if (!TYPE_TARGET_TYPE (type
))
1372 /* It is dangerous to call lookup_symbol if we are currently
1373 reading a symtab. Infinite recursion is one danger. */
1374 if (currently_reading_symtab
)
1377 name
= type_name_no_tag (type
);
1378 /* FIXME: shouldn't we separately check the TYPE_NAME and
1379 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1380 VAR_DOMAIN as appropriate? (this code was written before
1381 TYPE_NAME and TYPE_TAG_NAME were separate). */
1384 stub_noname_complaint ();
1387 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1389 TYPE_TARGET_TYPE (type
) = SYMBOL_TYPE (sym
);
1390 else /* TYPE_CODE_UNDEF */
1391 TYPE_TARGET_TYPE (type
) = alloc_type_arch (get_type_arch (type
));
1393 type
= TYPE_TARGET_TYPE (type
);
1396 is_const
= TYPE_CONST (type
);
1397 is_volatile
= TYPE_VOLATILE (type
);
1399 /* If this is a struct/class/union with no fields, then check
1400 whether a full definition exists somewhere else. This is for
1401 systems where a type definition with no fields is issued for such
1402 types, instead of identifying them as stub types in the first
1405 if (TYPE_IS_OPAQUE (type
)
1406 && opaque_type_resolution
1407 && !currently_reading_symtab
)
1409 char *name
= type_name_no_tag (type
);
1410 struct type
*newtype
;
1413 stub_noname_complaint ();
1416 newtype
= lookup_transparent_type (name
);
1420 /* If the resolved type and the stub are in the same
1421 objfile, then replace the stub type with the real deal.
1422 But if they're in separate objfiles, leave the stub
1423 alone; we'll just look up the transparent type every time
1424 we call check_typedef. We can't create pointers between
1425 types allocated to different objfiles, since they may
1426 have different lifetimes. Trying to copy NEWTYPE over to
1427 TYPE's objfile is pointless, too, since you'll have to
1428 move over any other types NEWTYPE refers to, which could
1429 be an unbounded amount of stuff. */
1430 if (TYPE_OBJFILE (newtype
) == TYPE_OBJFILE (type
))
1431 make_cv_type (is_const
, is_volatile
, newtype
, &type
);
1436 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1438 else if (TYPE_STUB (type
) && !currently_reading_symtab
)
1440 char *name
= type_name_no_tag (type
);
1441 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1442 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1443 as appropriate? (this code was written before TYPE_NAME and
1444 TYPE_TAG_NAME were separate). */
1448 stub_noname_complaint ();
1451 sym
= lookup_symbol (name
, 0, STRUCT_DOMAIN
, 0);
1454 /* Same as above for opaque types, we can replace the stub
1455 with the complete type only if they are int the same
1457 if (TYPE_OBJFILE (SYMBOL_TYPE(sym
)) == TYPE_OBJFILE (type
))
1458 make_cv_type (is_const
, is_volatile
,
1459 SYMBOL_TYPE (sym
), &type
);
1461 type
= SYMBOL_TYPE (sym
);
1465 if (TYPE_TARGET_STUB (type
))
1467 struct type
*range_type
;
1468 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1470 if (TYPE_STUB (target_type
) || TYPE_TARGET_STUB (target_type
))
1474 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
1475 && TYPE_NFIELDS (type
) == 1
1476 && (TYPE_CODE (range_type
= TYPE_INDEX_TYPE (type
))
1477 == TYPE_CODE_RANGE
))
1479 /* Now recompute the length of the array type, based on its
1480 number of elements and the target type's length.
1481 Watch out for Ada null Ada arrays where the high bound
1482 is smaller than the low bound. */
1483 const LONGEST low_bound
= TYPE_LOW_BOUND (range_type
);
1484 const LONGEST high_bound
= TYPE_HIGH_BOUND (range_type
);
1487 if (high_bound
< low_bound
)
1490 /* For now, we conservatively take the array length to be 0
1491 if its length exceeds UINT_MAX. The code below assumes
1492 that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
1493 which is technically not guaranteed by C, but is usually true
1494 (because it would be true if x were unsigned with its
1495 high-order bit on). It uses the fact that
1496 high_bound-low_bound is always representable in
1497 ULONGEST and that if high_bound-low_bound+1 overflows,
1498 it overflows to 0. We must change these tests if we
1499 decide to increase the representation of TYPE_LENGTH
1500 from unsigned int to ULONGEST. */
1501 ULONGEST ulow
= low_bound
, uhigh
= high_bound
;
1502 ULONGEST tlen
= TYPE_LENGTH (target_type
);
1504 len
= tlen
* (uhigh
- ulow
+ 1);
1505 if (tlen
== 0 || (len
/ tlen
- 1 + ulow
) != uhigh
1509 TYPE_LENGTH (type
) = len
;
1510 TYPE_TARGET_STUB (type
) = 0;
1512 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1514 TYPE_LENGTH (type
) = TYPE_LENGTH (target_type
);
1515 TYPE_TARGET_STUB (type
) = 0;
1518 /* Cache TYPE_LENGTH for future use. */
1519 TYPE_LENGTH (orig_type
) = TYPE_LENGTH (type
);
1523 /* Parse a type expression in the string [P..P+LENGTH). If an error
1524 occurs, silently return a void type. */
1526 static struct type
*
1527 safe_parse_type (struct gdbarch
*gdbarch
, char *p
, int length
)
1529 struct ui_file
*saved_gdb_stderr
;
1532 /* Suppress error messages. */
1533 saved_gdb_stderr
= gdb_stderr
;
1534 gdb_stderr
= ui_file_new ();
1536 /* Call parse_and_eval_type() without fear of longjmp()s. */
1537 if (!gdb_parse_and_eval_type (p
, length
, &type
))
1538 type
= builtin_type (gdbarch
)->builtin_void
;
1540 /* Stop suppressing error messages. */
1541 ui_file_delete (gdb_stderr
);
1542 gdb_stderr
= saved_gdb_stderr
;
1547 /* Ugly hack to convert method stubs into method types.
1549 He ain't kiddin'. This demangles the name of the method into a
1550 string including argument types, parses out each argument type,
1551 generates a string casting a zero to that type, evaluates the
1552 string, and stuffs the resulting type into an argtype vector!!!
1553 Then it knows the type of the whole function (including argument
1554 types for overloading), which info used to be in the stab's but was
1555 removed to hack back the space required for them. */
1558 check_stub_method (struct type
*type
, int method_id
, int signature_id
)
1560 struct gdbarch
*gdbarch
= get_type_arch (type
);
1562 char *mangled_name
= gdb_mangle_name (type
, method_id
, signature_id
);
1563 char *demangled_name
= cplus_demangle (mangled_name
,
1564 DMGL_PARAMS
| DMGL_ANSI
);
1565 char *argtypetext
, *p
;
1566 int depth
= 0, argcount
= 1;
1567 struct field
*argtypes
;
1570 /* Make sure we got back a function string that we can use. */
1572 p
= strchr (demangled_name
, '(');
1576 if (demangled_name
== NULL
|| p
== NULL
)
1577 error (_("Internal: Cannot demangle mangled name `%s'."),
1580 /* Now, read in the parameters that define this type. */
1585 if (*p
== '(' || *p
== '<')
1589 else if (*p
== ')' || *p
== '>')
1593 else if (*p
== ',' && depth
== 0)
1601 /* If we read one argument and it was ``void'', don't count it. */
1602 if (strncmp (argtypetext
, "(void)", 6) == 0)
1605 /* We need one extra slot, for the THIS pointer. */
1607 argtypes
= (struct field
*)
1608 TYPE_ALLOC (type
, (argcount
+ 1) * sizeof (struct field
));
1611 /* Add THIS pointer for non-static methods. */
1612 f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1613 if (TYPE_FN_FIELD_STATIC_P (f
, signature_id
))
1617 argtypes
[0].type
= lookup_pointer_type (type
);
1621 if (*p
!= ')') /* () means no args, skip while */
1626 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1628 /* Avoid parsing of ellipsis, they will be handled below.
1629 Also avoid ``void'' as above. */
1630 if (strncmp (argtypetext
, "...", p
- argtypetext
) != 0
1631 && strncmp (argtypetext
, "void", p
- argtypetext
) != 0)
1633 argtypes
[argcount
].type
=
1634 safe_parse_type (gdbarch
, argtypetext
, p
- argtypetext
);
1637 argtypetext
= p
+ 1;
1640 if (*p
== '(' || *p
== '<')
1644 else if (*p
== ')' || *p
== '>')
1653 TYPE_FN_FIELD_PHYSNAME (f
, signature_id
) = mangled_name
;
1655 /* Now update the old "stub" type into a real type. */
1656 mtype
= TYPE_FN_FIELD_TYPE (f
, signature_id
);
1657 TYPE_DOMAIN_TYPE (mtype
) = type
;
1658 TYPE_FIELDS (mtype
) = argtypes
;
1659 TYPE_NFIELDS (mtype
) = argcount
;
1660 TYPE_STUB (mtype
) = 0;
1661 TYPE_FN_FIELD_STUB (f
, signature_id
) = 0;
1663 TYPE_VARARGS (mtype
) = 1;
1665 xfree (demangled_name
);
1668 /* This is the external interface to check_stub_method, above. This
1669 function unstubs all of the signatures for TYPE's METHOD_ID method
1670 name. After calling this function TYPE_FN_FIELD_STUB will be
1671 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1674 This function unfortunately can not die until stabs do. */
1677 check_stub_method_group (struct type
*type
, int method_id
)
1679 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, method_id
);
1680 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
1681 int j
, found_stub
= 0;
1683 for (j
= 0; j
< len
; j
++)
1684 if (TYPE_FN_FIELD_STUB (f
, j
))
1687 check_stub_method (type
, method_id
, j
);
1690 /* GNU v3 methods with incorrect names were corrected when we read
1691 in type information, because it was cheaper to do it then. The
1692 only GNU v2 methods with incorrect method names are operators and
1693 destructors; destructors were also corrected when we read in type
1696 Therefore the only thing we need to handle here are v2 operator
1698 if (found_stub
&& strncmp (TYPE_FN_FIELD_PHYSNAME (f
, 0), "_Z", 2) != 0)
1701 char dem_opname
[256];
1703 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1705 dem_opname
, DMGL_ANSI
);
1707 ret
= cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type
,
1711 TYPE_FN_FIELDLIST_NAME (type
, method_id
) = xstrdup (dem_opname
);
1715 const struct cplus_struct_type cplus_struct_default
;
1718 allocate_cplus_struct_type (struct type
*type
)
1720 if (HAVE_CPLUS_STRUCT (type
))
1721 /* Structure was already allocated. Nothing more to do. */
1724 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_CPLUS_STUFF
;
1725 TYPE_RAW_CPLUS_SPECIFIC (type
) = (struct cplus_struct_type
*)
1726 TYPE_ALLOC (type
, sizeof (struct cplus_struct_type
));
1727 *(TYPE_RAW_CPLUS_SPECIFIC (type
)) = cplus_struct_default
;
1730 const struct gnat_aux_type gnat_aux_default
=
1733 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
1734 and allocate the associated gnat-specific data. The gnat-specific
1735 data is also initialized to gnat_aux_default. */
1737 allocate_gnat_aux_type (struct type
*type
)
1739 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_GNAT_STUFF
;
1740 TYPE_GNAT_SPECIFIC (type
) = (struct gnat_aux_type
*)
1741 TYPE_ALLOC (type
, sizeof (struct gnat_aux_type
));
1742 *(TYPE_GNAT_SPECIFIC (type
)) = gnat_aux_default
;
1746 /* Helper function to initialize the standard scalar types.
1748 If NAME is non-NULL, then we make a copy of the string pointed
1749 to by name in the objfile_obstack for that objfile, and initialize
1750 the type name to that copy. There are places (mipsread.c in particular),
1751 where init_type is called with a NULL value for NAME). */
1754 init_type (enum type_code code
, int length
, int flags
,
1755 char *name
, struct objfile
*objfile
)
1759 type
= alloc_type (objfile
);
1760 TYPE_CODE (type
) = code
;
1761 TYPE_LENGTH (type
) = length
;
1763 gdb_assert (!(flags
& (TYPE_FLAG_MIN
- 1)));
1764 if (flags
& TYPE_FLAG_UNSIGNED
)
1765 TYPE_UNSIGNED (type
) = 1;
1766 if (flags
& TYPE_FLAG_NOSIGN
)
1767 TYPE_NOSIGN (type
) = 1;
1768 if (flags
& TYPE_FLAG_STUB
)
1769 TYPE_STUB (type
) = 1;
1770 if (flags
& TYPE_FLAG_TARGET_STUB
)
1771 TYPE_TARGET_STUB (type
) = 1;
1772 if (flags
& TYPE_FLAG_STATIC
)
1773 TYPE_STATIC (type
) = 1;
1774 if (flags
& TYPE_FLAG_PROTOTYPED
)
1775 TYPE_PROTOTYPED (type
) = 1;
1776 if (flags
& TYPE_FLAG_INCOMPLETE
)
1777 TYPE_INCOMPLETE (type
) = 1;
1778 if (flags
& TYPE_FLAG_VARARGS
)
1779 TYPE_VARARGS (type
) = 1;
1780 if (flags
& TYPE_FLAG_VECTOR
)
1781 TYPE_VECTOR (type
) = 1;
1782 if (flags
& TYPE_FLAG_STUB_SUPPORTED
)
1783 TYPE_STUB_SUPPORTED (type
) = 1;
1784 if (flags
& TYPE_FLAG_NOTTEXT
)
1785 TYPE_NOTTEXT (type
) = 1;
1786 if (flags
& TYPE_FLAG_FIXED_INSTANCE
)
1787 TYPE_FIXED_INSTANCE (type
) = 1;
1790 TYPE_NAME (type
) = obsavestring (name
, strlen (name
),
1791 &objfile
->objfile_obstack
);
1795 if (name
&& strcmp (name
, "char") == 0)
1796 TYPE_NOSIGN (type
) = 1;
1800 case TYPE_CODE_STRUCT
:
1801 case TYPE_CODE_UNION
:
1802 case TYPE_CODE_NAMESPACE
:
1803 INIT_CPLUS_SPECIFIC (type
);
1806 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_FLOATFORMAT
;
1808 case TYPE_CODE_FUNC
:
1809 TYPE_SPECIFIC_FIELD (type
) = TYPE_SPECIFIC_CALLING_CONVENTION
;
1816 can_dereference (struct type
*t
)
1818 /* FIXME: Should we return true for references as well as
1823 && TYPE_CODE (t
) == TYPE_CODE_PTR
1824 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
);
1828 is_integral_type (struct type
*t
)
1833 && ((TYPE_CODE (t
) == TYPE_CODE_INT
)
1834 || (TYPE_CODE (t
) == TYPE_CODE_ENUM
)
1835 || (TYPE_CODE (t
) == TYPE_CODE_FLAGS
)
1836 || (TYPE_CODE (t
) == TYPE_CODE_CHAR
)
1837 || (TYPE_CODE (t
) == TYPE_CODE_RANGE
)
1838 || (TYPE_CODE (t
) == TYPE_CODE_BOOL
)));
1841 /* Check whether BASE is an ancestor or base class or DCLASS
1842 Return 1 if so, and 0 if not.
1843 Note: callers may want to check for identity of the types before
1844 calling this function -- identical types are considered to satisfy
1845 the ancestor relationship even if they're identical. */
1848 is_ancestor (struct type
*base
, struct type
*dclass
)
1852 CHECK_TYPEDEF (base
);
1853 CHECK_TYPEDEF (dclass
);
1857 if (TYPE_NAME (base
) && TYPE_NAME (dclass
)
1858 && !strcmp (TYPE_NAME (base
), TYPE_NAME (dclass
)))
1861 for (i
= 0; i
< TYPE_N_BASECLASSES (dclass
); i
++)
1862 if (is_ancestor (base
, TYPE_BASECLASS (dclass
, i
)))
1870 /* Functions for overload resolution begin here */
1872 /* Compare two badness vectors A and B and return the result.
1873 0 => A and B are identical
1874 1 => A and B are incomparable
1875 2 => A is better than B
1876 3 => A is worse than B */
1879 compare_badness (struct badness_vector
*a
, struct badness_vector
*b
)
1883 short found_pos
= 0; /* any positives in c? */
1884 short found_neg
= 0; /* any negatives in c? */
1886 /* differing lengths => incomparable */
1887 if (a
->length
!= b
->length
)
1890 /* Subtract b from a */
1891 for (i
= 0; i
< a
->length
; i
++)
1893 tmp
= a
->rank
[i
] - b
->rank
[i
];
1903 return 1; /* incomparable */
1905 return 3; /* A > B */
1911 return 2; /* A < B */
1913 return 0; /* A == B */
1917 /* Rank a function by comparing its parameter types (PARMS, length
1918 NPARMS), to the types of an argument list (ARGS, length NARGS).
1919 Return a pointer to a badness vector. This has NARGS + 1
1922 struct badness_vector
*
1923 rank_function (struct type
**parms
, int nparms
,
1924 struct type
**args
, int nargs
)
1927 struct badness_vector
*bv
;
1928 int min_len
= nparms
< nargs
? nparms
: nargs
;
1930 bv
= xmalloc (sizeof (struct badness_vector
));
1931 bv
->length
= nargs
+ 1; /* add 1 for the length-match rank */
1932 bv
->rank
= xmalloc ((nargs
+ 1) * sizeof (int));
1934 /* First compare the lengths of the supplied lists.
1935 If there is a mismatch, set it to a high value. */
1937 /* pai/1997-06-03 FIXME: when we have debug info about default
1938 arguments and ellipsis parameter lists, we should consider those
1939 and rank the length-match more finely. */
1941 LENGTH_MATCH (bv
) = (nargs
!= nparms
) ? LENGTH_MISMATCH_BADNESS
: 0;
1943 /* Now rank all the parameters of the candidate function */
1944 for (i
= 1; i
<= min_len
; i
++)
1945 bv
->rank
[i
] = rank_one_type (parms
[i
-1], args
[i
-1]);
1947 /* If more arguments than parameters, add dummy entries */
1948 for (i
= min_len
+ 1; i
<= nargs
; i
++)
1949 bv
->rank
[i
] = TOO_FEW_PARAMS_BADNESS
;
1954 /* Compare the names of two integer types, assuming that any sign
1955 qualifiers have been checked already. We do it this way because
1956 there may be an "int" in the name of one of the types. */
1959 integer_types_same_name_p (const char *first
, const char *second
)
1961 int first_p
, second_p
;
1963 /* If both are shorts, return 1; if neither is a short, keep
1965 first_p
= (strstr (first
, "short") != NULL
);
1966 second_p
= (strstr (second
, "short") != NULL
);
1967 if (first_p
&& second_p
)
1969 if (first_p
|| second_p
)
1972 /* Likewise for long. */
1973 first_p
= (strstr (first
, "long") != NULL
);
1974 second_p
= (strstr (second
, "long") != NULL
);
1975 if (first_p
&& second_p
)
1977 if (first_p
|| second_p
)
1980 /* Likewise for char. */
1981 first_p
= (strstr (first
, "char") != NULL
);
1982 second_p
= (strstr (second
, "char") != NULL
);
1983 if (first_p
&& second_p
)
1985 if (first_p
|| second_p
)
1988 /* They must both be ints. */
1992 /* Compare one type (PARM) for compatibility with another (ARG).
1993 * PARM is intended to be the parameter type of a function; and
1994 * ARG is the supplied argument's type. This function tests if
1995 * the latter can be converted to the former.
1997 * Return 0 if they are identical types;
1998 * Otherwise, return an integer which corresponds to how compatible
1999 * PARM is to ARG. The higher the return value, the worse the match.
2000 * Generally the "bad" conversions are all uniformly assigned a 100. */
2003 rank_one_type (struct type
*parm
, struct type
*arg
)
2005 /* Identical type pointers. */
2006 /* However, this still doesn't catch all cases of same type for arg
2007 and param. The reason is that builtin types are different from
2008 the same ones constructed from the object. */
2012 /* Resolve typedefs */
2013 if (TYPE_CODE (parm
) == TYPE_CODE_TYPEDEF
)
2014 parm
= check_typedef (parm
);
2015 if (TYPE_CODE (arg
) == TYPE_CODE_TYPEDEF
)
2016 arg
= check_typedef (arg
);
2019 Well, damnit, if the names are exactly the same, I'll say they
2020 are exactly the same. This happens when we generate method
2021 stubs. The types won't point to the same address, but they
2022 really are the same.
2025 if (TYPE_NAME (parm
) && TYPE_NAME (arg
)
2026 && !strcmp (TYPE_NAME (parm
), TYPE_NAME (arg
)))
2029 /* Check if identical after resolving typedefs. */
2033 /* See through references, since we can almost make non-references
2035 if (TYPE_CODE (arg
) == TYPE_CODE_REF
)
2036 return (rank_one_type (parm
, TYPE_TARGET_TYPE (arg
))
2037 + REFERENCE_CONVERSION_BADNESS
);
2038 if (TYPE_CODE (parm
) == TYPE_CODE_REF
)
2039 return (rank_one_type (TYPE_TARGET_TYPE (parm
), arg
)
2040 + REFERENCE_CONVERSION_BADNESS
);
2042 /* Debugging only. */
2043 fprintf_filtered (gdb_stderr
,
2044 "------ Arg is %s [%d], parm is %s [%d]\n",
2045 TYPE_NAME (arg
), TYPE_CODE (arg
),
2046 TYPE_NAME (parm
), TYPE_CODE (parm
));
2048 /* x -> y means arg of type x being supplied for parameter of type y */
2050 switch (TYPE_CODE (parm
))
2053 switch (TYPE_CODE (arg
))
2056 if (TYPE_CODE (TYPE_TARGET_TYPE (parm
)) == TYPE_CODE_VOID
2057 && TYPE_CODE (TYPE_TARGET_TYPE (arg
)) != TYPE_CODE_VOID
)
2058 return VOID_PTR_CONVERSION_BADNESS
;
2060 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2061 TYPE_TARGET_TYPE (arg
));
2062 case TYPE_CODE_ARRAY
:
2063 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2064 TYPE_TARGET_TYPE (arg
));
2065 case TYPE_CODE_FUNC
:
2066 return rank_one_type (TYPE_TARGET_TYPE (parm
), arg
);
2068 case TYPE_CODE_ENUM
:
2069 case TYPE_CODE_FLAGS
:
2070 case TYPE_CODE_CHAR
:
2071 case TYPE_CODE_RANGE
:
2072 case TYPE_CODE_BOOL
:
2073 return POINTER_CONVERSION_BADNESS
;
2075 return INCOMPATIBLE_TYPE_BADNESS
;
2077 case TYPE_CODE_ARRAY
:
2078 switch (TYPE_CODE (arg
))
2081 case TYPE_CODE_ARRAY
:
2082 return rank_one_type (TYPE_TARGET_TYPE (parm
),
2083 TYPE_TARGET_TYPE (arg
));
2085 return INCOMPATIBLE_TYPE_BADNESS
;
2087 case TYPE_CODE_FUNC
:
2088 switch (TYPE_CODE (arg
))
2090 case TYPE_CODE_PTR
: /* funcptr -> func */
2091 return rank_one_type (parm
, TYPE_TARGET_TYPE (arg
));
2093 return INCOMPATIBLE_TYPE_BADNESS
;
2096 switch (TYPE_CODE (arg
))
2099 if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2101 /* Deal with signed, unsigned, and plain chars and
2102 signed and unsigned ints. */
2103 if (TYPE_NOSIGN (parm
))
2105 /* This case only for character types */
2106 if (TYPE_NOSIGN (arg
))
2107 return 0; /* plain char -> plain char */
2108 else /* signed/unsigned char -> plain char */
2109 return INTEGER_CONVERSION_BADNESS
;
2111 else if (TYPE_UNSIGNED (parm
))
2113 if (TYPE_UNSIGNED (arg
))
2115 /* unsigned int -> unsigned int, or
2116 unsigned long -> unsigned long */
2117 if (integer_types_same_name_p (TYPE_NAME (parm
),
2120 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2122 && integer_types_same_name_p (TYPE_NAME (parm
),
2124 return INTEGER_PROMOTION_BADNESS
; /* unsigned int -> unsigned long */
2126 return INTEGER_CONVERSION_BADNESS
; /* unsigned long -> unsigned int */
2130 if (integer_types_same_name_p (TYPE_NAME (arg
),
2132 && integer_types_same_name_p (TYPE_NAME (parm
),
2134 return INTEGER_CONVERSION_BADNESS
; /* signed long -> unsigned int */
2136 return INTEGER_CONVERSION_BADNESS
; /* signed int/long -> unsigned int/long */
2139 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2141 if (integer_types_same_name_p (TYPE_NAME (parm
),
2144 else if (integer_types_same_name_p (TYPE_NAME (arg
),
2146 && integer_types_same_name_p (TYPE_NAME (parm
),
2148 return INTEGER_PROMOTION_BADNESS
;
2150 return INTEGER_CONVERSION_BADNESS
;
2153 return INTEGER_CONVERSION_BADNESS
;
2155 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2156 return INTEGER_PROMOTION_BADNESS
;
2158 return INTEGER_CONVERSION_BADNESS
;
2159 case TYPE_CODE_ENUM
:
2160 case TYPE_CODE_FLAGS
:
2161 case TYPE_CODE_CHAR
:
2162 case TYPE_CODE_RANGE
:
2163 case TYPE_CODE_BOOL
:
2164 return INTEGER_PROMOTION_BADNESS
;
2166 return INT_FLOAT_CONVERSION_BADNESS
;
2168 return NS_POINTER_CONVERSION_BADNESS
;
2170 return INCOMPATIBLE_TYPE_BADNESS
;
2173 case TYPE_CODE_ENUM
:
2174 switch (TYPE_CODE (arg
))
2177 case TYPE_CODE_CHAR
:
2178 case TYPE_CODE_RANGE
:
2179 case TYPE_CODE_BOOL
:
2180 case TYPE_CODE_ENUM
:
2181 return INTEGER_CONVERSION_BADNESS
;
2183 return INT_FLOAT_CONVERSION_BADNESS
;
2185 return INCOMPATIBLE_TYPE_BADNESS
;
2188 case TYPE_CODE_CHAR
:
2189 switch (TYPE_CODE (arg
))
2191 case TYPE_CODE_RANGE
:
2192 case TYPE_CODE_BOOL
:
2193 case TYPE_CODE_ENUM
:
2194 return INTEGER_CONVERSION_BADNESS
;
2196 return INT_FLOAT_CONVERSION_BADNESS
;
2198 if (TYPE_LENGTH (arg
) > TYPE_LENGTH (parm
))
2199 return INTEGER_CONVERSION_BADNESS
;
2200 else if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2201 return INTEGER_PROMOTION_BADNESS
;
2202 /* >>> !! else fall through !! <<< */
2203 case TYPE_CODE_CHAR
:
2204 /* Deal with signed, unsigned, and plain chars for C++ and
2205 with int cases falling through from previous case. */
2206 if (TYPE_NOSIGN (parm
))
2208 if (TYPE_NOSIGN (arg
))
2211 return INTEGER_CONVERSION_BADNESS
;
2213 else if (TYPE_UNSIGNED (parm
))
2215 if (TYPE_UNSIGNED (arg
))
2218 return INTEGER_PROMOTION_BADNESS
;
2220 else if (!TYPE_NOSIGN (arg
) && !TYPE_UNSIGNED (arg
))
2223 return INTEGER_CONVERSION_BADNESS
;
2225 return INCOMPATIBLE_TYPE_BADNESS
;
2228 case TYPE_CODE_RANGE
:
2229 switch (TYPE_CODE (arg
))
2232 case TYPE_CODE_CHAR
:
2233 case TYPE_CODE_RANGE
:
2234 case TYPE_CODE_BOOL
:
2235 case TYPE_CODE_ENUM
:
2236 return INTEGER_CONVERSION_BADNESS
;
2238 return INT_FLOAT_CONVERSION_BADNESS
;
2240 return INCOMPATIBLE_TYPE_BADNESS
;
2243 case TYPE_CODE_BOOL
:
2244 switch (TYPE_CODE (arg
))
2247 case TYPE_CODE_CHAR
:
2248 case TYPE_CODE_RANGE
:
2249 case TYPE_CODE_ENUM
:
2252 return BOOLEAN_CONVERSION_BADNESS
;
2253 case TYPE_CODE_BOOL
:
2256 return INCOMPATIBLE_TYPE_BADNESS
;
2260 switch (TYPE_CODE (arg
))
2263 if (TYPE_LENGTH (arg
) < TYPE_LENGTH (parm
))
2264 return FLOAT_PROMOTION_BADNESS
;
2265 else if (TYPE_LENGTH (arg
) == TYPE_LENGTH (parm
))
2268 return FLOAT_CONVERSION_BADNESS
;
2270 case TYPE_CODE_BOOL
:
2271 case TYPE_CODE_ENUM
:
2272 case TYPE_CODE_RANGE
:
2273 case TYPE_CODE_CHAR
:
2274 return INT_FLOAT_CONVERSION_BADNESS
;
2276 return INCOMPATIBLE_TYPE_BADNESS
;
2279 case TYPE_CODE_COMPLEX
:
2280 switch (TYPE_CODE (arg
))
2281 { /* Strictly not needed for C++, but... */
2283 return FLOAT_PROMOTION_BADNESS
;
2284 case TYPE_CODE_COMPLEX
:
2287 return INCOMPATIBLE_TYPE_BADNESS
;
2290 case TYPE_CODE_STRUCT
:
2291 /* currently same as TYPE_CODE_CLASS */
2292 switch (TYPE_CODE (arg
))
2294 case TYPE_CODE_STRUCT
:
2295 /* Check for derivation */
2296 if (is_ancestor (parm
, arg
))
2297 return BASE_CONVERSION_BADNESS
;
2298 /* else fall through */
2300 return INCOMPATIBLE_TYPE_BADNESS
;
2303 case TYPE_CODE_UNION
:
2304 switch (TYPE_CODE (arg
))
2306 case TYPE_CODE_UNION
:
2308 return INCOMPATIBLE_TYPE_BADNESS
;
2311 case TYPE_CODE_MEMBERPTR
:
2312 switch (TYPE_CODE (arg
))
2315 return INCOMPATIBLE_TYPE_BADNESS
;
2318 case TYPE_CODE_METHOD
:
2319 switch (TYPE_CODE (arg
))
2323 return INCOMPATIBLE_TYPE_BADNESS
;
2327 switch (TYPE_CODE (arg
))
2331 return INCOMPATIBLE_TYPE_BADNESS
;
2336 switch (TYPE_CODE (arg
))
2340 return rank_one_type (TYPE_FIELD_TYPE (parm
, 0),
2341 TYPE_FIELD_TYPE (arg
, 0));
2343 return INCOMPATIBLE_TYPE_BADNESS
;
2346 case TYPE_CODE_VOID
:
2348 return INCOMPATIBLE_TYPE_BADNESS
;
2349 } /* switch (TYPE_CODE (arg)) */
2353 /* End of functions for overload resolution */
2356 print_bit_vector (B_TYPE
*bits
, int nbits
)
2360 for (bitno
= 0; bitno
< nbits
; bitno
++)
2362 if ((bitno
% 8) == 0)
2364 puts_filtered (" ");
2366 if (B_TST (bits
, bitno
))
2367 printf_filtered (("1"));
2369 printf_filtered (("0"));
2373 /* Note the first arg should be the "this" pointer, we may not want to
2374 include it since we may get into a infinitely recursive
2378 print_arg_types (struct field
*args
, int nargs
, int spaces
)
2384 for (i
= 0; i
< nargs
; i
++)
2385 recursive_dump_type (args
[i
].type
, spaces
+ 2);
2390 field_is_static (struct field
*f
)
2392 /* "static" fields are the fields whose location is not relative
2393 to the address of the enclosing struct. It would be nice to
2394 have a dedicated flag that would be set for static fields when
2395 the type is being created. But in practice, checking the field
2396 loc_kind should give us an accurate answer (at least as long as
2397 we assume that DWARF block locations are not going to be used
2398 for static fields). FIXME? */
2399 return (FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSNAME
2400 || FIELD_LOC_KIND (*f
) == FIELD_LOC_KIND_PHYSADDR
);
2404 dump_fn_fieldlists (struct type
*type
, int spaces
)
2410 printfi_filtered (spaces
, "fn_fieldlists ");
2411 gdb_print_host_address (TYPE_FN_FIELDLISTS (type
), gdb_stdout
);
2412 printf_filtered ("\n");
2413 for (method_idx
= 0; method_idx
< TYPE_NFN_FIELDS (type
); method_idx
++)
2415 f
= TYPE_FN_FIELDLIST1 (type
, method_idx
);
2416 printfi_filtered (spaces
+ 2, "[%d] name '%s' (",
2418 TYPE_FN_FIELDLIST_NAME (type
, method_idx
));
2419 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type
, method_idx
),
2421 printf_filtered (_(") length %d\n"),
2422 TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
));
2423 for (overload_idx
= 0;
2424 overload_idx
< TYPE_FN_FIELDLIST_LENGTH (type
, method_idx
);
2427 printfi_filtered (spaces
+ 4, "[%d] physname '%s' (",
2429 TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
));
2430 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f
, overload_idx
),
2432 printf_filtered (")\n");
2433 printfi_filtered (spaces
+ 8, "type ");
2434 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2436 printf_filtered ("\n");
2438 recursive_dump_type (TYPE_FN_FIELD_TYPE (f
, overload_idx
),
2441 printfi_filtered (spaces
+ 8, "args ");
2442 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2444 printf_filtered ("\n");
2446 print_arg_types (TYPE_FN_FIELD_ARGS (f
, overload_idx
),
2447 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
,
2450 printfi_filtered (spaces
+ 8, "fcontext ");
2451 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f
, overload_idx
),
2453 printf_filtered ("\n");
2455 printfi_filtered (spaces
+ 8, "is_const %d\n",
2456 TYPE_FN_FIELD_CONST (f
, overload_idx
));
2457 printfi_filtered (spaces
+ 8, "is_volatile %d\n",
2458 TYPE_FN_FIELD_VOLATILE (f
, overload_idx
));
2459 printfi_filtered (spaces
+ 8, "is_private %d\n",
2460 TYPE_FN_FIELD_PRIVATE (f
, overload_idx
));
2461 printfi_filtered (spaces
+ 8, "is_protected %d\n",
2462 TYPE_FN_FIELD_PROTECTED (f
, overload_idx
));
2463 printfi_filtered (spaces
+ 8, "is_stub %d\n",
2464 TYPE_FN_FIELD_STUB (f
, overload_idx
));
2465 printfi_filtered (spaces
+ 8, "voffset %u\n",
2466 TYPE_FN_FIELD_VOFFSET (f
, overload_idx
));
2472 print_cplus_stuff (struct type
*type
, int spaces
)
2474 printfi_filtered (spaces
, "n_baseclasses %d\n",
2475 TYPE_N_BASECLASSES (type
));
2476 printfi_filtered (spaces
, "nfn_fields %d\n",
2477 TYPE_NFN_FIELDS (type
));
2478 printfi_filtered (spaces
, "nfn_fields_total %d\n",
2479 TYPE_NFN_FIELDS_TOTAL (type
));
2480 if (TYPE_N_BASECLASSES (type
) > 0)
2482 printfi_filtered (spaces
, "virtual_field_bits (%d bits at *",
2483 TYPE_N_BASECLASSES (type
));
2484 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type
),
2486 printf_filtered (")");
2488 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type
),
2489 TYPE_N_BASECLASSES (type
));
2490 puts_filtered ("\n");
2492 if (TYPE_NFIELDS (type
) > 0)
2494 if (TYPE_FIELD_PRIVATE_BITS (type
) != NULL
)
2496 printfi_filtered (spaces
,
2497 "private_field_bits (%d bits at *",
2498 TYPE_NFIELDS (type
));
2499 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type
),
2501 printf_filtered (")");
2502 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type
),
2503 TYPE_NFIELDS (type
));
2504 puts_filtered ("\n");
2506 if (TYPE_FIELD_PROTECTED_BITS (type
) != NULL
)
2508 printfi_filtered (spaces
,
2509 "protected_field_bits (%d bits at *",
2510 TYPE_NFIELDS (type
));
2511 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type
),
2513 printf_filtered (")");
2514 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type
),
2515 TYPE_NFIELDS (type
));
2516 puts_filtered ("\n");
2519 if (TYPE_NFN_FIELDS (type
) > 0)
2521 dump_fn_fieldlists (type
, spaces
);
2525 /* Print the contents of the TYPE's type_specific union, assuming that
2526 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
2529 print_gnat_stuff (struct type
*type
, int spaces
)
2531 struct type
*descriptive_type
= TYPE_DESCRIPTIVE_TYPE (type
);
2533 recursive_dump_type (descriptive_type
, spaces
+ 2);
2536 static struct obstack dont_print_type_obstack
;
2539 recursive_dump_type (struct type
*type
, int spaces
)
2544 obstack_begin (&dont_print_type_obstack
, 0);
2546 if (TYPE_NFIELDS (type
) > 0
2547 || (HAVE_CPLUS_STRUCT (type
) && TYPE_NFN_FIELDS (type
) > 0))
2549 struct type
**first_dont_print
2550 = (struct type
**) obstack_base (&dont_print_type_obstack
);
2552 int i
= (struct type
**)
2553 obstack_next_free (&dont_print_type_obstack
) - first_dont_print
;
2557 if (type
== first_dont_print
[i
])
2559 printfi_filtered (spaces
, "type node ");
2560 gdb_print_host_address (type
, gdb_stdout
);
2561 printf_filtered (_(" <same as already seen type>\n"));
2566 obstack_ptr_grow (&dont_print_type_obstack
, type
);
2569 printfi_filtered (spaces
, "type node ");
2570 gdb_print_host_address (type
, gdb_stdout
);
2571 printf_filtered ("\n");
2572 printfi_filtered (spaces
, "name '%s' (",
2573 TYPE_NAME (type
) ? TYPE_NAME (type
) : "<NULL>");
2574 gdb_print_host_address (TYPE_NAME (type
), gdb_stdout
);
2575 printf_filtered (")\n");
2576 printfi_filtered (spaces
, "tagname '%s' (",
2577 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) : "<NULL>");
2578 gdb_print_host_address (TYPE_TAG_NAME (type
), gdb_stdout
);
2579 printf_filtered (")\n");
2580 printfi_filtered (spaces
, "code 0x%x ", TYPE_CODE (type
));
2581 switch (TYPE_CODE (type
))
2583 case TYPE_CODE_UNDEF
:
2584 printf_filtered ("(TYPE_CODE_UNDEF)");
2587 printf_filtered ("(TYPE_CODE_PTR)");
2589 case TYPE_CODE_ARRAY
:
2590 printf_filtered ("(TYPE_CODE_ARRAY)");
2592 case TYPE_CODE_STRUCT
:
2593 printf_filtered ("(TYPE_CODE_STRUCT)");
2595 case TYPE_CODE_UNION
:
2596 printf_filtered ("(TYPE_CODE_UNION)");
2598 case TYPE_CODE_ENUM
:
2599 printf_filtered ("(TYPE_CODE_ENUM)");
2601 case TYPE_CODE_FLAGS
:
2602 printf_filtered ("(TYPE_CODE_FLAGS)");
2604 case TYPE_CODE_FUNC
:
2605 printf_filtered ("(TYPE_CODE_FUNC)");
2608 printf_filtered ("(TYPE_CODE_INT)");
2611 printf_filtered ("(TYPE_CODE_FLT)");
2613 case TYPE_CODE_VOID
:
2614 printf_filtered ("(TYPE_CODE_VOID)");
2617 printf_filtered ("(TYPE_CODE_SET)");
2619 case TYPE_CODE_RANGE
:
2620 printf_filtered ("(TYPE_CODE_RANGE)");
2622 case TYPE_CODE_STRING
:
2623 printf_filtered ("(TYPE_CODE_STRING)");
2625 case TYPE_CODE_BITSTRING
:
2626 printf_filtered ("(TYPE_CODE_BITSTRING)");
2628 case TYPE_CODE_ERROR
:
2629 printf_filtered ("(TYPE_CODE_ERROR)");
2631 case TYPE_CODE_MEMBERPTR
:
2632 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
2634 case TYPE_CODE_METHODPTR
:
2635 printf_filtered ("(TYPE_CODE_METHODPTR)");
2637 case TYPE_CODE_METHOD
:
2638 printf_filtered ("(TYPE_CODE_METHOD)");
2641 printf_filtered ("(TYPE_CODE_REF)");
2643 case TYPE_CODE_CHAR
:
2644 printf_filtered ("(TYPE_CODE_CHAR)");
2646 case TYPE_CODE_BOOL
:
2647 printf_filtered ("(TYPE_CODE_BOOL)");
2649 case TYPE_CODE_COMPLEX
:
2650 printf_filtered ("(TYPE_CODE_COMPLEX)");
2652 case TYPE_CODE_TYPEDEF
:
2653 printf_filtered ("(TYPE_CODE_TYPEDEF)");
2655 case TYPE_CODE_TEMPLATE
:
2656 printf_filtered ("(TYPE_CODE_TEMPLATE)");
2658 case TYPE_CODE_TEMPLATE_ARG
:
2659 printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)");
2661 case TYPE_CODE_NAMESPACE
:
2662 printf_filtered ("(TYPE_CODE_NAMESPACE)");
2665 printf_filtered ("(UNKNOWN TYPE CODE)");
2668 puts_filtered ("\n");
2669 printfi_filtered (spaces
, "length %d\n", TYPE_LENGTH (type
));
2670 if (TYPE_OBJFILE_OWNED (type
))
2672 printfi_filtered (spaces
, "objfile ");
2673 gdb_print_host_address (TYPE_OWNER (type
).objfile
, gdb_stdout
);
2677 printfi_filtered (spaces
, "gdbarch ");
2678 gdb_print_host_address (TYPE_OWNER (type
).gdbarch
, gdb_stdout
);
2680 printf_filtered ("\n");
2681 printfi_filtered (spaces
, "target_type ");
2682 gdb_print_host_address (TYPE_TARGET_TYPE (type
), gdb_stdout
);
2683 printf_filtered ("\n");
2684 if (TYPE_TARGET_TYPE (type
) != NULL
)
2686 recursive_dump_type (TYPE_TARGET_TYPE (type
), spaces
+ 2);
2688 printfi_filtered (spaces
, "pointer_type ");
2689 gdb_print_host_address (TYPE_POINTER_TYPE (type
), gdb_stdout
);
2690 printf_filtered ("\n");
2691 printfi_filtered (spaces
, "reference_type ");
2692 gdb_print_host_address (TYPE_REFERENCE_TYPE (type
), gdb_stdout
);
2693 printf_filtered ("\n");
2694 printfi_filtered (spaces
, "type_chain ");
2695 gdb_print_host_address (TYPE_CHAIN (type
), gdb_stdout
);
2696 printf_filtered ("\n");
2697 printfi_filtered (spaces
, "instance_flags 0x%x",
2698 TYPE_INSTANCE_FLAGS (type
));
2699 if (TYPE_CONST (type
))
2701 puts_filtered (" TYPE_FLAG_CONST");
2703 if (TYPE_VOLATILE (type
))
2705 puts_filtered (" TYPE_FLAG_VOLATILE");
2707 if (TYPE_CODE_SPACE (type
))
2709 puts_filtered (" TYPE_FLAG_CODE_SPACE");
2711 if (TYPE_DATA_SPACE (type
))
2713 puts_filtered (" TYPE_FLAG_DATA_SPACE");
2715 if (TYPE_ADDRESS_CLASS_1 (type
))
2717 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
2719 if (TYPE_ADDRESS_CLASS_2 (type
))
2721 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
2723 puts_filtered ("\n");
2725 printfi_filtered (spaces
, "flags");
2726 if (TYPE_UNSIGNED (type
))
2728 puts_filtered (" TYPE_FLAG_UNSIGNED");
2730 if (TYPE_NOSIGN (type
))
2732 puts_filtered (" TYPE_FLAG_NOSIGN");
2734 if (TYPE_STUB (type
))
2736 puts_filtered (" TYPE_FLAG_STUB");
2738 if (TYPE_TARGET_STUB (type
))
2740 puts_filtered (" TYPE_FLAG_TARGET_STUB");
2742 if (TYPE_STATIC (type
))
2744 puts_filtered (" TYPE_FLAG_STATIC");
2746 if (TYPE_PROTOTYPED (type
))
2748 puts_filtered (" TYPE_FLAG_PROTOTYPED");
2750 if (TYPE_INCOMPLETE (type
))
2752 puts_filtered (" TYPE_FLAG_INCOMPLETE");
2754 if (TYPE_VARARGS (type
))
2756 puts_filtered (" TYPE_FLAG_VARARGS");
2758 /* This is used for things like AltiVec registers on ppc. Gcc emits
2759 an attribute for the array type, which tells whether or not we
2760 have a vector, instead of a regular array. */
2761 if (TYPE_VECTOR (type
))
2763 puts_filtered (" TYPE_FLAG_VECTOR");
2765 if (TYPE_FIXED_INSTANCE (type
))
2767 puts_filtered (" TYPE_FIXED_INSTANCE");
2769 if (TYPE_STUB_SUPPORTED (type
))
2771 puts_filtered (" TYPE_STUB_SUPPORTED");
2773 if (TYPE_NOTTEXT (type
))
2775 puts_filtered (" TYPE_NOTTEXT");
2777 puts_filtered ("\n");
2778 printfi_filtered (spaces
, "nfields %d ", TYPE_NFIELDS (type
));
2779 gdb_print_host_address (TYPE_FIELDS (type
), gdb_stdout
);
2780 puts_filtered ("\n");
2781 for (idx
= 0; idx
< TYPE_NFIELDS (type
); idx
++)
2783 printfi_filtered (spaces
+ 2,
2784 "[%d] bitpos %d bitsize %d type ",
2785 idx
, TYPE_FIELD_BITPOS (type
, idx
),
2786 TYPE_FIELD_BITSIZE (type
, idx
));
2787 gdb_print_host_address (TYPE_FIELD_TYPE (type
, idx
), gdb_stdout
);
2788 printf_filtered (" name '%s' (",
2789 TYPE_FIELD_NAME (type
, idx
) != NULL
2790 ? TYPE_FIELD_NAME (type
, idx
)
2792 gdb_print_host_address (TYPE_FIELD_NAME (type
, idx
), gdb_stdout
);
2793 printf_filtered (")\n");
2794 if (TYPE_FIELD_TYPE (type
, idx
) != NULL
)
2796 recursive_dump_type (TYPE_FIELD_TYPE (type
, idx
), spaces
+ 4);
2799 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
2801 printfi_filtered (spaces
, "low %s%s high %s%s\n",
2802 plongest (TYPE_LOW_BOUND (type
)),
2803 TYPE_LOW_BOUND_UNDEFINED (type
) ? " (undefined)" : "",
2804 plongest (TYPE_HIGH_BOUND (type
)),
2805 TYPE_HIGH_BOUND_UNDEFINED (type
) ? " (undefined)" : "");
2807 printfi_filtered (spaces
, "vptr_basetype ");
2808 gdb_print_host_address (TYPE_VPTR_BASETYPE (type
), gdb_stdout
);
2809 puts_filtered ("\n");
2810 if (TYPE_VPTR_BASETYPE (type
) != NULL
)
2812 recursive_dump_type (TYPE_VPTR_BASETYPE (type
), spaces
+ 2);
2814 printfi_filtered (spaces
, "vptr_fieldno %d\n",
2815 TYPE_VPTR_FIELDNO (type
));
2817 switch (TYPE_SPECIFIC_FIELD (type
))
2819 case TYPE_SPECIFIC_CPLUS_STUFF
:
2820 printfi_filtered (spaces
, "cplus_stuff ");
2821 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type
),
2823 puts_filtered ("\n");
2824 print_cplus_stuff (type
, spaces
);
2827 case TYPE_SPECIFIC_GNAT_STUFF
:
2828 printfi_filtered (spaces
, "gnat_stuff ");
2829 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type
), gdb_stdout
);
2830 puts_filtered ("\n");
2831 print_gnat_stuff (type
, spaces
);
2834 case TYPE_SPECIFIC_FLOATFORMAT
:
2835 printfi_filtered (spaces
, "floatformat ");
2836 if (TYPE_FLOATFORMAT (type
) == NULL
)
2837 puts_filtered ("(null)");
2840 puts_filtered ("{ ");
2841 if (TYPE_FLOATFORMAT (type
)[0] == NULL
2842 || TYPE_FLOATFORMAT (type
)[0]->name
== NULL
)
2843 puts_filtered ("(null)");
2845 puts_filtered (TYPE_FLOATFORMAT (type
)[0]->name
);
2847 puts_filtered (", ");
2848 if (TYPE_FLOATFORMAT (type
)[1] == NULL
2849 || TYPE_FLOATFORMAT (type
)[1]->name
== NULL
)
2850 puts_filtered ("(null)");
2852 puts_filtered (TYPE_FLOATFORMAT (type
)[1]->name
);
2854 puts_filtered (" }");
2856 puts_filtered ("\n");
2859 case TYPE_SPECIFIC_CALLING_CONVENTION
:
2860 printfi_filtered (spaces
, "calling_convention %d\n",
2861 TYPE_CALLING_CONVENTION (type
));
2866 obstack_free (&dont_print_type_obstack
, NULL
);
2869 /* Trivial helpers for the libiberty hash table, for mapping one
2874 struct type
*old
, *new;
2878 type_pair_hash (const void *item
)
2880 const struct type_pair
*pair
= item
;
2881 return htab_hash_pointer (pair
->old
);
2885 type_pair_eq (const void *item_lhs
, const void *item_rhs
)
2887 const struct type_pair
*lhs
= item_lhs
, *rhs
= item_rhs
;
2888 return lhs
->old
== rhs
->old
;
2891 /* Allocate the hash table used by copy_type_recursive to walk
2892 types without duplicates. We use OBJFILE's obstack, because
2893 OBJFILE is about to be deleted. */
2896 create_copied_types_hash (struct objfile
*objfile
)
2898 return htab_create_alloc_ex (1, type_pair_hash
, type_pair_eq
,
2899 NULL
, &objfile
->objfile_obstack
,
2900 hashtab_obstack_allocate
,
2901 dummy_obstack_deallocate
);
2904 /* Recursively copy (deep copy) TYPE, if it is associated with
2905 OBJFILE. Return a new type allocated using malloc, a saved type if
2906 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
2907 not associated with OBJFILE. */
2910 copy_type_recursive (struct objfile
*objfile
,
2912 htab_t copied_types
)
2914 struct type_pair
*stored
, pair
;
2916 struct type
*new_type
;
2918 if (! TYPE_OBJFILE_OWNED (type
))
2921 /* This type shouldn't be pointing to any types in other objfiles;
2922 if it did, the type might disappear unexpectedly. */
2923 gdb_assert (TYPE_OBJFILE (type
) == objfile
);
2926 slot
= htab_find_slot (copied_types
, &pair
, INSERT
);
2928 return ((struct type_pair
*) *slot
)->new;
2930 new_type
= alloc_type_arch (get_type_arch (type
));
2932 /* We must add the new type to the hash table immediately, in case
2933 we encounter this type again during a recursive call below. */
2934 stored
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct type_pair
));
2936 stored
->new = new_type
;
2939 /* Copy the common fields of types. For the main type, we simply
2940 copy the entire thing and then update specific fields as needed. */
2941 *TYPE_MAIN_TYPE (new_type
) = *TYPE_MAIN_TYPE (type
);
2942 TYPE_OBJFILE_OWNED (new_type
) = 0;
2943 TYPE_OWNER (new_type
).gdbarch
= get_type_arch (type
);
2945 if (TYPE_NAME (type
))
2946 TYPE_NAME (new_type
) = xstrdup (TYPE_NAME (type
));
2947 if (TYPE_TAG_NAME (type
))
2948 TYPE_TAG_NAME (new_type
) = xstrdup (TYPE_TAG_NAME (type
));
2950 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
2951 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
2953 /* Copy the fields. */
2954 if (TYPE_NFIELDS (type
))
2958 nfields
= TYPE_NFIELDS (type
);
2959 TYPE_FIELDS (new_type
) = XCALLOC (nfields
, struct field
);
2960 for (i
= 0; i
< nfields
; i
++)
2962 TYPE_FIELD_ARTIFICIAL (new_type
, i
) =
2963 TYPE_FIELD_ARTIFICIAL (type
, i
);
2964 TYPE_FIELD_BITSIZE (new_type
, i
) = TYPE_FIELD_BITSIZE (type
, i
);
2965 if (TYPE_FIELD_TYPE (type
, i
))
2966 TYPE_FIELD_TYPE (new_type
, i
)
2967 = copy_type_recursive (objfile
, TYPE_FIELD_TYPE (type
, i
),
2969 if (TYPE_FIELD_NAME (type
, i
))
2970 TYPE_FIELD_NAME (new_type
, i
) =
2971 xstrdup (TYPE_FIELD_NAME (type
, i
));
2972 switch (TYPE_FIELD_LOC_KIND (type
, i
))
2974 case FIELD_LOC_KIND_BITPOS
:
2975 SET_FIELD_BITPOS (TYPE_FIELD (new_type
, i
),
2976 TYPE_FIELD_BITPOS (type
, i
));
2978 case FIELD_LOC_KIND_PHYSADDR
:
2979 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type
, i
),
2980 TYPE_FIELD_STATIC_PHYSADDR (type
, i
));
2982 case FIELD_LOC_KIND_PHYSNAME
:
2983 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type
, i
),
2984 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type
,
2988 internal_error (__FILE__
, __LINE__
,
2989 _("Unexpected type field location kind: %d"),
2990 TYPE_FIELD_LOC_KIND (type
, i
));
2995 /* For range types, copy the bounds information. */
2996 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
2998 TYPE_RANGE_DATA (new_type
) = xmalloc (sizeof (struct range_bounds
));
2999 *TYPE_RANGE_DATA (new_type
) = *TYPE_RANGE_DATA (type
);
3002 /* Copy pointers to other types. */
3003 if (TYPE_TARGET_TYPE (type
))
3004 TYPE_TARGET_TYPE (new_type
) =
3005 copy_type_recursive (objfile
,
3006 TYPE_TARGET_TYPE (type
),
3008 if (TYPE_VPTR_BASETYPE (type
))
3009 TYPE_VPTR_BASETYPE (new_type
) =
3010 copy_type_recursive (objfile
,
3011 TYPE_VPTR_BASETYPE (type
),
3013 /* Maybe copy the type_specific bits.
3015 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3016 base classes and methods. There's no fundamental reason why we
3017 can't, but at the moment it is not needed. */
3019 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
3020 TYPE_FLOATFORMAT (new_type
) = TYPE_FLOATFORMAT (type
);
3021 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3022 || TYPE_CODE (type
) == TYPE_CODE_UNION
3023 || TYPE_CODE (type
) == TYPE_CODE_TEMPLATE
3024 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
3025 INIT_CPLUS_SPECIFIC (new_type
);
3030 /* Make a copy of the given TYPE, except that the pointer & reference
3031 types are not preserved.
3033 This function assumes that the given type has an associated objfile.
3034 This objfile is used to allocate the new type. */
3037 copy_type (const struct type
*type
)
3039 struct type
*new_type
;
3041 gdb_assert (TYPE_OBJFILE_OWNED (type
));
3043 new_type
= alloc_type_copy (type
);
3044 TYPE_INSTANCE_FLAGS (new_type
) = TYPE_INSTANCE_FLAGS (type
);
3045 TYPE_LENGTH (new_type
) = TYPE_LENGTH (type
);
3046 memcpy (TYPE_MAIN_TYPE (new_type
), TYPE_MAIN_TYPE (type
),
3047 sizeof (struct main_type
));
3053 /* Helper functions to initialize architecture-specific types. */
3055 /* Allocate a type structure associated with GDBARCH and set its
3056 CODE, LENGTH, and NAME fields. */
3058 arch_type (struct gdbarch
*gdbarch
,
3059 enum type_code code
, int length
, char *name
)
3063 type
= alloc_type_arch (gdbarch
);
3064 TYPE_CODE (type
) = code
;
3065 TYPE_LENGTH (type
) = length
;
3068 TYPE_NAME (type
) = xstrdup (name
);
3073 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
3074 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3075 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3077 arch_integer_type (struct gdbarch
*gdbarch
,
3078 int bit
, int unsigned_p
, char *name
)
3082 t
= arch_type (gdbarch
, TYPE_CODE_INT
, bit
/ TARGET_CHAR_BIT
, name
);
3084 TYPE_UNSIGNED (t
) = 1;
3085 if (name
&& strcmp (name
, "char") == 0)
3086 TYPE_NOSIGN (t
) = 1;
3091 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
3092 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3093 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3095 arch_character_type (struct gdbarch
*gdbarch
,
3096 int bit
, int unsigned_p
, char *name
)
3100 t
= arch_type (gdbarch
, TYPE_CODE_CHAR
, bit
/ TARGET_CHAR_BIT
, name
);
3102 TYPE_UNSIGNED (t
) = 1;
3107 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
3108 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3109 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3111 arch_boolean_type (struct gdbarch
*gdbarch
,
3112 int bit
, int unsigned_p
, char *name
)
3116 t
= arch_type (gdbarch
, TYPE_CODE_BOOL
, bit
/ TARGET_CHAR_BIT
, name
);
3118 TYPE_UNSIGNED (t
) = 1;
3123 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
3124 BIT is the type size in bits; if BIT equals -1, the size is
3125 determined by the floatformat. NAME is the type name. Set the
3126 TYPE_FLOATFORMAT from FLOATFORMATS. */
3128 arch_float_type (struct gdbarch
*gdbarch
,
3129 int bit
, char *name
, const struct floatformat
**floatformats
)
3135 gdb_assert (floatformats
!= NULL
);
3136 gdb_assert (floatformats
[0] != NULL
&& floatformats
[1] != NULL
);
3137 bit
= floatformats
[0]->totalsize
;
3139 gdb_assert (bit
>= 0);
3141 t
= arch_type (gdbarch
, TYPE_CODE_FLT
, bit
/ TARGET_CHAR_BIT
, name
);
3142 TYPE_FLOATFORMAT (t
) = floatformats
;
3146 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
3147 NAME is the type name. TARGET_TYPE is the component float type. */
3149 arch_complex_type (struct gdbarch
*gdbarch
,
3150 char *name
, struct type
*target_type
)
3153 t
= arch_type (gdbarch
, TYPE_CODE_COMPLEX
,
3154 2 * TYPE_LENGTH (target_type
), name
);
3155 TYPE_TARGET_TYPE (t
) = target_type
;
3159 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
3160 NAME is the type name. LENGTH is the number of flag bits. */
3162 arch_flags_type (struct gdbarch
*gdbarch
, char *name
, int length
)
3164 int nfields
= length
* TARGET_CHAR_BIT
;
3167 type
= arch_type (gdbarch
, TYPE_CODE_FLAGS
, length
, name
);
3168 TYPE_UNSIGNED (type
) = 1;
3169 TYPE_NFIELDS (type
) = nfields
;
3170 TYPE_FIELDS (type
) = TYPE_ZALLOC (type
, nfields
* sizeof (struct field
));
3175 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
3176 position BITPOS is called NAME. */
3178 append_flags_type_flag (struct type
*type
, int bitpos
, char *name
)
3180 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLAGS
);
3181 gdb_assert (bitpos
< TYPE_NFIELDS (type
));
3182 gdb_assert (bitpos
>= 0);
3186 TYPE_FIELD_NAME (type
, bitpos
) = xstrdup (name
);
3187 TYPE_FIELD_BITPOS (type
, bitpos
) = bitpos
;
3191 /* Don't show this field to the user. */
3192 TYPE_FIELD_BITPOS (type
, bitpos
) = -1;
3196 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
3197 specified by CODE) associated with GDBARCH. NAME is the type name. */
3199 arch_composite_type (struct gdbarch
*gdbarch
, char *name
, enum type_code code
)
3202 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
3203 t
= arch_type (gdbarch
, code
, 0, NULL
);
3204 TYPE_TAG_NAME (t
) = name
;
3205 INIT_CPLUS_SPECIFIC (t
);
3209 /* Add new field with name NAME and type FIELD to composite type T.
3210 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
3212 append_composite_type_field_aligned (struct type
*t
, char *name
,
3213 struct type
*field
, int alignment
)
3216 TYPE_NFIELDS (t
) = TYPE_NFIELDS (t
) + 1;
3217 TYPE_FIELDS (t
) = xrealloc (TYPE_FIELDS (t
),
3218 sizeof (struct field
) * TYPE_NFIELDS (t
));
3219 f
= &(TYPE_FIELDS (t
)[TYPE_NFIELDS (t
) - 1]);
3220 memset (f
, 0, sizeof f
[0]);
3221 FIELD_TYPE (f
[0]) = field
;
3222 FIELD_NAME (f
[0]) = name
;
3223 if (TYPE_CODE (t
) == TYPE_CODE_UNION
)
3225 if (TYPE_LENGTH (t
) < TYPE_LENGTH (field
))
3226 TYPE_LENGTH (t
) = TYPE_LENGTH (field
);
3228 else if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
3230 TYPE_LENGTH (t
) = TYPE_LENGTH (t
) + TYPE_LENGTH (field
);
3231 if (TYPE_NFIELDS (t
) > 1)
3233 FIELD_BITPOS (f
[0]) = (FIELD_BITPOS (f
[-1])
3234 + (TYPE_LENGTH (FIELD_TYPE (f
[-1]))
3235 * TARGET_CHAR_BIT
));
3239 int left
= FIELD_BITPOS (f
[0]) % (alignment
* TARGET_CHAR_BIT
);
3242 FIELD_BITPOS (f
[0]) += left
;
3243 TYPE_LENGTH (t
) += left
/ TARGET_CHAR_BIT
;
3250 /* Add new field with name NAME and type FIELD to composite type T. */
3252 append_composite_type_field (struct type
*t
, char *name
,
3255 append_composite_type_field_aligned (t
, name
, field
, 0);
3259 static struct gdbarch_data
*gdbtypes_data
;
3261 const struct builtin_type
*
3262 builtin_type (struct gdbarch
*gdbarch
)
3264 return gdbarch_data (gdbarch
, gdbtypes_data
);
3268 gdbtypes_post_init (struct gdbarch
*gdbarch
)
3270 struct builtin_type
*builtin_type
3271 = GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct builtin_type
);
3274 builtin_type
->builtin_void
3275 = arch_type (gdbarch
, TYPE_CODE_VOID
, 1, "void");
3276 builtin_type
->builtin_char
3277 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3278 !gdbarch_char_signed (gdbarch
), "char");
3279 builtin_type
->builtin_signed_char
3280 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3282 builtin_type
->builtin_unsigned_char
3283 = arch_integer_type (gdbarch
, TARGET_CHAR_BIT
,
3284 1, "unsigned char");
3285 builtin_type
->builtin_short
3286 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
3288 builtin_type
->builtin_unsigned_short
3289 = arch_integer_type (gdbarch
, gdbarch_short_bit (gdbarch
),
3290 1, "unsigned short");
3291 builtin_type
->builtin_int
3292 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
3294 builtin_type
->builtin_unsigned_int
3295 = arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
3297 builtin_type
->builtin_long
3298 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
3300 builtin_type
->builtin_unsigned_long
3301 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
3302 1, "unsigned long");
3303 builtin_type
->builtin_long_long
3304 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
3306 builtin_type
->builtin_unsigned_long_long
3307 = arch_integer_type (gdbarch
, gdbarch_long_long_bit (gdbarch
),
3308 1, "unsigned long long");
3309 builtin_type
->builtin_float
3310 = arch_float_type (gdbarch
, gdbarch_float_bit (gdbarch
),
3311 "float", gdbarch_float_format (gdbarch
));
3312 builtin_type
->builtin_double
3313 = arch_float_type (gdbarch
, gdbarch_double_bit (gdbarch
),
3314 "double", gdbarch_double_format (gdbarch
));
3315 builtin_type
->builtin_long_double
3316 = arch_float_type (gdbarch
, gdbarch_long_double_bit (gdbarch
),
3317 "long double", gdbarch_long_double_format (gdbarch
));
3318 builtin_type
->builtin_complex
3319 = arch_complex_type (gdbarch
, "complex",
3320 builtin_type
->builtin_float
);
3321 builtin_type
->builtin_double_complex
3322 = arch_complex_type (gdbarch
, "double complex",
3323 builtin_type
->builtin_double
);
3324 builtin_type
->builtin_string
3325 = arch_type (gdbarch
, TYPE_CODE_STRING
, 1, "string");
3326 builtin_type
->builtin_bool
3327 = arch_type (gdbarch
, TYPE_CODE_BOOL
, 1, "bool");
3329 /* The following three are about decimal floating point types, which
3330 are 32-bits, 64-bits and 128-bits respectively. */
3331 builtin_type
->builtin_decfloat
3332 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 32 / 8, "_Decimal32");
3333 builtin_type
->builtin_decdouble
3334 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 64 / 8, "_Decimal64");
3335 builtin_type
->builtin_declong
3336 = arch_type (gdbarch
, TYPE_CODE_DECFLOAT
, 128 / 8, "_Decimal128");
3338 /* "True" character types. */
3339 builtin_type
->builtin_true_char
3340 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 0, "true character");
3341 builtin_type
->builtin_true_unsigned_char
3342 = arch_character_type (gdbarch
, TARGET_CHAR_BIT
, 1, "true character");
3344 /* Fixed-size integer types. */
3345 builtin_type
->builtin_int0
3346 = arch_integer_type (gdbarch
, 0, 0, "int0_t");
3347 builtin_type
->builtin_int8
3348 = arch_integer_type (gdbarch
, 8, 0, "int8_t");
3349 builtin_type
->builtin_uint8
3350 = arch_integer_type (gdbarch
, 8, 1, "uint8_t");
3351 builtin_type
->builtin_int16
3352 = arch_integer_type (gdbarch
, 16, 0, "int16_t");
3353 builtin_type
->builtin_uint16
3354 = arch_integer_type (gdbarch
, 16, 1, "uint16_t");
3355 builtin_type
->builtin_int32
3356 = arch_integer_type (gdbarch
, 32, 0, "int32_t");
3357 builtin_type
->builtin_uint32
3358 = arch_integer_type (gdbarch
, 32, 1, "uint32_t");
3359 builtin_type
->builtin_int64
3360 = arch_integer_type (gdbarch
, 64, 0, "int64_t");
3361 builtin_type
->builtin_uint64
3362 = arch_integer_type (gdbarch
, 64, 1, "uint64_t");
3363 builtin_type
->builtin_int128
3364 = arch_integer_type (gdbarch
, 128, 0, "int128_t");
3365 builtin_type
->builtin_uint128
3366 = arch_integer_type (gdbarch
, 128, 1, "uint128_t");
3367 TYPE_NOTTEXT (builtin_type
->builtin_int8
) = 1;
3368 TYPE_NOTTEXT (builtin_type
->builtin_uint8
) = 1;
3370 /* Default data/code pointer types. */
3371 builtin_type
->builtin_data_ptr
3372 = lookup_pointer_type (builtin_type
->builtin_void
);
3373 builtin_type
->builtin_func_ptr
3374 = lookup_pointer_type (lookup_function_type (builtin_type
->builtin_void
));
3376 /* This type represents a GDB internal function. */
3377 builtin_type
->internal_fn
3378 = arch_type (gdbarch
, TYPE_CODE_INTERNAL_FUNCTION
, 0,
3379 "<internal function>");
3381 return builtin_type
;
3385 /* This set of objfile-based types is intended to be used by symbol
3386 readers as basic types. */
3388 static const struct objfile_data
*objfile_type_data
;
3390 const struct objfile_type
*
3391 objfile_type (struct objfile
*objfile
)
3393 struct gdbarch
*gdbarch
;
3394 struct objfile_type
*objfile_type
3395 = objfile_data (objfile
, objfile_type_data
);
3398 return objfile_type
;
3400 objfile_type
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
3401 1, struct objfile_type
);
3403 /* Use the objfile architecture to determine basic type properties. */
3404 gdbarch
= get_objfile_arch (objfile
);
3407 objfile_type
->builtin_void
3408 = init_type (TYPE_CODE_VOID
, 1,
3412 objfile_type
->builtin_char
3413 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3415 | (gdbarch_char_signed (gdbarch
) ? 0 : TYPE_FLAG_UNSIGNED
)),
3417 objfile_type
->builtin_signed_char
3418 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3420 "signed char", objfile
);
3421 objfile_type
->builtin_unsigned_char
3422 = init_type (TYPE_CODE_INT
, TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3424 "unsigned char", objfile
);
3425 objfile_type
->builtin_short
3426 = init_type (TYPE_CODE_INT
,
3427 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3428 0, "short", objfile
);
3429 objfile_type
->builtin_unsigned_short
3430 = init_type (TYPE_CODE_INT
,
3431 gdbarch_short_bit (gdbarch
) / TARGET_CHAR_BIT
,
3432 TYPE_FLAG_UNSIGNED
, "unsigned short", objfile
);
3433 objfile_type
->builtin_int
3434 = init_type (TYPE_CODE_INT
,
3435 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3437 objfile_type
->builtin_unsigned_int
3438 = init_type (TYPE_CODE_INT
,
3439 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
,
3440 TYPE_FLAG_UNSIGNED
, "unsigned int", objfile
);
3441 objfile_type
->builtin_long
3442 = init_type (TYPE_CODE_INT
,
3443 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3444 0, "long", objfile
);
3445 objfile_type
->builtin_unsigned_long
3446 = init_type (TYPE_CODE_INT
,
3447 gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3448 TYPE_FLAG_UNSIGNED
, "unsigned long", objfile
);
3449 objfile_type
->builtin_long_long
3450 = init_type (TYPE_CODE_INT
,
3451 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3452 0, "long long", objfile
);
3453 objfile_type
->builtin_unsigned_long_long
3454 = init_type (TYPE_CODE_INT
,
3455 gdbarch_long_long_bit (gdbarch
) / TARGET_CHAR_BIT
,
3456 TYPE_FLAG_UNSIGNED
, "unsigned long long", objfile
);
3458 objfile_type
->builtin_float
3459 = init_type (TYPE_CODE_FLT
,
3460 gdbarch_float_bit (gdbarch
) / TARGET_CHAR_BIT
,
3461 0, "float", objfile
);
3462 TYPE_FLOATFORMAT (objfile_type
->builtin_float
)
3463 = gdbarch_float_format (gdbarch
);
3464 objfile_type
->builtin_double
3465 = init_type (TYPE_CODE_FLT
,
3466 gdbarch_double_bit (gdbarch
) / TARGET_CHAR_BIT
,
3467 0, "double", objfile
);
3468 TYPE_FLOATFORMAT (objfile_type
->builtin_double
)
3469 = gdbarch_double_format (gdbarch
);
3470 objfile_type
->builtin_long_double
3471 = init_type (TYPE_CODE_FLT
,
3472 gdbarch_long_double_bit (gdbarch
) / TARGET_CHAR_BIT
,
3473 0, "long double", objfile
);
3474 TYPE_FLOATFORMAT (objfile_type
->builtin_long_double
)
3475 = gdbarch_long_double_format (gdbarch
);
3477 /* This type represents a type that was unrecognized in symbol read-in. */
3478 objfile_type
->builtin_error
3479 = init_type (TYPE_CODE_ERROR
, 0, 0, "<unknown type>", objfile
);
3481 /* The following set of types is used for symbols with no
3482 debug information. */
3483 objfile_type
->nodebug_text_symbol
3484 = init_type (TYPE_CODE_FUNC
, 1, 0,
3485 "<text variable, no debug info>", objfile
);
3486 TYPE_TARGET_TYPE (objfile_type
->nodebug_text_symbol
)
3487 = objfile_type
->builtin_int
;
3488 objfile_type
->nodebug_data_symbol
3489 = init_type (TYPE_CODE_INT
,
3490 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3491 "<data variable, no debug info>", objfile
);
3492 objfile_type
->nodebug_unknown_symbol
3493 = init_type (TYPE_CODE_INT
, 1, 0,
3494 "<variable (not text or data), no debug info>", objfile
);
3495 objfile_type
->nodebug_tls_symbol
3496 = init_type (TYPE_CODE_INT
,
3497 gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
, 0,
3498 "<thread local variable, no debug info>", objfile
);
3500 /* NOTE: on some targets, addresses and pointers are not necessarily
3501 the same --- for example, on the D10V, pointers are 16 bits long,
3502 but addresses are 32 bits long. See doc/gdbint.texinfo,
3503 ``Pointers Are Not Always Addresses''.
3506 - gdb's `struct type' always describes the target's
3508 - gdb's `struct value' objects should always hold values in
3510 - gdb's CORE_ADDR values are addresses in the unified virtual
3511 address space that the assembler and linker work with. Thus,
3512 since target_read_memory takes a CORE_ADDR as an argument, it
3513 can access any memory on the target, even if the processor has
3514 separate code and data address spaces.
3517 - If v is a value holding a D10V code pointer, its contents are
3518 in target form: a big-endian address left-shifted two bits.
3519 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3520 sizeof (void *) == 2 on the target.
3522 In this context, objfile_type->builtin_core_addr is a bit odd:
3523 it's a target type for a value the target will never see. It's
3524 only used to hold the values of (typeless) linker symbols, which
3525 are indeed in the unified virtual address space. */
3527 objfile_type
->builtin_core_addr
3528 = init_type (TYPE_CODE_INT
,
3529 gdbarch_addr_bit (gdbarch
) / 8,
3530 TYPE_FLAG_UNSIGNED
, "__CORE_ADDR", objfile
);
3532 set_objfile_data (objfile
, objfile_type_data
, objfile_type
);
3533 return objfile_type
;
3537 extern void _initialize_gdbtypes (void);
3539 _initialize_gdbtypes (void)
3541 gdbtypes_data
= gdbarch_data_register_post_init (gdbtypes_post_init
);
3542 objfile_type_data
= register_objfile_data ();
3544 add_setshow_zinteger_cmd ("overload", no_class
, &overload_debug
, _("\
3545 Set debugging of C++ overloading."), _("\
3546 Show debugging of C++ overloading."), _("\
3547 When enabled, ranking of the functions is displayed."),
3549 show_overload_debug
,
3550 &setdebuglist
, &showdebuglist
);
3552 /* Add user knob for controlling resolution of opaque types. */
3553 add_setshow_boolean_cmd ("opaque-type-resolution", class_support
,
3554 &opaque_type_resolution
, _("\
3555 Set resolution of opaque struct/class/union types (if set before loading symbols)."), _("\
3556 Show resolution of opaque struct/class/union types (if set before loading symbols)."), NULL
,
3558 show_opaque_type_resolution
,
3559 &setlist
, &showlist
);