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