2011-01-07 Michael Snyder <msnyder@vmware.com>
[deliverable/binutils-gdb.git] / gdb / gdbtypes.c
CommitLineData
c906108c 1/* Support routines for manipulating internal types for GDB.
4f2aea11 2
9b254dd1 3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
7b6bb8da 4 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4c38e0a4 5 Free Software Foundation, Inc.
4f2aea11 6
c906108c
SS
7 Contributed by Cygnus Support, using pieces from other GDB modules.
8
c5aa993b 9 This file is part of GDB.
c906108c 10
c5aa993b
JM
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
a9762ec7 13 the Free Software Foundation; either version 3 of the License, or
c5aa993b 14 (at your option) any later version.
c906108c 15
c5aa993b
JM
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.
c906108c 20
c5aa993b 21 You should have received a copy of the GNU General Public License
a9762ec7 22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
23
24#include "defs.h"
25#include "gdb_string.h"
26#include "bfd.h"
27#include "symtab.h"
28#include "symfile.h"
29#include "objfiles.h"
30#include "gdbtypes.h"
31#include "expression.h"
32#include "language.h"
33#include "target.h"
34#include "value.h"
35#include "demangle.h"
36#include "complaints.h"
37#include "gdbcmd.h"
c91ecb25 38#include "wrapper.h"
015a42b4 39#include "cp-abi.h"
a02fd225 40#include "gdb_assert.h"
ae5a43e0 41#include "hashtab.h"
c906108c 42
ac3aafc7 43
6403aeea
SW
44/* Initialize BADNESS constants. */
45
a9d5ef47 46const struct rank LENGTH_MISMATCH_BADNESS = {100,0};
6403aeea 47
a9d5ef47
SW
48const struct rank TOO_FEW_PARAMS_BADNESS = {100,0};
49const struct rank INCOMPATIBLE_TYPE_BADNESS = {100,0};
6403aeea 50
a9d5ef47 51const struct rank EXACT_MATCH_BADNESS = {0,0};
6403aeea 52
a9d5ef47
SW
53const struct rank INTEGER_PROMOTION_BADNESS = {1,0};
54const struct rank FLOAT_PROMOTION_BADNESS = {1,0};
55const struct rank BASE_PTR_CONVERSION_BADNESS = {1,0};
56const struct rank INTEGER_CONVERSION_BADNESS = {2,0};
57const struct rank FLOAT_CONVERSION_BADNESS = {2,0};
58const struct rank INT_FLOAT_CONVERSION_BADNESS = {2,0};
59const struct rank VOID_PTR_CONVERSION_BADNESS = {2,0};
60const struct rank BOOL_PTR_CONVERSION_BADNESS = {3,0};
61const struct rank BASE_CONVERSION_BADNESS = {2,0};
62const struct rank REFERENCE_CONVERSION_BADNESS = {2,0};
6403aeea 63
a9d5ef47 64const struct rank NS_POINTER_CONVERSION_BADNESS = {10,0};
6403aeea 65
8da61cc4 66/* Floatformat pairs. */
f9e9243a
UW
67const struct floatformat *floatformats_ieee_half[BFD_ENDIAN_UNKNOWN] = {
68 &floatformat_ieee_half_big,
69 &floatformat_ieee_half_little
70};
8da61cc4
DJ
71const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN] = {
72 &floatformat_ieee_single_big,
73 &floatformat_ieee_single_little
74};
75const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN] = {
76 &floatformat_ieee_double_big,
77 &floatformat_ieee_double_little
78};
79const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN] = {
80 &floatformat_ieee_double_big,
81 &floatformat_ieee_double_littlebyte_bigword
82};
83const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN] = {
84 &floatformat_i387_ext,
85 &floatformat_i387_ext
86};
87const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN] = {
88 &floatformat_m68881_ext,
89 &floatformat_m68881_ext
90};
91const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN] = {
92 &floatformat_arm_ext_big,
93 &floatformat_arm_ext_littlebyte_bigword
94};
95const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN] = {
96 &floatformat_ia64_spill_big,
97 &floatformat_ia64_spill_little
98};
99const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN] = {
100 &floatformat_ia64_quad_big,
101 &floatformat_ia64_quad_little
102};
103const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN] = {
104 &floatformat_vax_f,
105 &floatformat_vax_f
106};
107const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN] = {
108 &floatformat_vax_d,
109 &floatformat_vax_d
110};
b14d30e1
JM
111const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN] = {
112 &floatformat_ibm_long_double,
113 &floatformat_ibm_long_double
114};
8da61cc4 115
8da61cc4 116
c906108c 117int opaque_type_resolution = 1;
920d2a44
AC
118static void
119show_opaque_type_resolution (struct ui_file *file, int from_tty,
7ba81444
MS
120 struct cmd_list_element *c,
121 const char *value)
920d2a44 122{
3e43a32a
MS
123 fprintf_filtered (file, _("Resolution of opaque struct/class/union types "
124 "(if set before loading symbols) is %s.\n"),
920d2a44
AC
125 value);
126}
127
5d161b24 128int overload_debug = 0;
920d2a44
AC
129static void
130show_overload_debug (struct ui_file *file, int from_tty,
131 struct cmd_list_element *c, const char *value)
132{
7ba81444
MS
133 fprintf_filtered (file, _("Debugging of C++ overloading is %s.\n"),
134 value);
920d2a44 135}
c906108c 136
c5aa993b
JM
137struct extra
138 {
139 char str[128];
140 int len;
7ba81444 141 }; /* Maximum extension is 128! FIXME */
c906108c 142
a14ed312 143static void print_bit_vector (B_TYPE *, int);
ad2f7632 144static void print_arg_types (struct field *, int, int);
a14ed312
KB
145static void dump_fn_fieldlists (struct type *, int);
146static void print_cplus_stuff (struct type *, int);
7a292a7a 147
c906108c 148
e9bb382b
UW
149/* Allocate a new OBJFILE-associated type structure and fill it
150 with some defaults. Space for the type structure is allocated
151 on the objfile's objfile_obstack. */
c906108c
SS
152
153struct type *
fba45db2 154alloc_type (struct objfile *objfile)
c906108c 155{
52f0bd74 156 struct type *type;
c906108c 157
e9bb382b
UW
158 gdb_assert (objfile != NULL);
159
7ba81444 160 /* Alloc the structure and start off with all fields zeroed. */
e9bb382b
UW
161 type = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct type);
162 TYPE_MAIN_TYPE (type) = OBSTACK_ZALLOC (&objfile->objfile_obstack,
163 struct main_type);
164 OBJSTAT (objfile, n_types++);
c906108c 165
e9bb382b
UW
166 TYPE_OBJFILE_OWNED (type) = 1;
167 TYPE_OWNER (type).objfile = objfile;
c906108c 168
7ba81444 169 /* Initialize the fields that might not be zero. */
c906108c
SS
170
171 TYPE_CODE (type) = TYPE_CODE_UNDEF;
c906108c 172 TYPE_VPTR_FIELDNO (type) = -1;
2fdde8f8 173 TYPE_CHAIN (type) = type; /* Chain back to itself. */
c906108c 174
c16abbde 175 return type;
c906108c
SS
176}
177
e9bb382b
UW
178/* Allocate a new GDBARCH-associated type structure and fill it
179 with some defaults. Space for the type structure is allocated
180 on the heap. */
181
182struct type *
183alloc_type_arch (struct gdbarch *gdbarch)
184{
185 struct type *type;
186
187 gdb_assert (gdbarch != NULL);
188
189 /* Alloc the structure and start off with all fields zeroed. */
190
191 type = XZALLOC (struct type);
192 TYPE_MAIN_TYPE (type) = XZALLOC (struct main_type);
193
194 TYPE_OBJFILE_OWNED (type) = 0;
195 TYPE_OWNER (type).gdbarch = gdbarch;
196
197 /* Initialize the fields that might not be zero. */
198
199 TYPE_CODE (type) = TYPE_CODE_UNDEF;
200 TYPE_VPTR_FIELDNO (type) = -1;
201 TYPE_CHAIN (type) = type; /* Chain back to itself. */
202
203 return type;
204}
205
206/* If TYPE is objfile-associated, allocate a new type structure
207 associated with the same objfile. If TYPE is gdbarch-associated,
208 allocate a new type structure associated with the same gdbarch. */
209
210struct type *
211alloc_type_copy (const struct type *type)
212{
213 if (TYPE_OBJFILE_OWNED (type))
214 return alloc_type (TYPE_OWNER (type).objfile);
215 else
216 return alloc_type_arch (TYPE_OWNER (type).gdbarch);
217}
218
219/* If TYPE is gdbarch-associated, return that architecture.
220 If TYPE is objfile-associated, return that objfile's architecture. */
221
222struct gdbarch *
223get_type_arch (const struct type *type)
224{
225 if (TYPE_OBJFILE_OWNED (type))
226 return get_objfile_arch (TYPE_OWNER (type).objfile);
227 else
228 return TYPE_OWNER (type).gdbarch;
229}
230
231
2fdde8f8
DJ
232/* Alloc a new type instance structure, fill it with some defaults,
233 and point it at OLDTYPE. Allocate the new type instance from the
234 same place as OLDTYPE. */
235
236static struct type *
237alloc_type_instance (struct type *oldtype)
238{
239 struct type *type;
240
241 /* Allocate the structure. */
242
e9bb382b 243 if (! TYPE_OBJFILE_OWNED (oldtype))
1deafd4e 244 type = XZALLOC (struct type);
2fdde8f8 245 else
1deafd4e
PA
246 type = OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype)->objfile_obstack,
247 struct type);
248
2fdde8f8
DJ
249 TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype);
250
251 TYPE_CHAIN (type) = type; /* Chain back to itself for now. */
252
c16abbde 253 return type;
2fdde8f8
DJ
254}
255
256/* Clear all remnants of the previous type at TYPE, in preparation for
e9bb382b 257 replacing it with something else. Preserve owner information. */
2fdde8f8
DJ
258static void
259smash_type (struct type *type)
260{
e9bb382b
UW
261 int objfile_owned = TYPE_OBJFILE_OWNED (type);
262 union type_owner owner = TYPE_OWNER (type);
263
2fdde8f8
DJ
264 memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
265
e9bb382b
UW
266 /* Restore owner information. */
267 TYPE_OBJFILE_OWNED (type) = objfile_owned;
268 TYPE_OWNER (type) = owner;
269
2fdde8f8
DJ
270 /* For now, delete the rings. */
271 TYPE_CHAIN (type) = type;
272
273 /* For now, leave the pointer/reference types alone. */
274}
275
c906108c
SS
276/* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
277 to a pointer to memory where the pointer type should be stored.
278 If *TYPEPTR is zero, update it to point to the pointer type we return.
279 We allocate new memory if needed. */
280
281struct type *
fba45db2 282make_pointer_type (struct type *type, struct type **typeptr)
c906108c 283{
52f0bd74 284 struct type *ntype; /* New type */
053cb41b 285 struct type *chain;
c906108c
SS
286
287 ntype = TYPE_POINTER_TYPE (type);
288
c5aa993b 289 if (ntype)
c906108c 290 {
c5aa993b 291 if (typeptr == 0)
7ba81444
MS
292 return ntype; /* Don't care about alloc,
293 and have new type. */
c906108c 294 else if (*typeptr == 0)
c5aa993b 295 {
7ba81444 296 *typeptr = ntype; /* Tracking alloc, and have new type. */
c906108c 297 return ntype;
c5aa993b 298 }
c906108c
SS
299 }
300
301 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
302 {
e9bb382b 303 ntype = alloc_type_copy (type);
c906108c
SS
304 if (typeptr)
305 *typeptr = ntype;
306 }
7ba81444 307 else /* We have storage, but need to reset it. */
c906108c
SS
308 {
309 ntype = *typeptr;
053cb41b 310 chain = TYPE_CHAIN (ntype);
2fdde8f8 311 smash_type (ntype);
053cb41b 312 TYPE_CHAIN (ntype) = chain;
c906108c
SS
313 }
314
315 TYPE_TARGET_TYPE (ntype) = type;
316 TYPE_POINTER_TYPE (type) = ntype;
317
7ba81444
MS
318 /* FIXME! Assume the machine has only one representation for
319 pointers! */
c906108c 320
50810684
UW
321 TYPE_LENGTH (ntype)
322 = gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
c906108c
SS
323 TYPE_CODE (ntype) = TYPE_CODE_PTR;
324
67b2adb2 325 /* Mark pointers as unsigned. The target converts between pointers
76e71323 326 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
7ba81444 327 gdbarch_address_to_pointer. */
876cecd0 328 TYPE_UNSIGNED (ntype) = 1;
c5aa993b 329
c906108c
SS
330 if (!TYPE_POINTER_TYPE (type)) /* Remember it, if don't have one. */
331 TYPE_POINTER_TYPE (type) = ntype;
332
053cb41b
JB
333 /* Update the length of all the other variants of this type. */
334 chain = TYPE_CHAIN (ntype);
335 while (chain != ntype)
336 {
337 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
338 chain = TYPE_CHAIN (chain);
339 }
340
c906108c
SS
341 return ntype;
342}
343
344/* Given a type TYPE, return a type of pointers to that type.
345 May need to construct such a type if this is the first use. */
346
347struct type *
fba45db2 348lookup_pointer_type (struct type *type)
c906108c 349{
c5aa993b 350 return make_pointer_type (type, (struct type **) 0);
c906108c
SS
351}
352
7ba81444
MS
353/* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
354 points to a pointer to memory where the reference type should be
355 stored. If *TYPEPTR is zero, update it to point to the reference
356 type we return. We allocate new memory if needed. */
c906108c
SS
357
358struct type *
fba45db2 359make_reference_type (struct type *type, struct type **typeptr)
c906108c 360{
52f0bd74 361 struct type *ntype; /* New type */
1e98b326 362 struct type *chain;
c906108c
SS
363
364 ntype = TYPE_REFERENCE_TYPE (type);
365
c5aa993b 366 if (ntype)
c906108c 367 {
c5aa993b 368 if (typeptr == 0)
7ba81444
MS
369 return ntype; /* Don't care about alloc,
370 and have new type. */
c906108c 371 else if (*typeptr == 0)
c5aa993b 372 {
7ba81444 373 *typeptr = ntype; /* Tracking alloc, and have new type. */
c906108c 374 return ntype;
c5aa993b 375 }
c906108c
SS
376 }
377
378 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
379 {
e9bb382b 380 ntype = alloc_type_copy (type);
c906108c
SS
381 if (typeptr)
382 *typeptr = ntype;
383 }
7ba81444 384 else /* We have storage, but need to reset it. */
c906108c
SS
385 {
386 ntype = *typeptr;
1e98b326 387 chain = TYPE_CHAIN (ntype);
2fdde8f8 388 smash_type (ntype);
1e98b326 389 TYPE_CHAIN (ntype) = chain;
c906108c
SS
390 }
391
392 TYPE_TARGET_TYPE (ntype) = type;
393 TYPE_REFERENCE_TYPE (type) = ntype;
394
7ba81444
MS
395 /* FIXME! Assume the machine has only one representation for
396 references, and that it matches the (only) representation for
397 pointers! */
c906108c 398
50810684
UW
399 TYPE_LENGTH (ntype) =
400 gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
c906108c 401 TYPE_CODE (ntype) = TYPE_CODE_REF;
c5aa993b 402
c906108c
SS
403 if (!TYPE_REFERENCE_TYPE (type)) /* Remember it, if don't have one. */
404 TYPE_REFERENCE_TYPE (type) = ntype;
405
1e98b326
JB
406 /* Update the length of all the other variants of this type. */
407 chain = TYPE_CHAIN (ntype);
408 while (chain != ntype)
409 {
410 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
411 chain = TYPE_CHAIN (chain);
412 }
413
c906108c
SS
414 return ntype;
415}
416
7ba81444
MS
417/* Same as above, but caller doesn't care about memory allocation
418 details. */
c906108c
SS
419
420struct type *
fba45db2 421lookup_reference_type (struct type *type)
c906108c 422{
c5aa993b 423 return make_reference_type (type, (struct type **) 0);
c906108c
SS
424}
425
7ba81444
MS
426/* Lookup a function type that returns type TYPE. TYPEPTR, if
427 nonzero, points to a pointer to memory where the function type
428 should be stored. If *TYPEPTR is zero, update it to point to the
0c8b41f1 429 function type we return. We allocate new memory if needed. */
c906108c
SS
430
431struct type *
0c8b41f1 432make_function_type (struct type *type, struct type **typeptr)
c906108c 433{
52f0bd74 434 struct type *ntype; /* New type */
c906108c
SS
435
436 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
437 {
e9bb382b 438 ntype = alloc_type_copy (type);
c906108c
SS
439 if (typeptr)
440 *typeptr = ntype;
441 }
7ba81444 442 else /* We have storage, but need to reset it. */
c906108c
SS
443 {
444 ntype = *typeptr;
2fdde8f8 445 smash_type (ntype);
c906108c
SS
446 }
447
448 TYPE_TARGET_TYPE (ntype) = type;
449
450 TYPE_LENGTH (ntype) = 1;
451 TYPE_CODE (ntype) = TYPE_CODE_FUNC;
c5aa993b 452
c906108c
SS
453 return ntype;
454}
455
456
457/* Given a type TYPE, return a type of functions that return that type.
458 May need to construct such a type if this is the first use. */
459
460struct type *
fba45db2 461lookup_function_type (struct type *type)
c906108c 462{
0c8b41f1 463 return make_function_type (type, (struct type **) 0);
c906108c
SS
464}
465
47663de5
MS
466/* Identify address space identifier by name --
467 return the integer flag defined in gdbtypes.h. */
468extern int
50810684 469address_space_name_to_int (struct gdbarch *gdbarch, char *space_identifier)
47663de5 470{
8b2dbe47 471 int type_flags;
d8734c88 472
7ba81444 473 /* Check for known address space delimiters. */
47663de5 474 if (!strcmp (space_identifier, "code"))
876cecd0 475 return TYPE_INSTANCE_FLAG_CODE_SPACE;
47663de5 476 else if (!strcmp (space_identifier, "data"))
876cecd0 477 return TYPE_INSTANCE_FLAG_DATA_SPACE;
5f11f355
AC
478 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch)
479 && gdbarch_address_class_name_to_type_flags (gdbarch,
480 space_identifier,
481 &type_flags))
8b2dbe47 482 return type_flags;
47663de5 483 else
8a3fe4f8 484 error (_("Unknown address space specifier: \"%s\""), space_identifier);
47663de5
MS
485}
486
487/* Identify address space identifier by integer flag as defined in
7ba81444 488 gdbtypes.h -- return the string version of the adress space name. */
47663de5 489
321432c0 490const char *
50810684 491address_space_int_to_name (struct gdbarch *gdbarch, int space_flag)
47663de5 492{
876cecd0 493 if (space_flag & TYPE_INSTANCE_FLAG_CODE_SPACE)
47663de5 494 return "code";
876cecd0 495 else if (space_flag & TYPE_INSTANCE_FLAG_DATA_SPACE)
47663de5 496 return "data";
876cecd0 497 else if ((space_flag & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
5f11f355
AC
498 && gdbarch_address_class_type_flags_to_name_p (gdbarch))
499 return gdbarch_address_class_type_flags_to_name (gdbarch, space_flag);
47663de5
MS
500 else
501 return NULL;
502}
503
2fdde8f8 504/* Create a new type with instance flags NEW_FLAGS, based on TYPE.
ad766c0a
JB
505
506 If STORAGE is non-NULL, create the new type instance there.
507 STORAGE must be in the same obstack as TYPE. */
47663de5 508
b9362cc7 509static struct type *
2fdde8f8
DJ
510make_qualified_type (struct type *type, int new_flags,
511 struct type *storage)
47663de5
MS
512{
513 struct type *ntype;
514
515 ntype = type;
5f61c20e
JK
516 do
517 {
518 if (TYPE_INSTANCE_FLAGS (ntype) == new_flags)
519 return ntype;
520 ntype = TYPE_CHAIN (ntype);
521 }
522 while (ntype != type);
47663de5 523
2fdde8f8
DJ
524 /* Create a new type instance. */
525 if (storage == NULL)
526 ntype = alloc_type_instance (type);
527 else
528 {
7ba81444
MS
529 /* If STORAGE was provided, it had better be in the same objfile
530 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
531 if one objfile is freed and the other kept, we'd have
532 dangling pointers. */
ad766c0a
JB
533 gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage));
534
2fdde8f8
DJ
535 ntype = storage;
536 TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type);
537 TYPE_CHAIN (ntype) = ntype;
538 }
47663de5
MS
539
540 /* Pointers or references to the original type are not relevant to
2fdde8f8 541 the new type. */
47663de5
MS
542 TYPE_POINTER_TYPE (ntype) = (struct type *) 0;
543 TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0;
47663de5 544
2fdde8f8
DJ
545 /* Chain the new qualified type to the old type. */
546 TYPE_CHAIN (ntype) = TYPE_CHAIN (type);
547 TYPE_CHAIN (type) = ntype;
548
549 /* Now set the instance flags and return the new type. */
550 TYPE_INSTANCE_FLAGS (ntype) = new_flags;
47663de5 551
ab5d3da6
KB
552 /* Set length of new type to that of the original type. */
553 TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
554
47663de5
MS
555 return ntype;
556}
557
2fdde8f8
DJ
558/* Make an address-space-delimited variant of a type -- a type that
559 is identical to the one supplied except that it has an address
560 space attribute attached to it (such as "code" or "data").
561
7ba81444
MS
562 The space attributes "code" and "data" are for Harvard
563 architectures. The address space attributes are for architectures
564 which have alternately sized pointers or pointers with alternate
565 representations. */
2fdde8f8
DJ
566
567struct type *
568make_type_with_address_space (struct type *type, int space_flag)
569{
2fdde8f8 570 int new_flags = ((TYPE_INSTANCE_FLAGS (type)
876cecd0
TT
571 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
572 | TYPE_INSTANCE_FLAG_DATA_SPACE
573 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL))
2fdde8f8
DJ
574 | space_flag);
575
576 return make_qualified_type (type, new_flags, NULL);
577}
c906108c
SS
578
579/* Make a "c-v" variant of a type -- a type that is identical to the
580 one supplied except that it may have const or volatile attributes
581 CNST is a flag for setting the const attribute
582 VOLTL is a flag for setting the volatile attribute
583 TYPE is the base type whose variant we are creating.
c906108c 584
ad766c0a
JB
585 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
586 storage to hold the new qualified type; *TYPEPTR and TYPE must be
587 in the same objfile. Otherwise, allocate fresh memory for the new
588 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
589 new type we construct. */
c906108c 590struct type *
7ba81444
MS
591make_cv_type (int cnst, int voltl,
592 struct type *type,
593 struct type **typeptr)
c906108c 594{
52f0bd74 595 struct type *ntype; /* New type */
c906108c 596
2fdde8f8 597 int new_flags = (TYPE_INSTANCE_FLAGS (type)
308d96ed
MS
598 & ~(TYPE_INSTANCE_FLAG_CONST
599 | TYPE_INSTANCE_FLAG_VOLATILE));
c906108c 600
c906108c 601 if (cnst)
876cecd0 602 new_flags |= TYPE_INSTANCE_FLAG_CONST;
c906108c
SS
603
604 if (voltl)
876cecd0 605 new_flags |= TYPE_INSTANCE_FLAG_VOLATILE;
a02fd225 606
2fdde8f8 607 if (typeptr && *typeptr != NULL)
a02fd225 608 {
ad766c0a
JB
609 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
610 a C-V variant chain that threads across objfiles: if one
611 objfile gets freed, then the other has a broken C-V chain.
612
613 This code used to try to copy over the main type from TYPE to
614 *TYPEPTR if they were in different objfiles, but that's
615 wrong, too: TYPE may have a field list or member function
616 lists, which refer to types of their own, etc. etc. The
617 whole shebang would need to be copied over recursively; you
618 can't have inter-objfile pointers. The only thing to do is
619 to leave stub types as stub types, and look them up afresh by
620 name each time you encounter them. */
621 gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type));
2fdde8f8
DJ
622 }
623
7ba81444
MS
624 ntype = make_qualified_type (type, new_flags,
625 typeptr ? *typeptr : NULL);
c906108c 626
2fdde8f8
DJ
627 if (typeptr != NULL)
628 *typeptr = ntype;
a02fd225 629
2fdde8f8 630 return ntype;
a02fd225 631}
c906108c 632
2fdde8f8
DJ
633/* Replace the contents of ntype with the type *type. This changes the
634 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
635 the changes are propogated to all types in the TYPE_CHAIN.
dd6bda65 636
cda6c68a
JB
637 In order to build recursive types, it's inevitable that we'll need
638 to update types in place --- but this sort of indiscriminate
639 smashing is ugly, and needs to be replaced with something more
2fdde8f8
DJ
640 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
641 clear if more steps are needed. */
dd6bda65
DJ
642void
643replace_type (struct type *ntype, struct type *type)
644{
ab5d3da6 645 struct type *chain;
dd6bda65 646
ad766c0a
JB
647 /* These two types had better be in the same objfile. Otherwise,
648 the assignment of one type's main type structure to the other
649 will produce a type with references to objects (names; field
650 lists; etc.) allocated on an objfile other than its own. */
651 gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (ntype));
652
2fdde8f8 653 *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
dd6bda65 654
7ba81444
MS
655 /* The type length is not a part of the main type. Update it for
656 each type on the variant chain. */
ab5d3da6 657 chain = ntype;
5f61c20e
JK
658 do
659 {
660 /* Assert that this element of the chain has no address-class bits
661 set in its flags. Such type variants might have type lengths
662 which are supposed to be different from the non-address-class
663 variants. This assertion shouldn't ever be triggered because
664 symbol readers which do construct address-class variants don't
665 call replace_type(). */
666 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0);
667
668 TYPE_LENGTH (chain) = TYPE_LENGTH (type);
669 chain = TYPE_CHAIN (chain);
670 }
671 while (ntype != chain);
ab5d3da6 672
2fdde8f8
DJ
673 /* Assert that the two types have equivalent instance qualifiers.
674 This should be true for at least all of our debug readers. */
675 gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type));
dd6bda65
DJ
676}
677
c906108c
SS
678/* Implement direct support for MEMBER_TYPE in GNU C++.
679 May need to construct such a type if this is the first use.
680 The TYPE is the type of the member. The DOMAIN is the type
681 of the aggregate that the member belongs to. */
682
683struct type *
0d5de010 684lookup_memberptr_type (struct type *type, struct type *domain)
c906108c 685{
52f0bd74 686 struct type *mtype;
c906108c 687
e9bb382b 688 mtype = alloc_type_copy (type);
0d5de010 689 smash_to_memberptr_type (mtype, domain, type);
c16abbde 690 return mtype;
c906108c
SS
691}
692
0d5de010
DJ
693/* Return a pointer-to-method type, for a method of type TO_TYPE. */
694
695struct type *
696lookup_methodptr_type (struct type *to_type)
697{
698 struct type *mtype;
699
e9bb382b 700 mtype = alloc_type_copy (to_type);
0b92b5bb 701 smash_to_methodptr_type (mtype, to_type);
0d5de010
DJ
702 return mtype;
703}
704
7ba81444
MS
705/* Allocate a stub method whose return type is TYPE. This apparently
706 happens for speed of symbol reading, since parsing out the
707 arguments to the method is cpu-intensive, the way we are doing it.
708 So, we will fill in arguments later. This always returns a fresh
709 type. */
c906108c
SS
710
711struct type *
fba45db2 712allocate_stub_method (struct type *type)
c906108c
SS
713{
714 struct type *mtype;
715
e9bb382b
UW
716 mtype = alloc_type_copy (type);
717 TYPE_CODE (mtype) = TYPE_CODE_METHOD;
718 TYPE_LENGTH (mtype) = 1;
719 TYPE_STUB (mtype) = 1;
c906108c
SS
720 TYPE_TARGET_TYPE (mtype) = type;
721 /* _DOMAIN_TYPE (mtype) = unknown yet */
c16abbde 722 return mtype;
c906108c
SS
723}
724
7ba81444
MS
725/* Create a range type using either a blank type supplied in
726 RESULT_TYPE, or creating a new type, inheriting the objfile from
727 INDEX_TYPE.
c906108c 728
7ba81444
MS
729 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
730 to HIGH_BOUND, inclusive.
c906108c 731
7ba81444
MS
732 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
733 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
c906108c
SS
734
735struct type *
fba45db2 736create_range_type (struct type *result_type, struct type *index_type,
43bbcdc2 737 LONGEST low_bound, LONGEST high_bound)
c906108c
SS
738{
739 if (result_type == NULL)
e9bb382b 740 result_type = alloc_type_copy (index_type);
c906108c
SS
741 TYPE_CODE (result_type) = TYPE_CODE_RANGE;
742 TYPE_TARGET_TYPE (result_type) = index_type;
74a9bb82 743 if (TYPE_STUB (index_type))
876cecd0 744 TYPE_TARGET_STUB (result_type) = 1;
c906108c
SS
745 else
746 TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
43bbcdc2
PH
747 TYPE_RANGE_DATA (result_type) = (struct range_bounds *)
748 TYPE_ZALLOC (result_type, sizeof (struct range_bounds));
262452ec
JK
749 TYPE_LOW_BOUND (result_type) = low_bound;
750 TYPE_HIGH_BOUND (result_type) = high_bound;
c906108c 751
c5aa993b 752 if (low_bound >= 0)
876cecd0 753 TYPE_UNSIGNED (result_type) = 1;
c906108c 754
262452ec 755 return result_type;
c906108c
SS
756}
757
7ba81444
MS
758/* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
759 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
760 bounds will fit in LONGEST), or -1 otherwise. */
c906108c
SS
761
762int
fba45db2 763get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
c906108c
SS
764{
765 CHECK_TYPEDEF (type);
766 switch (TYPE_CODE (type))
767 {
768 case TYPE_CODE_RANGE:
769 *lowp = TYPE_LOW_BOUND (type);
770 *highp = TYPE_HIGH_BOUND (type);
771 return 1;
772 case TYPE_CODE_ENUM:
773 if (TYPE_NFIELDS (type) > 0)
774 {
775 /* The enums may not be sorted by value, so search all
0963b4bd 776 entries. */
c906108c
SS
777 int i;
778
779 *lowp = *highp = TYPE_FIELD_BITPOS (type, 0);
780 for (i = 0; i < TYPE_NFIELDS (type); i++)
781 {
782 if (TYPE_FIELD_BITPOS (type, i) < *lowp)
783 *lowp = TYPE_FIELD_BITPOS (type, i);
784 if (TYPE_FIELD_BITPOS (type, i) > *highp)
785 *highp = TYPE_FIELD_BITPOS (type, i);
786 }
787
7ba81444 788 /* Set unsigned indicator if warranted. */
c5aa993b 789 if (*lowp >= 0)
c906108c 790 {
876cecd0 791 TYPE_UNSIGNED (type) = 1;
c906108c
SS
792 }
793 }
794 else
795 {
796 *lowp = 0;
797 *highp = -1;
798 }
799 return 0;
800 case TYPE_CODE_BOOL:
801 *lowp = 0;
802 *highp = 1;
803 return 0;
804 case TYPE_CODE_INT:
c5aa993b 805 if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */
c906108c
SS
806 return -1;
807 if (!TYPE_UNSIGNED (type))
808 {
c5aa993b 809 *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
c906108c
SS
810 *highp = -*lowp - 1;
811 return 0;
812 }
7ba81444 813 /* ... fall through for unsigned ints ... */
c906108c
SS
814 case TYPE_CODE_CHAR:
815 *lowp = 0;
816 /* This round-about calculation is to avoid shifting by
7b83ea04 817 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
7ba81444 818 if TYPE_LENGTH (type) == sizeof (LONGEST). */
c906108c
SS
819 *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
820 *highp = (*highp - 1) | *highp;
821 return 0;
822 default:
823 return -1;
824 }
825}
826
dbc98a8b
KW
827/* Assuming TYPE is a simple, non-empty array type, compute its upper
828 and lower bound. Save the low bound into LOW_BOUND if not NULL.
829 Save the high bound into HIGH_BOUND if not NULL.
830
0963b4bd 831 Return 1 if the operation was successful. Return zero otherwise,
dbc98a8b
KW
832 in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
833
834 We now simply use get_discrete_bounds call to get the values
835 of the low and high bounds.
836 get_discrete_bounds can return three values:
837 1, meaning that index is a range,
838 0, meaning that index is a discrete type,
839 or -1 for failure. */
840
841int
842get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound)
843{
844 struct type *index = TYPE_INDEX_TYPE (type);
845 LONGEST low = 0;
846 LONGEST high = 0;
847 int res;
848
849 if (index == NULL)
850 return 0;
851
852 res = get_discrete_bounds (index, &low, &high);
853 if (res == -1)
854 return 0;
855
856 /* Check if the array bounds are undefined. */
857 if (res == 1
858 && ((low_bound && TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type))
859 || (high_bound && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))))
860 return 0;
861
862 if (low_bound)
863 *low_bound = low;
864
865 if (high_bound)
866 *high_bound = high;
867
868 return 1;
869}
870
7ba81444
MS
871/* Create an array type using either a blank type supplied in
872 RESULT_TYPE, or creating a new type, inheriting the objfile from
873 RANGE_TYPE.
c906108c
SS
874
875 Elements will be of type ELEMENT_TYPE, the indices will be of type
876 RANGE_TYPE.
877
7ba81444
MS
878 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
879 sure it is TYPE_CODE_UNDEF before we bash it into an array
880 type? */
c906108c
SS
881
882struct type *
7ba81444
MS
883create_array_type (struct type *result_type,
884 struct type *element_type,
fba45db2 885 struct type *range_type)
c906108c
SS
886{
887 LONGEST low_bound, high_bound;
888
889 if (result_type == NULL)
e9bb382b
UW
890 result_type = alloc_type_copy (range_type);
891
c906108c
SS
892 TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
893 TYPE_TARGET_TYPE (result_type) = element_type;
894 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
895 low_bound = high_bound = 0;
896 CHECK_TYPEDEF (element_type);
ab0d6e0d
JB
897 /* Be careful when setting the array length. Ada arrays can be
898 empty arrays with the high_bound being smaller than the low_bound.
899 In such cases, the array length should be zero. */
900 if (high_bound < low_bound)
901 TYPE_LENGTH (result_type) = 0;
902 else
903 TYPE_LENGTH (result_type) =
904 TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
c906108c
SS
905 TYPE_NFIELDS (result_type) = 1;
906 TYPE_FIELDS (result_type) =
1deafd4e 907 (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
262452ec 908 TYPE_INDEX_TYPE (result_type) = range_type;
c906108c
SS
909 TYPE_VPTR_FIELDNO (result_type) = -1;
910
0963b4bd 911 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays. */
c906108c 912 if (TYPE_LENGTH (result_type) == 0)
876cecd0 913 TYPE_TARGET_STUB (result_type) = 1;
c906108c 914
c16abbde 915 return result_type;
c906108c
SS
916}
917
e3506a9f
UW
918struct type *
919lookup_array_range_type (struct type *element_type,
920 int low_bound, int high_bound)
921{
50810684 922 struct gdbarch *gdbarch = get_type_arch (element_type);
e3506a9f
UW
923 struct type *index_type = builtin_type (gdbarch)->builtin_int;
924 struct type *range_type
925 = create_range_type (NULL, index_type, low_bound, high_bound);
d8734c88 926
e3506a9f
UW
927 return create_array_type (NULL, element_type, range_type);
928}
929
7ba81444
MS
930/* Create a string type using either a blank type supplied in
931 RESULT_TYPE, or creating a new type. String types are similar
932 enough to array of char types that we can use create_array_type to
933 build the basic type and then bash it into a string type.
c906108c
SS
934
935 For fixed length strings, the range type contains 0 as the lower
936 bound and the length of the string minus one as the upper bound.
937
7ba81444
MS
938 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
939 sure it is TYPE_CODE_UNDEF before we bash it into a string
940 type? */
c906108c
SS
941
942struct type *
3b7538c0
UW
943create_string_type (struct type *result_type,
944 struct type *string_char_type,
7ba81444 945 struct type *range_type)
c906108c
SS
946{
947 result_type = create_array_type (result_type,
f290d38e 948 string_char_type,
c906108c
SS
949 range_type);
950 TYPE_CODE (result_type) = TYPE_CODE_STRING;
c16abbde 951 return result_type;
c906108c
SS
952}
953
e3506a9f
UW
954struct type *
955lookup_string_range_type (struct type *string_char_type,
956 int low_bound, int high_bound)
957{
958 struct type *result_type;
d8734c88 959
e3506a9f
UW
960 result_type = lookup_array_range_type (string_char_type,
961 low_bound, high_bound);
962 TYPE_CODE (result_type) = TYPE_CODE_STRING;
963 return result_type;
964}
965
c906108c 966struct type *
fba45db2 967create_set_type (struct type *result_type, struct type *domain_type)
c906108c 968{
c906108c 969 if (result_type == NULL)
e9bb382b
UW
970 result_type = alloc_type_copy (domain_type);
971
c906108c
SS
972 TYPE_CODE (result_type) = TYPE_CODE_SET;
973 TYPE_NFIELDS (result_type) = 1;
1deafd4e 974 TYPE_FIELDS (result_type) = TYPE_ZALLOC (result_type, sizeof (struct field));
c906108c 975
74a9bb82 976 if (!TYPE_STUB (domain_type))
c906108c 977 {
f9780d5b 978 LONGEST low_bound, high_bound, bit_length;
d8734c88 979
c906108c
SS
980 if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
981 low_bound = high_bound = 0;
982 bit_length = high_bound - low_bound + 1;
983 TYPE_LENGTH (result_type)
984 = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
f9780d5b 985 if (low_bound >= 0)
876cecd0 986 TYPE_UNSIGNED (result_type) = 1;
c906108c
SS
987 }
988 TYPE_FIELD_TYPE (result_type, 0) = domain_type;
989
c16abbde 990 return result_type;
c906108c
SS
991}
992
ea37ba09
DJ
993/* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
994 and any array types nested inside it. */
995
996void
997make_vector_type (struct type *array_type)
998{
999 struct type *inner_array, *elt_type;
1000 int flags;
1001
1002 /* Find the innermost array type, in case the array is
1003 multi-dimensional. */
1004 inner_array = array_type;
1005 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
1006 inner_array = TYPE_TARGET_TYPE (inner_array);
1007
1008 elt_type = TYPE_TARGET_TYPE (inner_array);
1009 if (TYPE_CODE (elt_type) == TYPE_CODE_INT)
1010 {
2844d6b5 1011 flags = TYPE_INSTANCE_FLAGS (elt_type) | TYPE_INSTANCE_FLAG_NOTTEXT;
ea37ba09
DJ
1012 elt_type = make_qualified_type (elt_type, flags, NULL);
1013 TYPE_TARGET_TYPE (inner_array) = elt_type;
1014 }
1015
876cecd0 1016 TYPE_VECTOR (array_type) = 1;
ea37ba09
DJ
1017}
1018
794ac428 1019struct type *
ac3aafc7
EZ
1020init_vector_type (struct type *elt_type, int n)
1021{
1022 struct type *array_type;
d8734c88 1023
e3506a9f 1024 array_type = lookup_array_range_type (elt_type, 0, n - 1);
ea37ba09 1025 make_vector_type (array_type);
ac3aafc7
EZ
1026 return array_type;
1027}
1028
0d5de010
DJ
1029/* Smash TYPE to be a type of pointers to members of DOMAIN with type
1030 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1031 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1032 TYPE doesn't include the offset (that's the value of the MEMBER
1033 itself), but does include the structure type into which it points
1034 (for some reason).
c906108c 1035
7ba81444
MS
1036 When "smashing" the type, we preserve the objfile that the old type
1037 pointed to, since we aren't changing where the type is actually
c906108c
SS
1038 allocated. */
1039
1040void
0d5de010
DJ
1041smash_to_memberptr_type (struct type *type, struct type *domain,
1042 struct type *to_type)
c906108c 1043{
2fdde8f8 1044 smash_type (type);
c906108c
SS
1045 TYPE_TARGET_TYPE (type) = to_type;
1046 TYPE_DOMAIN_TYPE (type) = domain;
0d5de010
DJ
1047 /* Assume that a data member pointer is the same size as a normal
1048 pointer. */
50810684
UW
1049 TYPE_LENGTH (type)
1050 = gdbarch_ptr_bit (get_type_arch (to_type)) / TARGET_CHAR_BIT;
0d5de010 1051 TYPE_CODE (type) = TYPE_CODE_MEMBERPTR;
c906108c
SS
1052}
1053
0b92b5bb
TT
1054/* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1055
1056 When "smashing" the type, we preserve the objfile that the old type
1057 pointed to, since we aren't changing where the type is actually
1058 allocated. */
1059
1060void
1061smash_to_methodptr_type (struct type *type, struct type *to_type)
1062{
1063 smash_type (type);
1064 TYPE_TARGET_TYPE (type) = to_type;
1065 TYPE_DOMAIN_TYPE (type) = TYPE_DOMAIN_TYPE (to_type);
1066 TYPE_LENGTH (type) = cplus_method_ptr_size (to_type);
1067 TYPE_CODE (type) = TYPE_CODE_METHODPTR;
1068}
1069
c906108c
SS
1070/* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
1071 METHOD just means `function that gets an extra "this" argument'.
1072
7ba81444
MS
1073 When "smashing" the type, we preserve the objfile that the old type
1074 pointed to, since we aren't changing where the type is actually
c906108c
SS
1075 allocated. */
1076
1077void
fba45db2 1078smash_to_method_type (struct type *type, struct type *domain,
ad2f7632
DJ
1079 struct type *to_type, struct field *args,
1080 int nargs, int varargs)
c906108c 1081{
2fdde8f8 1082 smash_type (type);
c906108c
SS
1083 TYPE_TARGET_TYPE (type) = to_type;
1084 TYPE_DOMAIN_TYPE (type) = domain;
ad2f7632
DJ
1085 TYPE_FIELDS (type) = args;
1086 TYPE_NFIELDS (type) = nargs;
1087 if (varargs)
876cecd0 1088 TYPE_VARARGS (type) = 1;
c906108c
SS
1089 TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
1090 TYPE_CODE (type) = TYPE_CODE_METHOD;
1091}
1092
1093/* Return a typename for a struct/union/enum type without "struct ",
1094 "union ", or "enum ". If the type has a NULL name, return NULL. */
1095
1096char *
aa1ee363 1097type_name_no_tag (const struct type *type)
c906108c
SS
1098{
1099 if (TYPE_TAG_NAME (type) != NULL)
1100 return TYPE_TAG_NAME (type);
1101
7ba81444
MS
1102 /* Is there code which expects this to return the name if there is
1103 no tag name? My guess is that this is mainly used for C++ in
1104 cases where the two will always be the same. */
c906108c
SS
1105 return TYPE_NAME (type);
1106}
1107
7ba81444
MS
1108/* Lookup a typedef or primitive type named NAME, visible in lexical
1109 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1110 suitably defined. */
c906108c
SS
1111
1112struct type *
e6c014f2
UW
1113lookup_typename (const struct language_defn *language,
1114 struct gdbarch *gdbarch, char *name,
34eaf542 1115 const struct block *block, int noerr)
c906108c 1116{
52f0bd74
AC
1117 struct symbol *sym;
1118 struct type *tmp;
c906108c 1119
774b6a14 1120 sym = lookup_symbol (name, block, VAR_DOMAIN, 0);
c906108c
SS
1121 if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
1122 {
e6c014f2 1123 tmp = language_lookup_primitive_type_by_name (language, gdbarch, name);
c906108c
SS
1124 if (tmp)
1125 {
c16abbde 1126 return tmp;
c906108c
SS
1127 }
1128 else if (!tmp && noerr)
1129 {
c16abbde 1130 return NULL;
c906108c
SS
1131 }
1132 else
1133 {
8a3fe4f8 1134 error (_("No type named %s."), name);
c906108c
SS
1135 }
1136 }
1137 return (SYMBOL_TYPE (sym));
1138}
1139
1140struct type *
e6c014f2
UW
1141lookup_unsigned_typename (const struct language_defn *language,
1142 struct gdbarch *gdbarch, char *name)
c906108c
SS
1143{
1144 char *uns = alloca (strlen (name) + 10);
1145
1146 strcpy (uns, "unsigned ");
1147 strcpy (uns + 9, name);
e6c014f2 1148 return lookup_typename (language, gdbarch, uns, (struct block *) NULL, 0);
c906108c
SS
1149}
1150
1151struct type *
e6c014f2
UW
1152lookup_signed_typename (const struct language_defn *language,
1153 struct gdbarch *gdbarch, char *name)
c906108c
SS
1154{
1155 struct type *t;
1156 char *uns = alloca (strlen (name) + 8);
1157
1158 strcpy (uns, "signed ");
1159 strcpy (uns + 7, name);
e6c014f2 1160 t = lookup_typename (language, gdbarch, uns, (struct block *) NULL, 1);
7ba81444 1161 /* If we don't find "signed FOO" just try again with plain "FOO". */
c906108c
SS
1162 if (t != NULL)
1163 return t;
e6c014f2 1164 return lookup_typename (language, gdbarch, name, (struct block *) NULL, 0);
c906108c
SS
1165}
1166
1167/* Lookup a structure type named "struct NAME",
1168 visible in lexical block BLOCK. */
1169
1170struct type *
fba45db2 1171lookup_struct (char *name, struct block *block)
c906108c 1172{
52f0bd74 1173 struct symbol *sym;
c906108c 1174
2570f2b7 1175 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
c906108c
SS
1176
1177 if (sym == NULL)
1178 {
8a3fe4f8 1179 error (_("No struct type named %s."), name);
c906108c
SS
1180 }
1181 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1182 {
7ba81444
MS
1183 error (_("This context has class, union or enum %s, not a struct."),
1184 name);
c906108c
SS
1185 }
1186 return (SYMBOL_TYPE (sym));
1187}
1188
1189/* Lookup a union type named "union NAME",
1190 visible in lexical block BLOCK. */
1191
1192struct type *
fba45db2 1193lookup_union (char *name, struct block *block)
c906108c 1194{
52f0bd74 1195 struct symbol *sym;
c5aa993b 1196 struct type *t;
c906108c 1197
2570f2b7 1198 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
c906108c
SS
1199
1200 if (sym == NULL)
8a3fe4f8 1201 error (_("No union type named %s."), name);
c906108c 1202
c5aa993b 1203 t = SYMBOL_TYPE (sym);
c906108c
SS
1204
1205 if (TYPE_CODE (t) == TYPE_CODE_UNION)
c16abbde 1206 return t;
c906108c 1207
7ba81444
MS
1208 /* If we get here, it's not a union. */
1209 error (_("This context has class, struct or enum %s, not a union."),
1210 name);
c906108c
SS
1211}
1212
1213
1214/* Lookup an enum type named "enum NAME",
1215 visible in lexical block BLOCK. */
1216
1217struct type *
fba45db2 1218lookup_enum (char *name, struct block *block)
c906108c 1219{
52f0bd74 1220 struct symbol *sym;
c906108c 1221
2570f2b7 1222 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
c906108c
SS
1223 if (sym == NULL)
1224 {
8a3fe4f8 1225 error (_("No enum type named %s."), name);
c906108c
SS
1226 }
1227 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
1228 {
7ba81444
MS
1229 error (_("This context has class, struct or union %s, not an enum."),
1230 name);
c906108c
SS
1231 }
1232 return (SYMBOL_TYPE (sym));
1233}
1234
1235/* Lookup a template type named "template NAME<TYPE>",
1236 visible in lexical block BLOCK. */
1237
1238struct type *
7ba81444
MS
1239lookup_template_type (char *name, struct type *type,
1240 struct block *block)
c906108c
SS
1241{
1242 struct symbol *sym;
7ba81444
MS
1243 char *nam = (char *)
1244 alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4);
d8734c88 1245
c906108c
SS
1246 strcpy (nam, name);
1247 strcat (nam, "<");
0004e5a2 1248 strcat (nam, TYPE_NAME (type));
0963b4bd 1249 strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
c906108c 1250
2570f2b7 1251 sym = lookup_symbol (nam, block, VAR_DOMAIN, 0);
c906108c
SS
1252
1253 if (sym == NULL)
1254 {
8a3fe4f8 1255 error (_("No template type named %s."), name);
c906108c
SS
1256 }
1257 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1258 {
7ba81444
MS
1259 error (_("This context has class, union or enum %s, not a struct."),
1260 name);
c906108c
SS
1261 }
1262 return (SYMBOL_TYPE (sym));
1263}
1264
7ba81444
MS
1265/* Given a type TYPE, lookup the type of the component of type named
1266 NAME.
c906108c 1267
7ba81444
MS
1268 TYPE can be either a struct or union, or a pointer or reference to
1269 a struct or union. If it is a pointer or reference, its target
1270 type is automatically used. Thus '.' and '->' are interchangable,
1271 as specified for the definitions of the expression element types
1272 STRUCTOP_STRUCT and STRUCTOP_PTR.
c906108c
SS
1273
1274 If NOERR is nonzero, return zero if NAME is not suitably defined.
1275 If NAME is the name of a baseclass type, return that type. */
1276
1277struct type *
fba45db2 1278lookup_struct_elt_type (struct type *type, char *name, int noerr)
c906108c
SS
1279{
1280 int i;
c92817ce 1281 char *typename;
c906108c
SS
1282
1283 for (;;)
1284 {
1285 CHECK_TYPEDEF (type);
1286 if (TYPE_CODE (type) != TYPE_CODE_PTR
1287 && TYPE_CODE (type) != TYPE_CODE_REF)
1288 break;
1289 type = TYPE_TARGET_TYPE (type);
1290 }
1291
687d6395
MS
1292 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1293 && TYPE_CODE (type) != TYPE_CODE_UNION)
c906108c 1294 {
c92817ce
TT
1295 typename = type_to_string (type);
1296 make_cleanup (xfree, typename);
1297 error (_("Type %s is not a structure or union type."), typename);
c906108c
SS
1298 }
1299
1300#if 0
7ba81444
MS
1301 /* FIXME: This change put in by Michael seems incorrect for the case
1302 where the structure tag name is the same as the member name.
0963b4bd 1303 I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
7ba81444 1304 foo; } bell;" Disabled by fnf. */
c906108c
SS
1305 {
1306 char *typename;
1307
1308 typename = type_name_no_tag (type);
762f08a3 1309 if (typename != NULL && strcmp (typename, name) == 0)
c906108c
SS
1310 return type;
1311 }
1312#endif
1313
1314 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1315 {
1316 char *t_field_name = TYPE_FIELD_NAME (type, i);
1317
db577aea 1318 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
c906108c
SS
1319 {
1320 return TYPE_FIELD_TYPE (type, i);
1321 }
f5a010c0
PM
1322 else if (!t_field_name || *t_field_name == '\0')
1323 {
d8734c88
MS
1324 struct type *subtype
1325 = lookup_struct_elt_type (TYPE_FIELD_TYPE (type, i), name, 1);
1326
f5a010c0
PM
1327 if (subtype != NULL)
1328 return subtype;
1329 }
c906108c
SS
1330 }
1331
1332 /* OK, it's not in this class. Recursively check the baseclasses. */
1333 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1334 {
1335 struct type *t;
1336
9733fc94 1337 t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 1);
c906108c
SS
1338 if (t != NULL)
1339 {
1340 return t;
1341 }
1342 }
1343
1344 if (noerr)
1345 {
1346 return NULL;
1347 }
c5aa993b 1348
c92817ce
TT
1349 typename = type_to_string (type);
1350 make_cleanup (xfree, typename);
1351 error (_("Type %s has no component named %s."), typename, name);
c906108c
SS
1352}
1353
81fe8080
DE
1354/* Lookup the vptr basetype/fieldno values for TYPE.
1355 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1356 vptr_fieldno. Also, if found and basetype is from the same objfile,
1357 cache the results.
1358 If not found, return -1 and ignore BASETYPEP.
1359 Callers should be aware that in some cases (for example,
c906108c 1360 the type or one of its baseclasses is a stub type and we are
d48cc9dd
DJ
1361 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1362 this function will not be able to find the
7ba81444 1363 virtual function table pointer, and vptr_fieldno will remain -1 and
81fe8080 1364 vptr_basetype will remain NULL or incomplete. */
c906108c 1365
81fe8080
DE
1366int
1367get_vptr_fieldno (struct type *type, struct type **basetypep)
c906108c
SS
1368{
1369 CHECK_TYPEDEF (type);
1370
1371 if (TYPE_VPTR_FIELDNO (type) < 0)
1372 {
1373 int i;
1374
7ba81444
MS
1375 /* We must start at zero in case the first (and only) baseclass
1376 is virtual (and hence we cannot share the table pointer). */
c906108c
SS
1377 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1378 {
81fe8080
DE
1379 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
1380 int fieldno;
1381 struct type *basetype;
1382
1383 fieldno = get_vptr_fieldno (baseclass, &basetype);
1384 if (fieldno >= 0)
c906108c 1385 {
81fe8080 1386 /* If the type comes from a different objfile we can't cache
0963b4bd 1387 it, it may have a different lifetime. PR 2384 */
5ef73790 1388 if (TYPE_OBJFILE (type) == TYPE_OBJFILE (basetype))
81fe8080
DE
1389 {
1390 TYPE_VPTR_FIELDNO (type) = fieldno;
1391 TYPE_VPTR_BASETYPE (type) = basetype;
1392 }
1393 if (basetypep)
1394 *basetypep = basetype;
1395 return fieldno;
c906108c
SS
1396 }
1397 }
81fe8080
DE
1398
1399 /* Not found. */
1400 return -1;
1401 }
1402 else
1403 {
1404 if (basetypep)
1405 *basetypep = TYPE_VPTR_BASETYPE (type);
1406 return TYPE_VPTR_FIELDNO (type);
c906108c
SS
1407 }
1408}
1409
44e1a9eb
DJ
1410static void
1411stub_noname_complaint (void)
1412{
e2e0b3e5 1413 complaint (&symfile_complaints, _("stub type has NULL name"));
44e1a9eb
DJ
1414}
1415
92163a10
JK
1416/* Find the real type of TYPE. This function returns the real type,
1417 after removing all layers of typedefs, and completing opaque or stub
1418 types. Completion changes the TYPE argument, but stripping of
1419 typedefs does not.
1420
1421 Instance flags (e.g. const/volatile) are preserved as typedefs are
1422 stripped. If necessary a new qualified form of the underlying type
1423 is created.
1424
1425 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
1426 not been computed and we're either in the middle of reading symbols, or
1427 there was no name for the typedef in the debug info.
1428
1429 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
1430 the target type.
c906108c
SS
1431
1432 If this is a stubbed struct (i.e. declared as struct foo *), see if
0963b4bd 1433 we can find a full definition in some other file. If so, copy this
7ba81444
MS
1434 definition, so we can use it in future. There used to be a comment
1435 (but not any code) that if we don't find a full definition, we'd
1436 set a flag so we don't spend time in the future checking the same
1437 type. That would be a mistake, though--we might load in more
92163a10 1438 symbols which contain a full definition for the type. */
c906108c
SS
1439
1440struct type *
a02fd225 1441check_typedef (struct type *type)
c906108c
SS
1442{
1443 struct type *orig_type = type;
92163a10
JK
1444 /* While we're removing typedefs, we don't want to lose qualifiers.
1445 E.g., const/volatile. */
1446 int instance_flags = TYPE_INSTANCE_FLAGS (type);
a02fd225 1447
423c0af8
MS
1448 gdb_assert (type);
1449
c906108c
SS
1450 while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1451 {
1452 if (!TYPE_TARGET_TYPE (type))
1453 {
c5aa993b 1454 char *name;
c906108c
SS
1455 struct symbol *sym;
1456
1457 /* It is dangerous to call lookup_symbol if we are currently
7ba81444 1458 reading a symtab. Infinite recursion is one danger. */
c906108c 1459 if (currently_reading_symtab)
92163a10 1460 return make_qualified_type (type, instance_flags, NULL);
c906108c
SS
1461
1462 name = type_name_no_tag (type);
7ba81444
MS
1463 /* FIXME: shouldn't we separately check the TYPE_NAME and
1464 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1465 VAR_DOMAIN as appropriate? (this code was written before
1466 TYPE_NAME and TYPE_TAG_NAME were separate). */
c906108c
SS
1467 if (name == NULL)
1468 {
23136709 1469 stub_noname_complaint ();
92163a10 1470 return make_qualified_type (type, instance_flags, NULL);
c906108c 1471 }
2570f2b7 1472 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
c906108c
SS
1473 if (sym)
1474 TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
7ba81444 1475 else /* TYPE_CODE_UNDEF */
e9bb382b 1476 TYPE_TARGET_TYPE (type) = alloc_type_arch (get_type_arch (type));
c906108c
SS
1477 }
1478 type = TYPE_TARGET_TYPE (type);
c906108c 1479
92163a10
JK
1480 /* Preserve the instance flags as we traverse down the typedef chain.
1481
1482 Handling address spaces/classes is nasty, what do we do if there's a
1483 conflict?
1484 E.g., what if an outer typedef marks the type as class_1 and an inner
1485 typedef marks the type as class_2?
1486 This is the wrong place to do such error checking. We leave it to
1487 the code that created the typedef in the first place to flag the
1488 error. We just pick the outer address space (akin to letting the
1489 outer cast in a chain of casting win), instead of assuming
1490 "it can't happen". */
1491 {
1492 const int ALL_SPACES = (TYPE_INSTANCE_FLAG_CODE_SPACE
1493 | TYPE_INSTANCE_FLAG_DATA_SPACE);
1494 const int ALL_CLASSES = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL;
1495 int new_instance_flags = TYPE_INSTANCE_FLAGS (type);
1496
1497 /* Treat code vs data spaces and address classes separately. */
1498 if ((instance_flags & ALL_SPACES) != 0)
1499 new_instance_flags &= ~ALL_SPACES;
1500 if ((instance_flags & ALL_CLASSES) != 0)
1501 new_instance_flags &= ~ALL_CLASSES;
1502
1503 instance_flags |= new_instance_flags;
1504 }
1505 }
a02fd225 1506
7ba81444
MS
1507 /* If this is a struct/class/union with no fields, then check
1508 whether a full definition exists somewhere else. This is for
1509 systems where a type definition with no fields is issued for such
1510 types, instead of identifying them as stub types in the first
1511 place. */
c5aa993b 1512
7ba81444
MS
1513 if (TYPE_IS_OPAQUE (type)
1514 && opaque_type_resolution
1515 && !currently_reading_symtab)
c906108c 1516 {
c5aa993b
JM
1517 char *name = type_name_no_tag (type);
1518 struct type *newtype;
d8734c88 1519
c906108c
SS
1520 if (name == NULL)
1521 {
23136709 1522 stub_noname_complaint ();
92163a10 1523 return make_qualified_type (type, instance_flags, NULL);
c906108c
SS
1524 }
1525 newtype = lookup_transparent_type (name);
ad766c0a 1526
c906108c 1527 if (newtype)
ad766c0a 1528 {
7ba81444
MS
1529 /* If the resolved type and the stub are in the same
1530 objfile, then replace the stub type with the real deal.
1531 But if they're in separate objfiles, leave the stub
1532 alone; we'll just look up the transparent type every time
1533 we call check_typedef. We can't create pointers between
1534 types allocated to different objfiles, since they may
1535 have different lifetimes. Trying to copy NEWTYPE over to
1536 TYPE's objfile is pointless, too, since you'll have to
1537 move over any other types NEWTYPE refers to, which could
1538 be an unbounded amount of stuff. */
ad766c0a 1539 if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type))
92163a10
JK
1540 type = make_qualified_type (newtype,
1541 TYPE_INSTANCE_FLAGS (type),
1542 type);
ad766c0a
JB
1543 else
1544 type = newtype;
1545 }
c906108c 1546 }
7ba81444
MS
1547 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1548 types. */
74a9bb82 1549 else if (TYPE_STUB (type) && !currently_reading_symtab)
c906108c 1550 {
c5aa993b 1551 char *name = type_name_no_tag (type);
c906108c 1552 /* FIXME: shouldn't we separately check the TYPE_NAME and the
176620f1 1553 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
7b83ea04
AC
1554 as appropriate? (this code was written before TYPE_NAME and
1555 TYPE_TAG_NAME were separate). */
c906108c 1556 struct symbol *sym;
d8734c88 1557
c906108c
SS
1558 if (name == NULL)
1559 {
23136709 1560 stub_noname_complaint ();
92163a10 1561 return make_qualified_type (type, instance_flags, NULL);
c906108c 1562 }
2570f2b7 1563 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
c906108c 1564 if (sym)
c26f2453
JB
1565 {
1566 /* Same as above for opaque types, we can replace the stub
92163a10 1567 with the complete type only if they are in the same
c26f2453
JB
1568 objfile. */
1569 if (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type))
92163a10
JK
1570 type = make_qualified_type (SYMBOL_TYPE (sym),
1571 TYPE_INSTANCE_FLAGS (type),
1572 type);
c26f2453
JB
1573 else
1574 type = SYMBOL_TYPE (sym);
1575 }
c906108c
SS
1576 }
1577
74a9bb82 1578 if (TYPE_TARGET_STUB (type))
c906108c
SS
1579 {
1580 struct type *range_type;
1581 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1582
74a9bb82 1583 if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type))
c5aa993b 1584 {
73e2eb35 1585 /* Nothing we can do. */
c5aa993b 1586 }
c906108c
SS
1587 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
1588 && TYPE_NFIELDS (type) == 1
262452ec 1589 && (TYPE_CODE (range_type = TYPE_INDEX_TYPE (type))
c906108c
SS
1590 == TYPE_CODE_RANGE))
1591 {
1592 /* Now recompute the length of the array type, based on its
ab0d6e0d
JB
1593 number of elements and the target type's length.
1594 Watch out for Ada null Ada arrays where the high bound
0963b4bd 1595 is smaller than the low bound. */
43bbcdc2
PH
1596 const LONGEST low_bound = TYPE_LOW_BOUND (range_type);
1597 const LONGEST high_bound = TYPE_HIGH_BOUND (range_type);
1598 ULONGEST len;
1599
ab0d6e0d 1600 if (high_bound < low_bound)
43bbcdc2 1601 len = 0;
d8734c88
MS
1602 else
1603 {
1604 /* For now, we conservatively take the array length to be 0
1605 if its length exceeds UINT_MAX. The code below assumes
1606 that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
1607 which is technically not guaranteed by C, but is usually true
1608 (because it would be true if x were unsigned with its
0963b4bd 1609 high-order bit on). It uses the fact that
d8734c88
MS
1610 high_bound-low_bound is always representable in
1611 ULONGEST and that if high_bound-low_bound+1 overflows,
1612 it overflows to 0. We must change these tests if we
1613 decide to increase the representation of TYPE_LENGTH
0963b4bd 1614 from unsigned int to ULONGEST. */
d8734c88
MS
1615 ULONGEST ulow = low_bound, uhigh = high_bound;
1616 ULONGEST tlen = TYPE_LENGTH (target_type);
1617
1618 len = tlen * (uhigh - ulow + 1);
1619 if (tlen == 0 || (len / tlen - 1 + ulow) != uhigh
1620 || len > UINT_MAX)
1621 len = 0;
1622 }
43bbcdc2 1623 TYPE_LENGTH (type) = len;
876cecd0 1624 TYPE_TARGET_STUB (type) = 0;
c906108c
SS
1625 }
1626 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
1627 {
1628 TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
876cecd0 1629 TYPE_TARGET_STUB (type) = 0;
c906108c
SS
1630 }
1631 }
92163a10
JK
1632
1633 type = make_qualified_type (type, instance_flags, NULL);
1634
7ba81444 1635 /* Cache TYPE_LENGTH for future use. */
c906108c 1636 TYPE_LENGTH (orig_type) = TYPE_LENGTH (type);
92163a10 1637
c906108c
SS
1638 return type;
1639}
1640
7ba81444 1641/* Parse a type expression in the string [P..P+LENGTH). If an error
48319d1f 1642 occurs, silently return a void type. */
c91ecb25 1643
b9362cc7 1644static struct type *
48319d1f 1645safe_parse_type (struct gdbarch *gdbarch, char *p, int length)
c91ecb25
ND
1646{
1647 struct ui_file *saved_gdb_stderr;
1648 struct type *type;
1649
7ba81444 1650 /* Suppress error messages. */
c91ecb25
ND
1651 saved_gdb_stderr = gdb_stderr;
1652 gdb_stderr = ui_file_new ();
1653
7ba81444 1654 /* Call parse_and_eval_type() without fear of longjmp()s. */
c91ecb25 1655 if (!gdb_parse_and_eval_type (p, length, &type))
48319d1f 1656 type = builtin_type (gdbarch)->builtin_void;
c91ecb25 1657
7ba81444 1658 /* Stop suppressing error messages. */
c91ecb25
ND
1659 ui_file_delete (gdb_stderr);
1660 gdb_stderr = saved_gdb_stderr;
1661
1662 return type;
1663}
1664
c906108c
SS
1665/* Ugly hack to convert method stubs into method types.
1666
7ba81444
MS
1667 He ain't kiddin'. This demangles the name of the method into a
1668 string including argument types, parses out each argument type,
1669 generates a string casting a zero to that type, evaluates the
1670 string, and stuffs the resulting type into an argtype vector!!!
1671 Then it knows the type of the whole function (including argument
1672 types for overloading), which info used to be in the stab's but was
1673 removed to hack back the space required for them. */
c906108c 1674
de17c821 1675static void
fba45db2 1676check_stub_method (struct type *type, int method_id, int signature_id)
c906108c 1677{
50810684 1678 struct gdbarch *gdbarch = get_type_arch (type);
c906108c
SS
1679 struct fn_field *f;
1680 char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
1681 char *demangled_name = cplus_demangle (mangled_name,
1682 DMGL_PARAMS | DMGL_ANSI);
1683 char *argtypetext, *p;
1684 int depth = 0, argcount = 1;
ad2f7632 1685 struct field *argtypes;
c906108c
SS
1686 struct type *mtype;
1687
1688 /* Make sure we got back a function string that we can use. */
1689 if (demangled_name)
1690 p = strchr (demangled_name, '(');
502dcf4e
AC
1691 else
1692 p = NULL;
c906108c
SS
1693
1694 if (demangled_name == NULL || p == NULL)
7ba81444
MS
1695 error (_("Internal: Cannot demangle mangled name `%s'."),
1696 mangled_name);
c906108c
SS
1697
1698 /* Now, read in the parameters that define this type. */
1699 p += 1;
1700 argtypetext = p;
1701 while (*p)
1702 {
070ad9f0 1703 if (*p == '(' || *p == '<')
c906108c
SS
1704 {
1705 depth += 1;
1706 }
070ad9f0 1707 else if (*p == ')' || *p == '>')
c906108c
SS
1708 {
1709 depth -= 1;
1710 }
1711 else if (*p == ',' && depth == 0)
1712 {
1713 argcount += 1;
1714 }
1715
1716 p += 1;
1717 }
1718
ad2f7632
DJ
1719 /* If we read one argument and it was ``void'', don't count it. */
1720 if (strncmp (argtypetext, "(void)", 6) == 0)
1721 argcount -= 1;
c906108c 1722
ad2f7632
DJ
1723 /* We need one extra slot, for the THIS pointer. */
1724
1725 argtypes = (struct field *)
1726 TYPE_ALLOC (type, (argcount + 1) * sizeof (struct field));
c906108c 1727 p = argtypetext;
4a1970e4
DJ
1728
1729 /* Add THIS pointer for non-static methods. */
1730 f = TYPE_FN_FIELDLIST1 (type, method_id);
1731 if (TYPE_FN_FIELD_STATIC_P (f, signature_id))
1732 argcount = 0;
1733 else
1734 {
ad2f7632 1735 argtypes[0].type = lookup_pointer_type (type);
4a1970e4
DJ
1736 argcount = 1;
1737 }
c906108c 1738
0963b4bd 1739 if (*p != ')') /* () means no args, skip while. */
c906108c
SS
1740 {
1741 depth = 0;
1742 while (*p)
1743 {
1744 if (depth <= 0 && (*p == ',' || *p == ')'))
1745 {
ad2f7632
DJ
1746 /* Avoid parsing of ellipsis, they will be handled below.
1747 Also avoid ``void'' as above. */
1748 if (strncmp (argtypetext, "...", p - argtypetext) != 0
1749 && strncmp (argtypetext, "void", p - argtypetext) != 0)
c906108c 1750 {
ad2f7632 1751 argtypes[argcount].type =
48319d1f 1752 safe_parse_type (gdbarch, argtypetext, p - argtypetext);
c906108c
SS
1753 argcount += 1;
1754 }
1755 argtypetext = p + 1;
1756 }
1757
070ad9f0 1758 if (*p == '(' || *p == '<')
c906108c
SS
1759 {
1760 depth += 1;
1761 }
070ad9f0 1762 else if (*p == ')' || *p == '>')
c906108c
SS
1763 {
1764 depth -= 1;
1765 }
1766
1767 p += 1;
1768 }
1769 }
1770
c906108c
SS
1771 TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name;
1772
1773 /* Now update the old "stub" type into a real type. */
1774 mtype = TYPE_FN_FIELD_TYPE (f, signature_id);
1775 TYPE_DOMAIN_TYPE (mtype) = type;
ad2f7632
DJ
1776 TYPE_FIELDS (mtype) = argtypes;
1777 TYPE_NFIELDS (mtype) = argcount;
876cecd0 1778 TYPE_STUB (mtype) = 0;
c906108c 1779 TYPE_FN_FIELD_STUB (f, signature_id) = 0;
ad2f7632 1780 if (p[-2] == '.')
876cecd0 1781 TYPE_VARARGS (mtype) = 1;
ad2f7632
DJ
1782
1783 xfree (demangled_name);
c906108c
SS
1784}
1785
7ba81444
MS
1786/* This is the external interface to check_stub_method, above. This
1787 function unstubs all of the signatures for TYPE's METHOD_ID method
1788 name. After calling this function TYPE_FN_FIELD_STUB will be
1789 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1790 correct.
de17c821
DJ
1791
1792 This function unfortunately can not die until stabs do. */
1793
1794void
1795check_stub_method_group (struct type *type, int method_id)
1796{
1797 int len = TYPE_FN_FIELDLIST_LENGTH (type, method_id);
1798 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
f710f4fc 1799 int j, found_stub = 0;
de17c821
DJ
1800
1801 for (j = 0; j < len; j++)
1802 if (TYPE_FN_FIELD_STUB (f, j))
1803 {
1804 found_stub = 1;
1805 check_stub_method (type, method_id, j);
1806 }
1807
7ba81444
MS
1808 /* GNU v3 methods with incorrect names were corrected when we read
1809 in type information, because it was cheaper to do it then. The
1810 only GNU v2 methods with incorrect method names are operators and
1811 destructors; destructors were also corrected when we read in type
1812 information.
de17c821
DJ
1813
1814 Therefore the only thing we need to handle here are v2 operator
1815 names. */
1816 if (found_stub && strncmp (TYPE_FN_FIELD_PHYSNAME (f, 0), "_Z", 2) != 0)
1817 {
1818 int ret;
1819 char dem_opname[256];
1820
7ba81444
MS
1821 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
1822 method_id),
de17c821
DJ
1823 dem_opname, DMGL_ANSI);
1824 if (!ret)
7ba81444
MS
1825 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
1826 method_id),
de17c821
DJ
1827 dem_opname, 0);
1828 if (ret)
1829 TYPE_FN_FIELDLIST_NAME (type, method_id) = xstrdup (dem_opname);
1830 }
1831}
1832
9655fd1a
JK
1833/* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */
1834const struct cplus_struct_type cplus_struct_default = { };
c906108c
SS
1835
1836void
fba45db2 1837allocate_cplus_struct_type (struct type *type)
c906108c 1838{
b4ba55a1
JB
1839 if (HAVE_CPLUS_STRUCT (type))
1840 /* Structure was already allocated. Nothing more to do. */
1841 return;
1842
1843 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CPLUS_STUFF;
1844 TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
1845 TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
1846 *(TYPE_RAW_CPLUS_SPECIFIC (type)) = cplus_struct_default;
c906108c
SS
1847}
1848
b4ba55a1
JB
1849const struct gnat_aux_type gnat_aux_default =
1850 { NULL };
1851
1852/* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
1853 and allocate the associated gnat-specific data. The gnat-specific
1854 data is also initialized to gnat_aux_default. */
1855void
1856allocate_gnat_aux_type (struct type *type)
1857{
1858 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_GNAT_STUFF;
1859 TYPE_GNAT_SPECIFIC (type) = (struct gnat_aux_type *)
1860 TYPE_ALLOC (type, sizeof (struct gnat_aux_type));
1861 *(TYPE_GNAT_SPECIFIC (type)) = gnat_aux_default;
1862}
1863
1864
c906108c
SS
1865/* Helper function to initialize the standard scalar types.
1866
e9bb382b
UW
1867 If NAME is non-NULL, then we make a copy of the string pointed
1868 to by name in the objfile_obstack for that objfile, and initialize
1869 the type name to that copy. There are places (mipsread.c in particular),
1870 where init_type is called with a NULL value for NAME). */
c906108c
SS
1871
1872struct type *
7ba81444
MS
1873init_type (enum type_code code, int length, int flags,
1874 char *name, struct objfile *objfile)
c906108c 1875{
52f0bd74 1876 struct type *type;
c906108c
SS
1877
1878 type = alloc_type (objfile);
1879 TYPE_CODE (type) = code;
1880 TYPE_LENGTH (type) = length;
876cecd0
TT
1881
1882 gdb_assert (!(flags & (TYPE_FLAG_MIN - 1)));
1883 if (flags & TYPE_FLAG_UNSIGNED)
1884 TYPE_UNSIGNED (type) = 1;
1885 if (flags & TYPE_FLAG_NOSIGN)
1886 TYPE_NOSIGN (type) = 1;
1887 if (flags & TYPE_FLAG_STUB)
1888 TYPE_STUB (type) = 1;
1889 if (flags & TYPE_FLAG_TARGET_STUB)
1890 TYPE_TARGET_STUB (type) = 1;
1891 if (flags & TYPE_FLAG_STATIC)
1892 TYPE_STATIC (type) = 1;
1893 if (flags & TYPE_FLAG_PROTOTYPED)
1894 TYPE_PROTOTYPED (type) = 1;
1895 if (flags & TYPE_FLAG_INCOMPLETE)
1896 TYPE_INCOMPLETE (type) = 1;
1897 if (flags & TYPE_FLAG_VARARGS)
1898 TYPE_VARARGS (type) = 1;
1899 if (flags & TYPE_FLAG_VECTOR)
1900 TYPE_VECTOR (type) = 1;
1901 if (flags & TYPE_FLAG_STUB_SUPPORTED)
1902 TYPE_STUB_SUPPORTED (type) = 1;
876cecd0
TT
1903 if (flags & TYPE_FLAG_FIXED_INSTANCE)
1904 TYPE_FIXED_INSTANCE (type) = 1;
1905
e9bb382b
UW
1906 if (name)
1907 TYPE_NAME (type) = obsavestring (name, strlen (name),
1908 &objfile->objfile_obstack);
c906108c
SS
1909
1910 /* C++ fancies. */
1911
973ccf8b 1912 if (name && strcmp (name, "char") == 0)
876cecd0 1913 TYPE_NOSIGN (type) = 1;
973ccf8b 1914
b4ba55a1 1915 switch (code)
c906108c 1916 {
b4ba55a1
JB
1917 case TYPE_CODE_STRUCT:
1918 case TYPE_CODE_UNION:
1919 case TYPE_CODE_NAMESPACE:
1920 INIT_CPLUS_SPECIFIC (type);
1921 break;
1922 case TYPE_CODE_FLT:
1923 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FLOATFORMAT;
1924 break;
1925 case TYPE_CODE_FUNC:
1926 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CALLING_CONVENTION;
1927 break;
c906108c 1928 }
c16abbde 1929 return type;
c906108c
SS
1930}
1931
c906108c 1932int
fba45db2 1933can_dereference (struct type *t)
c906108c 1934{
7ba81444
MS
1935 /* FIXME: Should we return true for references as well as
1936 pointers? */
c906108c
SS
1937 CHECK_TYPEDEF (t);
1938 return
1939 (t != NULL
1940 && TYPE_CODE (t) == TYPE_CODE_PTR
1941 && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
1942}
1943
adf40b2e 1944int
fba45db2 1945is_integral_type (struct type *t)
adf40b2e
JM
1946{
1947 CHECK_TYPEDEF (t);
1948 return
1949 ((t != NULL)
d4f3574e
SS
1950 && ((TYPE_CODE (t) == TYPE_CODE_INT)
1951 || (TYPE_CODE (t) == TYPE_CODE_ENUM)
4f2aea11 1952 || (TYPE_CODE (t) == TYPE_CODE_FLAGS)
d4f3574e
SS
1953 || (TYPE_CODE (t) == TYPE_CODE_CHAR)
1954 || (TYPE_CODE (t) == TYPE_CODE_RANGE)
1955 || (TYPE_CODE (t) == TYPE_CODE_BOOL)));
adf40b2e
JM
1956}
1957
4e8f195d
TT
1958/* A helper function which returns true if types A and B represent the
1959 "same" class type. This is true if the types have the same main
1960 type, or the same name. */
1961
1962int
1963class_types_same_p (const struct type *a, const struct type *b)
1964{
1965 return (TYPE_MAIN_TYPE (a) == TYPE_MAIN_TYPE (b)
1966 || (TYPE_NAME (a) && TYPE_NAME (b)
1967 && !strcmp (TYPE_NAME (a), TYPE_NAME (b))));
1968}
1969
a9d5ef47
SW
1970/* If BASE is an ancestor of DCLASS return the distance between them.
1971 otherwise return -1;
1972 eg:
1973
1974 class A {};
1975 class B: public A {};
1976 class C: public B {};
1977 class D: C {};
1978
1979 distance_to_ancestor (A, A, 0) = 0
1980 distance_to_ancestor (A, B, 0) = 1
1981 distance_to_ancestor (A, C, 0) = 2
1982 distance_to_ancestor (A, D, 0) = 3
1983
1984 If PUBLIC is 1 then only public ancestors are considered,
1985 and the function returns the distance only if BASE is a public ancestor
1986 of DCLASS.
1987 Eg:
1988
0963b4bd 1989 distance_to_ancestor (A, D, 1) = -1. */
c906108c 1990
0526b37a 1991static int
a9d5ef47 1992distance_to_ancestor (struct type *base, struct type *dclass, int public)
c906108c
SS
1993{
1994 int i;
a9d5ef47 1995 int d;
c5aa993b 1996
c906108c
SS
1997 CHECK_TYPEDEF (base);
1998 CHECK_TYPEDEF (dclass);
1999
4e8f195d 2000 if (class_types_same_p (base, dclass))
a9d5ef47 2001 return 0;
c906108c
SS
2002
2003 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
4e8f195d 2004 {
0526b37a
SW
2005 if (public && ! BASETYPE_VIA_PUBLIC (dclass, i))
2006 continue;
2007
a9d5ef47
SW
2008 d = distance_to_ancestor (base, TYPE_BASECLASS (dclass, i), public);
2009 if (d >= 0)
2010 return 1 + d;
4e8f195d 2011 }
c906108c 2012
a9d5ef47 2013 return -1;
c906108c 2014}
4e8f195d 2015
0526b37a
SW
2016/* Check whether BASE is an ancestor or base class or DCLASS
2017 Return 1 if so, and 0 if not.
2018 Note: If BASE and DCLASS are of the same type, this function
2019 will return 1. So for some class A, is_ancestor (A, A) will
2020 return 1. */
2021
2022int
2023is_ancestor (struct type *base, struct type *dclass)
2024{
a9d5ef47 2025 return distance_to_ancestor (base, dclass, 0) >= 0;
0526b37a
SW
2026}
2027
4e8f195d
TT
2028/* Like is_ancestor, but only returns true when BASE is a public
2029 ancestor of DCLASS. */
2030
2031int
2032is_public_ancestor (struct type *base, struct type *dclass)
2033{
a9d5ef47 2034 return distance_to_ancestor (base, dclass, 1) >= 0;
4e8f195d
TT
2035}
2036
2037/* A helper function for is_unique_ancestor. */
2038
2039static int
2040is_unique_ancestor_worker (struct type *base, struct type *dclass,
2041 int *offset,
2042 const bfd_byte *contents, CORE_ADDR address)
2043{
2044 int i, count = 0;
2045
2046 CHECK_TYPEDEF (base);
2047 CHECK_TYPEDEF (dclass);
2048
2049 for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i)
2050 {
2051 struct type *iter = check_typedef (TYPE_BASECLASS (dclass, i));
2052 int this_offset = baseclass_offset (dclass, i, contents, address);
2053
2054 if (this_offset == -1)
2055 error (_("virtual baseclass botch"));
2056
2057 if (class_types_same_p (base, iter))
2058 {
2059 /* If this is the first subclass, set *OFFSET and set count
2060 to 1. Otherwise, if this is at the same offset as
2061 previous instances, do nothing. Otherwise, increment
2062 count. */
2063 if (*offset == -1)
2064 {
2065 *offset = this_offset;
2066 count = 1;
2067 }
2068 else if (this_offset == *offset)
2069 {
2070 /* Nothing. */
2071 }
2072 else
2073 ++count;
2074 }
2075 else
2076 count += is_unique_ancestor_worker (base, iter, offset,
2077 contents + this_offset,
2078 address + this_offset);
2079 }
2080
2081 return count;
2082}
2083
2084/* Like is_ancestor, but only returns true if BASE is a unique base
2085 class of the type of VAL. */
2086
2087int
2088is_unique_ancestor (struct type *base, struct value *val)
2089{
2090 int offset = -1;
2091
2092 return is_unique_ancestor_worker (base, value_type (val), &offset,
2093 value_contents (val),
2094 value_address (val)) == 1;
2095}
2096
c906108c
SS
2097\f
2098
6403aeea
SW
2099/* Return the sum of the rank of A with the rank of B. */
2100
2101struct rank
2102sum_ranks (struct rank a, struct rank b)
2103{
2104 struct rank c;
2105 c.rank = a.rank + b.rank;
a9d5ef47 2106 c.subrank = a.subrank + b.subrank;
6403aeea
SW
2107 return c;
2108}
2109
2110/* Compare rank A and B and return:
2111 0 if a = b
2112 1 if a is better than b
2113 -1 if b is better than a. */
2114
2115int
2116compare_ranks (struct rank a, struct rank b)
2117{
2118 if (a.rank == b.rank)
a9d5ef47
SW
2119 {
2120 if (a.subrank == b.subrank)
2121 return 0;
2122 if (a.subrank < b.subrank)
2123 return 1;
2124 if (a.subrank > b.subrank)
2125 return -1;
2126 }
6403aeea
SW
2127
2128 if (a.rank < b.rank)
2129 return 1;
2130
0963b4bd 2131 /* a.rank > b.rank */
6403aeea
SW
2132 return -1;
2133}
c5aa993b 2134
0963b4bd 2135/* Functions for overload resolution begin here. */
c906108c
SS
2136
2137/* Compare two badness vectors A and B and return the result.
7ba81444
MS
2138 0 => A and B are identical
2139 1 => A and B are incomparable
2140 2 => A is better than B
2141 3 => A is worse than B */
c906108c
SS
2142
2143int
fba45db2 2144compare_badness (struct badness_vector *a, struct badness_vector *b)
c906108c
SS
2145{
2146 int i;
2147 int tmp;
c5aa993b
JM
2148 short found_pos = 0; /* any positives in c? */
2149 short found_neg = 0; /* any negatives in c? */
2150
2151 /* differing lengths => incomparable */
c906108c
SS
2152 if (a->length != b->length)
2153 return 1;
2154
c5aa993b
JM
2155 /* Subtract b from a */
2156 for (i = 0; i < a->length; i++)
c906108c 2157 {
6403aeea 2158 tmp = compare_ranks (b->rank[i], a->rank[i]);
c906108c 2159 if (tmp > 0)
c5aa993b 2160 found_pos = 1;
c906108c 2161 else if (tmp < 0)
c5aa993b 2162 found_neg = 1;
c906108c
SS
2163 }
2164
2165 if (found_pos)
2166 {
2167 if (found_neg)
c5aa993b 2168 return 1; /* incomparable */
c906108c 2169 else
c5aa993b 2170 return 3; /* A > B */
c906108c 2171 }
c5aa993b
JM
2172 else
2173 /* no positives */
c906108c
SS
2174 {
2175 if (found_neg)
c5aa993b 2176 return 2; /* A < B */
c906108c 2177 else
c5aa993b 2178 return 0; /* A == B */
c906108c
SS
2179 }
2180}
2181
7ba81444
MS
2182/* Rank a function by comparing its parameter types (PARMS, length
2183 NPARMS), to the types of an argument list (ARGS, length NARGS).
2184 Return a pointer to a badness vector. This has NARGS + 1
2185 entries. */
c906108c
SS
2186
2187struct badness_vector *
7ba81444
MS
2188rank_function (struct type **parms, int nparms,
2189 struct type **args, int nargs)
c906108c
SS
2190{
2191 int i;
c5aa993b 2192 struct badness_vector *bv;
c906108c
SS
2193 int min_len = nparms < nargs ? nparms : nargs;
2194
2195 bv = xmalloc (sizeof (struct badness_vector));
0963b4bd 2196 bv->length = nargs + 1; /* add 1 for the length-match rank. */
c906108c
SS
2197 bv->rank = xmalloc ((nargs + 1) * sizeof (int));
2198
2199 /* First compare the lengths of the supplied lists.
7ba81444 2200 If there is a mismatch, set it to a high value. */
c5aa993b 2201
c906108c 2202 /* pai/1997-06-03 FIXME: when we have debug info about default
7ba81444
MS
2203 arguments and ellipsis parameter lists, we should consider those
2204 and rank the length-match more finely. */
c906108c 2205
6403aeea
SW
2206 LENGTH_MATCH (bv) = (nargs != nparms)
2207 ? LENGTH_MISMATCH_BADNESS
2208 : EXACT_MATCH_BADNESS;
c906108c 2209
0963b4bd 2210 /* Now rank all the parameters of the candidate function. */
74cc24b0
DB
2211 for (i = 1; i <= min_len; i++)
2212 bv->rank[i] = rank_one_type (parms[i-1], args[i-1]);
c906108c 2213
0963b4bd 2214 /* If more arguments than parameters, add dummy entries. */
c5aa993b 2215 for (i = min_len + 1; i <= nargs; i++)
c906108c
SS
2216 bv->rank[i] = TOO_FEW_PARAMS_BADNESS;
2217
2218 return bv;
2219}
2220
973ccf8b
DJ
2221/* Compare the names of two integer types, assuming that any sign
2222 qualifiers have been checked already. We do it this way because
2223 there may be an "int" in the name of one of the types. */
2224
2225static int
2226integer_types_same_name_p (const char *first, const char *second)
2227{
2228 int first_p, second_p;
2229
7ba81444
MS
2230 /* If both are shorts, return 1; if neither is a short, keep
2231 checking. */
973ccf8b
DJ
2232 first_p = (strstr (first, "short") != NULL);
2233 second_p = (strstr (second, "short") != NULL);
2234 if (first_p && second_p)
2235 return 1;
2236 if (first_p || second_p)
2237 return 0;
2238
2239 /* Likewise for long. */
2240 first_p = (strstr (first, "long") != NULL);
2241 second_p = (strstr (second, "long") != NULL);
2242 if (first_p && second_p)
2243 return 1;
2244 if (first_p || second_p)
2245 return 0;
2246
2247 /* Likewise for char. */
2248 first_p = (strstr (first, "char") != NULL);
2249 second_p = (strstr (second, "char") != NULL);
2250 if (first_p && second_p)
2251 return 1;
2252 if (first_p || second_p)
2253 return 0;
2254
2255 /* They must both be ints. */
2256 return 1;
2257}
2258
7062b0a0
SW
2259/* Compares type A to type B returns 1 if the represent the same type
2260 0 otherwise. */
2261
2262static int
2263types_equal (struct type *a, struct type *b)
2264{
2265 /* Identical type pointers. */
2266 /* However, this still doesn't catch all cases of same type for b
2267 and a. The reason is that builtin types are different from
2268 the same ones constructed from the object. */
2269 if (a == b)
2270 return 1;
2271
2272 /* Resolve typedefs */
2273 if (TYPE_CODE (a) == TYPE_CODE_TYPEDEF)
2274 a = check_typedef (a);
2275 if (TYPE_CODE (b) == TYPE_CODE_TYPEDEF)
2276 b = check_typedef (b);
2277
2278 /* If after resolving typedefs a and b are not of the same type
2279 code then they are not equal. */
2280 if (TYPE_CODE (a) != TYPE_CODE (b))
2281 return 0;
2282
2283 /* If a and b are both pointers types or both reference types then
2284 they are equal of the same type iff the objects they refer to are
2285 of the same type. */
2286 if (TYPE_CODE (a) == TYPE_CODE_PTR
2287 || TYPE_CODE (a) == TYPE_CODE_REF)
2288 return types_equal (TYPE_TARGET_TYPE (a),
2289 TYPE_TARGET_TYPE (b));
2290
0963b4bd 2291 /* Well, damnit, if the names are exactly the same, I'll say they
7062b0a0
SW
2292 are exactly the same. This happens when we generate method
2293 stubs. The types won't point to the same address, but they
0963b4bd 2294 really are the same. */
7062b0a0
SW
2295
2296 if (TYPE_NAME (a) && TYPE_NAME (b)
2297 && strcmp (TYPE_NAME (a), TYPE_NAME (b)) == 0)
2298 return 1;
2299
2300 /* Check if identical after resolving typedefs. */
2301 if (a == b)
2302 return 1;
2303
2304 return 0;
2305}
2306
c906108c
SS
2307/* Compare one type (PARM) for compatibility with another (ARG).
2308 * PARM is intended to be the parameter type of a function; and
2309 * ARG is the supplied argument's type. This function tests if
2310 * the latter can be converted to the former.
2311 *
2312 * Return 0 if they are identical types;
2313 * Otherwise, return an integer which corresponds to how compatible
7ba81444
MS
2314 * PARM is to ARG. The higher the return value, the worse the match.
2315 * Generally the "bad" conversions are all uniformly assigned a 100. */
c906108c 2316
6403aeea 2317struct rank
fba45db2 2318rank_one_type (struct type *parm, struct type *arg)
c906108c 2319{
a9d5ef47 2320 struct rank rank = {0,0};
7062b0a0
SW
2321
2322 if (types_equal (parm, arg))
6403aeea 2323 return EXACT_MATCH_BADNESS;
c906108c
SS
2324
2325 /* Resolve typedefs */
2326 if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF)
2327 parm = check_typedef (parm);
2328 if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
2329 arg = check_typedef (arg);
2330
db577aea 2331 /* See through references, since we can almost make non-references
7ba81444 2332 references. */
db577aea 2333 if (TYPE_CODE (arg) == TYPE_CODE_REF)
6403aeea
SW
2334 return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg)),
2335 REFERENCE_CONVERSION_BADNESS));
db577aea 2336 if (TYPE_CODE (parm) == TYPE_CODE_REF)
6403aeea
SW
2337 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg),
2338 REFERENCE_CONVERSION_BADNESS));
5d161b24 2339 if (overload_debug)
7ba81444
MS
2340 /* Debugging only. */
2341 fprintf_filtered (gdb_stderr,
2342 "------ Arg is %s [%d], parm is %s [%d]\n",
2343 TYPE_NAME (arg), TYPE_CODE (arg),
2344 TYPE_NAME (parm), TYPE_CODE (parm));
c906108c 2345
0963b4bd 2346 /* x -> y means arg of type x being supplied for parameter of type y. */
c906108c
SS
2347
2348 switch (TYPE_CODE (parm))
2349 {
c5aa993b
JM
2350 case TYPE_CODE_PTR:
2351 switch (TYPE_CODE (arg))
2352 {
2353 case TYPE_CODE_PTR:
7062b0a0
SW
2354
2355 /* Allowed pointer conversions are:
2356 (a) pointer to void-pointer conversion. */
2357 if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID)
c5aa993b 2358 return VOID_PTR_CONVERSION_BADNESS;
7062b0a0
SW
2359
2360 /* (b) pointer to ancestor-pointer conversion. */
a9d5ef47
SW
2361 rank.subrank = distance_to_ancestor (TYPE_TARGET_TYPE (parm),
2362 TYPE_TARGET_TYPE (arg),
2363 0);
2364 if (rank.subrank >= 0)
2365 return sum_ranks (BASE_PTR_CONVERSION_BADNESS, rank);
7062b0a0
SW
2366
2367 return INCOMPATIBLE_TYPE_BADNESS;
c5aa993b 2368 case TYPE_CODE_ARRAY:
7062b0a0
SW
2369 if (types_equal (TYPE_TARGET_TYPE (parm),
2370 TYPE_TARGET_TYPE (arg)))
6403aeea 2371 return EXACT_MATCH_BADNESS;
7062b0a0 2372 return INCOMPATIBLE_TYPE_BADNESS;
c5aa993b
JM
2373 case TYPE_CODE_FUNC:
2374 return rank_one_type (TYPE_TARGET_TYPE (parm), arg);
2375 case TYPE_CODE_INT:
2376 case TYPE_CODE_ENUM:
4f2aea11 2377 case TYPE_CODE_FLAGS:
c5aa993b
JM
2378 case TYPE_CODE_CHAR:
2379 case TYPE_CODE_RANGE:
2380 case TYPE_CODE_BOOL:
c5aa993b
JM
2381 default:
2382 return INCOMPATIBLE_TYPE_BADNESS;
2383 }
2384 case TYPE_CODE_ARRAY:
2385 switch (TYPE_CODE (arg))
2386 {
2387 case TYPE_CODE_PTR:
2388 case TYPE_CODE_ARRAY:
7ba81444
MS
2389 return rank_one_type (TYPE_TARGET_TYPE (parm),
2390 TYPE_TARGET_TYPE (arg));
c5aa993b
JM
2391 default:
2392 return INCOMPATIBLE_TYPE_BADNESS;
2393 }
2394 case TYPE_CODE_FUNC:
2395 switch (TYPE_CODE (arg))
2396 {
2397 case TYPE_CODE_PTR: /* funcptr -> func */
2398 return rank_one_type (parm, TYPE_TARGET_TYPE (arg));
2399 default:
2400 return INCOMPATIBLE_TYPE_BADNESS;
2401 }
2402 case TYPE_CODE_INT:
2403 switch (TYPE_CODE (arg))
2404 {
2405 case TYPE_CODE_INT:
2406 if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2407 {
2408 /* Deal with signed, unsigned, and plain chars and
7ba81444 2409 signed and unsigned ints. */
c5aa993b
JM
2410 if (TYPE_NOSIGN (parm))
2411 {
0963b4bd 2412 /* This case only for character types. */
7ba81444 2413 if (TYPE_NOSIGN (arg))
6403aeea 2414 return EXACT_MATCH_BADNESS; /* plain char -> plain char */
7ba81444
MS
2415 else /* signed/unsigned char -> plain char */
2416 return INTEGER_CONVERSION_BADNESS;
c5aa993b
JM
2417 }
2418 else if (TYPE_UNSIGNED (parm))
2419 {
2420 if (TYPE_UNSIGNED (arg))
2421 {
7ba81444
MS
2422 /* unsigned int -> unsigned int, or
2423 unsigned long -> unsigned long */
2424 if (integer_types_same_name_p (TYPE_NAME (parm),
2425 TYPE_NAME (arg)))
6403aeea 2426 return EXACT_MATCH_BADNESS;
7ba81444
MS
2427 else if (integer_types_same_name_p (TYPE_NAME (arg),
2428 "int")
2429 && integer_types_same_name_p (TYPE_NAME (parm),
2430 "long"))
3e43a32a
MS
2431 /* unsigned int -> unsigned long */
2432 return INTEGER_PROMOTION_BADNESS;
c5aa993b 2433 else
3e43a32a
MS
2434 /* unsigned long -> unsigned int */
2435 return INTEGER_CONVERSION_BADNESS;
c5aa993b
JM
2436 }
2437 else
2438 {
7ba81444
MS
2439 if (integer_types_same_name_p (TYPE_NAME (arg),
2440 "long")
2441 && integer_types_same_name_p (TYPE_NAME (parm),
2442 "int"))
3e43a32a
MS
2443 /* signed long -> unsigned int */
2444 return INTEGER_CONVERSION_BADNESS;
c5aa993b 2445 else
3e43a32a
MS
2446 /* signed int/long -> unsigned int/long */
2447 return INTEGER_CONVERSION_BADNESS;
c5aa993b
JM
2448 }
2449 }
2450 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2451 {
7ba81444
MS
2452 if (integer_types_same_name_p (TYPE_NAME (parm),
2453 TYPE_NAME (arg)))
6403aeea 2454 return EXACT_MATCH_BADNESS;
7ba81444
MS
2455 else if (integer_types_same_name_p (TYPE_NAME (arg),
2456 "int")
2457 && integer_types_same_name_p (TYPE_NAME (parm),
2458 "long"))
c5aa993b
JM
2459 return INTEGER_PROMOTION_BADNESS;
2460 else
1c5cb38e 2461 return INTEGER_CONVERSION_BADNESS;
c5aa993b
JM
2462 }
2463 else
1c5cb38e 2464 return INTEGER_CONVERSION_BADNESS;
c5aa993b
JM
2465 }
2466 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2467 return INTEGER_PROMOTION_BADNESS;
2468 else
1c5cb38e 2469 return INTEGER_CONVERSION_BADNESS;
c5aa993b 2470 case TYPE_CODE_ENUM:
4f2aea11 2471 case TYPE_CODE_FLAGS:
c5aa993b
JM
2472 case TYPE_CODE_CHAR:
2473 case TYPE_CODE_RANGE:
2474 case TYPE_CODE_BOOL:
2475 return INTEGER_PROMOTION_BADNESS;
2476 case TYPE_CODE_FLT:
2477 return INT_FLOAT_CONVERSION_BADNESS;
2478 case TYPE_CODE_PTR:
2479 return NS_POINTER_CONVERSION_BADNESS;
2480 default:
2481 return INCOMPATIBLE_TYPE_BADNESS;
2482 }
2483 break;
2484 case TYPE_CODE_ENUM:
2485 switch (TYPE_CODE (arg))
2486 {
2487 case TYPE_CODE_INT:
2488 case TYPE_CODE_CHAR:
2489 case TYPE_CODE_RANGE:
2490 case TYPE_CODE_BOOL:
2491 case TYPE_CODE_ENUM:
1c5cb38e 2492 return INTEGER_CONVERSION_BADNESS;
c5aa993b
JM
2493 case TYPE_CODE_FLT:
2494 return INT_FLOAT_CONVERSION_BADNESS;
2495 default:
2496 return INCOMPATIBLE_TYPE_BADNESS;
2497 }
2498 break;
2499 case TYPE_CODE_CHAR:
2500 switch (TYPE_CODE (arg))
2501 {
2502 case TYPE_CODE_RANGE:
2503 case TYPE_CODE_BOOL:
2504 case TYPE_CODE_ENUM:
1c5cb38e 2505 return INTEGER_CONVERSION_BADNESS;
c5aa993b
JM
2506 case TYPE_CODE_FLT:
2507 return INT_FLOAT_CONVERSION_BADNESS;
2508 case TYPE_CODE_INT:
2509 if (TYPE_LENGTH (arg) > TYPE_LENGTH (parm))
1c5cb38e 2510 return INTEGER_CONVERSION_BADNESS;
c5aa993b
JM
2511 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2512 return INTEGER_PROMOTION_BADNESS;
2513 /* >>> !! else fall through !! <<< */
2514 case TYPE_CODE_CHAR:
7ba81444
MS
2515 /* Deal with signed, unsigned, and plain chars for C++ and
2516 with int cases falling through from previous case. */
c5aa993b
JM
2517 if (TYPE_NOSIGN (parm))
2518 {
2519 if (TYPE_NOSIGN (arg))
6403aeea 2520 return EXACT_MATCH_BADNESS;
c5aa993b 2521 else
1c5cb38e 2522 return INTEGER_CONVERSION_BADNESS;
c5aa993b
JM
2523 }
2524 else if (TYPE_UNSIGNED (parm))
2525 {
2526 if (TYPE_UNSIGNED (arg))
6403aeea 2527 return EXACT_MATCH_BADNESS;
c5aa993b
JM
2528 else
2529 return INTEGER_PROMOTION_BADNESS;
2530 }
2531 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
6403aeea 2532 return EXACT_MATCH_BADNESS;
c5aa993b 2533 else
1c5cb38e 2534 return INTEGER_CONVERSION_BADNESS;
c5aa993b
JM
2535 default:
2536 return INCOMPATIBLE_TYPE_BADNESS;
2537 }
2538 break;
2539 case TYPE_CODE_RANGE:
2540 switch (TYPE_CODE (arg))
2541 {
2542 case TYPE_CODE_INT:
2543 case TYPE_CODE_CHAR:
2544 case TYPE_CODE_RANGE:
2545 case TYPE_CODE_BOOL:
2546 case TYPE_CODE_ENUM:
1c5cb38e 2547 return INTEGER_CONVERSION_BADNESS;
c5aa993b
JM
2548 case TYPE_CODE_FLT:
2549 return INT_FLOAT_CONVERSION_BADNESS;
2550 default:
2551 return INCOMPATIBLE_TYPE_BADNESS;
2552 }
2553 break;
2554 case TYPE_CODE_BOOL:
2555 switch (TYPE_CODE (arg))
2556 {
2557 case TYPE_CODE_INT:
2558 case TYPE_CODE_CHAR:
2559 case TYPE_CODE_RANGE:
2560 case TYPE_CODE_ENUM:
2561 case TYPE_CODE_FLT:
026ffab7 2562 return INCOMPATIBLE_TYPE_BADNESS;
c5aa993b 2563 case TYPE_CODE_PTR:
026ffab7 2564 return BOOL_PTR_CONVERSION_BADNESS;
c5aa993b 2565 case TYPE_CODE_BOOL:
6403aeea 2566 return EXACT_MATCH_BADNESS;
c5aa993b
JM
2567 default:
2568 return INCOMPATIBLE_TYPE_BADNESS;
2569 }
2570 break;
2571 case TYPE_CODE_FLT:
2572 switch (TYPE_CODE (arg))
2573 {
2574 case TYPE_CODE_FLT:
2575 if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2576 return FLOAT_PROMOTION_BADNESS;
2577 else if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
6403aeea 2578 return EXACT_MATCH_BADNESS;
c5aa993b
JM
2579 else
2580 return FLOAT_CONVERSION_BADNESS;
2581 case TYPE_CODE_INT:
2582 case TYPE_CODE_BOOL:
2583 case TYPE_CODE_ENUM:
2584 case TYPE_CODE_RANGE:
2585 case TYPE_CODE_CHAR:
2586 return INT_FLOAT_CONVERSION_BADNESS;
2587 default:
2588 return INCOMPATIBLE_TYPE_BADNESS;
2589 }
2590 break;
2591 case TYPE_CODE_COMPLEX:
2592 switch (TYPE_CODE (arg))
7ba81444 2593 { /* Strictly not needed for C++, but... */
c5aa993b
JM
2594 case TYPE_CODE_FLT:
2595 return FLOAT_PROMOTION_BADNESS;
2596 case TYPE_CODE_COMPLEX:
6403aeea 2597 return EXACT_MATCH_BADNESS;
c5aa993b
JM
2598 default:
2599 return INCOMPATIBLE_TYPE_BADNESS;
2600 }
2601 break;
2602 case TYPE_CODE_STRUCT:
0963b4bd 2603 /* currently same as TYPE_CODE_CLASS. */
c5aa993b
JM
2604 switch (TYPE_CODE (arg))
2605 {
2606 case TYPE_CODE_STRUCT:
2607 /* Check for derivation */
a9d5ef47
SW
2608 rank.subrank = distance_to_ancestor (parm, arg, 0);
2609 if (rank.subrank >= 0)
2610 return sum_ranks (BASE_CONVERSION_BADNESS, rank);
c5aa993b
JM
2611 /* else fall through */
2612 default:
2613 return INCOMPATIBLE_TYPE_BADNESS;
2614 }
2615 break;
2616 case TYPE_CODE_UNION:
2617 switch (TYPE_CODE (arg))
2618 {
2619 case TYPE_CODE_UNION:
2620 default:
2621 return INCOMPATIBLE_TYPE_BADNESS;
2622 }
2623 break;
0d5de010 2624 case TYPE_CODE_MEMBERPTR:
c5aa993b
JM
2625 switch (TYPE_CODE (arg))
2626 {
2627 default:
2628 return INCOMPATIBLE_TYPE_BADNESS;
2629 }
2630 break;
2631 case TYPE_CODE_METHOD:
2632 switch (TYPE_CODE (arg))
2633 {
2634
2635 default:
2636 return INCOMPATIBLE_TYPE_BADNESS;
2637 }
2638 break;
2639 case TYPE_CODE_REF:
2640 switch (TYPE_CODE (arg))
2641 {
2642
2643 default:
2644 return INCOMPATIBLE_TYPE_BADNESS;
2645 }
2646
2647 break;
2648 case TYPE_CODE_SET:
2649 switch (TYPE_CODE (arg))
2650 {
2651 /* Not in C++ */
2652 case TYPE_CODE_SET:
7ba81444
MS
2653 return rank_one_type (TYPE_FIELD_TYPE (parm, 0),
2654 TYPE_FIELD_TYPE (arg, 0));
c5aa993b
JM
2655 default:
2656 return INCOMPATIBLE_TYPE_BADNESS;
2657 }
2658 break;
2659 case TYPE_CODE_VOID:
2660 default:
2661 return INCOMPATIBLE_TYPE_BADNESS;
2662 } /* switch (TYPE_CODE (arg)) */
c906108c
SS
2663}
2664
c5aa993b 2665
0963b4bd 2666/* End of functions for overload resolution. */
c906108c 2667
c906108c 2668static void
fba45db2 2669print_bit_vector (B_TYPE *bits, int nbits)
c906108c
SS
2670{
2671 int bitno;
2672
2673 for (bitno = 0; bitno < nbits; bitno++)
2674 {
2675 if ((bitno % 8) == 0)
2676 {
2677 puts_filtered (" ");
2678 }
2679 if (B_TST (bits, bitno))
a3f17187 2680 printf_filtered (("1"));
c906108c 2681 else
a3f17187 2682 printf_filtered (("0"));
c906108c
SS
2683 }
2684}
2685
ad2f7632 2686/* Note the first arg should be the "this" pointer, we may not want to
7ba81444
MS
2687 include it since we may get into a infinitely recursive
2688 situation. */
c906108c
SS
2689
2690static void
ad2f7632 2691print_arg_types (struct field *args, int nargs, int spaces)
c906108c
SS
2692{
2693 if (args != NULL)
2694 {
ad2f7632
DJ
2695 int i;
2696
2697 for (i = 0; i < nargs; i++)
2698 recursive_dump_type (args[i].type, spaces + 2);
c906108c
SS
2699 }
2700}
2701
d6a843b5
JK
2702int
2703field_is_static (struct field *f)
2704{
2705 /* "static" fields are the fields whose location is not relative
2706 to the address of the enclosing struct. It would be nice to
2707 have a dedicated flag that would be set for static fields when
2708 the type is being created. But in practice, checking the field
254e6b9e 2709 loc_kind should give us an accurate answer. */
d6a843b5
JK
2710 return (FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSNAME
2711 || FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSADDR);
2712}
2713
c906108c 2714static void
fba45db2 2715dump_fn_fieldlists (struct type *type, int spaces)
c906108c
SS
2716{
2717 int method_idx;
2718 int overload_idx;
2719 struct fn_field *f;
2720
2721 printfi_filtered (spaces, "fn_fieldlists ");
d4f3574e 2722 gdb_print_host_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
c906108c
SS
2723 printf_filtered ("\n");
2724 for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
2725 {
2726 f = TYPE_FN_FIELDLIST1 (type, method_idx);
2727 printfi_filtered (spaces + 2, "[%d] name '%s' (",
2728 method_idx,
2729 TYPE_FN_FIELDLIST_NAME (type, method_idx));
d4f3574e
SS
2730 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
2731 gdb_stdout);
a3f17187 2732 printf_filtered (_(") length %d\n"),
c906108c
SS
2733 TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
2734 for (overload_idx = 0;
2735 overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
2736 overload_idx++)
2737 {
2738 printfi_filtered (spaces + 4, "[%d] physname '%s' (",
2739 overload_idx,
2740 TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
d4f3574e
SS
2741 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
2742 gdb_stdout);
c906108c
SS
2743 printf_filtered (")\n");
2744 printfi_filtered (spaces + 8, "type ");
7ba81444
MS
2745 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx),
2746 gdb_stdout);
c906108c
SS
2747 printf_filtered ("\n");
2748
2749 recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
2750 spaces + 8 + 2);
2751
2752 printfi_filtered (spaces + 8, "args ");
7ba81444
MS
2753 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx),
2754 gdb_stdout);
c906108c
SS
2755 printf_filtered ("\n");
2756
ad2f7632 2757 print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx),
7ba81444
MS
2758 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f,
2759 overload_idx)),
ad2f7632 2760 spaces);
c906108c 2761 printfi_filtered (spaces + 8, "fcontext ");
d4f3574e
SS
2762 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
2763 gdb_stdout);
c906108c
SS
2764 printf_filtered ("\n");
2765
2766 printfi_filtered (spaces + 8, "is_const %d\n",
2767 TYPE_FN_FIELD_CONST (f, overload_idx));
2768 printfi_filtered (spaces + 8, "is_volatile %d\n",
2769 TYPE_FN_FIELD_VOLATILE (f, overload_idx));
2770 printfi_filtered (spaces + 8, "is_private %d\n",
2771 TYPE_FN_FIELD_PRIVATE (f, overload_idx));
2772 printfi_filtered (spaces + 8, "is_protected %d\n",
2773 TYPE_FN_FIELD_PROTECTED (f, overload_idx));
2774 printfi_filtered (spaces + 8, "is_stub %d\n",
2775 TYPE_FN_FIELD_STUB (f, overload_idx));
2776 printfi_filtered (spaces + 8, "voffset %u\n",
2777 TYPE_FN_FIELD_VOFFSET (f, overload_idx));
2778 }
2779 }
2780}
2781
2782static void
fba45db2 2783print_cplus_stuff (struct type *type, int spaces)
c906108c
SS
2784{
2785 printfi_filtered (spaces, "n_baseclasses %d\n",
2786 TYPE_N_BASECLASSES (type));
2787 printfi_filtered (spaces, "nfn_fields %d\n",
2788 TYPE_NFN_FIELDS (type));
2789 printfi_filtered (spaces, "nfn_fields_total %d\n",
2790 TYPE_NFN_FIELDS_TOTAL (type));
2791 if (TYPE_N_BASECLASSES (type) > 0)
2792 {
2793 printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
2794 TYPE_N_BASECLASSES (type));
7ba81444
MS
2795 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type),
2796 gdb_stdout);
c906108c
SS
2797 printf_filtered (")");
2798
2799 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
2800 TYPE_N_BASECLASSES (type));
2801 puts_filtered ("\n");
2802 }
2803 if (TYPE_NFIELDS (type) > 0)
2804 {
2805 if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
2806 {
7ba81444
MS
2807 printfi_filtered (spaces,
2808 "private_field_bits (%d bits at *",
c906108c 2809 TYPE_NFIELDS (type));
7ba81444
MS
2810 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type),
2811 gdb_stdout);
c906108c
SS
2812 printf_filtered (")");
2813 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
2814 TYPE_NFIELDS (type));
2815 puts_filtered ("\n");
2816 }
2817 if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
2818 {
7ba81444
MS
2819 printfi_filtered (spaces,
2820 "protected_field_bits (%d bits at *",
c906108c 2821 TYPE_NFIELDS (type));
7ba81444
MS
2822 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type),
2823 gdb_stdout);
c906108c
SS
2824 printf_filtered (")");
2825 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
2826 TYPE_NFIELDS (type));
2827 puts_filtered ("\n");
2828 }
2829 }
2830 if (TYPE_NFN_FIELDS (type) > 0)
2831 {
2832 dump_fn_fieldlists (type, spaces);
2833 }
2834}
2835
b4ba55a1
JB
2836/* Print the contents of the TYPE's type_specific union, assuming that
2837 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
2838
2839static void
2840print_gnat_stuff (struct type *type, int spaces)
2841{
2842 struct type *descriptive_type = TYPE_DESCRIPTIVE_TYPE (type);
2843
2844 recursive_dump_type (descriptive_type, spaces + 2);
2845}
2846
c906108c
SS
2847static struct obstack dont_print_type_obstack;
2848
2849void
fba45db2 2850recursive_dump_type (struct type *type, int spaces)
c906108c
SS
2851{
2852 int idx;
2853
2854 if (spaces == 0)
2855 obstack_begin (&dont_print_type_obstack, 0);
2856
2857 if (TYPE_NFIELDS (type) > 0
b4ba55a1 2858 || (HAVE_CPLUS_STRUCT (type) && TYPE_NFN_FIELDS (type) > 0))
c906108c
SS
2859 {
2860 struct type **first_dont_print
7ba81444 2861 = (struct type **) obstack_base (&dont_print_type_obstack);
c906108c 2862
7ba81444
MS
2863 int i = (struct type **)
2864 obstack_next_free (&dont_print_type_obstack) - first_dont_print;
c906108c
SS
2865
2866 while (--i >= 0)
2867 {
2868 if (type == first_dont_print[i])
2869 {
2870 printfi_filtered (spaces, "type node ");
d4f3574e 2871 gdb_print_host_address (type, gdb_stdout);
a3f17187 2872 printf_filtered (_(" <same as already seen type>\n"));
c906108c
SS
2873 return;
2874 }
2875 }
2876
2877 obstack_ptr_grow (&dont_print_type_obstack, type);
2878 }
2879
2880 printfi_filtered (spaces, "type node ");
d4f3574e 2881 gdb_print_host_address (type, gdb_stdout);
c906108c
SS
2882 printf_filtered ("\n");
2883 printfi_filtered (spaces, "name '%s' (",
2884 TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
d4f3574e 2885 gdb_print_host_address (TYPE_NAME (type), gdb_stdout);
c906108c 2886 printf_filtered (")\n");
e9e79dd9
FF
2887 printfi_filtered (spaces, "tagname '%s' (",
2888 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : "<NULL>");
2889 gdb_print_host_address (TYPE_TAG_NAME (type), gdb_stdout);
2890 printf_filtered (")\n");
c906108c
SS
2891 printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
2892 switch (TYPE_CODE (type))
2893 {
c5aa993b
JM
2894 case TYPE_CODE_UNDEF:
2895 printf_filtered ("(TYPE_CODE_UNDEF)");
2896 break;
2897 case TYPE_CODE_PTR:
2898 printf_filtered ("(TYPE_CODE_PTR)");
2899 break;
2900 case TYPE_CODE_ARRAY:
2901 printf_filtered ("(TYPE_CODE_ARRAY)");
2902 break;
2903 case TYPE_CODE_STRUCT:
2904 printf_filtered ("(TYPE_CODE_STRUCT)");
2905 break;
2906 case TYPE_CODE_UNION:
2907 printf_filtered ("(TYPE_CODE_UNION)");
2908 break;
2909 case TYPE_CODE_ENUM:
2910 printf_filtered ("(TYPE_CODE_ENUM)");
2911 break;
4f2aea11
MK
2912 case TYPE_CODE_FLAGS:
2913 printf_filtered ("(TYPE_CODE_FLAGS)");
2914 break;
c5aa993b
JM
2915 case TYPE_CODE_FUNC:
2916 printf_filtered ("(TYPE_CODE_FUNC)");
2917 break;
2918 case TYPE_CODE_INT:
2919 printf_filtered ("(TYPE_CODE_INT)");
2920 break;
2921 case TYPE_CODE_FLT:
2922 printf_filtered ("(TYPE_CODE_FLT)");
2923 break;
2924 case TYPE_CODE_VOID:
2925 printf_filtered ("(TYPE_CODE_VOID)");
2926 break;
2927 case TYPE_CODE_SET:
2928 printf_filtered ("(TYPE_CODE_SET)");
2929 break;
2930 case TYPE_CODE_RANGE:
2931 printf_filtered ("(TYPE_CODE_RANGE)");
2932 break;
2933 case TYPE_CODE_STRING:
2934 printf_filtered ("(TYPE_CODE_STRING)");
2935 break;
e9e79dd9
FF
2936 case TYPE_CODE_BITSTRING:
2937 printf_filtered ("(TYPE_CODE_BITSTRING)");
2938 break;
c5aa993b
JM
2939 case TYPE_CODE_ERROR:
2940 printf_filtered ("(TYPE_CODE_ERROR)");
2941 break;
0d5de010
DJ
2942 case TYPE_CODE_MEMBERPTR:
2943 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
2944 break;
2945 case TYPE_CODE_METHODPTR:
2946 printf_filtered ("(TYPE_CODE_METHODPTR)");
c5aa993b
JM
2947 break;
2948 case TYPE_CODE_METHOD:
2949 printf_filtered ("(TYPE_CODE_METHOD)");
2950 break;
2951 case TYPE_CODE_REF:
2952 printf_filtered ("(TYPE_CODE_REF)");
2953 break;
2954 case TYPE_CODE_CHAR:
2955 printf_filtered ("(TYPE_CODE_CHAR)");
2956 break;
2957 case TYPE_CODE_BOOL:
2958 printf_filtered ("(TYPE_CODE_BOOL)");
2959 break;
e9e79dd9
FF
2960 case TYPE_CODE_COMPLEX:
2961 printf_filtered ("(TYPE_CODE_COMPLEX)");
2962 break;
c5aa993b
JM
2963 case TYPE_CODE_TYPEDEF:
2964 printf_filtered ("(TYPE_CODE_TYPEDEF)");
2965 break;
5c4e30ca
DC
2966 case TYPE_CODE_NAMESPACE:
2967 printf_filtered ("(TYPE_CODE_NAMESPACE)");
2968 break;
c5aa993b
JM
2969 default:
2970 printf_filtered ("(UNKNOWN TYPE CODE)");
2971 break;
c906108c
SS
2972 }
2973 puts_filtered ("\n");
2974 printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
e9bb382b
UW
2975 if (TYPE_OBJFILE_OWNED (type))
2976 {
2977 printfi_filtered (spaces, "objfile ");
2978 gdb_print_host_address (TYPE_OWNER (type).objfile, gdb_stdout);
2979 }
2980 else
2981 {
2982 printfi_filtered (spaces, "gdbarch ");
2983 gdb_print_host_address (TYPE_OWNER (type).gdbarch, gdb_stdout);
2984 }
c906108c
SS
2985 printf_filtered ("\n");
2986 printfi_filtered (spaces, "target_type ");
d4f3574e 2987 gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout);
c906108c
SS
2988 printf_filtered ("\n");
2989 if (TYPE_TARGET_TYPE (type) != NULL)
2990 {
2991 recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
2992 }
2993 printfi_filtered (spaces, "pointer_type ");
d4f3574e 2994 gdb_print_host_address (TYPE_POINTER_TYPE (type), gdb_stdout);
c906108c
SS
2995 printf_filtered ("\n");
2996 printfi_filtered (spaces, "reference_type ");
d4f3574e 2997 gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
c906108c 2998 printf_filtered ("\n");
2fdde8f8
DJ
2999 printfi_filtered (spaces, "type_chain ");
3000 gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);
e9e79dd9 3001 printf_filtered ("\n");
7ba81444
MS
3002 printfi_filtered (spaces, "instance_flags 0x%x",
3003 TYPE_INSTANCE_FLAGS (type));
2fdde8f8
DJ
3004 if (TYPE_CONST (type))
3005 {
3006 puts_filtered (" TYPE_FLAG_CONST");
3007 }
3008 if (TYPE_VOLATILE (type))
3009 {
3010 puts_filtered (" TYPE_FLAG_VOLATILE");
3011 }
3012 if (TYPE_CODE_SPACE (type))
3013 {
3014 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3015 }
3016 if (TYPE_DATA_SPACE (type))
3017 {
3018 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3019 }
8b2dbe47
KB
3020 if (TYPE_ADDRESS_CLASS_1 (type))
3021 {
3022 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3023 }
3024 if (TYPE_ADDRESS_CLASS_2 (type))
3025 {
3026 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3027 }
2fdde8f8 3028 puts_filtered ("\n");
876cecd0
TT
3029
3030 printfi_filtered (spaces, "flags");
762a036f 3031 if (TYPE_UNSIGNED (type))
c906108c
SS
3032 {
3033 puts_filtered (" TYPE_FLAG_UNSIGNED");
3034 }
762a036f
FF
3035 if (TYPE_NOSIGN (type))
3036 {
3037 puts_filtered (" TYPE_FLAG_NOSIGN");
3038 }
3039 if (TYPE_STUB (type))
c906108c
SS
3040 {
3041 puts_filtered (" TYPE_FLAG_STUB");
3042 }
762a036f
FF
3043 if (TYPE_TARGET_STUB (type))
3044 {
3045 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3046 }
3047 if (TYPE_STATIC (type))
3048 {
3049 puts_filtered (" TYPE_FLAG_STATIC");
3050 }
762a036f
FF
3051 if (TYPE_PROTOTYPED (type))
3052 {
3053 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3054 }
3055 if (TYPE_INCOMPLETE (type))
3056 {
3057 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3058 }
762a036f
FF
3059 if (TYPE_VARARGS (type))
3060 {
3061 puts_filtered (" TYPE_FLAG_VARARGS");
3062 }
f5f8a009
EZ
3063 /* This is used for things like AltiVec registers on ppc. Gcc emits
3064 an attribute for the array type, which tells whether or not we
3065 have a vector, instead of a regular array. */
3066 if (TYPE_VECTOR (type))
3067 {
3068 puts_filtered (" TYPE_FLAG_VECTOR");
3069 }
876cecd0
TT
3070 if (TYPE_FIXED_INSTANCE (type))
3071 {
3072 puts_filtered (" TYPE_FIXED_INSTANCE");
3073 }
3074 if (TYPE_STUB_SUPPORTED (type))
3075 {
3076 puts_filtered (" TYPE_STUB_SUPPORTED");
3077 }
3078 if (TYPE_NOTTEXT (type))
3079 {
3080 puts_filtered (" TYPE_NOTTEXT");
3081 }
c906108c
SS
3082 puts_filtered ("\n");
3083 printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
d4f3574e 3084 gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
c906108c
SS
3085 puts_filtered ("\n");
3086 for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
3087 {
3088 printfi_filtered (spaces + 2,
3089 "[%d] bitpos %d bitsize %d type ",
3090 idx, TYPE_FIELD_BITPOS (type, idx),
3091 TYPE_FIELD_BITSIZE (type, idx));
d4f3574e 3092 gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
c906108c
SS
3093 printf_filtered (" name '%s' (",
3094 TYPE_FIELD_NAME (type, idx) != NULL
3095 ? TYPE_FIELD_NAME (type, idx)
3096 : "<NULL>");
d4f3574e 3097 gdb_print_host_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
c906108c
SS
3098 printf_filtered (")\n");
3099 if (TYPE_FIELD_TYPE (type, idx) != NULL)
3100 {
3101 recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
3102 }
3103 }
43bbcdc2
PH
3104 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
3105 {
3106 printfi_filtered (spaces, "low %s%s high %s%s\n",
3107 plongest (TYPE_LOW_BOUND (type)),
3108 TYPE_LOW_BOUND_UNDEFINED (type) ? " (undefined)" : "",
3109 plongest (TYPE_HIGH_BOUND (type)),
3e43a32a
MS
3110 TYPE_HIGH_BOUND_UNDEFINED (type)
3111 ? " (undefined)" : "");
43bbcdc2 3112 }
c906108c 3113 printfi_filtered (spaces, "vptr_basetype ");
d4f3574e 3114 gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
c906108c
SS
3115 puts_filtered ("\n");
3116 if (TYPE_VPTR_BASETYPE (type) != NULL)
3117 {
3118 recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
3119 }
7ba81444
MS
3120 printfi_filtered (spaces, "vptr_fieldno %d\n",
3121 TYPE_VPTR_FIELDNO (type));
c906108c 3122
b4ba55a1
JB
3123 switch (TYPE_SPECIFIC_FIELD (type))
3124 {
3125 case TYPE_SPECIFIC_CPLUS_STUFF:
3126 printfi_filtered (spaces, "cplus_stuff ");
3127 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type),
3128 gdb_stdout);
3129 puts_filtered ("\n");
3130 print_cplus_stuff (type, spaces);
3131 break;
8da61cc4 3132
b4ba55a1
JB
3133 case TYPE_SPECIFIC_GNAT_STUFF:
3134 printfi_filtered (spaces, "gnat_stuff ");
3135 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type), gdb_stdout);
3136 puts_filtered ("\n");
3137 print_gnat_stuff (type, spaces);
3138 break;
701c159d 3139
b4ba55a1
JB
3140 case TYPE_SPECIFIC_FLOATFORMAT:
3141 printfi_filtered (spaces, "floatformat ");
3142 if (TYPE_FLOATFORMAT (type) == NULL)
3143 puts_filtered ("(null)");
3144 else
3145 {
3146 puts_filtered ("{ ");
3147 if (TYPE_FLOATFORMAT (type)[0] == NULL
3148 || TYPE_FLOATFORMAT (type)[0]->name == NULL)
3149 puts_filtered ("(null)");
3150 else
3151 puts_filtered (TYPE_FLOATFORMAT (type)[0]->name);
3152
3153 puts_filtered (", ");
3154 if (TYPE_FLOATFORMAT (type)[1] == NULL
3155 || TYPE_FLOATFORMAT (type)[1]->name == NULL)
3156 puts_filtered ("(null)");
3157 else
3158 puts_filtered (TYPE_FLOATFORMAT (type)[1]->name);
3159
3160 puts_filtered (" }");
3161 }
3162 puts_filtered ("\n");
3163 break;
c906108c 3164
b4ba55a1
JB
3165 case TYPE_SPECIFIC_CALLING_CONVENTION:
3166 printfi_filtered (spaces, "calling_convention %d\n",
3167 TYPE_CALLING_CONVENTION (type));
3168 break;
c906108c 3169 }
b4ba55a1 3170
c906108c
SS
3171 if (spaces == 0)
3172 obstack_free (&dont_print_type_obstack, NULL);
3173}
3174
ae5a43e0
DJ
3175/* Trivial helpers for the libiberty hash table, for mapping one
3176 type to another. */
3177
3178struct type_pair
3179{
3180 struct type *old, *new;
3181};
3182
3183static hashval_t
3184type_pair_hash (const void *item)
3185{
3186 const struct type_pair *pair = item;
d8734c88 3187
ae5a43e0
DJ
3188 return htab_hash_pointer (pair->old);
3189}
3190
3191static int
3192type_pair_eq (const void *item_lhs, const void *item_rhs)
3193{
3194 const struct type_pair *lhs = item_lhs, *rhs = item_rhs;
d8734c88 3195
ae5a43e0
DJ
3196 return lhs->old == rhs->old;
3197}
3198
3199/* Allocate the hash table used by copy_type_recursive to walk
3200 types without duplicates. We use OBJFILE's obstack, because
3201 OBJFILE is about to be deleted. */
3202
3203htab_t
3204create_copied_types_hash (struct objfile *objfile)
3205{
3206 return htab_create_alloc_ex (1, type_pair_hash, type_pair_eq,
3207 NULL, &objfile->objfile_obstack,
3208 hashtab_obstack_allocate,
3209 dummy_obstack_deallocate);
3210}
3211
7ba81444
MS
3212/* Recursively copy (deep copy) TYPE, if it is associated with
3213 OBJFILE. Return a new type allocated using malloc, a saved type if
3214 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
3215 not associated with OBJFILE. */
ae5a43e0
DJ
3216
3217struct type *
7ba81444
MS
3218copy_type_recursive (struct objfile *objfile,
3219 struct type *type,
ae5a43e0
DJ
3220 htab_t copied_types)
3221{
3222 struct type_pair *stored, pair;
3223 void **slot;
3224 struct type *new_type;
3225
e9bb382b 3226 if (! TYPE_OBJFILE_OWNED (type))
ae5a43e0
DJ
3227 return type;
3228
7ba81444
MS
3229 /* This type shouldn't be pointing to any types in other objfiles;
3230 if it did, the type might disappear unexpectedly. */
ae5a43e0
DJ
3231 gdb_assert (TYPE_OBJFILE (type) == objfile);
3232
3233 pair.old = type;
3234 slot = htab_find_slot (copied_types, &pair, INSERT);
3235 if (*slot != NULL)
3236 return ((struct type_pair *) *slot)->new;
3237
e9bb382b 3238 new_type = alloc_type_arch (get_type_arch (type));
ae5a43e0
DJ
3239
3240 /* We must add the new type to the hash table immediately, in case
3241 we encounter this type again during a recursive call below. */
3e43a32a
MS
3242 stored
3243 = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair));
ae5a43e0
DJ
3244 stored->old = type;
3245 stored->new = new_type;
3246 *slot = stored;
3247
876cecd0
TT
3248 /* Copy the common fields of types. For the main type, we simply
3249 copy the entire thing and then update specific fields as needed. */
3250 *TYPE_MAIN_TYPE (new_type) = *TYPE_MAIN_TYPE (type);
e9bb382b
UW
3251 TYPE_OBJFILE_OWNED (new_type) = 0;
3252 TYPE_OWNER (new_type).gdbarch = get_type_arch (type);
876cecd0 3253
ae5a43e0
DJ
3254 if (TYPE_NAME (type))
3255 TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type));
3256 if (TYPE_TAG_NAME (type))
3257 TYPE_TAG_NAME (new_type) = xstrdup (TYPE_TAG_NAME (type));
ae5a43e0
DJ
3258
3259 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
3260 TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
3261
3262 /* Copy the fields. */
ae5a43e0
DJ
3263 if (TYPE_NFIELDS (type))
3264 {
3265 int i, nfields;
3266
3267 nfields = TYPE_NFIELDS (type);
1deafd4e 3268 TYPE_FIELDS (new_type) = XCALLOC (nfields, struct field);
ae5a43e0
DJ
3269 for (i = 0; i < nfields; i++)
3270 {
7ba81444
MS
3271 TYPE_FIELD_ARTIFICIAL (new_type, i) =
3272 TYPE_FIELD_ARTIFICIAL (type, i);
ae5a43e0
DJ
3273 TYPE_FIELD_BITSIZE (new_type, i) = TYPE_FIELD_BITSIZE (type, i);
3274 if (TYPE_FIELD_TYPE (type, i))
3275 TYPE_FIELD_TYPE (new_type, i)
3276 = copy_type_recursive (objfile, TYPE_FIELD_TYPE (type, i),
3277 copied_types);
3278 if (TYPE_FIELD_NAME (type, i))
7ba81444
MS
3279 TYPE_FIELD_NAME (new_type, i) =
3280 xstrdup (TYPE_FIELD_NAME (type, i));
d6a843b5 3281 switch (TYPE_FIELD_LOC_KIND (type, i))
ae5a43e0 3282 {
d6a843b5
JK
3283 case FIELD_LOC_KIND_BITPOS:
3284 SET_FIELD_BITPOS (TYPE_FIELD (new_type, i),
3285 TYPE_FIELD_BITPOS (type, i));
3286 break;
3287 case FIELD_LOC_KIND_PHYSADDR:
3288 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i),
3289 TYPE_FIELD_STATIC_PHYSADDR (type, i));
3290 break;
3291 case FIELD_LOC_KIND_PHYSNAME:
3292 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i),
3293 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type,
3294 i)));
3295 break;
3296 default:
3297 internal_error (__FILE__, __LINE__,
3298 _("Unexpected type field location kind: %d"),
3299 TYPE_FIELD_LOC_KIND (type, i));
ae5a43e0
DJ
3300 }
3301 }
3302 }
3303
0963b4bd 3304 /* For range types, copy the bounds information. */
43bbcdc2
PH
3305 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
3306 {
3307 TYPE_RANGE_DATA (new_type) = xmalloc (sizeof (struct range_bounds));
3308 *TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type);
3309 }
3310
ae5a43e0
DJ
3311 /* Copy pointers to other types. */
3312 if (TYPE_TARGET_TYPE (type))
7ba81444
MS
3313 TYPE_TARGET_TYPE (new_type) =
3314 copy_type_recursive (objfile,
3315 TYPE_TARGET_TYPE (type),
3316 copied_types);
ae5a43e0 3317 if (TYPE_VPTR_BASETYPE (type))
7ba81444
MS
3318 TYPE_VPTR_BASETYPE (new_type) =
3319 copy_type_recursive (objfile,
3320 TYPE_VPTR_BASETYPE (type),
3321 copied_types);
ae5a43e0
DJ
3322 /* Maybe copy the type_specific bits.
3323
3324 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3325 base classes and methods. There's no fundamental reason why we
3326 can't, but at the moment it is not needed. */
3327
3328 if (TYPE_CODE (type) == TYPE_CODE_FLT)
d5d6fca5 3329 TYPE_FLOATFORMAT (new_type) = TYPE_FLOATFORMAT (type);
ae5a43e0
DJ
3330 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
3331 || TYPE_CODE (type) == TYPE_CODE_UNION
ae5a43e0
DJ
3332 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
3333 INIT_CPLUS_SPECIFIC (new_type);
3334
3335 return new_type;
3336}
3337
4af88198
JB
3338/* Make a copy of the given TYPE, except that the pointer & reference
3339 types are not preserved.
3340
3341 This function assumes that the given type has an associated objfile.
3342 This objfile is used to allocate the new type. */
3343
3344struct type *
3345copy_type (const struct type *type)
3346{
3347 struct type *new_type;
3348
e9bb382b 3349 gdb_assert (TYPE_OBJFILE_OWNED (type));
4af88198 3350
e9bb382b 3351 new_type = alloc_type_copy (type);
4af88198
JB
3352 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
3353 TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
3354 memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type),
3355 sizeof (struct main_type));
3356
3357 return new_type;
3358}
3359
e9bb382b
UW
3360
3361/* Helper functions to initialize architecture-specific types. */
3362
3363/* Allocate a type structure associated with GDBARCH and set its
3364 CODE, LENGTH, and NAME fields. */
3365struct type *
3366arch_type (struct gdbarch *gdbarch,
3367 enum type_code code, int length, char *name)
3368{
3369 struct type *type;
3370
3371 type = alloc_type_arch (gdbarch);
3372 TYPE_CODE (type) = code;
3373 TYPE_LENGTH (type) = length;
3374
3375 if (name)
3376 TYPE_NAME (type) = xstrdup (name);
3377
3378 return type;
3379}
3380
3381/* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
3382 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3383 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3384struct type *
3385arch_integer_type (struct gdbarch *gdbarch,
3386 int bit, int unsigned_p, char *name)
3387{
3388 struct type *t;
3389
3390 t = arch_type (gdbarch, TYPE_CODE_INT, bit / TARGET_CHAR_BIT, name);
3391 if (unsigned_p)
3392 TYPE_UNSIGNED (t) = 1;
3393 if (name && strcmp (name, "char") == 0)
3394 TYPE_NOSIGN (t) = 1;
3395
3396 return t;
3397}
3398
3399/* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
3400 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3401 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3402struct type *
3403arch_character_type (struct gdbarch *gdbarch,
3404 int bit, int unsigned_p, char *name)
3405{
3406 struct type *t;
3407
3408 t = arch_type (gdbarch, TYPE_CODE_CHAR, bit / TARGET_CHAR_BIT, name);
3409 if (unsigned_p)
3410 TYPE_UNSIGNED (t) = 1;
3411
3412 return t;
3413}
3414
3415/* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
3416 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3417 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3418struct type *
3419arch_boolean_type (struct gdbarch *gdbarch,
3420 int bit, int unsigned_p, char *name)
3421{
3422 struct type *t;
3423
3424 t = arch_type (gdbarch, TYPE_CODE_BOOL, bit / TARGET_CHAR_BIT, name);
3425 if (unsigned_p)
3426 TYPE_UNSIGNED (t) = 1;
3427
3428 return t;
3429}
3430
3431/* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
3432 BIT is the type size in bits; if BIT equals -1, the size is
3433 determined by the floatformat. NAME is the type name. Set the
3434 TYPE_FLOATFORMAT from FLOATFORMATS. */
27067745 3435struct type *
e9bb382b
UW
3436arch_float_type (struct gdbarch *gdbarch,
3437 int bit, char *name, const struct floatformat **floatformats)
8da61cc4
DJ
3438{
3439 struct type *t;
3440
3441 if (bit == -1)
3442 {
3443 gdb_assert (floatformats != NULL);
3444 gdb_assert (floatformats[0] != NULL && floatformats[1] != NULL);
3445 bit = floatformats[0]->totalsize;
3446 }
3447 gdb_assert (bit >= 0);
3448
e9bb382b 3449 t = arch_type (gdbarch, TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, name);
8da61cc4
DJ
3450 TYPE_FLOATFORMAT (t) = floatformats;
3451 return t;
3452}
3453
e9bb382b
UW
3454/* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
3455 NAME is the type name. TARGET_TYPE is the component float type. */
27067745 3456struct type *
e9bb382b
UW
3457arch_complex_type (struct gdbarch *gdbarch,
3458 char *name, struct type *target_type)
27067745
UW
3459{
3460 struct type *t;
d8734c88 3461
e9bb382b
UW
3462 t = arch_type (gdbarch, TYPE_CODE_COMPLEX,
3463 2 * TYPE_LENGTH (target_type), name);
27067745
UW
3464 TYPE_TARGET_TYPE (t) = target_type;
3465 return t;
3466}
3467
e9bb382b 3468/* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
eb90ce83 3469 NAME is the type name. LENGTH is the size of the flag word in bytes. */
e9bb382b
UW
3470struct type *
3471arch_flags_type (struct gdbarch *gdbarch, char *name, int length)
3472{
3473 int nfields = length * TARGET_CHAR_BIT;
3474 struct type *type;
3475
3476 type = arch_type (gdbarch, TYPE_CODE_FLAGS, length, name);
3477 TYPE_UNSIGNED (type) = 1;
3478 TYPE_NFIELDS (type) = nfields;
3479 TYPE_FIELDS (type) = TYPE_ZALLOC (type, nfields * sizeof (struct field));
3480
3481 return type;
3482}
3483
3484/* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
3485 position BITPOS is called NAME. */
3486void
3487append_flags_type_flag (struct type *type, int bitpos, char *name)
3488{
3489 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS);
3490 gdb_assert (bitpos < TYPE_NFIELDS (type));
3491 gdb_assert (bitpos >= 0);
3492
3493 if (name)
3494 {
3495 TYPE_FIELD_NAME (type, bitpos) = xstrdup (name);
3496 TYPE_FIELD_BITPOS (type, bitpos) = bitpos;
3497 }
3498 else
3499 {
3500 /* Don't show this field to the user. */
3501 TYPE_FIELD_BITPOS (type, bitpos) = -1;
3502 }
3503}
3504
3505/* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
3506 specified by CODE) associated with GDBARCH. NAME is the type name. */
3507struct type *
3508arch_composite_type (struct gdbarch *gdbarch, char *name, enum type_code code)
3509{
3510 struct type *t;
d8734c88 3511
e9bb382b
UW
3512 gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION);
3513 t = arch_type (gdbarch, code, 0, NULL);
3514 TYPE_TAG_NAME (t) = name;
3515 INIT_CPLUS_SPECIFIC (t);
3516 return t;
3517}
3518
3519/* Add new field with name NAME and type FIELD to composite type T.
f5dff777
DJ
3520 Do not set the field's position or adjust the type's length;
3521 the caller should do so. Return the new field. */
3522struct field *
3523append_composite_type_field_raw (struct type *t, char *name,
3524 struct type *field)
e9bb382b
UW
3525{
3526 struct field *f;
d8734c88 3527
e9bb382b
UW
3528 TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
3529 TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t),
3530 sizeof (struct field) * TYPE_NFIELDS (t));
3531 f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
3532 memset (f, 0, sizeof f[0]);
3533 FIELD_TYPE (f[0]) = field;
3534 FIELD_NAME (f[0]) = name;
f5dff777
DJ
3535 return f;
3536}
3537
3538/* Add new field with name NAME and type FIELD to composite type T.
3539 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
3540void
3541append_composite_type_field_aligned (struct type *t, char *name,
3542 struct type *field, int alignment)
3543{
3544 struct field *f = append_composite_type_field_raw (t, name, field);
d8734c88 3545
e9bb382b
UW
3546 if (TYPE_CODE (t) == TYPE_CODE_UNION)
3547 {
3548 if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
3549 TYPE_LENGTH (t) = TYPE_LENGTH (field);
3550 }
3551 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
3552 {
3553 TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
3554 if (TYPE_NFIELDS (t) > 1)
3555 {
3556 FIELD_BITPOS (f[0]) = (FIELD_BITPOS (f[-1])
3557 + (TYPE_LENGTH (FIELD_TYPE (f[-1]))
3558 * TARGET_CHAR_BIT));
3559
3560 if (alignment)
3561 {
3562 int left = FIELD_BITPOS (f[0]) % (alignment * TARGET_CHAR_BIT);
d8734c88 3563
e9bb382b
UW
3564 if (left)
3565 {
3566 FIELD_BITPOS (f[0]) += left;
3567 TYPE_LENGTH (t) += left / TARGET_CHAR_BIT;
3568 }
3569 }
3570 }
3571 }
3572}
3573
3574/* Add new field with name NAME and type FIELD to composite type T. */
3575void
3576append_composite_type_field (struct type *t, char *name,
3577 struct type *field)
3578{
3579 append_composite_type_field_aligned (t, name, field, 0);
3580}
3581
3582
000177f0
AC
3583static struct gdbarch_data *gdbtypes_data;
3584
3585const struct builtin_type *
3586builtin_type (struct gdbarch *gdbarch)
3587{
3588 return gdbarch_data (gdbarch, gdbtypes_data);
3589}
3590
3591static void *
3592gdbtypes_post_init (struct gdbarch *gdbarch)
3593{
3594 struct builtin_type *builtin_type
3595 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type);
3596
46bf5051 3597 /* Basic types. */
e9bb382b
UW
3598 builtin_type->builtin_void
3599 = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
3600 builtin_type->builtin_char
3601 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3602 !gdbarch_char_signed (gdbarch), "char");
3603 builtin_type->builtin_signed_char
3604 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3605 0, "signed char");
3606 builtin_type->builtin_unsigned_char
3607 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3608 1, "unsigned char");
3609 builtin_type->builtin_short
3610 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
3611 0, "short");
3612 builtin_type->builtin_unsigned_short
3613 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
3614 1, "unsigned short");
3615 builtin_type->builtin_int
3616 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
3617 0, "int");
3618 builtin_type->builtin_unsigned_int
3619 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
3620 1, "unsigned int");
3621 builtin_type->builtin_long
3622 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
3623 0, "long");
3624 builtin_type->builtin_unsigned_long
3625 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
3626 1, "unsigned long");
3627 builtin_type->builtin_long_long
3628 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
3629 0, "long long");
3630 builtin_type->builtin_unsigned_long_long
3631 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
3632 1, "unsigned long long");
70bd8e24 3633 builtin_type->builtin_float
e9bb382b 3634 = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
27067745 3635 "float", gdbarch_float_format (gdbarch));
70bd8e24 3636 builtin_type->builtin_double
e9bb382b 3637 = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
27067745 3638 "double", gdbarch_double_format (gdbarch));
70bd8e24 3639 builtin_type->builtin_long_double
e9bb382b 3640 = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
27067745 3641 "long double", gdbarch_long_double_format (gdbarch));
70bd8e24 3642 builtin_type->builtin_complex
e9bb382b
UW
3643 = arch_complex_type (gdbarch, "complex",
3644 builtin_type->builtin_float);
70bd8e24 3645 builtin_type->builtin_double_complex
e9bb382b
UW
3646 = arch_complex_type (gdbarch, "double complex",
3647 builtin_type->builtin_double);
3648 builtin_type->builtin_string
3649 = arch_type (gdbarch, TYPE_CODE_STRING, 1, "string");
3650 builtin_type->builtin_bool
3651 = arch_type (gdbarch, TYPE_CODE_BOOL, 1, "bool");
000177f0 3652
7678ef8f
TJB
3653 /* The following three are about decimal floating point types, which
3654 are 32-bits, 64-bits and 128-bits respectively. */
3655 builtin_type->builtin_decfloat
e9bb382b 3656 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 32 / 8, "_Decimal32");
7678ef8f 3657 builtin_type->builtin_decdouble
e9bb382b 3658 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 64 / 8, "_Decimal64");
7678ef8f 3659 builtin_type->builtin_declong
e9bb382b 3660 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 128 / 8, "_Decimal128");
7678ef8f 3661
69feb676 3662 /* "True" character types. */
e9bb382b
UW
3663 builtin_type->builtin_true_char
3664 = arch_character_type (gdbarch, TARGET_CHAR_BIT, 0, "true character");
3665 builtin_type->builtin_true_unsigned_char
3666 = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "true character");
69feb676 3667
df4df182 3668 /* Fixed-size integer types. */
e9bb382b
UW
3669 builtin_type->builtin_int0
3670 = arch_integer_type (gdbarch, 0, 0, "int0_t");
3671 builtin_type->builtin_int8
3672 = arch_integer_type (gdbarch, 8, 0, "int8_t");
3673 builtin_type->builtin_uint8
3674 = arch_integer_type (gdbarch, 8, 1, "uint8_t");
3675 builtin_type->builtin_int16
3676 = arch_integer_type (gdbarch, 16, 0, "int16_t");
3677 builtin_type->builtin_uint16
3678 = arch_integer_type (gdbarch, 16, 1, "uint16_t");
3679 builtin_type->builtin_int32
3680 = arch_integer_type (gdbarch, 32, 0, "int32_t");
3681 builtin_type->builtin_uint32
3682 = arch_integer_type (gdbarch, 32, 1, "uint32_t");
3683 builtin_type->builtin_int64
3684 = arch_integer_type (gdbarch, 64, 0, "int64_t");
3685 builtin_type->builtin_uint64
3686 = arch_integer_type (gdbarch, 64, 1, "uint64_t");
3687 builtin_type->builtin_int128
3688 = arch_integer_type (gdbarch, 128, 0, "int128_t");
3689 builtin_type->builtin_uint128
3690 = arch_integer_type (gdbarch, 128, 1, "uint128_t");
2844d6b5
KW
3691 TYPE_INSTANCE_FLAGS (builtin_type->builtin_int8) |=
3692 TYPE_INSTANCE_FLAG_NOTTEXT;
3693 TYPE_INSTANCE_FLAGS (builtin_type->builtin_uint8) |=
3694 TYPE_INSTANCE_FLAG_NOTTEXT;
df4df182 3695
9a22f0d0
PM
3696 /* Wide character types. */
3697 builtin_type->builtin_char16
3698 = arch_integer_type (gdbarch, 16, 0, "char16_t");
3699 builtin_type->builtin_char32
3700 = arch_integer_type (gdbarch, 32, 0, "char32_t");
3701
3702
46bf5051 3703 /* Default data/code pointer types. */
e9bb382b
UW
3704 builtin_type->builtin_data_ptr
3705 = lookup_pointer_type (builtin_type->builtin_void);
3706 builtin_type->builtin_func_ptr
3707 = lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
46bf5051 3708
78267919 3709 /* This type represents a GDB internal function. */
e9bb382b
UW
3710 builtin_type->internal_fn
3711 = arch_type (gdbarch, TYPE_CODE_INTERNAL_FUNCTION, 0,
3712 "<internal function>");
78267919 3713
46bf5051
UW
3714 return builtin_type;
3715}
3716
3717
3718/* This set of objfile-based types is intended to be used by symbol
3719 readers as basic types. */
3720
3721static const struct objfile_data *objfile_type_data;
3722
3723const struct objfile_type *
3724objfile_type (struct objfile *objfile)
3725{
3726 struct gdbarch *gdbarch;
3727 struct objfile_type *objfile_type
3728 = objfile_data (objfile, objfile_type_data);
3729
3730 if (objfile_type)
3731 return objfile_type;
3732
3733 objfile_type = OBSTACK_CALLOC (&objfile->objfile_obstack,
3734 1, struct objfile_type);
3735
3736 /* Use the objfile architecture to determine basic type properties. */
3737 gdbarch = get_objfile_arch (objfile);
3738
3739 /* Basic types. */
3740 objfile_type->builtin_void
3741 = init_type (TYPE_CODE_VOID, 1,
3742 0,
3743 "void", objfile);
3744
3745 objfile_type->builtin_char
3746 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3747 (TYPE_FLAG_NOSIGN
3748 | (gdbarch_char_signed (gdbarch) ? 0 : TYPE_FLAG_UNSIGNED)),
3749 "char", objfile);
3750 objfile_type->builtin_signed_char
3751 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3752 0,
3753 "signed char", objfile);
3754 objfile_type->builtin_unsigned_char
3755 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3756 TYPE_FLAG_UNSIGNED,
3757 "unsigned char", objfile);
3758 objfile_type->builtin_short
3759 = init_type (TYPE_CODE_INT,
3760 gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
3761 0, "short", objfile);
3762 objfile_type->builtin_unsigned_short
3763 = init_type (TYPE_CODE_INT,
3764 gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
3765 TYPE_FLAG_UNSIGNED, "unsigned short", objfile);
3766 objfile_type->builtin_int
3767 = init_type (TYPE_CODE_INT,
3768 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
3769 0, "int", objfile);
3770 objfile_type->builtin_unsigned_int
3771 = init_type (TYPE_CODE_INT,
3772 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
3773 TYPE_FLAG_UNSIGNED, "unsigned int", objfile);
3774 objfile_type->builtin_long
3775 = init_type (TYPE_CODE_INT,
3776 gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
3777 0, "long", objfile);
3778 objfile_type->builtin_unsigned_long
3779 = init_type (TYPE_CODE_INT,
3780 gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
3781 TYPE_FLAG_UNSIGNED, "unsigned long", objfile);
3782 objfile_type->builtin_long_long
3783 = init_type (TYPE_CODE_INT,
3784 gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
3785 0, "long long", objfile);
3786 objfile_type->builtin_unsigned_long_long
3787 = init_type (TYPE_CODE_INT,
3788 gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
3789 TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
3790
3791 objfile_type->builtin_float
3792 = init_type (TYPE_CODE_FLT,
3793 gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT,
3794 0, "float", objfile);
3795 TYPE_FLOATFORMAT (objfile_type->builtin_float)
3796 = gdbarch_float_format (gdbarch);
3797 objfile_type->builtin_double
3798 = init_type (TYPE_CODE_FLT,
3799 gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT,
3800 0, "double", objfile);
3801 TYPE_FLOATFORMAT (objfile_type->builtin_double)
3802 = gdbarch_double_format (gdbarch);
3803 objfile_type->builtin_long_double
3804 = init_type (TYPE_CODE_FLT,
3805 gdbarch_long_double_bit (gdbarch) / TARGET_CHAR_BIT,
3806 0, "long double", objfile);
3807 TYPE_FLOATFORMAT (objfile_type->builtin_long_double)
3808 = gdbarch_long_double_format (gdbarch);
3809
3810 /* This type represents a type that was unrecognized in symbol read-in. */
3811 objfile_type->builtin_error
3812 = init_type (TYPE_CODE_ERROR, 0, 0, "<unknown type>", objfile);
3813
3814 /* The following set of types is used for symbols with no
3815 debug information. */
3816 objfile_type->nodebug_text_symbol
3817 = init_type (TYPE_CODE_FUNC, 1, 0,
3818 "<text variable, no debug info>", objfile);
3819 TYPE_TARGET_TYPE (objfile_type->nodebug_text_symbol)
3820 = objfile_type->builtin_int;
3821 objfile_type->nodebug_data_symbol
3822 = init_type (TYPE_CODE_INT,
3823 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
3824 "<data variable, no debug info>", objfile);
3825 objfile_type->nodebug_unknown_symbol
3826 = init_type (TYPE_CODE_INT, 1, 0,
3827 "<variable (not text or data), no debug info>", objfile);
3828 objfile_type->nodebug_tls_symbol
3829 = init_type (TYPE_CODE_INT,
3830 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
3831 "<thread local variable, no debug info>", objfile);
000177f0
AC
3832
3833 /* NOTE: on some targets, addresses and pointers are not necessarily
3834 the same --- for example, on the D10V, pointers are 16 bits long,
3835 but addresses are 32 bits long. See doc/gdbint.texinfo,
3836 ``Pointers Are Not Always Addresses''.
3837
3838 The upshot is:
3839 - gdb's `struct type' always describes the target's
3840 representation.
3841 - gdb's `struct value' objects should always hold values in
3842 target form.
3843 - gdb's CORE_ADDR values are addresses in the unified virtual
3844 address space that the assembler and linker work with. Thus,
3845 since target_read_memory takes a CORE_ADDR as an argument, it
3846 can access any memory on the target, even if the processor has
3847 separate code and data address spaces.
3848
3849 So, for example:
3850 - If v is a value holding a D10V code pointer, its contents are
3851 in target form: a big-endian address left-shifted two bits.
3852 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3853 sizeof (void *) == 2 on the target.
3854
46bf5051
UW
3855 In this context, objfile_type->builtin_core_addr is a bit odd:
3856 it's a target type for a value the target will never see. It's
3857 only used to hold the values of (typeless) linker symbols, which
3858 are indeed in the unified virtual address space. */
000177f0 3859
46bf5051
UW
3860 objfile_type->builtin_core_addr
3861 = init_type (TYPE_CODE_INT,
3862 gdbarch_addr_bit (gdbarch) / 8,
3863 TYPE_FLAG_UNSIGNED, "__CORE_ADDR", objfile);
64c50499 3864
46bf5051
UW
3865 set_objfile_data (objfile, objfile_type_data, objfile_type);
3866 return objfile_type;
000177f0
AC
3867}
3868
46bf5051 3869
a14ed312 3870extern void _initialize_gdbtypes (void);
c906108c 3871void
fba45db2 3872_initialize_gdbtypes (void)
c906108c 3873{
5674de60 3874 gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
46bf5051 3875 objfile_type_data = register_objfile_data ();
5674de60 3876
3e43a32a
MS
3877 add_setshow_zinteger_cmd ("overload", no_class, &overload_debug,
3878 _("Set debugging of C++ overloading."),
3879 _("Show debugging of C++ overloading."),
3880 _("When enabled, ranking of the "
3881 "functions is displayed."),
85c07804 3882 NULL,
920d2a44 3883 show_overload_debug,
85c07804 3884 &setdebuglist, &showdebuglist);
5674de60 3885
7ba81444 3886 /* Add user knob for controlling resolution of opaque types. */
5674de60 3887 add_setshow_boolean_cmd ("opaque-type-resolution", class_support,
3e43a32a
MS
3888 &opaque_type_resolution,
3889 _("Set resolution of opaque struct/class/union"
3890 " types (if set before loading symbols)."),
3891 _("Show resolution of opaque struct/class/union"
3892 " types (if set before loading symbols)."),
3893 NULL, NULL,
5674de60
UW
3894 show_opaque_type_resolution,
3895 &setlist, &showlist);
c906108c 3896}
This page took 1.367355 seconds and 4 git commands to generate.