Automatic date update in version.in
[external/binutils.git] / gdb / gdbtypes.c
1 /* Support routines for manipulating internal types for GDB.
2
3    Copyright (C) 1992-2019 Free Software Foundation, Inc.
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 "bfd.h"
24 #include "symtab.h"
25 #include "symfile.h"
26 #include "objfiles.h"
27 #include "gdbtypes.h"
28 #include "expression.h"
29 #include "language.h"
30 #include "target.h"
31 #include "value.h"
32 #include "demangle.h"
33 #include "complaints.h"
34 #include "gdbcmd.h"
35 #include "cp-abi.h"
36 #include "hashtab.h"
37 #include "cp-support.h"
38 #include "bcache.h"
39 #include "dwarf2loc.h"
40 #include "gdbcore.h"
41 #include "floatformat.h"
42
43 /* Initialize BADNESS constants.  */
44
45 const struct rank LENGTH_MISMATCH_BADNESS = {100,0};
46
47 const struct rank TOO_FEW_PARAMS_BADNESS = {100,0};
48 const struct rank INCOMPATIBLE_TYPE_BADNESS = {100,0};
49
50 const struct rank EXACT_MATCH_BADNESS = {0,0};
51
52 const struct rank INTEGER_PROMOTION_BADNESS = {1,0};
53 const struct rank FLOAT_PROMOTION_BADNESS = {1,0};
54 const struct rank BASE_PTR_CONVERSION_BADNESS = {1,0};
55 const struct rank CV_CONVERSION_BADNESS = {1, 0};
56 const struct rank INTEGER_CONVERSION_BADNESS = {2,0};
57 const struct rank FLOAT_CONVERSION_BADNESS = {2,0};
58 const struct rank INT_FLOAT_CONVERSION_BADNESS = {2,0};
59 const struct rank VOID_PTR_CONVERSION_BADNESS = {2,0};
60 const struct rank BOOL_CONVERSION_BADNESS = {3,0};
61 const struct rank BASE_CONVERSION_BADNESS = {2,0};
62 const struct rank REFERENCE_CONVERSION_BADNESS = {2,0};
63 const struct rank NULL_POINTER_CONVERSION_BADNESS = {2,0};
64 const struct rank NS_POINTER_CONVERSION_BADNESS = {10,0};
65 const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS = {3,0};
66
67 /* Floatformat pairs.  */
68 const struct floatformat *floatformats_ieee_half[BFD_ENDIAN_UNKNOWN] = {
69   &floatformat_ieee_half_big,
70   &floatformat_ieee_half_little
71 };
72 const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN] = {
73   &floatformat_ieee_single_big,
74   &floatformat_ieee_single_little
75 };
76 const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN] = {
77   &floatformat_ieee_double_big,
78   &floatformat_ieee_double_little
79 };
80 const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN] = {
81   &floatformat_ieee_double_big,
82   &floatformat_ieee_double_littlebyte_bigword
83 };
84 const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN] = {
85   &floatformat_i387_ext,
86   &floatformat_i387_ext
87 };
88 const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN] = {
89   &floatformat_m68881_ext,
90   &floatformat_m68881_ext
91 };
92 const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN] = {
93   &floatformat_arm_ext_big,
94   &floatformat_arm_ext_littlebyte_bigword
95 };
96 const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN] = {
97   &floatformat_ia64_spill_big,
98   &floatformat_ia64_spill_little
99 };
100 const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN] = {
101   &floatformat_ia64_quad_big,
102   &floatformat_ia64_quad_little
103 };
104 const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN] = {
105   &floatformat_vax_f,
106   &floatformat_vax_f
107 };
108 const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN] = {
109   &floatformat_vax_d,
110   &floatformat_vax_d
111 };
112 const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN] = {
113   &floatformat_ibm_long_double_big,
114   &floatformat_ibm_long_double_little
115 };
116
117 /* Should opaque types be resolved?  */
118
119 static int opaque_type_resolution = 1;
120
121 /* A flag to enable printing of debugging information of C++
122    overloading.  */
123
124 unsigned int overload_debug = 0;
125
126 /* A flag to enable strict type checking.  */
127
128 static int strict_type_checking = 1;
129
130 /* A function to show whether opaque types are resolved.  */
131
132 static void
133 show_opaque_type_resolution (struct ui_file *file, int from_tty,
134                              struct cmd_list_element *c, 
135                              const char *value)
136 {
137   fprintf_filtered (file, _("Resolution of opaque struct/class/union types "
138                             "(if set before loading symbols) is %s.\n"),
139                     value);
140 }
141
142 /* A function to show whether C++ overload debugging is enabled.  */
143
144 static void
145 show_overload_debug (struct ui_file *file, int from_tty,
146                      struct cmd_list_element *c, const char *value)
147 {
148   fprintf_filtered (file, _("Debugging of C++ overloading is %s.\n"), 
149                     value);
150 }
151
152 /* A function to show the status of strict type checking.  */
153
154 static void
155 show_strict_type_checking (struct ui_file *file, int from_tty,
156                            struct cmd_list_element *c, const char *value)
157 {
158   fprintf_filtered (file, _("Strict type checking is %s.\n"), value);
159 }
160
161 \f
162 /* Allocate a new OBJFILE-associated type structure and fill it
163    with some defaults.  Space for the type structure is allocated
164    on the objfile's objfile_obstack.  */
165
166 struct type *
167 alloc_type (struct objfile *objfile)
168 {
169   struct type *type;
170
171   gdb_assert (objfile != NULL);
172
173   /* Alloc the structure and start off with all fields zeroed.  */
174   type = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct type);
175   TYPE_MAIN_TYPE (type) = OBSTACK_ZALLOC (&objfile->objfile_obstack,
176                                           struct main_type);
177   OBJSTAT (objfile, n_types++);
178
179   TYPE_OBJFILE_OWNED (type) = 1;
180   TYPE_OWNER (type).objfile = objfile;
181
182   /* Initialize the fields that might not be zero.  */
183
184   TYPE_CODE (type) = TYPE_CODE_UNDEF;
185   TYPE_CHAIN (type) = type;     /* Chain back to itself.  */
186
187   return type;
188 }
189
190 /* Allocate a new GDBARCH-associated type structure and fill it
191    with some defaults.  Space for the type structure is allocated
192    on the obstack associated with GDBARCH.  */
193
194 struct type *
195 alloc_type_arch (struct gdbarch *gdbarch)
196 {
197   struct type *type;
198
199   gdb_assert (gdbarch != NULL);
200
201   /* Alloc the structure and start off with all fields zeroed.  */
202
203   type = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct type);
204   TYPE_MAIN_TYPE (type) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct main_type);
205
206   TYPE_OBJFILE_OWNED (type) = 0;
207   TYPE_OWNER (type).gdbarch = gdbarch;
208
209   /* Initialize the fields that might not be zero.  */
210
211   TYPE_CODE (type) = TYPE_CODE_UNDEF;
212   TYPE_CHAIN (type) = type;     /* Chain back to itself.  */
213
214   return type;
215 }
216
217 /* If TYPE is objfile-associated, allocate a new type structure
218    associated with the same objfile.  If TYPE is gdbarch-associated,
219    allocate a new type structure associated with the same gdbarch.  */
220
221 struct type *
222 alloc_type_copy (const struct type *type)
223 {
224   if (TYPE_OBJFILE_OWNED (type))
225     return alloc_type (TYPE_OWNER (type).objfile);
226   else
227     return alloc_type_arch (TYPE_OWNER (type).gdbarch);
228 }
229
230 /* If TYPE is gdbarch-associated, return that architecture.
231    If TYPE is objfile-associated, return that objfile's architecture.  */
232
233 struct gdbarch *
234 get_type_arch (const struct type *type)
235 {
236   struct gdbarch *arch;
237
238   if (TYPE_OBJFILE_OWNED (type))
239     arch = get_objfile_arch (TYPE_OWNER (type).objfile);
240   else
241     arch = TYPE_OWNER (type).gdbarch;
242
243   /* The ARCH can be NULL if TYPE is associated with neither an objfile nor
244      a gdbarch, however, this is very rare, and even then, in most cases
245      that get_type_arch is called, we assume that a non-NULL value is
246      returned.  */
247   gdb_assert (arch != NULL);
248   return arch;
249 }
250
251 /* See gdbtypes.h.  */
252
253 struct type *
254 get_target_type (struct type *type)
255 {
256   if (type != NULL)
257     {
258       type = TYPE_TARGET_TYPE (type);
259       if (type != NULL)
260         type = check_typedef (type);
261     }
262
263   return type;
264 }
265
266 /* See gdbtypes.h.  */
267
268 unsigned int
269 type_length_units (struct type *type)
270 {
271   struct gdbarch *arch = get_type_arch (type);
272   int unit_size = gdbarch_addressable_memory_unit_size (arch);
273
274   return TYPE_LENGTH (type) / unit_size;
275 }
276
277 /* Alloc a new type instance structure, fill it with some defaults,
278    and point it at OLDTYPE.  Allocate the new type instance from the
279    same place as OLDTYPE.  */
280
281 static struct type *
282 alloc_type_instance (struct type *oldtype)
283 {
284   struct type *type;
285
286   /* Allocate the structure.  */
287
288   if (! TYPE_OBJFILE_OWNED (oldtype))
289     type = GDBARCH_OBSTACK_ZALLOC (get_type_arch (oldtype), struct type);
290   else
291     type = OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype)->objfile_obstack,
292                            struct type);
293
294   TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype);
295
296   TYPE_CHAIN (type) = type;     /* Chain back to itself for now.  */
297
298   return type;
299 }
300
301 /* Clear all remnants of the previous type at TYPE, in preparation for
302    replacing it with something else.  Preserve owner information.  */
303
304 static void
305 smash_type (struct type *type)
306 {
307   int objfile_owned = TYPE_OBJFILE_OWNED (type);
308   union type_owner owner = TYPE_OWNER (type);
309
310   memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
311
312   /* Restore owner information.  */
313   TYPE_OBJFILE_OWNED (type) = objfile_owned;
314   TYPE_OWNER (type) = owner;
315
316   /* For now, delete the rings.  */
317   TYPE_CHAIN (type) = type;
318
319   /* For now, leave the pointer/reference types alone.  */
320 }
321
322 /* Lookup a pointer to a type TYPE.  TYPEPTR, if nonzero, points
323    to a pointer to memory where the pointer type should be stored.
324    If *TYPEPTR is zero, update it to point to the pointer type we return.
325    We allocate new memory if needed.  */
326
327 struct type *
328 make_pointer_type (struct type *type, struct type **typeptr)
329 {
330   struct type *ntype;   /* New type */
331   struct type *chain;
332
333   ntype = TYPE_POINTER_TYPE (type);
334
335   if (ntype)
336     {
337       if (typeptr == 0)
338         return ntype;           /* Don't care about alloc, 
339                                    and have new type.  */
340       else if (*typeptr == 0)
341         {
342           *typeptr = ntype;     /* Tracking alloc, and have new type.  */
343           return ntype;
344         }
345     }
346
347   if (typeptr == 0 || *typeptr == 0)    /* We'll need to allocate one.  */
348     {
349       ntype = alloc_type_copy (type);
350       if (typeptr)
351         *typeptr = ntype;
352     }
353   else                  /* We have storage, but need to reset it.  */
354     {
355       ntype = *typeptr;
356       chain = TYPE_CHAIN (ntype);
357       smash_type (ntype);
358       TYPE_CHAIN (ntype) = chain;
359     }
360
361   TYPE_TARGET_TYPE (ntype) = type;
362   TYPE_POINTER_TYPE (type) = ntype;
363
364   /* FIXME!  Assumes the machine has only one representation for pointers!  */
365
366   TYPE_LENGTH (ntype)
367     = gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
368   TYPE_CODE (ntype) = TYPE_CODE_PTR;
369
370   /* Mark pointers as unsigned.  The target converts between pointers
371      and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
372      gdbarch_address_to_pointer.  */
373   TYPE_UNSIGNED (ntype) = 1;
374
375   /* Update the length of all the other variants of this type.  */
376   chain = TYPE_CHAIN (ntype);
377   while (chain != ntype)
378     {
379       TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
380       chain = TYPE_CHAIN (chain);
381     }
382
383   return ntype;
384 }
385
386 /* Given a type TYPE, return a type of pointers to that type.
387    May need to construct such a type if this is the first use.  */
388
389 struct type *
390 lookup_pointer_type (struct type *type)
391 {
392   return make_pointer_type (type, (struct type **) 0);
393 }
394
395 /* Lookup a C++ `reference' to a type TYPE.  TYPEPTR, if nonzero,
396    points to a pointer to memory where the reference type should be
397    stored.  If *TYPEPTR is zero, update it to point to the reference
398    type we return.  We allocate new memory if needed. REFCODE denotes
399    the kind of reference type to lookup (lvalue or rvalue reference).  */
400
401 struct type *
402 make_reference_type (struct type *type, struct type **typeptr,
403                       enum type_code refcode)
404 {
405   struct type *ntype;   /* New type */
406   struct type **reftype;
407   struct type *chain;
408
409   gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
410
411   ntype = (refcode == TYPE_CODE_REF ? TYPE_REFERENCE_TYPE (type)
412            : TYPE_RVALUE_REFERENCE_TYPE (type));
413
414   if (ntype)
415     {
416       if (typeptr == 0)
417         return ntype;           /* Don't care about alloc, 
418                                    and have new type.  */
419       else if (*typeptr == 0)
420         {
421           *typeptr = ntype;     /* Tracking alloc, and have new type.  */
422           return ntype;
423         }
424     }
425
426   if (typeptr == 0 || *typeptr == 0)    /* We'll need to allocate one.  */
427     {
428       ntype = alloc_type_copy (type);
429       if (typeptr)
430         *typeptr = ntype;
431     }
432   else                  /* We have storage, but need to reset it.  */
433     {
434       ntype = *typeptr;
435       chain = TYPE_CHAIN (ntype);
436       smash_type (ntype);
437       TYPE_CHAIN (ntype) = chain;
438     }
439
440   TYPE_TARGET_TYPE (ntype) = type;
441   reftype = (refcode == TYPE_CODE_REF ? &TYPE_REFERENCE_TYPE (type)
442              : &TYPE_RVALUE_REFERENCE_TYPE (type));
443
444   *reftype = ntype;
445
446   /* FIXME!  Assume the machine has only one representation for
447      references, and that it matches the (only) representation for
448      pointers!  */
449
450   TYPE_LENGTH (ntype) =
451     gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
452   TYPE_CODE (ntype) = refcode;
453
454   *reftype = ntype;
455
456   /* Update the length of all the other variants of this type.  */
457   chain = TYPE_CHAIN (ntype);
458   while (chain != ntype)
459     {
460       TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
461       chain = TYPE_CHAIN (chain);
462     }
463
464   return ntype;
465 }
466
467 /* Same as above, but caller doesn't care about memory allocation
468    details.  */
469
470 struct type *
471 lookup_reference_type (struct type *type, enum type_code refcode)
472 {
473   return make_reference_type (type, (struct type **) 0, refcode);
474 }
475
476 /* Lookup the lvalue reference type for the type TYPE.  */
477
478 struct type *
479 lookup_lvalue_reference_type (struct type *type)
480 {
481   return lookup_reference_type (type, TYPE_CODE_REF);
482 }
483
484 /* Lookup the rvalue reference type for the type TYPE.  */
485
486 struct type *
487 lookup_rvalue_reference_type (struct type *type)
488 {
489   return lookup_reference_type (type, TYPE_CODE_RVALUE_REF);
490 }
491
492 /* Lookup a function type that returns type TYPE.  TYPEPTR, if
493    nonzero, points to a pointer to memory where the function type
494    should be stored.  If *TYPEPTR is zero, update it to point to the
495    function type we return.  We allocate new memory if needed.  */
496
497 struct type *
498 make_function_type (struct type *type, struct type **typeptr)
499 {
500   struct type *ntype;   /* New type */
501
502   if (typeptr == 0 || *typeptr == 0)    /* We'll need to allocate one.  */
503     {
504       ntype = alloc_type_copy (type);
505       if (typeptr)
506         *typeptr = ntype;
507     }
508   else                  /* We have storage, but need to reset it.  */
509     {
510       ntype = *typeptr;
511       smash_type (ntype);
512     }
513
514   TYPE_TARGET_TYPE (ntype) = type;
515
516   TYPE_LENGTH (ntype) = 1;
517   TYPE_CODE (ntype) = TYPE_CODE_FUNC;
518
519   INIT_FUNC_SPECIFIC (ntype);
520
521   return ntype;
522 }
523
524 /* Given a type TYPE, return a type of functions that return that type.
525    May need to construct such a type if this is the first use.  */
526
527 struct type *
528 lookup_function_type (struct type *type)
529 {
530   return make_function_type (type, (struct type **) 0);
531 }
532
533 /* Given a type TYPE and argument types, return the appropriate
534    function type.  If the final type in PARAM_TYPES is NULL, make a
535    varargs function.  */
536
537 struct type *
538 lookup_function_type_with_arguments (struct type *type,
539                                      int nparams,
540                                      struct type **param_types)
541 {
542   struct type *fn = make_function_type (type, (struct type **) 0);
543   int i;
544
545   if (nparams > 0)
546     {
547       if (param_types[nparams - 1] == NULL)
548         {
549           --nparams;
550           TYPE_VARARGS (fn) = 1;
551         }
552       else if (TYPE_CODE (check_typedef (param_types[nparams - 1]))
553                == TYPE_CODE_VOID)
554         {
555           --nparams;
556           /* Caller should have ensured this.  */
557           gdb_assert (nparams == 0);
558           TYPE_PROTOTYPED (fn) = 1;
559         }
560       else
561         TYPE_PROTOTYPED (fn) = 1;
562     }
563
564   TYPE_NFIELDS (fn) = nparams;
565   TYPE_FIELDS (fn)
566     = (struct field *) TYPE_ZALLOC (fn, nparams * sizeof (struct field));
567   for (i = 0; i < nparams; ++i)
568     TYPE_FIELD_TYPE (fn, i) = param_types[i];
569
570   return fn;
571 }
572
573 /* Identify address space identifier by name --
574    return the integer flag defined in gdbtypes.h.  */
575
576 int
577 address_space_name_to_int (struct gdbarch *gdbarch, char *space_identifier)
578 {
579   int type_flags;
580
581   /* Check for known address space delimiters.  */
582   if (!strcmp (space_identifier, "code"))
583     return TYPE_INSTANCE_FLAG_CODE_SPACE;
584   else if (!strcmp (space_identifier, "data"))
585     return TYPE_INSTANCE_FLAG_DATA_SPACE;
586   else if (gdbarch_address_class_name_to_type_flags_p (gdbarch)
587            && gdbarch_address_class_name_to_type_flags (gdbarch,
588                                                         space_identifier,
589                                                         &type_flags))
590     return type_flags;
591   else
592     error (_("Unknown address space specifier: \"%s\""), space_identifier);
593 }
594
595 /* Identify address space identifier by integer flag as defined in 
596    gdbtypes.h -- return the string version of the adress space name.  */
597
598 const char *
599 address_space_int_to_name (struct gdbarch *gdbarch, int space_flag)
600 {
601   if (space_flag & TYPE_INSTANCE_FLAG_CODE_SPACE)
602     return "code";
603   else if (space_flag & TYPE_INSTANCE_FLAG_DATA_SPACE)
604     return "data";
605   else if ((space_flag & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
606            && gdbarch_address_class_type_flags_to_name_p (gdbarch))
607     return gdbarch_address_class_type_flags_to_name (gdbarch, space_flag);
608   else
609     return NULL;
610 }
611
612 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
613
614    If STORAGE is non-NULL, create the new type instance there.
615    STORAGE must be in the same obstack as TYPE.  */
616
617 static struct type *
618 make_qualified_type (struct type *type, int new_flags,
619                      struct type *storage)
620 {
621   struct type *ntype;
622
623   ntype = type;
624   do
625     {
626       if (TYPE_INSTANCE_FLAGS (ntype) == new_flags)
627         return ntype;
628       ntype = TYPE_CHAIN (ntype);
629     }
630   while (ntype != type);
631
632   /* Create a new type instance.  */
633   if (storage == NULL)
634     ntype = alloc_type_instance (type);
635   else
636     {
637       /* If STORAGE was provided, it had better be in the same objfile
638          as TYPE.  Otherwise, we can't link it into TYPE's cv chain:
639          if one objfile is freed and the other kept, we'd have
640          dangling pointers.  */
641       gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage));
642
643       ntype = storage;
644       TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type);
645       TYPE_CHAIN (ntype) = ntype;
646     }
647
648   /* Pointers or references to the original type are not relevant to
649      the new type.  */
650   TYPE_POINTER_TYPE (ntype) = (struct type *) 0;
651   TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0;
652
653   /* Chain the new qualified type to the old type.  */
654   TYPE_CHAIN (ntype) = TYPE_CHAIN (type);
655   TYPE_CHAIN (type) = ntype;
656
657   /* Now set the instance flags and return the new type.  */
658   TYPE_INSTANCE_FLAGS (ntype) = new_flags;
659
660   /* Set length of new type to that of the original type.  */
661   TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
662
663   return ntype;
664 }
665
666 /* Make an address-space-delimited variant of a type -- a type that
667    is identical to the one supplied except that it has an address
668    space attribute attached to it (such as "code" or "data").
669
670    The space attributes "code" and "data" are for Harvard
671    architectures.  The address space attributes are for architectures
672    which have alternately sized pointers or pointers with alternate
673    representations.  */
674
675 struct type *
676 make_type_with_address_space (struct type *type, int space_flag)
677 {
678   int new_flags = ((TYPE_INSTANCE_FLAGS (type)
679                     & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
680                         | TYPE_INSTANCE_FLAG_DATA_SPACE
681                         | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL))
682                    | space_flag);
683
684   return make_qualified_type (type, new_flags, NULL);
685 }
686
687 /* Make a "c-v" variant of a type -- a type that is identical to the
688    one supplied except that it may have const or volatile attributes
689    CNST is a flag for setting the const attribute
690    VOLTL is a flag for setting the volatile attribute
691    TYPE is the base type whose variant we are creating.
692
693    If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
694    storage to hold the new qualified type; *TYPEPTR and TYPE must be
695    in the same objfile.  Otherwise, allocate fresh memory for the new
696    type whereever TYPE lives.  If TYPEPTR is non-zero, set it to the
697    new type we construct.  */
698
699 struct type *
700 make_cv_type (int cnst, int voltl, 
701               struct type *type, 
702               struct type **typeptr)
703 {
704   struct type *ntype;   /* New type */
705
706   int new_flags = (TYPE_INSTANCE_FLAGS (type)
707                    & ~(TYPE_INSTANCE_FLAG_CONST 
708                        | TYPE_INSTANCE_FLAG_VOLATILE));
709
710   if (cnst)
711     new_flags |= TYPE_INSTANCE_FLAG_CONST;
712
713   if (voltl)
714     new_flags |= TYPE_INSTANCE_FLAG_VOLATILE;
715
716   if (typeptr && *typeptr != NULL)
717     {
718       /* TYPE and *TYPEPTR must be in the same objfile.  We can't have
719          a C-V variant chain that threads across objfiles: if one
720          objfile gets freed, then the other has a broken C-V chain.
721
722          This code used to try to copy over the main type from TYPE to
723          *TYPEPTR if they were in different objfiles, but that's
724          wrong, too: TYPE may have a field list or member function
725          lists, which refer to types of their own, etc. etc.  The
726          whole shebang would need to be copied over recursively; you
727          can't have inter-objfile pointers.  The only thing to do is
728          to leave stub types as stub types, and look them up afresh by
729          name each time you encounter them.  */
730       gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type));
731     }
732   
733   ntype = make_qualified_type (type, new_flags, 
734                                typeptr ? *typeptr : NULL);
735
736   if (typeptr != NULL)
737     *typeptr = ntype;
738
739   return ntype;
740 }
741
742 /* Make a 'restrict'-qualified version of TYPE.  */
743
744 struct type *
745 make_restrict_type (struct type *type)
746 {
747   return make_qualified_type (type,
748                               (TYPE_INSTANCE_FLAGS (type)
749                                | TYPE_INSTANCE_FLAG_RESTRICT),
750                               NULL);
751 }
752
753 /* Make a type without const, volatile, or restrict.  */
754
755 struct type *
756 make_unqualified_type (struct type *type)
757 {
758   return make_qualified_type (type,
759                               (TYPE_INSTANCE_FLAGS (type)
760                                & ~(TYPE_INSTANCE_FLAG_CONST
761                                    | TYPE_INSTANCE_FLAG_VOLATILE
762                                    | TYPE_INSTANCE_FLAG_RESTRICT)),
763                               NULL);
764 }
765
766 /* Make a '_Atomic'-qualified version of TYPE.  */
767
768 struct type *
769 make_atomic_type (struct type *type)
770 {
771   return make_qualified_type (type,
772                               (TYPE_INSTANCE_FLAGS (type)
773                                | TYPE_INSTANCE_FLAG_ATOMIC),
774                               NULL);
775 }
776
777 /* Replace the contents of ntype with the type *type.  This changes the
778    contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
779    the changes are propogated to all types in the TYPE_CHAIN.
780
781    In order to build recursive types, it's inevitable that we'll need
782    to update types in place --- but this sort of indiscriminate
783    smashing is ugly, and needs to be replaced with something more
784    controlled.  TYPE_MAIN_TYPE is a step in this direction; it's not
785    clear if more steps are needed.  */
786
787 void
788 replace_type (struct type *ntype, struct type *type)
789 {
790   struct type *chain;
791
792   /* These two types had better be in the same objfile.  Otherwise,
793      the assignment of one type's main type structure to the other
794      will produce a type with references to objects (names; field
795      lists; etc.) allocated on an objfile other than its own.  */
796   gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (type));
797
798   *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
799
800   /* The type length is not a part of the main type.  Update it for
801      each type on the variant chain.  */
802   chain = ntype;
803   do
804     {
805       /* Assert that this element of the chain has no address-class bits
806          set in its flags.  Such type variants might have type lengths
807          which are supposed to be different from the non-address-class
808          variants.  This assertion shouldn't ever be triggered because
809          symbol readers which do construct address-class variants don't
810          call replace_type().  */
811       gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0);
812
813       TYPE_LENGTH (chain) = TYPE_LENGTH (type);
814       chain = TYPE_CHAIN (chain);
815     }
816   while (ntype != chain);
817
818   /* Assert that the two types have equivalent instance qualifiers.
819      This should be true for at least all of our debug readers.  */
820   gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type));
821 }
822
823 /* Implement direct support for MEMBER_TYPE in GNU C++.
824    May need to construct such a type if this is the first use.
825    The TYPE is the type of the member.  The DOMAIN is the type
826    of the aggregate that the member belongs to.  */
827
828 struct type *
829 lookup_memberptr_type (struct type *type, struct type *domain)
830 {
831   struct type *mtype;
832
833   mtype = alloc_type_copy (type);
834   smash_to_memberptr_type (mtype, domain, type);
835   return mtype;
836 }
837
838 /* Return a pointer-to-method type, for a method of type TO_TYPE.  */
839
840 struct type *
841 lookup_methodptr_type (struct type *to_type)
842 {
843   struct type *mtype;
844
845   mtype = alloc_type_copy (to_type);
846   smash_to_methodptr_type (mtype, to_type);
847   return mtype;
848 }
849
850 /* Allocate a stub method whose return type is TYPE.  This apparently
851    happens for speed of symbol reading, since parsing out the
852    arguments to the method is cpu-intensive, the way we are doing it.
853    So, we will fill in arguments later.  This always returns a fresh
854    type.  */
855
856 struct type *
857 allocate_stub_method (struct type *type)
858 {
859   struct type *mtype;
860
861   mtype = alloc_type_copy (type);
862   TYPE_CODE (mtype) = TYPE_CODE_METHOD;
863   TYPE_LENGTH (mtype) = 1;
864   TYPE_STUB (mtype) = 1;
865   TYPE_TARGET_TYPE (mtype) = type;
866   /* TYPE_SELF_TYPE (mtype) = unknown yet */
867   return mtype;
868 }
869
870 /* See gdbtypes.h.  */
871
872 bool
873 operator== (const dynamic_prop &l, const dynamic_prop &r)
874 {
875   if (l.kind != r.kind)
876     return false;
877
878   switch (l.kind)
879     {
880     case PROP_UNDEFINED:
881       return true;
882     case PROP_CONST:
883       return l.data.const_val == r.data.const_val;
884     case PROP_ADDR_OFFSET:
885     case PROP_LOCEXPR:
886     case PROP_LOCLIST:
887       return l.data.baton == r.data.baton;
888     }
889
890   gdb_assert_not_reached ("unhandled dynamic_prop kind");
891 }
892
893 /* See gdbtypes.h.  */
894
895 bool
896 operator== (const range_bounds &l, const range_bounds &r)
897 {
898 #define FIELD_EQ(FIELD) (l.FIELD == r.FIELD)
899
900   return (FIELD_EQ (low)
901           && FIELD_EQ (high)
902           && FIELD_EQ (flag_upper_bound_is_count)
903           && FIELD_EQ (flag_bound_evaluated));
904
905 #undef FIELD_EQ
906 }
907
908 /* Create a range type with a dynamic range from LOW_BOUND to
909    HIGH_BOUND, inclusive.  See create_range_type for further details. */
910
911 struct type *
912 create_range_type (struct type *result_type, struct type *index_type,
913                    const struct dynamic_prop *low_bound,
914                    const struct dynamic_prop *high_bound)
915 {
916   if (result_type == NULL)
917     result_type = alloc_type_copy (index_type);
918   TYPE_CODE (result_type) = TYPE_CODE_RANGE;
919   TYPE_TARGET_TYPE (result_type) = index_type;
920   if (TYPE_STUB (index_type))
921     TYPE_TARGET_STUB (result_type) = 1;
922   else
923     TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
924
925   TYPE_RANGE_DATA (result_type) = (struct range_bounds *)
926     TYPE_ZALLOC (result_type, sizeof (struct range_bounds));
927   TYPE_RANGE_DATA (result_type)->low = *low_bound;
928   TYPE_RANGE_DATA (result_type)->high = *high_bound;
929
930   if (low_bound->kind == PROP_CONST && low_bound->data.const_val >= 0)
931     TYPE_UNSIGNED (result_type) = 1;
932
933   /* Ada allows the declaration of range types whose upper bound is
934      less than the lower bound, so checking the lower bound is not
935      enough.  Make sure we do not mark a range type whose upper bound
936      is negative as unsigned.  */
937   if (high_bound->kind == PROP_CONST && high_bound->data.const_val < 0)
938     TYPE_UNSIGNED (result_type) = 0;
939
940   return result_type;
941 }
942
943 /* Create a range type using either a blank type supplied in
944    RESULT_TYPE, or creating a new type, inheriting the objfile from
945    INDEX_TYPE.
946
947    Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
948    to HIGH_BOUND, inclusive.
949
950    FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
951    sure it is TYPE_CODE_UNDEF before we bash it into a range type?  */
952
953 struct type *
954 create_static_range_type (struct type *result_type, struct type *index_type,
955                           LONGEST low_bound, LONGEST high_bound)
956 {
957   struct dynamic_prop low, high;
958
959   low.kind = PROP_CONST;
960   low.data.const_val = low_bound;
961
962   high.kind = PROP_CONST;
963   high.data.const_val = high_bound;
964
965   result_type = create_range_type (result_type, index_type, &low, &high);
966
967   return result_type;
968 }
969
970 /* Predicate tests whether BOUNDS are static.  Returns 1 if all bounds values
971    are static, otherwise returns 0.  */
972
973 static int
974 has_static_range (const struct range_bounds *bounds)
975 {
976   return (bounds->low.kind == PROP_CONST
977           && bounds->high.kind == PROP_CONST);
978 }
979
980
981 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
982    TYPE.  Return 1 if type is a range type, 0 if it is discrete (and
983    bounds will fit in LONGEST), or -1 otherwise.  */
984
985 int
986 get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
987 {
988   type = check_typedef (type);
989   switch (TYPE_CODE (type))
990     {
991     case TYPE_CODE_RANGE:
992       *lowp = TYPE_LOW_BOUND (type);
993       *highp = TYPE_HIGH_BOUND (type);
994       return 1;
995     case TYPE_CODE_ENUM:
996       if (TYPE_NFIELDS (type) > 0)
997         {
998           /* The enums may not be sorted by value, so search all
999              entries.  */
1000           int i;
1001
1002           *lowp = *highp = TYPE_FIELD_ENUMVAL (type, 0);
1003           for (i = 0; i < TYPE_NFIELDS (type); i++)
1004             {
1005               if (TYPE_FIELD_ENUMVAL (type, i) < *lowp)
1006                 *lowp = TYPE_FIELD_ENUMVAL (type, i);
1007               if (TYPE_FIELD_ENUMVAL (type, i) > *highp)
1008                 *highp = TYPE_FIELD_ENUMVAL (type, i);
1009             }
1010
1011           /* Set unsigned indicator if warranted.  */
1012           if (*lowp >= 0)
1013             {
1014               TYPE_UNSIGNED (type) = 1;
1015             }
1016         }
1017       else
1018         {
1019           *lowp = 0;
1020           *highp = -1;
1021         }
1022       return 0;
1023     case TYPE_CODE_BOOL:
1024       *lowp = 0;
1025       *highp = 1;
1026       return 0;
1027     case TYPE_CODE_INT:
1028       if (TYPE_LENGTH (type) > sizeof (LONGEST))        /* Too big */
1029         return -1;
1030       if (!TYPE_UNSIGNED (type))
1031         {
1032           *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
1033           *highp = -*lowp - 1;
1034           return 0;
1035         }
1036       /* fall through */
1037     case TYPE_CODE_CHAR:
1038       *lowp = 0;
1039       /* This round-about calculation is to avoid shifting by
1040          TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
1041          if TYPE_LENGTH (type) == sizeof (LONGEST).  */
1042       *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
1043       *highp = (*highp - 1) | *highp;
1044       return 0;
1045     default:
1046       return -1;
1047     }
1048 }
1049
1050 /* Assuming TYPE is a simple, non-empty array type, compute its upper
1051    and lower bound.  Save the low bound into LOW_BOUND if not NULL.
1052    Save the high bound into HIGH_BOUND if not NULL.
1053
1054    Return 1 if the operation was successful.  Return zero otherwise,
1055    in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
1056
1057    We now simply use get_discrete_bounds call to get the values
1058    of the low and high bounds.
1059    get_discrete_bounds can return three values:
1060    1, meaning that index is a range,
1061    0, meaning that index is a discrete type,
1062    or -1 for failure.  */
1063
1064 int
1065 get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound)
1066 {
1067   struct type *index = TYPE_INDEX_TYPE (type);
1068   LONGEST low = 0;
1069   LONGEST high = 0;
1070   int res;
1071
1072   if (index == NULL)
1073     return 0;
1074
1075   res = get_discrete_bounds (index, &low, &high);
1076   if (res == -1)
1077     return 0;
1078
1079   /* Check if the array bounds are undefined.  */
1080   if (res == 1
1081       && ((low_bound && TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type))
1082           || (high_bound && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))))
1083     return 0;
1084
1085   if (low_bound)
1086     *low_bound = low;
1087
1088   if (high_bound)
1089     *high_bound = high;
1090
1091   return 1;
1092 }
1093
1094 /* Assuming that TYPE is a discrete type and VAL is a valid integer
1095    representation of a value of this type, save the corresponding
1096    position number in POS.
1097
1098    Its differs from VAL only in the case of enumeration types.  In
1099    this case, the position number of the value of the first listed
1100    enumeration literal is zero; the position number of the value of
1101    each subsequent enumeration literal is one more than that of its
1102    predecessor in the list.
1103
1104    Return 1 if the operation was successful.  Return zero otherwise,
1105    in which case the value of POS is unmodified.
1106 */
1107
1108 int
1109 discrete_position (struct type *type, LONGEST val, LONGEST *pos)
1110 {
1111   if (TYPE_CODE (type) == TYPE_CODE_ENUM)
1112     {
1113       int i;
1114
1115       for (i = 0; i < TYPE_NFIELDS (type); i += 1)
1116         {
1117           if (val == TYPE_FIELD_ENUMVAL (type, i))
1118             {
1119               *pos = i;
1120               return 1;
1121             }
1122         }
1123       /* Invalid enumeration value.  */
1124       return 0;
1125     }
1126   else
1127     {
1128       *pos = val;
1129       return 1;
1130     }
1131 }
1132
1133 /* Create an array type using either a blank type supplied in
1134    RESULT_TYPE, or creating a new type, inheriting the objfile from
1135    RANGE_TYPE.
1136
1137    Elements will be of type ELEMENT_TYPE, the indices will be of type
1138    RANGE_TYPE.
1139
1140    BYTE_STRIDE_PROP, when not NULL, provides the array's byte stride.
1141    This byte stride property is added to the resulting array type
1142    as a DYN_PROP_BYTE_STRIDE.  As a consequence, the BYTE_STRIDE_PROP
1143    argument can only be used to create types that are objfile-owned
1144    (see add_dyn_prop), meaning that either this function must be called
1145    with an objfile-owned RESULT_TYPE, or an objfile-owned RANGE_TYPE.
1146
1147    BIT_STRIDE is taken into account only when BYTE_STRIDE_PROP is NULL.
1148    If BIT_STRIDE is not zero, build a packed array type whose element
1149    size is BIT_STRIDE.  Otherwise, ignore this parameter.
1150
1151    FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1152    sure it is TYPE_CODE_UNDEF before we bash it into an array
1153    type?  */
1154
1155 struct type *
1156 create_array_type_with_stride (struct type *result_type,
1157                                struct type *element_type,
1158                                struct type *range_type,
1159                                struct dynamic_prop *byte_stride_prop,
1160                                unsigned int bit_stride)
1161 {
1162   if (byte_stride_prop != NULL
1163       && byte_stride_prop->kind == PROP_CONST)
1164     {
1165       /* The byte stride is actually not dynamic.  Pretend we were
1166          called with bit_stride set instead of byte_stride_prop.
1167          This will give us the same result type, while avoiding
1168          the need to handle this as a special case.  */
1169       bit_stride = byte_stride_prop->data.const_val * 8;
1170       byte_stride_prop = NULL;
1171     }
1172
1173   if (result_type == NULL)
1174     result_type = alloc_type_copy (range_type);
1175
1176   TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
1177   TYPE_TARGET_TYPE (result_type) = element_type;
1178   if (byte_stride_prop == NULL
1179       && has_static_range (TYPE_RANGE_DATA (range_type))
1180       && (!type_not_associated (result_type)
1181           && !type_not_allocated (result_type)))
1182     {
1183       LONGEST low_bound, high_bound;
1184
1185       if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
1186         low_bound = high_bound = 0;
1187       element_type = check_typedef (element_type);
1188       /* Be careful when setting the array length.  Ada arrays can be
1189          empty arrays with the high_bound being smaller than the low_bound.
1190          In such cases, the array length should be zero.  */
1191       if (high_bound < low_bound)
1192         TYPE_LENGTH (result_type) = 0;
1193       else if (bit_stride > 0)
1194         TYPE_LENGTH (result_type) =
1195           (bit_stride * (high_bound - low_bound + 1) + 7) / 8;
1196       else
1197         TYPE_LENGTH (result_type) =
1198           TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
1199     }
1200   else
1201     {
1202       /* This type is dynamic and its length needs to be computed
1203          on demand.  In the meantime, avoid leaving the TYPE_LENGTH
1204          undefined by setting it to zero.  Although we are not expected
1205          to trust TYPE_LENGTH in this case, setting the size to zero
1206          allows us to avoid allocating objects of random sizes in case
1207          we accidently do.  */
1208       TYPE_LENGTH (result_type) = 0;
1209     }
1210
1211   TYPE_NFIELDS (result_type) = 1;
1212   TYPE_FIELDS (result_type) =
1213     (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
1214   TYPE_INDEX_TYPE (result_type) = range_type;
1215   if (byte_stride_prop != NULL)
1216     add_dyn_prop (DYN_PROP_BYTE_STRIDE, *byte_stride_prop, result_type);
1217   else if (bit_stride > 0)
1218     TYPE_FIELD_BITSIZE (result_type, 0) = bit_stride;
1219
1220   /* TYPE_TARGET_STUB will take care of zero length arrays.  */
1221   if (TYPE_LENGTH (result_type) == 0)
1222     TYPE_TARGET_STUB (result_type) = 1;
1223
1224   return result_type;
1225 }
1226
1227 /* Same as create_array_type_with_stride but with no bit_stride
1228    (BIT_STRIDE = 0), thus building an unpacked array.  */
1229
1230 struct type *
1231 create_array_type (struct type *result_type,
1232                    struct type *element_type,
1233                    struct type *range_type)
1234 {
1235   return create_array_type_with_stride (result_type, element_type,
1236                                         range_type, NULL, 0);
1237 }
1238
1239 struct type *
1240 lookup_array_range_type (struct type *element_type,
1241                          LONGEST low_bound, LONGEST high_bound)
1242 {
1243   struct type *index_type;
1244   struct type *range_type;
1245
1246   if (TYPE_OBJFILE_OWNED (element_type))
1247     index_type = objfile_type (TYPE_OWNER (element_type).objfile)->builtin_int;
1248   else
1249     index_type = builtin_type (get_type_arch (element_type))->builtin_int;
1250   range_type = create_static_range_type (NULL, index_type,
1251                                          low_bound, high_bound);
1252
1253   return create_array_type (NULL, element_type, range_type);
1254 }
1255
1256 /* Create a string type using either a blank type supplied in
1257    RESULT_TYPE, or creating a new type.  String types are similar
1258    enough to array of char types that we can use create_array_type to
1259    build the basic type and then bash it into a string type.
1260
1261    For fixed length strings, the range type contains 0 as the lower
1262    bound and the length of the string minus one as the upper bound.
1263
1264    FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
1265    sure it is TYPE_CODE_UNDEF before we bash it into a string
1266    type?  */
1267
1268 struct type *
1269 create_string_type (struct type *result_type,
1270                     struct type *string_char_type,
1271                     struct type *range_type)
1272 {
1273   result_type = create_array_type (result_type,
1274                                    string_char_type,
1275                                    range_type);
1276   TYPE_CODE (result_type) = TYPE_CODE_STRING;
1277   return result_type;
1278 }
1279
1280 struct type *
1281 lookup_string_range_type (struct type *string_char_type,
1282                           LONGEST low_bound, LONGEST high_bound)
1283 {
1284   struct type *result_type;
1285
1286   result_type = lookup_array_range_type (string_char_type,
1287                                          low_bound, high_bound);
1288   TYPE_CODE (result_type) = TYPE_CODE_STRING;
1289   return result_type;
1290 }
1291
1292 struct type *
1293 create_set_type (struct type *result_type, struct type *domain_type)
1294 {
1295   if (result_type == NULL)
1296     result_type = alloc_type_copy (domain_type);
1297
1298   TYPE_CODE (result_type) = TYPE_CODE_SET;
1299   TYPE_NFIELDS (result_type) = 1;
1300   TYPE_FIELDS (result_type)
1301     = (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
1302
1303   if (!TYPE_STUB (domain_type))
1304     {
1305       LONGEST low_bound, high_bound, bit_length;
1306
1307       if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
1308         low_bound = high_bound = 0;
1309       bit_length = high_bound - low_bound + 1;
1310       TYPE_LENGTH (result_type)
1311         = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
1312       if (low_bound >= 0)
1313         TYPE_UNSIGNED (result_type) = 1;
1314     }
1315   TYPE_FIELD_TYPE (result_type, 0) = domain_type;
1316
1317   return result_type;
1318 }
1319
1320 /* Convert ARRAY_TYPE to a vector type.  This may modify ARRAY_TYPE
1321    and any array types nested inside it.  */
1322
1323 void
1324 make_vector_type (struct type *array_type)
1325 {
1326   struct type *inner_array, *elt_type;
1327   int flags;
1328
1329   /* Find the innermost array type, in case the array is
1330      multi-dimensional.  */
1331   inner_array = array_type;
1332   while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
1333     inner_array = TYPE_TARGET_TYPE (inner_array);
1334
1335   elt_type = TYPE_TARGET_TYPE (inner_array);
1336   if (TYPE_CODE (elt_type) == TYPE_CODE_INT)
1337     {
1338       flags = TYPE_INSTANCE_FLAGS (elt_type) | TYPE_INSTANCE_FLAG_NOTTEXT;
1339       elt_type = make_qualified_type (elt_type, flags, NULL);
1340       TYPE_TARGET_TYPE (inner_array) = elt_type;
1341     }
1342
1343   TYPE_VECTOR (array_type) = 1;
1344 }
1345
1346 struct type *
1347 init_vector_type (struct type *elt_type, int n)
1348 {
1349   struct type *array_type;
1350
1351   array_type = lookup_array_range_type (elt_type, 0, n - 1);
1352   make_vector_type (array_type);
1353   return array_type;
1354 }
1355
1356 /* Internal routine called by TYPE_SELF_TYPE to return the type that TYPE
1357    belongs to.  In c++ this is the class of "this", but TYPE_THIS_TYPE is too
1358    confusing.  "self" is a common enough replacement for "this".
1359    TYPE must be one of TYPE_CODE_METHODPTR, TYPE_CODE_MEMBERPTR, or
1360    TYPE_CODE_METHOD.  */
1361
1362 struct type *
1363 internal_type_self_type (struct type *type)
1364 {
1365   switch (TYPE_CODE (type))
1366     {
1367     case TYPE_CODE_METHODPTR:
1368     case TYPE_CODE_MEMBERPTR:
1369       if (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_NONE)
1370         return NULL;
1371       gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_SELF_TYPE);
1372       return TYPE_MAIN_TYPE (type)->type_specific.self_type;
1373     case TYPE_CODE_METHOD:
1374       if (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_NONE)
1375         return NULL;
1376       gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_FUNC);
1377       return TYPE_MAIN_TYPE (type)->type_specific.func_stuff->self_type;
1378     default:
1379       gdb_assert_not_reached ("bad type");
1380     }
1381 }
1382
1383 /* Set the type of the class that TYPE belongs to.
1384    In c++ this is the class of "this".
1385    TYPE must be one of TYPE_CODE_METHODPTR, TYPE_CODE_MEMBERPTR, or
1386    TYPE_CODE_METHOD.  */
1387
1388 void
1389 set_type_self_type (struct type *type, struct type *self_type)
1390 {
1391   switch (TYPE_CODE (type))
1392     {
1393     case TYPE_CODE_METHODPTR:
1394     case TYPE_CODE_MEMBERPTR:
1395       if (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_NONE)
1396         TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_SELF_TYPE;
1397       gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_SELF_TYPE);
1398       TYPE_MAIN_TYPE (type)->type_specific.self_type = self_type;
1399       break;
1400     case TYPE_CODE_METHOD:
1401       if (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_NONE)
1402         INIT_FUNC_SPECIFIC (type);
1403       gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_FUNC);
1404       TYPE_MAIN_TYPE (type)->type_specific.func_stuff->self_type = self_type;
1405       break;
1406     default:
1407       gdb_assert_not_reached ("bad type");
1408     }
1409 }
1410
1411 /* Smash TYPE to be a type of pointers to members of SELF_TYPE with type
1412    TO_TYPE.  A member pointer is a wierd thing -- it amounts to a
1413    typed offset into a struct, e.g. "an int at offset 8".  A MEMBER
1414    TYPE doesn't include the offset (that's the value of the MEMBER
1415    itself), but does include the structure type into which it points
1416    (for some reason).
1417
1418    When "smashing" the type, we preserve the objfile that the old type
1419    pointed to, since we aren't changing where the type is actually
1420    allocated.  */
1421
1422 void
1423 smash_to_memberptr_type (struct type *type, struct type *self_type,
1424                          struct type *to_type)
1425 {
1426   smash_type (type);
1427   TYPE_CODE (type) = TYPE_CODE_MEMBERPTR;
1428   TYPE_TARGET_TYPE (type) = to_type;
1429   set_type_self_type (type, self_type);
1430   /* Assume that a data member pointer is the same size as a normal
1431      pointer.  */
1432   TYPE_LENGTH (type)
1433     = gdbarch_ptr_bit (get_type_arch (to_type)) / TARGET_CHAR_BIT;
1434 }
1435
1436 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1437
1438    When "smashing" the type, we preserve the objfile that the old type
1439    pointed to, since we aren't changing where the type is actually
1440    allocated.  */
1441
1442 void
1443 smash_to_methodptr_type (struct type *type, struct type *to_type)
1444 {
1445   smash_type (type);
1446   TYPE_CODE (type) = TYPE_CODE_METHODPTR;
1447   TYPE_TARGET_TYPE (type) = to_type;
1448   set_type_self_type (type, TYPE_SELF_TYPE (to_type));
1449   TYPE_LENGTH (type) = cplus_method_ptr_size (to_type);
1450 }
1451
1452 /* Smash TYPE to be a type of method of SELF_TYPE with type TO_TYPE.
1453    METHOD just means `function that gets an extra "this" argument'.
1454
1455    When "smashing" the type, we preserve the objfile that the old type
1456    pointed to, since we aren't changing where the type is actually
1457    allocated.  */
1458
1459 void
1460 smash_to_method_type (struct type *type, struct type *self_type,
1461                       struct type *to_type, struct field *args,
1462                       int nargs, int varargs)
1463 {
1464   smash_type (type);
1465   TYPE_CODE (type) = TYPE_CODE_METHOD;
1466   TYPE_TARGET_TYPE (type) = to_type;
1467   set_type_self_type (type, self_type);
1468   TYPE_FIELDS (type) = args;
1469   TYPE_NFIELDS (type) = nargs;
1470   if (varargs)
1471     TYPE_VARARGS (type) = 1;
1472   TYPE_LENGTH (type) = 1;       /* In practice, this is never needed.  */
1473 }
1474
1475 /* A wrapper of TYPE_NAME which calls error if the type is anonymous.
1476    Since GCC PR debug/47510 DWARF provides associated information to detect the
1477    anonymous class linkage name from its typedef.
1478
1479    Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
1480    apply it itself.  */
1481
1482 const char *
1483 type_name_or_error (struct type *type)
1484 {
1485   struct type *saved_type = type;
1486   const char *name;
1487   struct objfile *objfile;
1488
1489   type = check_typedef (type);
1490
1491   name = TYPE_NAME (type);
1492   if (name != NULL)
1493     return name;
1494
1495   name = TYPE_NAME (saved_type);
1496   objfile = TYPE_OBJFILE (saved_type);
1497   error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
1498          name ? name : "<anonymous>",
1499          objfile ? objfile_name (objfile) : "<arch>");
1500 }
1501
1502 /* Lookup a typedef or primitive type named NAME, visible in lexical
1503    block BLOCK.  If NOERR is nonzero, return zero if NAME is not
1504    suitably defined.  */
1505
1506 struct type *
1507 lookup_typename (const struct language_defn *language,
1508                  struct gdbarch *gdbarch, const char *name,
1509                  const struct block *block, int noerr)
1510 {
1511   struct symbol *sym;
1512
1513   sym = lookup_symbol_in_language (name, block, VAR_DOMAIN,
1514                                    language->la_language, NULL).symbol;
1515   if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1516     return SYMBOL_TYPE (sym);
1517
1518   if (noerr)
1519     return NULL;
1520   error (_("No type named %s."), name);
1521 }
1522
1523 struct type *
1524 lookup_unsigned_typename (const struct language_defn *language,
1525                           struct gdbarch *gdbarch, const char *name)
1526 {
1527   char *uns = (char *) alloca (strlen (name) + 10);
1528
1529   strcpy (uns, "unsigned ");
1530   strcpy (uns + 9, name);
1531   return lookup_typename (language, gdbarch, uns, (struct block *) NULL, 0);
1532 }
1533
1534 struct type *
1535 lookup_signed_typename (const struct language_defn *language,
1536                         struct gdbarch *gdbarch, const char *name)
1537 {
1538   struct type *t;
1539   char *uns = (char *) alloca (strlen (name) + 8);
1540
1541   strcpy (uns, "signed ");
1542   strcpy (uns + 7, name);
1543   t = lookup_typename (language, gdbarch, uns, (struct block *) NULL, 1);
1544   /* If we don't find "signed FOO" just try again with plain "FOO".  */
1545   if (t != NULL)
1546     return t;
1547   return lookup_typename (language, gdbarch, name, (struct block *) NULL, 0);
1548 }
1549
1550 /* Lookup a structure type named "struct NAME",
1551    visible in lexical block BLOCK.  */
1552
1553 struct type *
1554 lookup_struct (const char *name, const struct block *block)
1555 {
1556   struct symbol *sym;
1557
1558   sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
1559
1560   if (sym == NULL)
1561     {
1562       error (_("No struct type named %s."), name);
1563     }
1564   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1565     {
1566       error (_("This context has class, union or enum %s, not a struct."),
1567              name);
1568     }
1569   return (SYMBOL_TYPE (sym));
1570 }
1571
1572 /* Lookup a union type named "union NAME",
1573    visible in lexical block BLOCK.  */
1574
1575 struct type *
1576 lookup_union (const char *name, const struct block *block)
1577 {
1578   struct symbol *sym;
1579   struct type *t;
1580
1581   sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
1582
1583   if (sym == NULL)
1584     error (_("No union type named %s."), name);
1585
1586   t = SYMBOL_TYPE (sym);
1587
1588   if (TYPE_CODE (t) == TYPE_CODE_UNION)
1589     return t;
1590
1591   /* If we get here, it's not a union.  */
1592   error (_("This context has class, struct or enum %s, not a union."), 
1593          name);
1594 }
1595
1596 /* Lookup an enum type named "enum NAME",
1597    visible in lexical block BLOCK.  */
1598
1599 struct type *
1600 lookup_enum (const char *name, const struct block *block)
1601 {
1602   struct symbol *sym;
1603
1604   sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
1605   if (sym == NULL)
1606     {
1607       error (_("No enum type named %s."), name);
1608     }
1609   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
1610     {
1611       error (_("This context has class, struct or union %s, not an enum."), 
1612              name);
1613     }
1614   return (SYMBOL_TYPE (sym));
1615 }
1616
1617 /* Lookup a template type named "template NAME<TYPE>",
1618    visible in lexical block BLOCK.  */
1619
1620 struct type *
1621 lookup_template_type (char *name, struct type *type, 
1622                       const struct block *block)
1623 {
1624   struct symbol *sym;
1625   char *nam = (char *) 
1626     alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4);
1627
1628   strcpy (nam, name);
1629   strcat (nam, "<");
1630   strcat (nam, TYPE_NAME (type));
1631   strcat (nam, " >");   /* FIXME, extra space still introduced in gcc?  */
1632
1633   sym = lookup_symbol (nam, block, VAR_DOMAIN, 0).symbol;
1634
1635   if (sym == NULL)
1636     {
1637       error (_("No template type named %s."), name);
1638     }
1639   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1640     {
1641       error (_("This context has class, union or enum %s, not a struct."),
1642              name);
1643     }
1644   return (SYMBOL_TYPE (sym));
1645 }
1646
1647 /* Given a type TYPE, lookup the type of the component of type named
1648    NAME.
1649
1650    TYPE can be either a struct or union, or a pointer or reference to
1651    a struct or union.  If it is a pointer or reference, its target
1652    type is automatically used.  Thus '.' and '->' are interchangable,
1653    as specified for the definitions of the expression element types
1654    STRUCTOP_STRUCT and STRUCTOP_PTR.
1655
1656    If NOERR is nonzero, return zero if NAME is not suitably defined.
1657    If NAME is the name of a baseclass type, return that type.  */
1658
1659 struct type *
1660 lookup_struct_elt_type (struct type *type, const char *name, int noerr)
1661 {
1662   int i;
1663
1664   for (;;)
1665     {
1666       type = check_typedef (type);
1667       if (TYPE_CODE (type) != TYPE_CODE_PTR
1668           && TYPE_CODE (type) != TYPE_CODE_REF)
1669         break;
1670       type = TYPE_TARGET_TYPE (type);
1671     }
1672
1673   if (TYPE_CODE (type) != TYPE_CODE_STRUCT 
1674       && TYPE_CODE (type) != TYPE_CODE_UNION)
1675     {
1676       std::string type_name = type_to_string (type);
1677       error (_("Type %s is not a structure or union type."),
1678              type_name.c_str ());
1679     }
1680
1681 #if 0
1682   /* FIXME: This change put in by Michael seems incorrect for the case
1683      where the structure tag name is the same as the member name.
1684      I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
1685      foo; } bell;" Disabled by fnf.  */
1686   {
1687     char *type_name;
1688
1689     type_name = TYPE_NAME (type);
1690     if (type_name != NULL && strcmp (type_name, name) == 0)
1691       return type;
1692   }
1693 #endif
1694
1695   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1696     {
1697       const char *t_field_name = TYPE_FIELD_NAME (type, i);
1698
1699       if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1700         {
1701           return TYPE_FIELD_TYPE (type, i);
1702         }
1703      else if (!t_field_name || *t_field_name == '\0')
1704         {
1705           struct type *subtype 
1706             = lookup_struct_elt_type (TYPE_FIELD_TYPE (type, i), name, 1);
1707
1708           if (subtype != NULL)
1709             return subtype;
1710         }
1711     }
1712
1713   /* OK, it's not in this class.  Recursively check the baseclasses.  */
1714   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1715     {
1716       struct type *t;
1717
1718       t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 1);
1719       if (t != NULL)
1720         {
1721           return t;
1722         }
1723     }
1724
1725   if (noerr)
1726     {
1727       return NULL;
1728     }
1729
1730   std::string type_name = type_to_string (type);
1731   error (_("Type %s has no component named %s."), type_name.c_str (), name);
1732 }
1733
1734 /* Store in *MAX the largest number representable by unsigned integer type
1735    TYPE.  */
1736
1737 void
1738 get_unsigned_type_max (struct type *type, ULONGEST *max)
1739 {
1740   unsigned int n;
1741
1742   type = check_typedef (type);
1743   gdb_assert (TYPE_CODE (type) == TYPE_CODE_INT && TYPE_UNSIGNED (type));
1744   gdb_assert (TYPE_LENGTH (type) <= sizeof (ULONGEST));
1745
1746   /* Written this way to avoid overflow.  */
1747   n = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
1748   *max = ((((ULONGEST) 1 << (n - 1)) - 1) << 1) | 1;
1749 }
1750
1751 /* Store in *MIN, *MAX the smallest and largest numbers representable by
1752    signed integer type TYPE.  */
1753
1754 void
1755 get_signed_type_minmax (struct type *type, LONGEST *min, LONGEST *max)
1756 {
1757   unsigned int n;
1758
1759   type = check_typedef (type);
1760   gdb_assert (TYPE_CODE (type) == TYPE_CODE_INT && !TYPE_UNSIGNED (type));
1761   gdb_assert (TYPE_LENGTH (type) <= sizeof (LONGEST));
1762
1763   n = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
1764   *min = -((ULONGEST) 1 << (n - 1));
1765   *max = ((ULONGEST) 1 << (n - 1)) - 1;
1766 }
1767
1768 /* Internal routine called by TYPE_VPTR_FIELDNO to return the value of
1769    cplus_stuff.vptr_fieldno.
1770
1771    cplus_stuff is initialized to cplus_struct_default which does not
1772    set vptr_fieldno to -1 for portability reasons (IWBN to use C99
1773    designated initializers).  We cope with that here.  */
1774
1775 int
1776 internal_type_vptr_fieldno (struct type *type)
1777 {
1778   type = check_typedef (type);
1779   gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
1780               || TYPE_CODE (type) == TYPE_CODE_UNION);
1781   if (!HAVE_CPLUS_STRUCT (type))
1782     return -1;
1783   return TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_fieldno;
1784 }
1785
1786 /* Set the value of cplus_stuff.vptr_fieldno.  */
1787
1788 void
1789 set_type_vptr_fieldno (struct type *type, int fieldno)
1790 {
1791   type = check_typedef (type);
1792   gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
1793               || TYPE_CODE (type) == TYPE_CODE_UNION);
1794   if (!HAVE_CPLUS_STRUCT (type))
1795     ALLOCATE_CPLUS_STRUCT_TYPE (type);
1796   TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_fieldno = fieldno;
1797 }
1798
1799 /* Internal routine called by TYPE_VPTR_BASETYPE to return the value of
1800    cplus_stuff.vptr_basetype.  */
1801
1802 struct type *
1803 internal_type_vptr_basetype (struct type *type)
1804 {
1805   type = check_typedef (type);
1806   gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
1807               || TYPE_CODE (type) == TYPE_CODE_UNION);
1808   gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_CPLUS_STUFF);
1809   return TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_basetype;
1810 }
1811
1812 /* Set the value of cplus_stuff.vptr_basetype.  */
1813
1814 void
1815 set_type_vptr_basetype (struct type *type, struct type *basetype)
1816 {
1817   type = check_typedef (type);
1818   gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
1819               || TYPE_CODE (type) == TYPE_CODE_UNION);
1820   if (!HAVE_CPLUS_STRUCT (type))
1821     ALLOCATE_CPLUS_STRUCT_TYPE (type);
1822   TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_basetype = basetype;
1823 }
1824
1825 /* Lookup the vptr basetype/fieldno values for TYPE.
1826    If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1827    vptr_fieldno.  Also, if found and basetype is from the same objfile,
1828    cache the results.
1829    If not found, return -1 and ignore BASETYPEP.
1830    Callers should be aware that in some cases (for example,
1831    the type or one of its baseclasses is a stub type and we are
1832    debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1833    this function will not be able to find the
1834    virtual function table pointer, and vptr_fieldno will remain -1 and
1835    vptr_basetype will remain NULL or incomplete.  */
1836
1837 int
1838 get_vptr_fieldno (struct type *type, struct type **basetypep)
1839 {
1840   type = check_typedef (type);
1841
1842   if (TYPE_VPTR_FIELDNO (type) < 0)
1843     {
1844       int i;
1845
1846       /* We must start at zero in case the first (and only) baseclass
1847          is virtual (and hence we cannot share the table pointer).  */
1848       for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1849         {
1850           struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
1851           int fieldno;
1852           struct type *basetype;
1853
1854           fieldno = get_vptr_fieldno (baseclass, &basetype);
1855           if (fieldno >= 0)
1856             {
1857               /* If the type comes from a different objfile we can't cache
1858                  it, it may have a different lifetime.  PR 2384 */
1859               if (TYPE_OBJFILE (type) == TYPE_OBJFILE (basetype))
1860                 {
1861                   set_type_vptr_fieldno (type, fieldno);
1862                   set_type_vptr_basetype (type, basetype);
1863                 }
1864               if (basetypep)
1865                 *basetypep = basetype;
1866               return fieldno;
1867             }
1868         }
1869
1870       /* Not found.  */
1871       return -1;
1872     }
1873   else
1874     {
1875       if (basetypep)
1876         *basetypep = TYPE_VPTR_BASETYPE (type);
1877       return TYPE_VPTR_FIELDNO (type);
1878     }
1879 }
1880
1881 static void
1882 stub_noname_complaint (void)
1883 {
1884   complaint (_("stub type has NULL name"));
1885 }
1886
1887 /* Return nonzero if TYPE has a DYN_PROP_BYTE_STRIDE dynamic property
1888    attached to it, and that property has a non-constant value.  */
1889
1890 static int
1891 array_type_has_dynamic_stride (struct type *type)
1892 {
1893   struct dynamic_prop *prop = get_dyn_prop (DYN_PROP_BYTE_STRIDE, type);
1894
1895   return (prop != NULL && prop->kind != PROP_CONST);
1896 }
1897
1898 /* Worker for is_dynamic_type.  */
1899
1900 static int
1901 is_dynamic_type_internal (struct type *type, int top_level)
1902 {
1903   type = check_typedef (type);
1904
1905   /* We only want to recognize references at the outermost level.  */
1906   if (top_level && TYPE_CODE (type) == TYPE_CODE_REF)
1907     type = check_typedef (TYPE_TARGET_TYPE (type));
1908
1909   /* Types that have a dynamic TYPE_DATA_LOCATION are considered
1910      dynamic, even if the type itself is statically defined.
1911      From a user's point of view, this may appear counter-intuitive;
1912      but it makes sense in this context, because the point is to determine
1913      whether any part of the type needs to be resolved before it can
1914      be exploited.  */
1915   if (TYPE_DATA_LOCATION (type) != NULL
1916       && (TYPE_DATA_LOCATION_KIND (type) == PROP_LOCEXPR
1917           || TYPE_DATA_LOCATION_KIND (type) == PROP_LOCLIST))
1918     return 1;
1919
1920   if (TYPE_ASSOCIATED_PROP (type))
1921     return 1;
1922
1923   if (TYPE_ALLOCATED_PROP (type))
1924     return 1;
1925
1926   switch (TYPE_CODE (type))
1927     {
1928     case TYPE_CODE_RANGE:
1929       {
1930         /* A range type is obviously dynamic if it has at least one
1931            dynamic bound.  But also consider the range type to be
1932            dynamic when its subtype is dynamic, even if the bounds
1933            of the range type are static.  It allows us to assume that
1934            the subtype of a static range type is also static.  */
1935         return (!has_static_range (TYPE_RANGE_DATA (type))
1936                 || is_dynamic_type_internal (TYPE_TARGET_TYPE (type), 0));
1937       }
1938
1939     case TYPE_CODE_ARRAY:
1940       {
1941         gdb_assert (TYPE_NFIELDS (type) == 1);
1942
1943         /* The array is dynamic if either the bounds are dynamic...  */
1944         if (is_dynamic_type_internal (TYPE_INDEX_TYPE (type), 0))
1945           return 1;
1946         /* ... or the elements it contains have a dynamic contents...  */
1947         if (is_dynamic_type_internal (TYPE_TARGET_TYPE (type), 0))
1948           return 1;
1949         /* ... or if it has a dynamic stride...  */
1950         if (array_type_has_dynamic_stride (type))
1951           return 1;
1952         return 0;
1953       }
1954
1955     case TYPE_CODE_STRUCT:
1956     case TYPE_CODE_UNION:
1957       {
1958         int i;
1959
1960         for (i = 0; i < TYPE_NFIELDS (type); ++i)
1961           if (!field_is_static (&TYPE_FIELD (type, i))
1962               && is_dynamic_type_internal (TYPE_FIELD_TYPE (type, i), 0))
1963             return 1;
1964       }
1965       break;
1966     }
1967
1968   return 0;
1969 }
1970
1971 /* See gdbtypes.h.  */
1972
1973 int
1974 is_dynamic_type (struct type *type)
1975 {
1976   return is_dynamic_type_internal (type, 1);
1977 }
1978
1979 static struct type *resolve_dynamic_type_internal
1980   (struct type *type, struct property_addr_info *addr_stack, int top_level);
1981
1982 /* Given a dynamic range type (dyn_range_type) and a stack of
1983    struct property_addr_info elements, return a static version
1984    of that type.  */
1985
1986 static struct type *
1987 resolve_dynamic_range (struct type *dyn_range_type,
1988                        struct property_addr_info *addr_stack)
1989 {
1990   CORE_ADDR value;
1991   struct type *static_range_type, *static_target_type;
1992   const struct dynamic_prop *prop;
1993   struct dynamic_prop low_bound, high_bound;
1994
1995   gdb_assert (TYPE_CODE (dyn_range_type) == TYPE_CODE_RANGE);
1996
1997   prop = &TYPE_RANGE_DATA (dyn_range_type)->low;
1998   if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
1999     {
2000       low_bound.kind = PROP_CONST;
2001       low_bound.data.const_val = value;
2002     }
2003   else
2004     {
2005       low_bound.kind = PROP_UNDEFINED;
2006       low_bound.data.const_val = 0;
2007     }
2008
2009   prop = &TYPE_RANGE_DATA (dyn_range_type)->high;
2010   if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
2011     {
2012       high_bound.kind = PROP_CONST;
2013       high_bound.data.const_val = value;
2014
2015       if (TYPE_RANGE_DATA (dyn_range_type)->flag_upper_bound_is_count)
2016         high_bound.data.const_val
2017           = low_bound.data.const_val + high_bound.data.const_val - 1;
2018     }
2019   else
2020     {
2021       high_bound.kind = PROP_UNDEFINED;
2022       high_bound.data.const_val = 0;
2023     }
2024
2025   static_target_type
2026     = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (dyn_range_type),
2027                                      addr_stack, 0);
2028   static_range_type = create_range_type (copy_type (dyn_range_type),
2029                                          static_target_type,
2030                                          &low_bound, &high_bound);
2031   TYPE_RANGE_DATA (static_range_type)->flag_bound_evaluated = 1;
2032   return static_range_type;
2033 }
2034
2035 /* Resolves dynamic bound values of an array type TYPE to static ones.
2036    ADDR_STACK is a stack of struct property_addr_info to be used
2037    if needed during the dynamic resolution.  */
2038
2039 static struct type *
2040 resolve_dynamic_array (struct type *type,
2041                        struct property_addr_info *addr_stack)
2042 {
2043   CORE_ADDR value;
2044   struct type *elt_type;
2045   struct type *range_type;
2046   struct type *ary_dim;
2047   struct dynamic_prop *prop;
2048   unsigned int bit_stride = 0;
2049
2050   gdb_assert (TYPE_CODE (type) == TYPE_CODE_ARRAY);
2051
2052   type = copy_type (type);
2053
2054   elt_type = type;
2055   range_type = check_typedef (TYPE_INDEX_TYPE (elt_type));
2056   range_type = resolve_dynamic_range (range_type, addr_stack);
2057
2058   /* Resolve allocated/associated here before creating a new array type, which
2059      will update the length of the array accordingly.  */
2060   prop = TYPE_ALLOCATED_PROP (type);
2061   if (prop != NULL && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
2062     {
2063       TYPE_DYN_PROP_ADDR (prop) = value;
2064       TYPE_DYN_PROP_KIND (prop) = PROP_CONST;
2065     }
2066   prop = TYPE_ASSOCIATED_PROP (type);
2067   if (prop != NULL && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
2068     {
2069       TYPE_DYN_PROP_ADDR (prop) = value;
2070       TYPE_DYN_PROP_KIND (prop) = PROP_CONST;
2071     }
2072
2073   ary_dim = check_typedef (TYPE_TARGET_TYPE (elt_type));
2074
2075   if (ary_dim != NULL && TYPE_CODE (ary_dim) == TYPE_CODE_ARRAY)
2076     elt_type = resolve_dynamic_array (ary_dim, addr_stack);
2077   else
2078     elt_type = TYPE_TARGET_TYPE (type);
2079
2080   prop = get_dyn_prop (DYN_PROP_BYTE_STRIDE, type);
2081   if (prop != NULL)
2082     {
2083       int prop_eval_ok
2084         = dwarf2_evaluate_property (prop, NULL, addr_stack, &value);
2085
2086       if (prop_eval_ok)
2087         {
2088           remove_dyn_prop (DYN_PROP_BYTE_STRIDE, type);
2089           bit_stride = (unsigned int) (value * 8);
2090         }
2091       else
2092         {
2093           /* Could be a bug in our code, but it could also happen
2094              if the DWARF info is not correct.  Issue a warning,
2095              and assume no byte/bit stride (leave bit_stride = 0).  */
2096           warning (_("cannot determine array stride for type %s"),
2097                    TYPE_NAME (type) ? TYPE_NAME (type) : "<no name>");
2098         }
2099     }
2100   else
2101     bit_stride = TYPE_FIELD_BITSIZE (type, 0);
2102
2103   return create_array_type_with_stride (type, elt_type, range_type, NULL,
2104                                         bit_stride);
2105 }
2106
2107 /* Resolve dynamic bounds of members of the union TYPE to static
2108    bounds.  ADDR_STACK is a stack of struct property_addr_info
2109    to be used if needed during the dynamic resolution.  */
2110
2111 static struct type *
2112 resolve_dynamic_union (struct type *type,
2113                        struct property_addr_info *addr_stack)
2114 {
2115   struct type *resolved_type;
2116   int i;
2117   unsigned int max_len = 0;
2118
2119   gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
2120
2121   resolved_type = copy_type (type);
2122   TYPE_FIELDS (resolved_type)
2123     = (struct field *) TYPE_ALLOC (resolved_type,
2124                                    TYPE_NFIELDS (resolved_type)
2125                                    * sizeof (struct field));
2126   memcpy (TYPE_FIELDS (resolved_type),
2127           TYPE_FIELDS (type),
2128           TYPE_NFIELDS (resolved_type) * sizeof (struct field));
2129   for (i = 0; i < TYPE_NFIELDS (resolved_type); ++i)
2130     {
2131       struct type *t;
2132
2133       if (field_is_static (&TYPE_FIELD (type, i)))
2134         continue;
2135
2136       t = resolve_dynamic_type_internal (TYPE_FIELD_TYPE (resolved_type, i),
2137                                          addr_stack, 0);
2138       TYPE_FIELD_TYPE (resolved_type, i) = t;
2139       if (TYPE_LENGTH (t) > max_len)
2140         max_len = TYPE_LENGTH (t);
2141     }
2142
2143   TYPE_LENGTH (resolved_type) = max_len;
2144   return resolved_type;
2145 }
2146
2147 /* Resolve dynamic bounds of members of the struct TYPE to static
2148    bounds.  ADDR_STACK is a stack of struct property_addr_info to
2149    be used if needed during the dynamic resolution.  */
2150
2151 static struct type *
2152 resolve_dynamic_struct (struct type *type,
2153                         struct property_addr_info *addr_stack)
2154 {
2155   struct type *resolved_type;
2156   int i;
2157   unsigned resolved_type_bit_length = 0;
2158
2159   gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT);
2160   gdb_assert (TYPE_NFIELDS (type) > 0);
2161
2162   resolved_type = copy_type (type);
2163   TYPE_FIELDS (resolved_type)
2164     = (struct field *) TYPE_ALLOC (resolved_type,
2165                                    TYPE_NFIELDS (resolved_type)
2166                                    * sizeof (struct field));
2167   memcpy (TYPE_FIELDS (resolved_type),
2168           TYPE_FIELDS (type),
2169           TYPE_NFIELDS (resolved_type) * sizeof (struct field));
2170   for (i = 0; i < TYPE_NFIELDS (resolved_type); ++i)
2171     {
2172       unsigned new_bit_length;
2173       struct property_addr_info pinfo;
2174
2175       if (field_is_static (&TYPE_FIELD (type, i)))
2176         continue;
2177
2178       /* As we know this field is not a static field, the field's
2179          field_loc_kind should be FIELD_LOC_KIND_BITPOS.  Verify
2180          this is the case, but only trigger a simple error rather
2181          than an internal error if that fails.  While failing
2182          that verification indicates a bug in our code, the error
2183          is not severe enough to suggest to the user he stops
2184          his debugging session because of it.  */
2185       if (TYPE_FIELD_LOC_KIND (type, i) != FIELD_LOC_KIND_BITPOS)
2186         error (_("Cannot determine struct field location"
2187                  " (invalid location kind)"));
2188
2189       pinfo.type = check_typedef (TYPE_FIELD_TYPE (type, i));
2190       pinfo.valaddr = addr_stack->valaddr;
2191       pinfo.addr
2192         = (addr_stack->addr
2193            + (TYPE_FIELD_BITPOS (resolved_type, i) / TARGET_CHAR_BIT));
2194       pinfo.next = addr_stack;
2195
2196       TYPE_FIELD_TYPE (resolved_type, i)
2197         = resolve_dynamic_type_internal (TYPE_FIELD_TYPE (resolved_type, i),
2198                                          &pinfo, 0);
2199       gdb_assert (TYPE_FIELD_LOC_KIND (resolved_type, i)
2200                   == FIELD_LOC_KIND_BITPOS);
2201
2202       new_bit_length = TYPE_FIELD_BITPOS (resolved_type, i);
2203       if (TYPE_FIELD_BITSIZE (resolved_type, i) != 0)
2204         new_bit_length += TYPE_FIELD_BITSIZE (resolved_type, i);
2205       else
2206         new_bit_length += (TYPE_LENGTH (TYPE_FIELD_TYPE (resolved_type, i))
2207                            * TARGET_CHAR_BIT);
2208
2209       /* Normally, we would use the position and size of the last field
2210          to determine the size of the enclosing structure.  But GCC seems
2211          to be encoding the position of some fields incorrectly when
2212          the struct contains a dynamic field that is not placed last.
2213          So we compute the struct size based on the field that has
2214          the highest position + size - probably the best we can do.  */
2215       if (new_bit_length > resolved_type_bit_length)
2216         resolved_type_bit_length = new_bit_length;
2217     }
2218
2219   /* The length of a type won't change for fortran, but it does for C and Ada.
2220      For fortran the size of dynamic fields might change over time but not the
2221      type length of the structure.  If we adapt it, we run into problems
2222      when calculating the element offset for arrays of structs.  */
2223   if (current_language->la_language != language_fortran)
2224     TYPE_LENGTH (resolved_type)
2225       = (resolved_type_bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
2226
2227   /* The Ada language uses this field as a cache for static fixed types: reset
2228      it as RESOLVED_TYPE must have its own static fixed type.  */
2229   TYPE_TARGET_TYPE (resolved_type) = NULL;
2230
2231   return resolved_type;
2232 }
2233
2234 /* Worker for resolved_dynamic_type.  */
2235
2236 static struct type *
2237 resolve_dynamic_type_internal (struct type *type,
2238                                struct property_addr_info *addr_stack,
2239                                int top_level)
2240 {
2241   struct type *real_type = check_typedef (type);
2242   struct type *resolved_type = type;
2243   struct dynamic_prop *prop;
2244   CORE_ADDR value;
2245
2246   if (!is_dynamic_type_internal (real_type, top_level))
2247     return type;
2248
2249   if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
2250     {
2251       resolved_type = copy_type (type);
2252       TYPE_TARGET_TYPE (resolved_type)
2253         = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type), addr_stack,
2254                                          top_level);
2255     }
2256   else 
2257     {
2258       /* Before trying to resolve TYPE, make sure it is not a stub.  */
2259       type = real_type;
2260
2261       switch (TYPE_CODE (type))
2262         {
2263         case TYPE_CODE_REF:
2264           {
2265             struct property_addr_info pinfo;
2266
2267             pinfo.type = check_typedef (TYPE_TARGET_TYPE (type));
2268             pinfo.valaddr = NULL;
2269             if (addr_stack->valaddr != NULL)
2270               pinfo.addr = extract_typed_address (addr_stack->valaddr, type);
2271             else
2272               pinfo.addr = read_memory_typed_address (addr_stack->addr, type);
2273             pinfo.next = addr_stack;
2274
2275             resolved_type = copy_type (type);
2276             TYPE_TARGET_TYPE (resolved_type)
2277               = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (type),
2278                                                &pinfo, top_level);
2279             break;
2280           }
2281
2282         case TYPE_CODE_ARRAY:
2283           resolved_type = resolve_dynamic_array (type, addr_stack);
2284           break;
2285
2286         case TYPE_CODE_RANGE:
2287           resolved_type = resolve_dynamic_range (type, addr_stack);
2288           break;
2289
2290         case TYPE_CODE_UNION:
2291           resolved_type = resolve_dynamic_union (type, addr_stack);
2292           break;
2293
2294         case TYPE_CODE_STRUCT:
2295           resolved_type = resolve_dynamic_struct (type, addr_stack);
2296           break;
2297         }
2298     }
2299
2300   /* Resolve data_location attribute.  */
2301   prop = TYPE_DATA_LOCATION (resolved_type);
2302   if (prop != NULL
2303       && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
2304     {
2305       TYPE_DYN_PROP_ADDR (prop) = value;
2306       TYPE_DYN_PROP_KIND (prop) = PROP_CONST;
2307     }
2308
2309   return resolved_type;
2310 }
2311
2312 /* See gdbtypes.h  */
2313
2314 struct type *
2315 resolve_dynamic_type (struct type *type, const gdb_byte *valaddr,
2316                       CORE_ADDR addr)
2317 {
2318   struct property_addr_info pinfo
2319     = {check_typedef (type), valaddr, addr, NULL};
2320
2321   return resolve_dynamic_type_internal (type, &pinfo, 1);
2322 }
2323
2324 /* See gdbtypes.h  */
2325
2326 struct dynamic_prop *
2327 get_dyn_prop (enum dynamic_prop_node_kind prop_kind, const struct type *type)
2328 {
2329   struct dynamic_prop_list *node = TYPE_DYN_PROP_LIST (type);
2330
2331   while (node != NULL)
2332     {
2333       if (node->prop_kind == prop_kind)
2334         return &node->prop;
2335       node = node->next;
2336     }
2337   return NULL;
2338 }
2339
2340 /* See gdbtypes.h  */
2341
2342 void
2343 add_dyn_prop (enum dynamic_prop_node_kind prop_kind, struct dynamic_prop prop,
2344               struct type *type)
2345 {
2346   struct dynamic_prop_list *temp;
2347
2348   gdb_assert (TYPE_OBJFILE_OWNED (type));
2349
2350   temp = XOBNEW (&TYPE_OBJFILE (type)->objfile_obstack,
2351                  struct dynamic_prop_list);
2352   temp->prop_kind = prop_kind;
2353   temp->prop = prop;
2354   temp->next = TYPE_DYN_PROP_LIST (type);
2355
2356   TYPE_DYN_PROP_LIST (type) = temp;
2357 }
2358
2359 /* Remove dynamic property from TYPE in case it exists.  */
2360
2361 void
2362 remove_dyn_prop (enum dynamic_prop_node_kind prop_kind,
2363                  struct type *type)
2364 {
2365   struct dynamic_prop_list *prev_node, *curr_node;
2366
2367   curr_node = TYPE_DYN_PROP_LIST (type);
2368   prev_node = NULL;
2369
2370   while (NULL != curr_node)
2371     {
2372       if (curr_node->prop_kind == prop_kind)
2373         {
2374           /* Update the linked list but don't free anything.
2375              The property was allocated on objstack and it is not known
2376              if we are on top of it.  Nevertheless, everything is released
2377              when the complete objstack is freed.  */
2378           if (NULL == prev_node)
2379             TYPE_DYN_PROP_LIST (type) = curr_node->next;
2380           else
2381             prev_node->next = curr_node->next;
2382
2383           return;
2384         }
2385
2386       prev_node = curr_node;
2387       curr_node = curr_node->next;
2388     }
2389 }
2390
2391 /* Find the real type of TYPE.  This function returns the real type,
2392    after removing all layers of typedefs, and completing opaque or stub
2393    types.  Completion changes the TYPE argument, but stripping of
2394    typedefs does not.
2395
2396    Instance flags (e.g. const/volatile) are preserved as typedefs are
2397    stripped.  If necessary a new qualified form of the underlying type
2398    is created.
2399
2400    NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
2401    not been computed and we're either in the middle of reading symbols, or
2402    there was no name for the typedef in the debug info.
2403
2404    NOTE: Lookup of opaque types can throw errors for invalid symbol files.
2405    QUITs in the symbol reading code can also throw.
2406    Thus this function can throw an exception.
2407
2408    If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
2409    the target type.
2410
2411    If this is a stubbed struct (i.e. declared as struct foo *), see if
2412    we can find a full definition in some other file.  If so, copy this
2413    definition, so we can use it in future.  There used to be a comment
2414    (but not any code) that if we don't find a full definition, we'd
2415    set a flag so we don't spend time in the future checking the same
2416    type.  That would be a mistake, though--we might load in more
2417    symbols which contain a full definition for the type.  */
2418
2419 struct type *
2420 check_typedef (struct type *type)
2421 {
2422   struct type *orig_type = type;
2423   /* While we're removing typedefs, we don't want to lose qualifiers.
2424      E.g., const/volatile.  */
2425   int instance_flags = TYPE_INSTANCE_FLAGS (type);
2426
2427   gdb_assert (type);
2428
2429   while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
2430     {
2431       if (!TYPE_TARGET_TYPE (type))
2432         {
2433           const char *name;
2434           struct symbol *sym;
2435
2436           /* It is dangerous to call lookup_symbol if we are currently
2437              reading a symtab.  Infinite recursion is one danger.  */
2438           if (currently_reading_symtab)
2439             return make_qualified_type (type, instance_flags, NULL);
2440
2441           name = TYPE_NAME (type);
2442           /* FIXME: shouldn't we look in STRUCT_DOMAIN and/or
2443              VAR_DOMAIN as appropriate?  */
2444           if (name == NULL)
2445             {
2446               stub_noname_complaint ();
2447               return make_qualified_type (type, instance_flags, NULL);
2448             }
2449           sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol;
2450           if (sym)
2451             TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
2452           else                                  /* TYPE_CODE_UNDEF */
2453             TYPE_TARGET_TYPE (type) = alloc_type_arch (get_type_arch (type));
2454         }
2455       type = TYPE_TARGET_TYPE (type);
2456
2457       /* Preserve the instance flags as we traverse down the typedef chain.
2458
2459          Handling address spaces/classes is nasty, what do we do if there's a
2460          conflict?
2461          E.g., what if an outer typedef marks the type as class_1 and an inner
2462          typedef marks the type as class_2?
2463          This is the wrong place to do such error checking.  We leave it to
2464          the code that created the typedef in the first place to flag the
2465          error.  We just pick the outer address space (akin to letting the
2466          outer cast in a chain of casting win), instead of assuming
2467          "it can't happen".  */
2468       {
2469         const int ALL_SPACES = (TYPE_INSTANCE_FLAG_CODE_SPACE
2470                                 | TYPE_INSTANCE_FLAG_DATA_SPACE);
2471         const int ALL_CLASSES = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL;
2472         int new_instance_flags = TYPE_INSTANCE_FLAGS (type);
2473
2474         /* Treat code vs data spaces and address classes separately.  */
2475         if ((instance_flags & ALL_SPACES) != 0)
2476           new_instance_flags &= ~ALL_SPACES;
2477         if ((instance_flags & ALL_CLASSES) != 0)
2478           new_instance_flags &= ~ALL_CLASSES;
2479
2480         instance_flags |= new_instance_flags;
2481       }
2482     }
2483
2484   /* If this is a struct/class/union with no fields, then check
2485      whether a full definition exists somewhere else.  This is for
2486      systems where a type definition with no fields is issued for such
2487      types, instead of identifying them as stub types in the first
2488      place.  */
2489
2490   if (TYPE_IS_OPAQUE (type) 
2491       && opaque_type_resolution 
2492       && !currently_reading_symtab)
2493     {
2494       const char *name = TYPE_NAME (type);
2495       struct type *newtype;
2496
2497       if (name == NULL)
2498         {
2499           stub_noname_complaint ();
2500           return make_qualified_type (type, instance_flags, NULL);
2501         }
2502       newtype = lookup_transparent_type (name);
2503
2504       if (newtype)
2505         {
2506           /* If the resolved type and the stub are in the same
2507              objfile, then replace the stub type with the real deal.
2508              But if they're in separate objfiles, leave the stub
2509              alone; we'll just look up the transparent type every time
2510              we call check_typedef.  We can't create pointers between
2511              types allocated to different objfiles, since they may
2512              have different lifetimes.  Trying to copy NEWTYPE over to
2513              TYPE's objfile is pointless, too, since you'll have to
2514              move over any other types NEWTYPE refers to, which could
2515              be an unbounded amount of stuff.  */
2516           if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type))
2517             type = make_qualified_type (newtype,
2518                                         TYPE_INSTANCE_FLAGS (type),
2519                                         type);
2520           else
2521             type = newtype;
2522         }
2523     }
2524   /* Otherwise, rely on the stub flag being set for opaque/stubbed
2525      types.  */
2526   else if (TYPE_STUB (type) && !currently_reading_symtab)
2527     {
2528       const char *name = TYPE_NAME (type);
2529       /* FIXME: shouldn't we look in STRUCT_DOMAIN and/or VAR_DOMAIN
2530          as appropriate?  */
2531       struct symbol *sym;
2532
2533       if (name == NULL)
2534         {
2535           stub_noname_complaint ();
2536           return make_qualified_type (type, instance_flags, NULL);
2537         }
2538       sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol;
2539       if (sym)
2540         {
2541           /* Same as above for opaque types, we can replace the stub
2542              with the complete type only if they are in the same
2543              objfile.  */
2544           if (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type))
2545             type = make_qualified_type (SYMBOL_TYPE (sym),
2546                                         TYPE_INSTANCE_FLAGS (type),
2547                                         type);
2548           else
2549             type = SYMBOL_TYPE (sym);
2550         }
2551     }
2552
2553   if (TYPE_TARGET_STUB (type))
2554     {
2555       struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
2556
2557       if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type))
2558         {
2559           /* Nothing we can do.  */
2560         }
2561       else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
2562         {
2563           TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
2564           TYPE_TARGET_STUB (type) = 0;
2565         }
2566     }
2567
2568   type = make_qualified_type (type, instance_flags, NULL);
2569
2570   /* Cache TYPE_LENGTH for future use.  */
2571   TYPE_LENGTH (orig_type) = TYPE_LENGTH (type);
2572
2573   return type;
2574 }
2575
2576 /* Parse a type expression in the string [P..P+LENGTH).  If an error
2577    occurs, silently return a void type.  */
2578
2579 static struct type *
2580 safe_parse_type (struct gdbarch *gdbarch, char *p, int length)
2581 {
2582   struct ui_file *saved_gdb_stderr;
2583   struct type *type = NULL; /* Initialize to keep gcc happy.  */
2584
2585   /* Suppress error messages.  */
2586   saved_gdb_stderr = gdb_stderr;
2587   gdb_stderr = &null_stream;
2588
2589   /* Call parse_and_eval_type() without fear of longjmp()s.  */
2590   TRY
2591     {
2592       type = parse_and_eval_type (p, length);
2593     }
2594   CATCH (except, RETURN_MASK_ERROR)
2595     {
2596       type = builtin_type (gdbarch)->builtin_void;
2597     }
2598   END_CATCH
2599
2600   /* Stop suppressing error messages.  */
2601   gdb_stderr = saved_gdb_stderr;
2602
2603   return type;
2604 }
2605
2606 /* Ugly hack to convert method stubs into method types.
2607
2608    He ain't kiddin'.  This demangles the name of the method into a
2609    string including argument types, parses out each argument type,
2610    generates a string casting a zero to that type, evaluates the
2611    string, and stuffs the resulting type into an argtype vector!!!
2612    Then it knows the type of the whole function (including argument
2613    types for overloading), which info used to be in the stab's but was
2614    removed to hack back the space required for them.  */
2615
2616 static void
2617 check_stub_method (struct type *type, int method_id, int signature_id)
2618 {
2619   struct gdbarch *gdbarch = get_type_arch (type);
2620   struct fn_field *f;
2621   char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
2622   char *demangled_name = gdb_demangle (mangled_name,
2623                                        DMGL_PARAMS | DMGL_ANSI);
2624   char *argtypetext, *p;
2625   int depth = 0, argcount = 1;
2626   struct field *argtypes;
2627   struct type *mtype;
2628
2629   /* Make sure we got back a function string that we can use.  */
2630   if (demangled_name)
2631     p = strchr (demangled_name, '(');
2632   else
2633     p = NULL;
2634
2635   if (demangled_name == NULL || p == NULL)
2636     error (_("Internal: Cannot demangle mangled name `%s'."), 
2637            mangled_name);
2638
2639   /* Now, read in the parameters that define this type.  */
2640   p += 1;
2641   argtypetext = p;
2642   while (*p)
2643     {
2644       if (*p == '(' || *p == '<')
2645         {
2646           depth += 1;
2647         }
2648       else if (*p == ')' || *p == '>')
2649         {
2650           depth -= 1;
2651         }
2652       else if (*p == ',' && depth == 0)
2653         {
2654           argcount += 1;
2655         }
2656
2657       p += 1;
2658     }
2659
2660   /* If we read one argument and it was ``void'', don't count it.  */
2661   if (startswith (argtypetext, "(void)"))
2662     argcount -= 1;
2663
2664   /* We need one extra slot, for the THIS pointer.  */
2665
2666   argtypes = (struct field *)
2667     TYPE_ALLOC (type, (argcount + 1) * sizeof (struct field));
2668   p = argtypetext;
2669
2670   /* Add THIS pointer for non-static methods.  */
2671   f = TYPE_FN_FIELDLIST1 (type, method_id);
2672   if (TYPE_FN_FIELD_STATIC_P (f, signature_id))
2673     argcount = 0;
2674   else
2675     {
2676       argtypes[0].type = lookup_pointer_type (type);
2677       argcount = 1;
2678     }
2679
2680   if (*p != ')')                /* () means no args, skip while.  */
2681     {
2682       depth = 0;
2683       while (*p)
2684         {
2685           if (depth <= 0 && (*p == ',' || *p == ')'))
2686             {
2687               /* Avoid parsing of ellipsis, they will be handled below.
2688                  Also avoid ``void'' as above.  */
2689               if (strncmp (argtypetext, "...", p - argtypetext) != 0
2690                   && strncmp (argtypetext, "void", p - argtypetext) != 0)
2691                 {
2692                   argtypes[argcount].type =
2693                     safe_parse_type (gdbarch, argtypetext, p - argtypetext);
2694                   argcount += 1;
2695                 }
2696               argtypetext = p + 1;
2697             }
2698
2699           if (*p == '(' || *p == '<')
2700             {
2701               depth += 1;
2702             }
2703           else if (*p == ')' || *p == '>')
2704             {
2705               depth -= 1;
2706             }
2707
2708           p += 1;
2709         }
2710     }
2711
2712   TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name;
2713
2714   /* Now update the old "stub" type into a real type.  */
2715   mtype = TYPE_FN_FIELD_TYPE (f, signature_id);
2716   /* MTYPE may currently be a function (TYPE_CODE_FUNC).
2717      We want a method (TYPE_CODE_METHOD).  */
2718   smash_to_method_type (mtype, type, TYPE_TARGET_TYPE (mtype),
2719                         argtypes, argcount, p[-2] == '.');
2720   TYPE_STUB (mtype) = 0;
2721   TYPE_FN_FIELD_STUB (f, signature_id) = 0;
2722
2723   xfree (demangled_name);
2724 }
2725
2726 /* This is the external interface to check_stub_method, above.  This
2727    function unstubs all of the signatures for TYPE's METHOD_ID method
2728    name.  After calling this function TYPE_FN_FIELD_STUB will be
2729    cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
2730    correct.
2731
2732    This function unfortunately can not die until stabs do.  */
2733
2734 void
2735 check_stub_method_group (struct type *type, int method_id)
2736 {
2737   int len = TYPE_FN_FIELDLIST_LENGTH (type, method_id);
2738   struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
2739
2740   for (int j = 0; j < len; j++)
2741     {
2742       if (TYPE_FN_FIELD_STUB (f, j))
2743         check_stub_method (type, method_id, j);
2744     }
2745 }
2746
2747 /* Ensure it is in .rodata (if available) by workarounding GCC PR 44690.  */
2748 const struct cplus_struct_type cplus_struct_default = { };
2749
2750 void
2751 allocate_cplus_struct_type (struct type *type)
2752 {
2753   if (HAVE_CPLUS_STRUCT (type))
2754     /* Structure was already allocated.  Nothing more to do.  */
2755     return;
2756
2757   TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CPLUS_STUFF;
2758   TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
2759     TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
2760   *(TYPE_RAW_CPLUS_SPECIFIC (type)) = cplus_struct_default;
2761   set_type_vptr_fieldno (type, -1);
2762 }
2763
2764 const struct gnat_aux_type gnat_aux_default =
2765   { NULL };
2766
2767 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
2768    and allocate the associated gnat-specific data.  The gnat-specific
2769    data is also initialized to gnat_aux_default.  */
2770
2771 void
2772 allocate_gnat_aux_type (struct type *type)
2773 {
2774   TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_GNAT_STUFF;
2775   TYPE_GNAT_SPECIFIC (type) = (struct gnat_aux_type *)
2776     TYPE_ALLOC (type, sizeof (struct gnat_aux_type));
2777   *(TYPE_GNAT_SPECIFIC (type)) = gnat_aux_default;
2778 }
2779
2780 /* Helper function to initialize a newly allocated type.  Set type code
2781    to CODE and initialize the type-specific fields accordingly.  */
2782
2783 static void
2784 set_type_code (struct type *type, enum type_code code)
2785 {
2786   TYPE_CODE (type) = code;
2787
2788   switch (code)
2789     {
2790       case TYPE_CODE_STRUCT:
2791       case TYPE_CODE_UNION:
2792       case TYPE_CODE_NAMESPACE:
2793         INIT_CPLUS_SPECIFIC (type);
2794         break;
2795       case TYPE_CODE_FLT:
2796         TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FLOATFORMAT;
2797         break;
2798       case TYPE_CODE_FUNC:
2799         INIT_FUNC_SPECIFIC (type);
2800         break;
2801     }
2802 }
2803
2804 /* Helper function to verify floating-point format and size.
2805    BIT is the type size in bits; if BIT equals -1, the size is
2806    determined by the floatformat.  Returns size to be used.  */
2807
2808 static int
2809 verify_floatformat (int bit, const struct floatformat *floatformat)
2810 {
2811   gdb_assert (floatformat != NULL);
2812
2813   if (bit == -1)
2814     bit = floatformat->totalsize;
2815
2816   gdb_assert (bit >= 0);
2817   gdb_assert (bit >= floatformat->totalsize);
2818
2819   return bit;
2820 }
2821
2822 /* Return the floating-point format for a floating-point variable of
2823    type TYPE.  */
2824
2825 const struct floatformat *
2826 floatformat_from_type (const struct type *type)
2827 {
2828   gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
2829   gdb_assert (TYPE_FLOATFORMAT (type));
2830   return TYPE_FLOATFORMAT (type);
2831 }
2832
2833 /* Helper function to initialize the standard scalar types.
2834
2835    If NAME is non-NULL, then it is used to initialize the type name.
2836    Note that NAME is not copied; it is required to have a lifetime at
2837    least as long as OBJFILE.  */
2838
2839 struct type *
2840 init_type (struct objfile *objfile, enum type_code code, int bit,
2841            const char *name)
2842 {
2843   struct type *type;
2844
2845   type = alloc_type (objfile);
2846   set_type_code (type, code);
2847   gdb_assert ((bit % TARGET_CHAR_BIT) == 0);
2848   TYPE_LENGTH (type) = bit / TARGET_CHAR_BIT;
2849   TYPE_NAME (type) = name;
2850
2851   return type;
2852 }
2853
2854 /* Allocate a TYPE_CODE_ERROR type structure associated with OBJFILE,
2855    to use with variables that have no debug info.  NAME is the type
2856    name.  */
2857
2858 static struct type *
2859 init_nodebug_var_type (struct objfile *objfile, const char *name)
2860 {
2861   return init_type (objfile, TYPE_CODE_ERROR, 0, name);
2862 }
2863
2864 /* Allocate a TYPE_CODE_INT type structure associated with OBJFILE.
2865    BIT is the type size in bits.  If UNSIGNED_P is non-zero, set
2866    the type's TYPE_UNSIGNED flag.  NAME is the type name.  */
2867
2868 struct type *
2869 init_integer_type (struct objfile *objfile,
2870                    int bit, int unsigned_p, const char *name)
2871 {
2872   struct type *t;
2873
2874   t = init_type (objfile, TYPE_CODE_INT, bit, name);
2875   if (unsigned_p)
2876     TYPE_UNSIGNED (t) = 1;
2877
2878   return t;
2879 }
2880
2881 /* Allocate a TYPE_CODE_CHAR type structure associated with OBJFILE.
2882    BIT is the type size in bits.  If UNSIGNED_P is non-zero, set
2883    the type's TYPE_UNSIGNED flag.  NAME is the type name.  */
2884
2885 struct type *
2886 init_character_type (struct objfile *objfile,
2887                      int bit, int unsigned_p, const char *name)
2888 {
2889   struct type *t;
2890
2891   t = init_type (objfile, TYPE_CODE_CHAR, bit, name);
2892   if (unsigned_p)
2893     TYPE_UNSIGNED (t) = 1;
2894
2895   return t;
2896 }
2897
2898 /* Allocate a TYPE_CODE_BOOL type structure associated with OBJFILE.
2899    BIT is the type size in bits.  If UNSIGNED_P is non-zero, set
2900    the type's TYPE_UNSIGNED flag.  NAME is the type name.  */
2901
2902 struct type *
2903 init_boolean_type (struct objfile *objfile,
2904                    int bit, int unsigned_p, const char *name)
2905 {
2906   struct type *t;
2907
2908   t = init_type (objfile, TYPE_CODE_BOOL, bit, name);
2909   if (unsigned_p)
2910     TYPE_UNSIGNED (t) = 1;
2911
2912   return t;
2913 }
2914
2915 /* Allocate a TYPE_CODE_FLT type structure associated with OBJFILE.
2916    BIT is the type size in bits; if BIT equals -1, the size is
2917    determined by the floatformat.  NAME is the type name.  Set the
2918    TYPE_FLOATFORMAT from FLOATFORMATS.  */
2919
2920 struct type *
2921 init_float_type (struct objfile *objfile,
2922                  int bit, const char *name,
2923                  const struct floatformat **floatformats)
2924 {
2925   struct gdbarch *gdbarch = get_objfile_arch (objfile);
2926   const struct floatformat *fmt = floatformats[gdbarch_byte_order (gdbarch)];
2927   struct type *t;
2928
2929   bit = verify_floatformat (bit, fmt);
2930   t = init_type (objfile, TYPE_CODE_FLT, bit, name);
2931   TYPE_FLOATFORMAT (t) = fmt;
2932
2933   return t;
2934 }
2935
2936 /* Allocate a TYPE_CODE_DECFLOAT type structure associated with OBJFILE.
2937    BIT is the type size in bits.  NAME is the type name.  */
2938
2939 struct type *
2940 init_decfloat_type (struct objfile *objfile, int bit, const char *name)
2941 {
2942   struct type *t;
2943
2944   t = init_type (objfile, TYPE_CODE_DECFLOAT, bit, name);
2945   return t;
2946 }
2947
2948 /* Allocate a TYPE_CODE_COMPLEX type structure associated with OBJFILE.
2949    NAME is the type name.  TARGET_TYPE is the component float type.  */
2950
2951 struct type *
2952 init_complex_type (struct objfile *objfile,
2953                    const char *name, struct type *target_type)
2954 {
2955   struct type *t;
2956
2957   t = init_type (objfile, TYPE_CODE_COMPLEX,
2958                  2 * TYPE_LENGTH (target_type) * TARGET_CHAR_BIT, name);
2959   TYPE_TARGET_TYPE (t) = target_type;
2960   return t;
2961 }
2962
2963 /* Allocate a TYPE_CODE_PTR type structure associated with OBJFILE.
2964    BIT is the pointer type size in bits.  NAME is the type name.
2965    TARGET_TYPE is the pointer target type.  Always sets the pointer type's
2966    TYPE_UNSIGNED flag.  */
2967
2968 struct type *
2969 init_pointer_type (struct objfile *objfile,
2970                    int bit, const char *name, struct type *target_type)
2971 {
2972   struct type *t;
2973
2974   t = init_type (objfile, TYPE_CODE_PTR, bit, name);
2975   TYPE_TARGET_TYPE (t) = target_type;
2976   TYPE_UNSIGNED (t) = 1;
2977   return t;
2978 }
2979
2980 /* See gdbtypes.h.  */
2981
2982 unsigned
2983 type_raw_align (struct type *type)
2984 {
2985   if (type->align_log2 != 0)
2986     return 1 << (type->align_log2 - 1);
2987   return 0;
2988 }
2989
2990 /* See gdbtypes.h.  */
2991
2992 unsigned
2993 type_align (struct type *type)
2994 {
2995   unsigned raw_align = type_raw_align (type);
2996   if (raw_align != 0)
2997     return raw_align;
2998
2999   ULONGEST align = 0;
3000   switch (TYPE_CODE (type))
3001     {
3002     case TYPE_CODE_PTR:
3003     case TYPE_CODE_FUNC:
3004     case TYPE_CODE_FLAGS:
3005     case TYPE_CODE_INT:
3006     case TYPE_CODE_RANGE:
3007     case TYPE_CODE_FLT:
3008     case TYPE_CODE_ENUM:
3009     case TYPE_CODE_REF:
3010     case TYPE_CODE_RVALUE_REF:
3011     case TYPE_CODE_CHAR:
3012     case TYPE_CODE_BOOL:
3013     case TYPE_CODE_DECFLOAT:
3014     case TYPE_CODE_METHODPTR:
3015     case TYPE_CODE_MEMBERPTR:
3016       {
3017         struct gdbarch *arch = get_type_arch (type);
3018         align = gdbarch_type_align (arch, type);
3019       }
3020       break;
3021
3022     case TYPE_CODE_ARRAY:
3023     case TYPE_CODE_COMPLEX:
3024     case TYPE_CODE_TYPEDEF:
3025       align = type_align (TYPE_TARGET_TYPE (type));
3026       break;
3027
3028     case TYPE_CODE_STRUCT:
3029     case TYPE_CODE_UNION:
3030       {
3031         if (TYPE_NFIELDS (type) == 0)
3032           {
3033             /* An empty struct has alignment 1.  */
3034             align = 1;
3035             break;
3036           }
3037         for (unsigned i = 0; i < TYPE_NFIELDS (type); ++i)
3038           {
3039             ULONGEST f_align = type_align (TYPE_FIELD_TYPE (type, i));
3040             if (f_align == 0)
3041               {
3042                 /* Don't pretend we know something we don't.  */
3043                 align = 0;
3044                 break;
3045               }
3046             if (f_align > align)
3047               align = f_align;
3048           }
3049       }
3050       break;
3051
3052     case TYPE_CODE_SET:
3053     case TYPE_CODE_STRING:
3054       /* Not sure what to do here, and these can't appear in C or C++
3055          anyway.  */
3056       break;
3057
3058     case TYPE_CODE_VOID:
3059       align = 1;
3060       break;
3061
3062     case TYPE_CODE_ERROR:
3063     case TYPE_CODE_METHOD:
3064     default:
3065       break;
3066     }
3067
3068   if ((align & (align - 1)) != 0)
3069     {
3070       /* Not a power of 2, so pass.  */
3071       align = 0;
3072     }
3073
3074   return align;
3075 }
3076
3077 /* See gdbtypes.h.  */
3078
3079 bool
3080 set_type_align (struct type *type, ULONGEST align)
3081 {
3082   /* Must be a power of 2.  Zero is ok.  */
3083   gdb_assert ((align & (align - 1)) == 0);
3084
3085   unsigned result = 0;
3086   while (align != 0)
3087     {
3088       ++result;
3089       align >>= 1;
3090     }
3091
3092   if (result >= (1 << TYPE_ALIGN_BITS))
3093     return false;
3094
3095   type->align_log2 = result;
3096   return true;
3097 }
3098
3099 \f
3100 /* Queries on types.  */
3101
3102 int
3103 can_dereference (struct type *t)
3104 {
3105   /* FIXME: Should we return true for references as well as
3106      pointers?  */
3107   t = check_typedef (t);
3108   return
3109     (t != NULL
3110      && TYPE_CODE (t) == TYPE_CODE_PTR
3111      && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
3112 }
3113
3114 int
3115 is_integral_type (struct type *t)
3116 {
3117   t = check_typedef (t);
3118   return
3119     ((t != NULL)
3120      && ((TYPE_CODE (t) == TYPE_CODE_INT)
3121          || (TYPE_CODE (t) == TYPE_CODE_ENUM)
3122          || (TYPE_CODE (t) == TYPE_CODE_FLAGS)
3123          || (TYPE_CODE (t) == TYPE_CODE_CHAR)
3124          || (TYPE_CODE (t) == TYPE_CODE_RANGE)
3125          || (TYPE_CODE (t) == TYPE_CODE_BOOL)));
3126 }
3127
3128 int
3129 is_floating_type (struct type *t)
3130 {
3131   t = check_typedef (t);
3132   return
3133     ((t != NULL)
3134      && ((TYPE_CODE (t) == TYPE_CODE_FLT)
3135          || (TYPE_CODE (t) == TYPE_CODE_DECFLOAT)));
3136 }
3137
3138 /* Return true if TYPE is scalar.  */
3139
3140 int
3141 is_scalar_type (struct type *type)
3142 {
3143   type = check_typedef (type);
3144
3145   switch (TYPE_CODE (type))
3146     {
3147     case TYPE_CODE_ARRAY:
3148     case TYPE_CODE_STRUCT:
3149     case TYPE_CODE_UNION:
3150     case TYPE_CODE_SET:
3151     case TYPE_CODE_STRING:
3152       return 0;
3153     default:
3154       return 1;
3155     }
3156 }
3157
3158 /* Return true if T is scalar, or a composite type which in practice has
3159    the memory layout of a scalar type.  E.g., an array or struct with only
3160    one scalar element inside it, or a union with only scalar elements.  */
3161
3162 int
3163 is_scalar_type_recursive (struct type *t)
3164 {
3165   t = check_typedef (t);
3166
3167   if (is_scalar_type (t))
3168     return 1;
3169   /* Are we dealing with an array or string of known dimensions?  */
3170   else if ((TYPE_CODE (t) == TYPE_CODE_ARRAY
3171             || TYPE_CODE (t) == TYPE_CODE_STRING) && TYPE_NFIELDS (t) == 1
3172            && TYPE_CODE (TYPE_INDEX_TYPE (t)) == TYPE_CODE_RANGE)
3173     {
3174       LONGEST low_bound, high_bound;
3175       struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t));
3176
3177       get_discrete_bounds (TYPE_INDEX_TYPE (t), &low_bound, &high_bound);
3178
3179       return high_bound == low_bound && is_scalar_type_recursive (elt_type);
3180     }
3181   /* Are we dealing with a struct with one element?  */
3182   else if (TYPE_CODE (t) == TYPE_CODE_STRUCT && TYPE_NFIELDS (t) == 1)
3183     return is_scalar_type_recursive (TYPE_FIELD_TYPE (t, 0));
3184   else if (TYPE_CODE (t) == TYPE_CODE_UNION)
3185     {
3186       int i, n = TYPE_NFIELDS (t);
3187
3188       /* If all elements of the union are scalar, then the union is scalar.  */
3189       for (i = 0; i < n; i++)
3190         if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t, i)))
3191           return 0;
3192
3193       return 1;
3194     }
3195
3196   return 0;
3197 }
3198
3199 /* Return true is T is a class or a union.  False otherwise.  */
3200
3201 int
3202 class_or_union_p (const struct type *t)
3203 {
3204   return (TYPE_CODE (t) == TYPE_CODE_STRUCT
3205           || TYPE_CODE (t) == TYPE_CODE_UNION);
3206 }
3207
3208 /* A helper function which returns true if types A and B represent the
3209    "same" class type.  This is true if the types have the same main
3210    type, or the same name.  */
3211
3212 int
3213 class_types_same_p (const struct type *a, const struct type *b)
3214 {
3215   return (TYPE_MAIN_TYPE (a) == TYPE_MAIN_TYPE (b)
3216           || (TYPE_NAME (a) && TYPE_NAME (b)
3217               && !strcmp (TYPE_NAME (a), TYPE_NAME (b))));
3218 }
3219
3220 /* If BASE is an ancestor of DCLASS return the distance between them.
3221    otherwise return -1;
3222    eg:
3223
3224    class A {};
3225    class B: public A {};
3226    class C: public B {};
3227    class D: C {};
3228
3229    distance_to_ancestor (A, A, 0) = 0
3230    distance_to_ancestor (A, B, 0) = 1
3231    distance_to_ancestor (A, C, 0) = 2
3232    distance_to_ancestor (A, D, 0) = 3
3233
3234    If PUBLIC is 1 then only public ancestors are considered,
3235    and the function returns the distance only if BASE is a public ancestor
3236    of DCLASS.
3237    Eg:
3238
3239    distance_to_ancestor (A, D, 1) = -1.  */
3240
3241 static int
3242 distance_to_ancestor (struct type *base, struct type *dclass, int is_public)
3243 {
3244   int i;
3245   int d;
3246
3247   base = check_typedef (base);
3248   dclass = check_typedef (dclass);
3249
3250   if (class_types_same_p (base, dclass))
3251     return 0;
3252
3253   for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
3254     {
3255       if (is_public && ! BASETYPE_VIA_PUBLIC (dclass, i))
3256         continue;
3257
3258       d = distance_to_ancestor (base, TYPE_BASECLASS (dclass, i), is_public);
3259       if (d >= 0)
3260         return 1 + d;
3261     }
3262
3263   return -1;
3264 }
3265
3266 /* Check whether BASE is an ancestor or base class or DCLASS
3267    Return 1 if so, and 0 if not.
3268    Note: If BASE and DCLASS are of the same type, this function
3269    will return 1. So for some class A, is_ancestor (A, A) will
3270    return 1.  */
3271
3272 int
3273 is_ancestor (struct type *base, struct type *dclass)
3274 {
3275   return distance_to_ancestor (base, dclass, 0) >= 0;
3276 }
3277
3278 /* Like is_ancestor, but only returns true when BASE is a public
3279    ancestor of DCLASS.  */
3280
3281 int
3282 is_public_ancestor (struct type *base, struct type *dclass)
3283 {
3284   return distance_to_ancestor (base, dclass, 1) >= 0;
3285 }
3286
3287 /* A helper function for is_unique_ancestor.  */
3288
3289 static int
3290 is_unique_ancestor_worker (struct type *base, struct type *dclass,
3291                            int *offset,
3292                            const gdb_byte *valaddr, int embedded_offset,
3293                            CORE_ADDR address, struct value *val)
3294 {
3295   int i, count = 0;
3296
3297   base = check_typedef (base);
3298   dclass = check_typedef (dclass);
3299
3300   for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i)
3301     {
3302       struct type *iter;
3303       int this_offset;
3304
3305       iter = check_typedef (TYPE_BASECLASS (dclass, i));
3306
3307       this_offset = baseclass_offset (dclass, i, valaddr, embedded_offset,
3308                                       address, val);
3309
3310       if (class_types_same_p (base, iter))
3311         {
3312           /* If this is the first subclass, set *OFFSET and set count
3313              to 1.  Otherwise, if this is at the same offset as
3314              previous instances, do nothing.  Otherwise, increment
3315              count.  */
3316           if (*offset == -1)
3317             {
3318               *offset = this_offset;
3319               count = 1;
3320             }
3321           else if (this_offset == *offset)
3322             {
3323               /* Nothing.  */
3324             }
3325           else
3326             ++count;
3327         }
3328       else
3329         count += is_unique_ancestor_worker (base, iter, offset,
3330                                             valaddr,
3331                                             embedded_offset + this_offset,
3332                                             address, val);
3333     }
3334
3335   return count;
3336 }
3337
3338 /* Like is_ancestor, but only returns true if BASE is a unique base
3339    class of the type of VAL.  */
3340
3341 int
3342 is_unique_ancestor (struct type *base, struct value *val)
3343 {
3344   int offset = -1;
3345
3346   return is_unique_ancestor_worker (base, value_type (val), &offset,
3347                                     value_contents_for_printing (val),
3348                                     value_embedded_offset (val),
3349                                     value_address (val), val) == 1;
3350 }
3351
3352 \f
3353 /* Overload resolution.  */
3354
3355 /* Return the sum of the rank of A with the rank of B.  */
3356
3357 struct rank
3358 sum_ranks (struct rank a, struct rank b)
3359 {
3360   struct rank c;
3361   c.rank = a.rank + b.rank;
3362   c.subrank = a.subrank + b.subrank;
3363   return c;
3364 }
3365
3366 /* Compare rank A and B and return:
3367    0 if a = b
3368    1 if a is better than b
3369   -1 if b is better than a.  */
3370
3371 int
3372 compare_ranks (struct rank a, struct rank b)
3373 {
3374   if (a.rank == b.rank)
3375     {
3376       if (a.subrank == b.subrank)
3377         return 0;
3378       if (a.subrank < b.subrank)
3379         return 1;
3380       if (a.subrank > b.subrank)
3381         return -1;
3382     }
3383
3384   if (a.rank < b.rank)
3385     return 1;
3386
3387   /* a.rank > b.rank */
3388   return -1;
3389 }
3390
3391 /* Functions for overload resolution begin here.  */
3392
3393 /* Compare two badness vectors A and B and return the result.
3394    0 => A and B are identical
3395    1 => A and B are incomparable
3396    2 => A is better than B
3397    3 => A is worse than B  */
3398
3399 int
3400 compare_badness (const badness_vector &a, const badness_vector &b)
3401 {
3402   int i;
3403   int tmp;
3404   short found_pos = 0;          /* any positives in c? */
3405   short found_neg = 0;          /* any negatives in c? */
3406
3407   /* differing sizes => incomparable */
3408   if (a.size () != b.size ())
3409     return 1;
3410
3411   /* Subtract b from a */
3412   for (i = 0; i < a.size (); i++)
3413     {
3414       tmp = compare_ranks (b[i], a[i]);
3415       if (tmp > 0)
3416         found_pos = 1;
3417       else if (tmp < 0)
3418         found_neg = 1;
3419     }
3420
3421   if (found_pos)
3422     {
3423       if (found_neg)
3424         return 1;               /* incomparable */
3425       else
3426         return 3;               /* A > B */
3427     }
3428   else
3429     /* no positives */
3430     {
3431       if (found_neg)
3432         return 2;               /* A < B */
3433       else
3434         return 0;               /* A == B */
3435     }
3436 }
3437
3438 /* Rank a function by comparing its parameter types (PARMS), to the
3439    types of an argument list (ARGS).  Return the badness vector.  This
3440    has ARGS.size() + 1 entries.  */
3441
3442 badness_vector
3443 rank_function (gdb::array_view<type *> parms,
3444                gdb::array_view<value *> args)
3445 {
3446   /* add 1 for the length-match rank.  */
3447   badness_vector bv;
3448   bv.reserve (1 + args.size ());
3449
3450   /* First compare the lengths of the supplied lists.
3451      If there is a mismatch, set it to a high value.  */
3452
3453   /* pai/1997-06-03 FIXME: when we have debug info about default
3454      arguments and ellipsis parameter lists, we should consider those
3455      and rank the length-match more finely.  */
3456
3457   bv.push_back ((args.size () != parms.size ())
3458                 ? LENGTH_MISMATCH_BADNESS
3459                 : EXACT_MATCH_BADNESS);
3460
3461   /* Now rank all the parameters of the candidate function.  */
3462   size_t min_len = std::min (parms.size (), args.size ());
3463
3464   for (size_t i = 0; i < min_len; i++)
3465     bv.push_back (rank_one_type (parms[i], value_type (args[i]),
3466                                  args[i]));
3467
3468   /* If more arguments than parameters, add dummy entries.  */
3469   for (size_t i = min_len; i < args.size (); i++)
3470     bv.push_back (TOO_FEW_PARAMS_BADNESS);
3471
3472   return bv;
3473 }
3474
3475 /* Compare the names of two integer types, assuming that any sign
3476    qualifiers have been checked already.  We do it this way because
3477    there may be an "int" in the name of one of the types.  */
3478
3479 static int
3480 integer_types_same_name_p (const char *first, const char *second)
3481 {
3482   int first_p, second_p;
3483
3484   /* If both are shorts, return 1; if neither is a short, keep
3485      checking.  */
3486   first_p = (strstr (first, "short") != NULL);
3487   second_p = (strstr (second, "short") != NULL);
3488   if (first_p && second_p)
3489     return 1;
3490   if (first_p || second_p)
3491     return 0;
3492
3493   /* Likewise for long.  */
3494   first_p = (strstr (first, "long") != NULL);
3495   second_p = (strstr (second, "long") != NULL);
3496   if (first_p && second_p)
3497     return 1;
3498   if (first_p || second_p)
3499     return 0;
3500
3501   /* Likewise for char.  */
3502   first_p = (strstr (first, "char") != NULL);
3503   second_p = (strstr (second, "char") != NULL);
3504   if (first_p && second_p)
3505     return 1;
3506   if (first_p || second_p)
3507     return 0;
3508
3509   /* They must both be ints.  */
3510   return 1;
3511 }
3512
3513 /* Compares type A to type B.  Returns true if they represent the same
3514    type, false otherwise.  */
3515
3516 bool
3517 types_equal (struct type *a, struct type *b)
3518 {
3519   /* Identical type pointers.  */
3520   /* However, this still doesn't catch all cases of same type for b
3521      and a.  The reason is that builtin types are different from
3522      the same ones constructed from the object.  */
3523   if (a == b)
3524     return true;
3525
3526   /* Resolve typedefs */
3527   if (TYPE_CODE (a) == TYPE_CODE_TYPEDEF)
3528     a = check_typedef (a);
3529   if (TYPE_CODE (b) == TYPE_CODE_TYPEDEF)
3530     b = check_typedef (b);
3531
3532   /* If after resolving typedefs a and b are not of the same type
3533      code then they are not equal.  */
3534   if (TYPE_CODE (a) != TYPE_CODE (b))
3535     return false;
3536
3537   /* If a and b are both pointers types or both reference types then
3538      they are equal of the same type iff the objects they refer to are
3539      of the same type.  */
3540   if (TYPE_CODE (a) == TYPE_CODE_PTR
3541       || TYPE_CODE (a) == TYPE_CODE_REF)
3542     return types_equal (TYPE_TARGET_TYPE (a),
3543                         TYPE_TARGET_TYPE (b));
3544
3545   /* Well, damnit, if the names are exactly the same, I'll say they
3546      are exactly the same.  This happens when we generate method
3547      stubs.  The types won't point to the same address, but they
3548      really are the same.  */
3549
3550   if (TYPE_NAME (a) && TYPE_NAME (b)
3551       && strcmp (TYPE_NAME (a), TYPE_NAME (b)) == 0)
3552     return true;
3553
3554   /* Check if identical after resolving typedefs.  */
3555   if (a == b)
3556     return true;
3557
3558   /* Two function types are equal if their argument and return types
3559      are equal.  */
3560   if (TYPE_CODE (a) == TYPE_CODE_FUNC)
3561     {
3562       int i;
3563
3564       if (TYPE_NFIELDS (a) != TYPE_NFIELDS (b))
3565         return false;
3566       
3567       if (!types_equal (TYPE_TARGET_TYPE (a), TYPE_TARGET_TYPE (b)))
3568         return false;
3569
3570       for (i = 0; i < TYPE_NFIELDS (a); ++i)
3571         if (!types_equal (TYPE_FIELD_TYPE (a, i), TYPE_FIELD_TYPE (b, i)))
3572           return false;
3573
3574       return true;
3575     }
3576
3577   return false;
3578 }
3579 \f
3580 /* Deep comparison of types.  */
3581
3582 /* An entry in the type-equality bcache.  */
3583
3584 struct type_equality_entry
3585 {
3586   type_equality_entry (struct type *t1, struct type *t2)
3587     : type1 (t1),
3588       type2 (t2)
3589   {
3590   }
3591
3592   struct type *type1, *type2;
3593 };
3594
3595 /* A helper function to compare two strings.  Returns true if they are
3596    the same, false otherwise.  Handles NULLs properly.  */
3597
3598 static bool
3599 compare_maybe_null_strings (const char *s, const char *t)
3600 {
3601   if (s == NULL || t == NULL)
3602     return s == t;
3603   return strcmp (s, t) == 0;
3604 }
3605
3606 /* A helper function for check_types_worklist that checks two types for
3607    "deep" equality.  Returns true if the types are considered the
3608    same, false otherwise.  */
3609
3610 static bool
3611 check_types_equal (struct type *type1, struct type *type2,
3612                    std::vector<type_equality_entry> *worklist)
3613 {
3614   type1 = check_typedef (type1);
3615   type2 = check_typedef (type2);
3616
3617   if (type1 == type2)
3618     return true;
3619
3620   if (TYPE_CODE (type1) != TYPE_CODE (type2)
3621       || TYPE_LENGTH (type1) != TYPE_LENGTH (type2)
3622       || TYPE_UNSIGNED (type1) != TYPE_UNSIGNED (type2)
3623       || TYPE_NOSIGN (type1) != TYPE_NOSIGN (type2)
3624       || TYPE_VARARGS (type1) != TYPE_VARARGS (type2)
3625       || TYPE_VECTOR (type1) != TYPE_VECTOR (type2)
3626       || TYPE_NOTTEXT (type1) != TYPE_NOTTEXT (type2)
3627       || TYPE_INSTANCE_FLAGS (type1) != TYPE_INSTANCE_FLAGS (type2)
3628       || TYPE_NFIELDS (type1) != TYPE_NFIELDS (type2))
3629     return false;
3630
3631   if (!compare_maybe_null_strings (TYPE_NAME (type1), TYPE_NAME (type2)))
3632     return false;
3633   if (!compare_maybe_null_strings (TYPE_NAME (type1), TYPE_NAME (type2)))
3634     return false;
3635
3636   if (TYPE_CODE (type1) == TYPE_CODE_RANGE)
3637     {
3638       if (*TYPE_RANGE_DATA (type1) != *TYPE_RANGE_DATA (type2))
3639         return false;
3640     }
3641   else
3642     {
3643       int i;
3644
3645       for (i = 0; i < TYPE_NFIELDS (type1); ++i)
3646         {
3647           const struct field *field1 = &TYPE_FIELD (type1, i);
3648           const struct field *field2 = &TYPE_FIELD (type2, i);
3649
3650           if (FIELD_ARTIFICIAL (*field1) != FIELD_ARTIFICIAL (*field2)
3651               || FIELD_BITSIZE (*field1) != FIELD_BITSIZE (*field2)
3652               || FIELD_LOC_KIND (*field1) != FIELD_LOC_KIND (*field2))
3653             return false;
3654           if (!compare_maybe_null_strings (FIELD_NAME (*field1),
3655                                            FIELD_NAME (*field2)))
3656             return false;
3657           switch (FIELD_LOC_KIND (*field1))
3658             {
3659             case FIELD_LOC_KIND_BITPOS:
3660               if (FIELD_BITPOS (*field1) != FIELD_BITPOS (*field2))
3661                 return false;
3662               break;
3663             case FIELD_LOC_KIND_ENUMVAL:
3664               if (FIELD_ENUMVAL (*field1) != FIELD_ENUMVAL (*field2))
3665                 return false;
3666               break;
3667             case FIELD_LOC_KIND_PHYSADDR:
3668               if (FIELD_STATIC_PHYSADDR (*field1)
3669                   != FIELD_STATIC_PHYSADDR (*field2))
3670                 return false;
3671               break;
3672             case FIELD_LOC_KIND_PHYSNAME:
3673               if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1),
3674                                                FIELD_STATIC_PHYSNAME (*field2)))
3675                 return false;
3676               break;
3677             case FIELD_LOC_KIND_DWARF_BLOCK:
3678               {
3679                 struct dwarf2_locexpr_baton *block1, *block2;
3680
3681                 block1 = FIELD_DWARF_BLOCK (*field1);
3682                 block2 = FIELD_DWARF_BLOCK (*field2);
3683                 if (block1->per_cu != block2->per_cu
3684                     || block1->size != block2->size
3685                     || memcmp (block1->data, block2->data, block1->size) != 0)
3686                   return false;
3687               }
3688               break;
3689             default:
3690               internal_error (__FILE__, __LINE__, _("Unsupported field kind "
3691                                                     "%d by check_types_equal"),
3692                               FIELD_LOC_KIND (*field1));
3693             }
3694
3695           worklist->emplace_back (FIELD_TYPE (*field1), FIELD_TYPE (*field2));
3696         }
3697     }
3698
3699   if (TYPE_TARGET_TYPE (type1) != NULL)
3700     {
3701       if (TYPE_TARGET_TYPE (type2) == NULL)
3702         return false;
3703
3704       worklist->emplace_back (TYPE_TARGET_TYPE (type1),
3705                               TYPE_TARGET_TYPE (type2));
3706     }
3707   else if (TYPE_TARGET_TYPE (type2) != NULL)
3708     return false;
3709
3710   return true;
3711 }
3712
3713 /* Check types on a worklist for equality.  Returns false if any pair
3714    is not equal, true if they are all considered equal.  */
3715
3716 static bool
3717 check_types_worklist (std::vector<type_equality_entry> *worklist,
3718                       struct bcache *cache)
3719 {
3720   while (!worklist->empty ())
3721     {
3722       int added;
3723
3724       struct type_equality_entry entry = std::move (worklist->back ());
3725       worklist->pop_back ();
3726
3727       /* If the type pair has already been visited, we know it is
3728          ok.  */
3729       bcache_full (&entry, sizeof (entry), cache, &added);
3730       if (!added)
3731         continue;
3732
3733       if (!check_types_equal (entry.type1, entry.type2, worklist))
3734         return false;
3735     }
3736
3737   return true;
3738 }
3739
3740 /* Return true if types TYPE1 and TYPE2 are equal, as determined by a
3741    "deep comparison".  Otherwise return false.  */
3742
3743 bool
3744 types_deeply_equal (struct type *type1, struct type *type2)
3745 {
3746   struct gdb_exception except = exception_none;
3747   bool result = false;
3748   struct bcache *cache;
3749   std::vector<type_equality_entry> worklist;
3750
3751   gdb_assert (type1 != NULL && type2 != NULL);
3752
3753   /* Early exit for the simple case.  */
3754   if (type1 == type2)
3755     return true;
3756
3757   cache = bcache_xmalloc (NULL, NULL);
3758
3759   worklist.emplace_back (type1, type2);
3760
3761   /* check_types_worklist calls several nested helper functions, some
3762      of which can raise a GDB exception, so we just check and rethrow
3763      here.  If there is a GDB exception, a comparison is not capable
3764      (or trusted), so exit.  */
3765   TRY
3766     {
3767       result = check_types_worklist (&worklist, cache);
3768     }
3769   CATCH (ex, RETURN_MASK_ALL)
3770     {
3771       except = ex;
3772     }
3773   END_CATCH
3774
3775   bcache_xfree (cache);
3776
3777   /* Rethrow if there was a problem.  */
3778   if (except.reason < 0)
3779     throw_exception (except);
3780
3781   return result;
3782 }
3783
3784 /* Allocated status of type TYPE.  Return zero if type TYPE is allocated.
3785    Otherwise return one.  */
3786
3787 int
3788 type_not_allocated (const struct type *type)
3789 {
3790   struct dynamic_prop *prop = TYPE_ALLOCATED_PROP (type);
3791
3792   return (prop && TYPE_DYN_PROP_KIND (prop) == PROP_CONST
3793          && !TYPE_DYN_PROP_ADDR (prop));
3794 }
3795
3796 /* Associated status of type TYPE.  Return zero if type TYPE is associated.
3797    Otherwise return one.  */
3798
3799 int
3800 type_not_associated (const struct type *type)
3801 {
3802   struct dynamic_prop *prop = TYPE_ASSOCIATED_PROP (type);
3803
3804   return (prop && TYPE_DYN_PROP_KIND (prop) == PROP_CONST
3805          && !TYPE_DYN_PROP_ADDR (prop));
3806 }
3807 \f
3808 /* Compare one type (PARM) for compatibility with another (ARG).
3809  * PARM is intended to be the parameter type of a function; and
3810  * ARG is the supplied argument's type.  This function tests if
3811  * the latter can be converted to the former.
3812  * VALUE is the argument's value or NULL if none (or called recursively)
3813  *
3814  * Return 0 if they are identical types;
3815  * Otherwise, return an integer which corresponds to how compatible
3816  * PARM is to ARG.  The higher the return value, the worse the match.
3817  * Generally the "bad" conversions are all uniformly assigned a 100.  */
3818
3819 struct rank
3820 rank_one_type (struct type *parm, struct type *arg, struct value *value)
3821 {
3822   struct rank rank = {0,0};
3823
3824   /* Resolve typedefs */
3825   if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF)
3826     parm = check_typedef (parm);
3827   if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
3828     arg = check_typedef (arg);
3829
3830   if (TYPE_IS_REFERENCE (parm) && value != NULL)
3831     {
3832       if (VALUE_LVAL (value) == not_lval)
3833         {
3834           /* Rvalues should preferably bind to rvalue references or const
3835              lvalue references.  */
3836           if (TYPE_CODE (parm) == TYPE_CODE_RVALUE_REF)
3837             rank.subrank = REFERENCE_CONVERSION_RVALUE;
3838           else if (TYPE_CONST (TYPE_TARGET_TYPE (parm)))
3839             rank.subrank = REFERENCE_CONVERSION_CONST_LVALUE;
3840           else
3841             return INCOMPATIBLE_TYPE_BADNESS;
3842           return sum_ranks (rank, REFERENCE_CONVERSION_BADNESS);
3843         }
3844       else
3845         {
3846           /* Lvalues should prefer lvalue overloads.  */
3847           if (TYPE_CODE (parm) == TYPE_CODE_RVALUE_REF)
3848             {
3849               rank.subrank = REFERENCE_CONVERSION_RVALUE;
3850               return sum_ranks (rank, REFERENCE_CONVERSION_BADNESS);
3851             }
3852         }
3853     }
3854
3855   if (types_equal (parm, arg))
3856     {
3857       struct type *t1 = parm;
3858       struct type *t2 = arg;
3859
3860       /* For pointers and references, compare target type.  */
3861       if (TYPE_CODE (parm) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (parm))
3862         {
3863           t1 = TYPE_TARGET_TYPE (parm);
3864           t2 = TYPE_TARGET_TYPE (arg);
3865         }
3866
3867       /* Make sure they are CV equal, too.  */
3868       if (TYPE_CONST (t1) != TYPE_CONST (t2))
3869         rank.subrank |= CV_CONVERSION_CONST;
3870       if (TYPE_VOLATILE (t1) != TYPE_VOLATILE (t2))
3871         rank.subrank |= CV_CONVERSION_VOLATILE;
3872       if (rank.subrank != 0)
3873         return sum_ranks (CV_CONVERSION_BADNESS, rank);
3874       return EXACT_MATCH_BADNESS;
3875     }
3876
3877   /* See through references, since we can almost make non-references
3878      references.  */
3879
3880   if (TYPE_IS_REFERENCE (arg))
3881     return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL),
3882                        REFERENCE_CONVERSION_BADNESS));
3883   if (TYPE_IS_REFERENCE (parm))
3884     return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL),
3885                        REFERENCE_CONVERSION_BADNESS));
3886   if (overload_debug)
3887   /* Debugging only.  */
3888     fprintf_filtered (gdb_stderr, 
3889                       "------ Arg is %s [%d], parm is %s [%d]\n",
3890                       TYPE_NAME (arg), TYPE_CODE (arg), 
3891                       TYPE_NAME (parm), TYPE_CODE (parm));
3892
3893   /* x -> y means arg of type x being supplied for parameter of type y.  */
3894
3895   switch (TYPE_CODE (parm))
3896     {
3897     case TYPE_CODE_PTR:
3898       switch (TYPE_CODE (arg))
3899         {
3900         case TYPE_CODE_PTR:
3901
3902           /* Allowed pointer conversions are:
3903              (a) pointer to void-pointer conversion.  */
3904           if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID)
3905             return VOID_PTR_CONVERSION_BADNESS;
3906
3907           /* (b) pointer to ancestor-pointer conversion.  */
3908           rank.subrank = distance_to_ancestor (TYPE_TARGET_TYPE (parm),
3909                                                TYPE_TARGET_TYPE (arg),
3910                                                0);
3911           if (rank.subrank >= 0)
3912             return sum_ranks (BASE_PTR_CONVERSION_BADNESS, rank);
3913
3914           return INCOMPATIBLE_TYPE_BADNESS;
3915         case TYPE_CODE_ARRAY:
3916           {
3917             struct type *t1 = TYPE_TARGET_TYPE (parm);
3918             struct type *t2 = TYPE_TARGET_TYPE (arg);
3919
3920             if (types_equal (t1, t2))
3921               {
3922                 /* Make sure they are CV equal.  */
3923                 if (TYPE_CONST (t1) != TYPE_CONST (t2))
3924                   rank.subrank |= CV_CONVERSION_CONST;
3925                 if (TYPE_VOLATILE (t1) != TYPE_VOLATILE (t2))
3926                   rank.subrank |= CV_CONVERSION_VOLATILE;
3927                 if (rank.subrank != 0)
3928                   return sum_ranks (CV_CONVERSION_BADNESS, rank);
3929                 return EXACT_MATCH_BADNESS;
3930               }
3931             return INCOMPATIBLE_TYPE_BADNESS;
3932           }
3933         case TYPE_CODE_FUNC:
3934           return rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL);
3935         case TYPE_CODE_INT:
3936           if (value != NULL && TYPE_CODE (value_type (value)) == TYPE_CODE_INT)
3937             {
3938               if (value_as_long (value) == 0)
3939                 {
3940                   /* Null pointer conversion: allow it to be cast to a pointer.
3941                      [4.10.1 of C++ standard draft n3290]  */
3942                   return NULL_POINTER_CONVERSION_BADNESS;
3943                 }
3944               else
3945                 {
3946                   /* If type checking is disabled, allow the conversion.  */
3947                   if (!strict_type_checking)
3948                     return NS_INTEGER_POINTER_CONVERSION_BADNESS;
3949                 }
3950             }
3951           /* fall through  */
3952         case TYPE_CODE_ENUM:
3953         case TYPE_CODE_FLAGS:
3954         case TYPE_CODE_CHAR:
3955         case TYPE_CODE_RANGE:
3956         case TYPE_CODE_BOOL:
3957         default:
3958           return INCOMPATIBLE_TYPE_BADNESS;
3959         }
3960     case TYPE_CODE_ARRAY:
3961       switch (TYPE_CODE (arg))
3962         {
3963         case TYPE_CODE_PTR:
3964         case TYPE_CODE_ARRAY:
3965           return rank_one_type (TYPE_TARGET_TYPE (parm), 
3966                                 TYPE_TARGET_TYPE (arg), NULL);
3967         default:
3968           return INCOMPATIBLE_TYPE_BADNESS;
3969         }
3970     case TYPE_CODE_FUNC:
3971       switch (TYPE_CODE (arg))
3972         {
3973         case TYPE_CODE_PTR:     /* funcptr -> func */
3974           return rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL);
3975         default:
3976           return INCOMPATIBLE_TYPE_BADNESS;
3977         }
3978     case TYPE_CODE_INT:
3979       switch (TYPE_CODE (arg))
3980         {
3981         case TYPE_CODE_INT:
3982           if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
3983             {
3984               /* Deal with signed, unsigned, and plain chars and
3985                  signed and unsigned ints.  */
3986               if (TYPE_NOSIGN (parm))
3987                 {
3988                   /* This case only for character types.  */
3989                   if (TYPE_NOSIGN (arg))
3990                     return EXACT_MATCH_BADNESS; /* plain char -> plain char */
3991                   else          /* signed/unsigned char -> plain char */
3992                     return INTEGER_CONVERSION_BADNESS;
3993                 }
3994               else if (TYPE_UNSIGNED (parm))
3995                 {
3996                   if (TYPE_UNSIGNED (arg))
3997                     {
3998                       /* unsigned int -> unsigned int, or 
3999                          unsigned long -> unsigned long */
4000                       if (integer_types_same_name_p (TYPE_NAME (parm), 
4001                                                      TYPE_NAME (arg)))
4002                         return EXACT_MATCH_BADNESS;
4003                       else if (integer_types_same_name_p (TYPE_NAME (arg), 
4004                                                           "int")
4005                                && integer_types_same_name_p (TYPE_NAME (parm),
4006                                                              "long"))
4007                         /* unsigned int -> unsigned long */
4008                         return INTEGER_PROMOTION_BADNESS;
4009                       else
4010                         /* unsigned long -> unsigned int */
4011                         return INTEGER_CONVERSION_BADNESS;
4012                     }
4013                   else
4014                     {
4015                       if (integer_types_same_name_p (TYPE_NAME (arg), 
4016                                                      "long")
4017                           && integer_types_same_name_p (TYPE_NAME (parm), 
4018                                                         "int"))
4019                         /* signed long -> unsigned int */
4020                         return INTEGER_CONVERSION_BADNESS;
4021                       else
4022                         /* signed int/long -> unsigned int/long */
4023                         return INTEGER_CONVERSION_BADNESS;
4024                     }
4025                 }
4026               else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
4027                 {
4028                   if (integer_types_same_name_p (TYPE_NAME (parm), 
4029                                                  TYPE_NAME (arg)))
4030                     return EXACT_MATCH_BADNESS;
4031                   else if (integer_types_same_name_p (TYPE_NAME (arg), 
4032                                                       "int")
4033                            && integer_types_same_name_p (TYPE_NAME (parm), 
4034                                                          "long"))
4035                     return INTEGER_PROMOTION_BADNESS;
4036                   else
4037                     return INTEGER_CONVERSION_BADNESS;
4038                 }
4039               else
4040                 return INTEGER_CONVERSION_BADNESS;
4041             }
4042           else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
4043             return INTEGER_PROMOTION_BADNESS;
4044           else
4045             return INTEGER_CONVERSION_BADNESS;
4046         case TYPE_CODE_ENUM:
4047         case TYPE_CODE_FLAGS:
4048         case TYPE_CODE_CHAR:
4049         case TYPE_CODE_RANGE:
4050         case TYPE_CODE_BOOL:
4051           if (TYPE_DECLARED_CLASS (arg))
4052             return INCOMPATIBLE_TYPE_BADNESS;
4053           return INTEGER_PROMOTION_BADNESS;
4054         case TYPE_CODE_FLT:
4055           return INT_FLOAT_CONVERSION_BADNESS;
4056         case TYPE_CODE_PTR:
4057           return NS_POINTER_CONVERSION_BADNESS;
4058         default:
4059           return INCOMPATIBLE_TYPE_BADNESS;
4060         }
4061       break;
4062     case TYPE_CODE_ENUM:
4063       switch (TYPE_CODE (arg))
4064         {
4065         case TYPE_CODE_INT:
4066         case TYPE_CODE_CHAR:
4067         case TYPE_CODE_RANGE:
4068         case TYPE_CODE_BOOL:
4069         case TYPE_CODE_ENUM:
4070           if (TYPE_DECLARED_CLASS (parm) || TYPE_DECLARED_CLASS (arg))
4071             return INCOMPATIBLE_TYPE_BADNESS;
4072           return INTEGER_CONVERSION_BADNESS;
4073         case TYPE_CODE_FLT:
4074           return INT_FLOAT_CONVERSION_BADNESS;
4075         default:
4076           return INCOMPATIBLE_TYPE_BADNESS;
4077         }
4078       break;
4079     case TYPE_CODE_CHAR:
4080       switch (TYPE_CODE (arg))
4081         {
4082         case TYPE_CODE_RANGE:
4083         case TYPE_CODE_BOOL:
4084         case TYPE_CODE_ENUM:
4085           if (TYPE_DECLARED_CLASS (arg))
4086             return INCOMPATIBLE_TYPE_BADNESS;
4087           return INTEGER_CONVERSION_BADNESS;
4088         case TYPE_CODE_FLT:
4089           return INT_FLOAT_CONVERSION_BADNESS;
4090         case TYPE_CODE_INT:
4091           if (TYPE_LENGTH (arg) > TYPE_LENGTH (parm))
4092             return INTEGER_CONVERSION_BADNESS;
4093           else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
4094             return INTEGER_PROMOTION_BADNESS;
4095           /* fall through */
4096         case TYPE_CODE_CHAR:
4097           /* Deal with signed, unsigned, and plain chars for C++ and
4098              with int cases falling through from previous case.  */
4099           if (TYPE_NOSIGN (parm))
4100             {
4101               if (TYPE_NOSIGN (arg))
4102                 return EXACT_MATCH_BADNESS;
4103               else
4104                 return INTEGER_CONVERSION_BADNESS;
4105             }
4106           else if (TYPE_UNSIGNED (parm))
4107             {
4108               if (TYPE_UNSIGNED (arg))
4109                 return EXACT_MATCH_BADNESS;
4110               else
4111                 return INTEGER_PROMOTION_BADNESS;
4112             }
4113           else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
4114             return EXACT_MATCH_BADNESS;
4115           else
4116             return INTEGER_CONVERSION_BADNESS;
4117         default:
4118           return INCOMPATIBLE_TYPE_BADNESS;
4119         }
4120       break;
4121     case TYPE_CODE_RANGE:
4122       switch (TYPE_CODE (arg))
4123         {
4124         case TYPE_CODE_INT:
4125         case TYPE_CODE_CHAR:
4126         case TYPE_CODE_RANGE:
4127         case TYPE_CODE_BOOL:
4128         case TYPE_CODE_ENUM:
4129           return INTEGER_CONVERSION_BADNESS;
4130         case TYPE_CODE_FLT:
4131           return INT_FLOAT_CONVERSION_BADNESS;
4132         default:
4133           return INCOMPATIBLE_TYPE_BADNESS;
4134         }
4135       break;
4136     case TYPE_CODE_BOOL:
4137       switch (TYPE_CODE (arg))
4138         {
4139           /* n3290 draft, section 4.12.1 (conv.bool):
4140
4141              "A prvalue of arithmetic, unscoped enumeration, pointer, or
4142              pointer to member type can be converted to a prvalue of type
4143              bool.  A zero value, null pointer value, or null member pointer
4144              value is converted to false; any other value is converted to
4145              true.  A prvalue of type std::nullptr_t can be converted to a
4146              prvalue of type bool; the resulting value is false."  */
4147         case TYPE_CODE_INT:
4148         case TYPE_CODE_CHAR:
4149         case TYPE_CODE_ENUM:
4150         case TYPE_CODE_FLT:
4151         case TYPE_CODE_MEMBERPTR:
4152         case TYPE_CODE_PTR:
4153           return BOOL_CONVERSION_BADNESS;
4154         case TYPE_CODE_RANGE:
4155           return INCOMPATIBLE_TYPE_BADNESS;
4156         case TYPE_CODE_BOOL:
4157           return EXACT_MATCH_BADNESS;
4158         default:
4159           return INCOMPATIBLE_TYPE_BADNESS;
4160         }
4161       break;
4162     case TYPE_CODE_FLT:
4163       switch (TYPE_CODE (arg))
4164         {
4165         case TYPE_CODE_FLT:
4166           if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
4167             return FLOAT_PROMOTION_BADNESS;
4168           else if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
4169             return EXACT_MATCH_BADNESS;
4170           else
4171             return FLOAT_CONVERSION_BADNESS;
4172         case TYPE_CODE_INT:
4173         case TYPE_CODE_BOOL:
4174         case TYPE_CODE_ENUM:
4175         case TYPE_CODE_RANGE:
4176         case TYPE_CODE_CHAR:
4177           return INT_FLOAT_CONVERSION_BADNESS;
4178         default:
4179           return INCOMPATIBLE_TYPE_BADNESS;
4180         }
4181       break;
4182     case TYPE_CODE_COMPLEX:
4183       switch (TYPE_CODE (arg))
4184         {               /* Strictly not needed for C++, but...  */
4185         case TYPE_CODE_FLT:
4186           return FLOAT_PROMOTION_BADNESS;
4187         case TYPE_CODE_COMPLEX:
4188           return EXACT_MATCH_BADNESS;
4189         default:
4190           return INCOMPATIBLE_TYPE_BADNESS;
4191         }
4192       break;
4193     case TYPE_CODE_STRUCT:
4194       switch (TYPE_CODE (arg))
4195         {
4196         case TYPE_CODE_STRUCT:
4197           /* Check for derivation */
4198           rank.subrank = distance_to_ancestor (parm, arg, 0);
4199           if (rank.subrank >= 0)
4200             return sum_ranks (BASE_CONVERSION_BADNESS, rank);
4201           /* fall through */
4202         default:
4203           return INCOMPATIBLE_TYPE_BADNESS;
4204         }
4205       break;
4206     case TYPE_CODE_UNION:
4207       switch (TYPE_CODE (arg))
4208         {
4209         case TYPE_CODE_UNION:
4210         default:
4211           return INCOMPATIBLE_TYPE_BADNESS;
4212         }
4213       break;
4214     case TYPE_CODE_MEMBERPTR:
4215       switch (TYPE_CODE (arg))
4216         {
4217         default:
4218           return INCOMPATIBLE_TYPE_BADNESS;
4219         }
4220       break;
4221     case TYPE_CODE_METHOD:
4222       switch (TYPE_CODE (arg))
4223         {
4224
4225         default:
4226           return INCOMPATIBLE_TYPE_BADNESS;
4227         }
4228       break;
4229     case TYPE_CODE_REF:
4230       switch (TYPE_CODE (arg))
4231         {
4232
4233         default:
4234           return INCOMPATIBLE_TYPE_BADNESS;
4235         }
4236
4237       break;
4238     case TYPE_CODE_SET:
4239       switch (TYPE_CODE (arg))
4240         {
4241           /* Not in C++ */
4242         case TYPE_CODE_SET:
4243           return rank_one_type (TYPE_FIELD_TYPE (parm, 0), 
4244                                 TYPE_FIELD_TYPE (arg, 0), NULL);
4245         default:
4246           return INCOMPATIBLE_TYPE_BADNESS;
4247         }
4248       break;
4249     case TYPE_CODE_VOID:
4250     default:
4251       return INCOMPATIBLE_TYPE_BADNESS;
4252     }                           /* switch (TYPE_CODE (arg)) */
4253 }
4254
4255 /* End of functions for overload resolution.  */
4256 \f
4257 /* Routines to pretty-print types.  */
4258
4259 static void
4260 print_bit_vector (B_TYPE *bits, int nbits)
4261 {
4262   int bitno;
4263
4264   for (bitno = 0; bitno < nbits; bitno++)
4265     {
4266       if ((bitno % 8) == 0)
4267         {
4268           puts_filtered (" ");
4269         }
4270       if (B_TST (bits, bitno))
4271         printf_filtered (("1"));
4272       else
4273         printf_filtered (("0"));
4274     }
4275 }
4276
4277 /* Note the first arg should be the "this" pointer, we may not want to
4278    include it since we may get into a infinitely recursive
4279    situation.  */
4280
4281 static void
4282 print_args (struct field *args, int nargs, int spaces)
4283 {
4284   if (args != NULL)
4285     {
4286       int i;
4287
4288       for (i = 0; i < nargs; i++)
4289         {
4290           printfi_filtered (spaces, "[%d] name '%s'\n", i,
4291                             args[i].name != NULL ? args[i].name : "<NULL>");
4292           recursive_dump_type (args[i].type, spaces + 2);
4293         }
4294     }
4295 }
4296
4297 int
4298 field_is_static (struct field *f)
4299 {
4300   /* "static" fields are the fields whose location is not relative
4301      to the address of the enclosing struct.  It would be nice to
4302      have a dedicated flag that would be set for static fields when
4303      the type is being created.  But in practice, checking the field
4304      loc_kind should give us an accurate answer.  */
4305   return (FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSNAME
4306           || FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSADDR);
4307 }
4308
4309 static void
4310 dump_fn_fieldlists (struct type *type, int spaces)
4311 {
4312   int method_idx;
4313   int overload_idx;
4314   struct fn_field *f;
4315
4316   printfi_filtered (spaces, "fn_fieldlists ");
4317   gdb_print_host_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
4318   printf_filtered ("\n");
4319   for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
4320     {
4321       f = TYPE_FN_FIELDLIST1 (type, method_idx);
4322       printfi_filtered (spaces + 2, "[%d] name '%s' (",
4323                         method_idx,
4324                         TYPE_FN_FIELDLIST_NAME (type, method_idx));
4325       gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
4326                               gdb_stdout);
4327       printf_filtered (_(") length %d\n"),
4328                        TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
4329       for (overload_idx = 0;
4330            overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
4331            overload_idx++)
4332         {
4333           printfi_filtered (spaces + 4, "[%d] physname '%s' (",
4334                             overload_idx,
4335                             TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
4336           gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
4337                                   gdb_stdout);
4338           printf_filtered (")\n");
4339           printfi_filtered (spaces + 8, "type ");
4340           gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx), 
4341                                   gdb_stdout);
4342           printf_filtered ("\n");
4343
4344           recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
4345                                spaces + 8 + 2);
4346
4347           printfi_filtered (spaces + 8, "args ");
4348           gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx), 
4349                                   gdb_stdout);
4350           printf_filtered ("\n");
4351           print_args (TYPE_FN_FIELD_ARGS (f, overload_idx),
4352                       TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, overload_idx)),
4353                       spaces + 8 + 2);
4354           printfi_filtered (spaces + 8, "fcontext ");
4355           gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
4356                                   gdb_stdout);
4357           printf_filtered ("\n");
4358
4359           printfi_filtered (spaces + 8, "is_const %d\n",
4360                             TYPE_FN_FIELD_CONST (f, overload_idx));
4361           printfi_filtered (spaces + 8, "is_volatile %d\n",
4362                             TYPE_FN_FIELD_VOLATILE (f, overload_idx));
4363           printfi_filtered (spaces + 8, "is_private %d\n",
4364                             TYPE_FN_FIELD_PRIVATE (f, overload_idx));
4365           printfi_filtered (spaces + 8, "is_protected %d\n",
4366                             TYPE_FN_FIELD_PROTECTED (f, overload_idx));
4367           printfi_filtered (spaces + 8, "is_stub %d\n",
4368                             TYPE_FN_FIELD_STUB (f, overload_idx));
4369           printfi_filtered (spaces + 8, "voffset %u\n",
4370                             TYPE_FN_FIELD_VOFFSET (f, overload_idx));
4371         }
4372     }
4373 }
4374
4375 static void
4376 print_cplus_stuff (struct type *type, int spaces)
4377 {
4378   printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type));
4379   printfi_filtered (spaces, "vptr_basetype ");
4380   gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
4381   puts_filtered ("\n");
4382   if (TYPE_VPTR_BASETYPE (type) != NULL)
4383     recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
4384
4385   printfi_filtered (spaces, "n_baseclasses %d\n",
4386                     TYPE_N_BASECLASSES (type));
4387   printfi_filtered (spaces, "nfn_fields %d\n",
4388                     TYPE_NFN_FIELDS (type));
4389   if (TYPE_N_BASECLASSES (type) > 0)
4390     {
4391       printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
4392                         TYPE_N_BASECLASSES (type));
4393       gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type), 
4394                               gdb_stdout);
4395       printf_filtered (")");
4396
4397       print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
4398                         TYPE_N_BASECLASSES (type));
4399       puts_filtered ("\n");
4400     }
4401   if (TYPE_NFIELDS (type) > 0)
4402     {
4403       if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
4404         {
4405           printfi_filtered (spaces, 
4406                             "private_field_bits (%d bits at *",
4407                             TYPE_NFIELDS (type));
4408           gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type), 
4409                                   gdb_stdout);
4410           printf_filtered (")");
4411           print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
4412                             TYPE_NFIELDS (type));
4413           puts_filtered ("\n");
4414         }
4415       if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
4416         {
4417           printfi_filtered (spaces, 
4418                             "protected_field_bits (%d bits at *",
4419                             TYPE_NFIELDS (type));
4420           gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type), 
4421                                   gdb_stdout);
4422           printf_filtered (")");
4423           print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
4424                             TYPE_NFIELDS (type));
4425           puts_filtered ("\n");
4426         }
4427     }
4428   if (TYPE_NFN_FIELDS (type) > 0)
4429     {
4430       dump_fn_fieldlists (type, spaces);
4431     }
4432 }
4433
4434 /* Print the contents of the TYPE's type_specific union, assuming that
4435    its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF.  */
4436
4437 static void
4438 print_gnat_stuff (struct type *type, int spaces)
4439 {
4440   struct type *descriptive_type = TYPE_DESCRIPTIVE_TYPE (type);
4441
4442   if (descriptive_type == NULL)
4443     printfi_filtered (spaces + 2, "no descriptive type\n");
4444   else
4445     {
4446       printfi_filtered (spaces + 2, "descriptive type\n");
4447       recursive_dump_type (descriptive_type, spaces + 4);
4448     }
4449 }
4450
4451 static struct obstack dont_print_type_obstack;
4452
4453 void
4454 recursive_dump_type (struct type *type, int spaces)
4455 {
4456   int idx;
4457
4458   if (spaces == 0)
4459     obstack_begin (&dont_print_type_obstack, 0);
4460
4461   if (TYPE_NFIELDS (type) > 0
4462       || (HAVE_CPLUS_STRUCT (type) && TYPE_NFN_FIELDS (type) > 0))
4463     {
4464       struct type **first_dont_print
4465         = (struct type **) obstack_base (&dont_print_type_obstack);
4466
4467       int i = (struct type **) 
4468         obstack_next_free (&dont_print_type_obstack) - first_dont_print;
4469
4470       while (--i >= 0)
4471         {
4472           if (type == first_dont_print[i])
4473             {
4474               printfi_filtered (spaces, "type node ");
4475               gdb_print_host_address (type, gdb_stdout);
4476               printf_filtered (_(" <same as already seen type>\n"));
4477               return;
4478             }
4479         }
4480
4481       obstack_ptr_grow (&dont_print_type_obstack, type);
4482     }
4483
4484   printfi_filtered (spaces, "type node ");
4485   gdb_print_host_address (type, gdb_stdout);
4486   printf_filtered ("\n");
4487   printfi_filtered (spaces, "name '%s' (",
4488                     TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
4489   gdb_print_host_address (TYPE_NAME (type), gdb_stdout);
4490   printf_filtered (")\n");
4491   printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
4492   switch (TYPE_CODE (type))
4493     {
4494     case TYPE_CODE_UNDEF:
4495       printf_filtered ("(TYPE_CODE_UNDEF)");
4496       break;
4497     case TYPE_CODE_PTR:
4498       printf_filtered ("(TYPE_CODE_PTR)");
4499       break;
4500     case TYPE_CODE_ARRAY:
4501       printf_filtered ("(TYPE_CODE_ARRAY)");
4502       break;
4503     case TYPE_CODE_STRUCT:
4504       printf_filtered ("(TYPE_CODE_STRUCT)");
4505       break;
4506     case TYPE_CODE_UNION:
4507       printf_filtered ("(TYPE_CODE_UNION)");
4508       break;
4509     case TYPE_CODE_ENUM:
4510       printf_filtered ("(TYPE_CODE_ENUM)");
4511       break;
4512     case TYPE_CODE_FLAGS:
4513       printf_filtered ("(TYPE_CODE_FLAGS)");
4514       break;
4515     case TYPE_CODE_FUNC:
4516       printf_filtered ("(TYPE_CODE_FUNC)");
4517       break;
4518     case TYPE_CODE_INT:
4519       printf_filtered ("(TYPE_CODE_INT)");
4520       break;
4521     case TYPE_CODE_FLT:
4522       printf_filtered ("(TYPE_CODE_FLT)");
4523       break;
4524     case TYPE_CODE_VOID:
4525       printf_filtered ("(TYPE_CODE_VOID)");
4526       break;
4527     case TYPE_CODE_SET:
4528       printf_filtered ("(TYPE_CODE_SET)");
4529       break;
4530     case TYPE_CODE_RANGE:
4531       printf_filtered ("(TYPE_CODE_RANGE)");
4532       break;
4533     case TYPE_CODE_STRING:
4534       printf_filtered ("(TYPE_CODE_STRING)");
4535       break;
4536     case TYPE_CODE_ERROR:
4537       printf_filtered ("(TYPE_CODE_ERROR)");
4538       break;
4539     case TYPE_CODE_MEMBERPTR:
4540       printf_filtered ("(TYPE_CODE_MEMBERPTR)");
4541       break;
4542     case TYPE_CODE_METHODPTR:
4543       printf_filtered ("(TYPE_CODE_METHODPTR)");
4544       break;
4545     case TYPE_CODE_METHOD:
4546       printf_filtered ("(TYPE_CODE_METHOD)");
4547       break;
4548     case TYPE_CODE_REF:
4549       printf_filtered ("(TYPE_CODE_REF)");
4550       break;
4551     case TYPE_CODE_CHAR:
4552       printf_filtered ("(TYPE_CODE_CHAR)");
4553       break;
4554     case TYPE_CODE_BOOL:
4555       printf_filtered ("(TYPE_CODE_BOOL)");
4556       break;
4557     case TYPE_CODE_COMPLEX:
4558       printf_filtered ("(TYPE_CODE_COMPLEX)");
4559       break;
4560     case TYPE_CODE_TYPEDEF:
4561       printf_filtered ("(TYPE_CODE_TYPEDEF)");
4562       break;
4563     case TYPE_CODE_NAMESPACE:
4564       printf_filtered ("(TYPE_CODE_NAMESPACE)");
4565       break;
4566     default:
4567       printf_filtered ("(UNKNOWN TYPE CODE)");
4568       break;
4569     }
4570   puts_filtered ("\n");
4571   printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
4572   if (TYPE_OBJFILE_OWNED (type))
4573     {
4574       printfi_filtered (spaces, "objfile ");
4575       gdb_print_host_address (TYPE_OWNER (type).objfile, gdb_stdout);
4576     }
4577   else
4578     {
4579       printfi_filtered (spaces, "gdbarch ");
4580       gdb_print_host_address (TYPE_OWNER (type).gdbarch, gdb_stdout);
4581     }
4582   printf_filtered ("\n");
4583   printfi_filtered (spaces, "target_type ");
4584   gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout);
4585   printf_filtered ("\n");
4586   if (TYPE_TARGET_TYPE (type) != NULL)
4587     {
4588       recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
4589     }
4590   printfi_filtered (spaces, "pointer_type ");
4591   gdb_print_host_address (TYPE_POINTER_TYPE (type), gdb_stdout);
4592   printf_filtered ("\n");
4593   printfi_filtered (spaces, "reference_type ");
4594   gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
4595   printf_filtered ("\n");
4596   printfi_filtered (spaces, "type_chain ");
4597   gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);
4598   printf_filtered ("\n");
4599   printfi_filtered (spaces, "instance_flags 0x%x", 
4600                     TYPE_INSTANCE_FLAGS (type));
4601   if (TYPE_CONST (type))
4602     {
4603       puts_filtered (" TYPE_CONST");
4604     }
4605   if (TYPE_VOLATILE (type))
4606     {
4607       puts_filtered (" TYPE_VOLATILE");
4608     }
4609   if (TYPE_CODE_SPACE (type))
4610     {
4611       puts_filtered (" TYPE_CODE_SPACE");
4612     }
4613   if (TYPE_DATA_SPACE (type))
4614     {
4615       puts_filtered (" TYPE_DATA_SPACE");
4616     }
4617   if (TYPE_ADDRESS_CLASS_1 (type))
4618     {
4619       puts_filtered (" TYPE_ADDRESS_CLASS_1");
4620     }
4621   if (TYPE_ADDRESS_CLASS_2 (type))
4622     {
4623       puts_filtered (" TYPE_ADDRESS_CLASS_2");
4624     }
4625   if (TYPE_RESTRICT (type))
4626     {
4627       puts_filtered (" TYPE_RESTRICT");
4628     }
4629   if (TYPE_ATOMIC (type))
4630     {
4631       puts_filtered (" TYPE_ATOMIC");
4632     }
4633   puts_filtered ("\n");
4634
4635   printfi_filtered (spaces, "flags");
4636   if (TYPE_UNSIGNED (type))
4637     {
4638       puts_filtered (" TYPE_UNSIGNED");
4639     }
4640   if (TYPE_NOSIGN (type))
4641     {
4642       puts_filtered (" TYPE_NOSIGN");
4643     }
4644   if (TYPE_STUB (type))
4645     {
4646       puts_filtered (" TYPE_STUB");
4647     }
4648   if (TYPE_TARGET_STUB (type))
4649     {
4650       puts_filtered (" TYPE_TARGET_STUB");
4651     }
4652   if (TYPE_PROTOTYPED (type))
4653     {
4654       puts_filtered (" TYPE_PROTOTYPED");
4655     }
4656   if (TYPE_INCOMPLETE (type))
4657     {
4658       puts_filtered (" TYPE_INCOMPLETE");
4659     }
4660   if (TYPE_VARARGS (type))
4661     {
4662       puts_filtered (" TYPE_VARARGS");
4663     }
4664   /* This is used for things like AltiVec registers on ppc.  Gcc emits
4665      an attribute for the array type, which tells whether or not we
4666      have a vector, instead of a regular array.  */
4667   if (TYPE_VECTOR (type))
4668     {
4669       puts_filtered (" TYPE_VECTOR");
4670     }
4671   if (TYPE_FIXED_INSTANCE (type))
4672     {
4673       puts_filtered (" TYPE_FIXED_INSTANCE");
4674     }
4675   if (TYPE_STUB_SUPPORTED (type))
4676     {
4677       puts_filtered (" TYPE_STUB_SUPPORTED");
4678     }
4679   if (TYPE_NOTTEXT (type))
4680     {
4681       puts_filtered (" TYPE_NOTTEXT");
4682     }
4683   puts_filtered ("\n");
4684   printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
4685   gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
4686   puts_filtered ("\n");
4687   for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
4688     {
4689       if (TYPE_CODE (type) == TYPE_CODE_ENUM)
4690         printfi_filtered (spaces + 2,
4691                           "[%d] enumval %s type ",
4692                           idx, plongest (TYPE_FIELD_ENUMVAL (type, idx)));
4693       else
4694         printfi_filtered (spaces + 2,
4695                           "[%d] bitpos %s bitsize %d type ",
4696                           idx, plongest (TYPE_FIELD_BITPOS (type, idx)),
4697                           TYPE_FIELD_BITSIZE (type, idx));
4698       gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
4699       printf_filtered (" name '%s' (",
4700                        TYPE_FIELD_NAME (type, idx) != NULL
4701                        ? TYPE_FIELD_NAME (type, idx)
4702                        : "<NULL>");
4703       gdb_print_host_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
4704       printf_filtered (")\n");
4705       if (TYPE_FIELD_TYPE (type, idx) != NULL)
4706         {
4707           recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
4708         }
4709     }
4710   if (TYPE_CODE (type) == TYPE_CODE_RANGE)
4711     {
4712       printfi_filtered (spaces, "low %s%s  high %s%s\n",
4713                         plongest (TYPE_LOW_BOUND (type)), 
4714                         TYPE_LOW_BOUND_UNDEFINED (type) ? " (undefined)" : "",
4715                         plongest (TYPE_HIGH_BOUND (type)),
4716                         TYPE_HIGH_BOUND_UNDEFINED (type) 
4717                         ? " (undefined)" : "");
4718     }
4719
4720   switch (TYPE_SPECIFIC_FIELD (type))
4721     {
4722       case TYPE_SPECIFIC_CPLUS_STUFF:
4723         printfi_filtered (spaces, "cplus_stuff ");
4724         gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), 
4725                                 gdb_stdout);
4726         puts_filtered ("\n");
4727         print_cplus_stuff (type, spaces);
4728         break;
4729
4730       case TYPE_SPECIFIC_GNAT_STUFF:
4731         printfi_filtered (spaces, "gnat_stuff ");
4732         gdb_print_host_address (TYPE_GNAT_SPECIFIC (type), gdb_stdout);
4733         puts_filtered ("\n");
4734         print_gnat_stuff (type, spaces);
4735         break;
4736
4737       case TYPE_SPECIFIC_FLOATFORMAT:
4738         printfi_filtered (spaces, "floatformat ");
4739         if (TYPE_FLOATFORMAT (type) == NULL
4740             || TYPE_FLOATFORMAT (type)->name == NULL)
4741           puts_filtered ("(null)");
4742         else
4743           puts_filtered (TYPE_FLOATFORMAT (type)->name);
4744         puts_filtered ("\n");
4745         break;
4746
4747       case TYPE_SPECIFIC_FUNC:
4748         printfi_filtered (spaces, "calling_convention %d\n",
4749                           TYPE_CALLING_CONVENTION (type));
4750         /* tail_call_list is not printed.  */
4751         break;
4752
4753       case TYPE_SPECIFIC_SELF_TYPE:
4754         printfi_filtered (spaces, "self_type ");
4755         gdb_print_host_address (TYPE_SELF_TYPE (type), gdb_stdout);
4756         puts_filtered ("\n");
4757         break;
4758     }
4759
4760   if (spaces == 0)
4761     obstack_free (&dont_print_type_obstack, NULL);
4762 }
4763 \f
4764 /* Trivial helpers for the libiberty hash table, for mapping one
4765    type to another.  */
4766
4767 struct type_pair : public allocate_on_obstack
4768 {
4769   type_pair (struct type *old_, struct type *newobj_)
4770     : old (old_), newobj (newobj_)
4771   {}
4772
4773   struct type * const old, * const newobj;
4774 };
4775
4776 static hashval_t
4777 type_pair_hash (const void *item)
4778 {
4779   const struct type_pair *pair = (const struct type_pair *) item;
4780
4781   return htab_hash_pointer (pair->old);
4782 }
4783
4784 static int
4785 type_pair_eq (const void *item_lhs, const void *item_rhs)
4786 {
4787   const struct type_pair *lhs = (const struct type_pair *) item_lhs;
4788   const struct type_pair *rhs = (const struct type_pair *) item_rhs;
4789
4790   return lhs->old == rhs->old;
4791 }
4792
4793 /* Allocate the hash table used by copy_type_recursive to walk
4794    types without duplicates.  We use OBJFILE's obstack, because
4795    OBJFILE is about to be deleted.  */
4796
4797 htab_t
4798 create_copied_types_hash (struct objfile *objfile)
4799 {
4800   return htab_create_alloc_ex (1, type_pair_hash, type_pair_eq,
4801                                NULL, &objfile->objfile_obstack,
4802                                hashtab_obstack_allocate,
4803                                dummy_obstack_deallocate);
4804 }
4805
4806 /* Recursively copy (deep copy) a dynamic attribute list of a type.  */
4807
4808 static struct dynamic_prop_list *
4809 copy_dynamic_prop_list (struct obstack *objfile_obstack,
4810                         struct dynamic_prop_list *list)
4811 {
4812   struct dynamic_prop_list *copy = list;
4813   struct dynamic_prop_list **node_ptr = &copy;
4814
4815   while (*node_ptr != NULL)
4816     {
4817       struct dynamic_prop_list *node_copy;
4818
4819       node_copy = ((struct dynamic_prop_list *)
4820                    obstack_copy (objfile_obstack, *node_ptr,
4821                                  sizeof (struct dynamic_prop_list)));
4822       node_copy->prop = (*node_ptr)->prop;
4823       *node_ptr = node_copy;
4824
4825       node_ptr = &node_copy->next;
4826     }
4827
4828   return copy;
4829 }
4830
4831 /* Recursively copy (deep copy) TYPE, if it is associated with
4832    OBJFILE.  Return a new type owned by the gdbarch associated with the type, a
4833    saved type if we have already visited TYPE (using COPIED_TYPES), or TYPE if
4834    it is not associated with OBJFILE.  */
4835
4836 struct type *
4837 copy_type_recursive (struct objfile *objfile, 
4838                      struct type *type,
4839                      htab_t copied_types)
4840 {
4841   void **slot;
4842   struct type *new_type;
4843
4844   if (! TYPE_OBJFILE_OWNED (type))
4845     return type;
4846
4847   /* This type shouldn't be pointing to any types in other objfiles;
4848      if it did, the type might disappear unexpectedly.  */
4849   gdb_assert (TYPE_OBJFILE (type) == objfile);
4850
4851   struct type_pair pair (type, nullptr);
4852
4853   slot = htab_find_slot (copied_types, &pair, INSERT);
4854   if (*slot != NULL)
4855     return ((struct type_pair *) *slot)->newobj;
4856
4857   new_type = alloc_type_arch (get_type_arch (type));
4858
4859   /* We must add the new type to the hash table immediately, in case
4860      we encounter this type again during a recursive call below.  */
4861   struct type_pair *stored
4862     = new (&objfile->objfile_obstack) struct type_pair (type, new_type);
4863
4864   *slot = stored;
4865
4866   /* Copy the common fields of types.  For the main type, we simply
4867      copy the entire thing and then update specific fields as needed.  */
4868   *TYPE_MAIN_TYPE (new_type) = *TYPE_MAIN_TYPE (type);
4869   TYPE_OBJFILE_OWNED (new_type) = 0;
4870   TYPE_OWNER (new_type).gdbarch = get_type_arch (type);
4871
4872   if (TYPE_NAME (type))
4873     TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type));
4874
4875   TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
4876   TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
4877
4878   /* Copy the fields.  */
4879   if (TYPE_NFIELDS (type))
4880     {
4881       int i, nfields;
4882
4883       nfields = TYPE_NFIELDS (type);
4884       TYPE_FIELDS (new_type) = (struct field *)
4885         TYPE_ZALLOC (new_type, nfields * sizeof (struct field));
4886       for (i = 0; i < nfields; i++)
4887         {
4888           TYPE_FIELD_ARTIFICIAL (new_type, i) = 
4889             TYPE_FIELD_ARTIFICIAL (type, i);
4890           TYPE_FIELD_BITSIZE (new_type, i) = TYPE_FIELD_BITSIZE (type, i);
4891           if (TYPE_FIELD_TYPE (type, i))
4892             TYPE_FIELD_TYPE (new_type, i)
4893               = copy_type_recursive (objfile, TYPE_FIELD_TYPE (type, i),
4894                                      copied_types);
4895           if (TYPE_FIELD_NAME (type, i))
4896             TYPE_FIELD_NAME (new_type, i) = 
4897               xstrdup (TYPE_FIELD_NAME (type, i));
4898           switch (TYPE_FIELD_LOC_KIND (type, i))
4899             {
4900             case FIELD_LOC_KIND_BITPOS:
4901               SET_FIELD_BITPOS (TYPE_FIELD (new_type, i),
4902                                 TYPE_FIELD_BITPOS (type, i));
4903               break;
4904             case FIELD_LOC_KIND_ENUMVAL:
4905               SET_FIELD_ENUMVAL (TYPE_FIELD (new_type, i),
4906                                  TYPE_FIELD_ENUMVAL (type, i));
4907               break;
4908             case FIELD_LOC_KIND_PHYSADDR:
4909               SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i),
4910                                   TYPE_FIELD_STATIC_PHYSADDR (type, i));
4911               break;
4912             case FIELD_LOC_KIND_PHYSNAME:
4913               SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i),
4914                                   xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type,
4915                                                                        i)));
4916               break;
4917             default:
4918               internal_error (__FILE__, __LINE__,
4919                               _("Unexpected type field location kind: %d"),
4920                               TYPE_FIELD_LOC_KIND (type, i));
4921             }
4922         }
4923     }
4924
4925   /* For range types, copy the bounds information.  */
4926   if (TYPE_CODE (type) == TYPE_CODE_RANGE)
4927     {
4928       TYPE_RANGE_DATA (new_type) = (struct range_bounds *)
4929         TYPE_ALLOC (new_type, sizeof (struct range_bounds));
4930       *TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type);
4931     }
4932
4933   if (TYPE_DYN_PROP_LIST (type) != NULL)
4934     TYPE_DYN_PROP_LIST (new_type)
4935       = copy_dynamic_prop_list (&objfile->objfile_obstack,
4936                                 TYPE_DYN_PROP_LIST (type));
4937
4938
4939   /* Copy pointers to other types.  */
4940   if (TYPE_TARGET_TYPE (type))
4941     TYPE_TARGET_TYPE (new_type) = 
4942       copy_type_recursive (objfile, 
4943                            TYPE_TARGET_TYPE (type),
4944                            copied_types);
4945
4946   /* Maybe copy the type_specific bits.
4947
4948      NOTE drow/2005-12-09: We do not copy the C++-specific bits like
4949      base classes and methods.  There's no fundamental reason why we
4950      can't, but at the moment it is not needed.  */
4951
4952   switch (TYPE_SPECIFIC_FIELD (type))
4953     {
4954     case TYPE_SPECIFIC_NONE:
4955       break;
4956     case TYPE_SPECIFIC_FUNC:
4957       INIT_FUNC_SPECIFIC (new_type);
4958       TYPE_CALLING_CONVENTION (new_type) = TYPE_CALLING_CONVENTION (type);
4959       TYPE_NO_RETURN (new_type) = TYPE_NO_RETURN (type);
4960       TYPE_TAIL_CALL_LIST (new_type) = NULL;
4961       break;
4962     case TYPE_SPECIFIC_FLOATFORMAT:
4963       TYPE_FLOATFORMAT (new_type) = TYPE_FLOATFORMAT (type);
4964       break;
4965     case TYPE_SPECIFIC_CPLUS_STUFF:
4966       INIT_CPLUS_SPECIFIC (new_type);
4967       break;
4968     case TYPE_SPECIFIC_GNAT_STUFF:
4969       INIT_GNAT_SPECIFIC (new_type);
4970       break;
4971     case TYPE_SPECIFIC_SELF_TYPE:
4972       set_type_self_type (new_type,
4973                           copy_type_recursive (objfile, TYPE_SELF_TYPE (type),
4974                                                copied_types));
4975       break;
4976     default:
4977       gdb_assert_not_reached ("bad type_specific_kind");
4978     }
4979
4980   return new_type;
4981 }
4982
4983 /* Make a copy of the given TYPE, except that the pointer & reference
4984    types are not preserved.
4985    
4986    This function assumes that the given type has an associated objfile.
4987    This objfile is used to allocate the new type.  */
4988
4989 struct type *
4990 copy_type (const struct type *type)
4991 {
4992   struct type *new_type;
4993
4994   gdb_assert (TYPE_OBJFILE_OWNED (type));
4995
4996   new_type = alloc_type_copy (type);
4997   TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
4998   TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
4999   memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type),
5000           sizeof (struct main_type));
5001   if (TYPE_DYN_PROP_LIST (type) != NULL)
5002     TYPE_DYN_PROP_LIST (new_type)
5003       = copy_dynamic_prop_list (&TYPE_OBJFILE (type) -> objfile_obstack,
5004                                 TYPE_DYN_PROP_LIST (type));
5005
5006   return new_type;
5007 }
5008 \f
5009 /* Helper functions to initialize architecture-specific types.  */
5010
5011 /* Allocate a type structure associated with GDBARCH and set its
5012    CODE, LENGTH, and NAME fields.  */
5013
5014 struct type *
5015 arch_type (struct gdbarch *gdbarch,
5016            enum type_code code, int bit, const char *name)
5017 {
5018   struct type *type;
5019
5020   type = alloc_type_arch (gdbarch);
5021   set_type_code (type, code);
5022   gdb_assert ((bit % TARGET_CHAR_BIT) == 0);
5023   TYPE_LENGTH (type) = bit / TARGET_CHAR_BIT;
5024
5025   if (name)
5026     TYPE_NAME (type) = gdbarch_obstack_strdup (gdbarch, name);
5027
5028   return type;
5029 }
5030
5031 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
5032    BIT is the type size in bits.  If UNSIGNED_P is non-zero, set
5033    the type's TYPE_UNSIGNED flag.  NAME is the type name.  */
5034
5035 struct type *
5036 arch_integer_type (struct gdbarch *gdbarch,
5037                    int bit, int unsigned_p, const char *name)
5038 {
5039   struct type *t;
5040
5041   t = arch_type (gdbarch, TYPE_CODE_INT, bit, name);
5042   if (unsigned_p)
5043     TYPE_UNSIGNED (t) = 1;
5044
5045   return t;
5046 }
5047
5048 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
5049    BIT is the type size in bits.  If UNSIGNED_P is non-zero, set
5050    the type's TYPE_UNSIGNED flag.  NAME is the type name.  */
5051
5052 struct type *
5053 arch_character_type (struct gdbarch *gdbarch,
5054                      int bit, int unsigned_p, const char *name)
5055 {
5056   struct type *t;
5057
5058   t = arch_type (gdbarch, TYPE_CODE_CHAR, bit, name);
5059   if (unsigned_p)
5060     TYPE_UNSIGNED (t) = 1;
5061
5062   return t;
5063 }
5064
5065 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
5066    BIT is the type size in bits.  If UNSIGNED_P is non-zero, set
5067    the type's TYPE_UNSIGNED flag.  NAME is the type name.  */
5068
5069 struct type *
5070 arch_boolean_type (struct gdbarch *gdbarch,
5071                    int bit, int unsigned_p, const char *name)
5072 {
5073   struct type *t;
5074
5075   t = arch_type (gdbarch, TYPE_CODE_BOOL, bit, name);
5076   if (unsigned_p)
5077     TYPE_UNSIGNED (t) = 1;
5078
5079   return t;
5080 }
5081
5082 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
5083    BIT is the type size in bits; if BIT equals -1, the size is
5084    determined by the floatformat.  NAME is the type name.  Set the
5085    TYPE_FLOATFORMAT from FLOATFORMATS.  */
5086
5087 struct type *
5088 arch_float_type (struct gdbarch *gdbarch,
5089                  int bit, const char *name,
5090                  const struct floatformat **floatformats)
5091 {
5092   const struct floatformat *fmt = floatformats[gdbarch_byte_order (gdbarch)];
5093   struct type *t;
5094
5095   bit = verify_floatformat (bit, fmt);
5096   t = arch_type (gdbarch, TYPE_CODE_FLT, bit, name);
5097   TYPE_FLOATFORMAT (t) = fmt;
5098
5099   return t;
5100 }
5101
5102 /* Allocate a TYPE_CODE_DECFLOAT type structure associated with GDBARCH.
5103    BIT is the type size in bits.  NAME is the type name.  */
5104
5105 struct type *
5106 arch_decfloat_type (struct gdbarch *gdbarch, int bit, const char *name)
5107 {
5108   struct type *t;
5109
5110   t = arch_type (gdbarch, TYPE_CODE_DECFLOAT, bit, name);
5111   return t;
5112 }
5113
5114 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
5115    NAME is the type name.  TARGET_TYPE is the component float type.  */
5116
5117 struct type *
5118 arch_complex_type (struct gdbarch *gdbarch,
5119                    const char *name, struct type *target_type)
5120 {
5121   struct type *t;
5122
5123   t = arch_type (gdbarch, TYPE_CODE_COMPLEX,
5124                  2 * TYPE_LENGTH (target_type) * TARGET_CHAR_BIT, name);
5125   TYPE_TARGET_TYPE (t) = target_type;
5126   return t;
5127 }
5128
5129 /* Allocate a TYPE_CODE_PTR type structure associated with GDBARCH.
5130    BIT is the pointer type size in bits.  NAME is the type name.
5131    TARGET_TYPE is the pointer target type.  Always sets the pointer type's
5132    TYPE_UNSIGNED flag.  */
5133
5134 struct type *
5135 arch_pointer_type (struct gdbarch *gdbarch,
5136                    int bit, const char *name, struct type *target_type)
5137 {
5138   struct type *t;
5139
5140   t = arch_type (gdbarch, TYPE_CODE_PTR, bit, name);
5141   TYPE_TARGET_TYPE (t) = target_type;
5142   TYPE_UNSIGNED (t) = 1;
5143   return t;
5144 }
5145
5146 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
5147    NAME is the type name.  BIT is the size of the flag word in bits.  */
5148
5149 struct type *
5150 arch_flags_type (struct gdbarch *gdbarch, const char *name, int bit)
5151 {
5152   struct type *type;
5153
5154   type = arch_type (gdbarch, TYPE_CODE_FLAGS, bit, name);
5155   TYPE_UNSIGNED (type) = 1;
5156   TYPE_NFIELDS (type) = 0;
5157   /* Pre-allocate enough space assuming every field is one bit.  */
5158   TYPE_FIELDS (type)
5159     = (struct field *) TYPE_ZALLOC (type, bit * sizeof (struct field));
5160
5161   return type;
5162 }
5163
5164 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
5165    position BITPOS is called NAME.  Pass NAME as "" for fields that
5166    should not be printed.  */
5167
5168 void
5169 append_flags_type_field (struct type *type, int start_bitpos, int nr_bits,
5170                          struct type *field_type, const char *name)
5171 {
5172   int type_bitsize = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
5173   int field_nr = TYPE_NFIELDS (type);
5174
5175   gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS);
5176   gdb_assert (TYPE_NFIELDS (type) + 1 <= type_bitsize);
5177   gdb_assert (start_bitpos >= 0 && start_bitpos < type_bitsize);
5178   gdb_assert (nr_bits >= 1 && nr_bits <= type_bitsize);
5179   gdb_assert (name != NULL);
5180
5181   TYPE_FIELD_NAME (type, field_nr) = xstrdup (name);
5182   TYPE_FIELD_TYPE (type, field_nr) = field_type;
5183   SET_FIELD_BITPOS (TYPE_FIELD (type, field_nr), start_bitpos);
5184   TYPE_FIELD_BITSIZE (type, field_nr) = nr_bits;
5185   ++TYPE_NFIELDS (type);
5186 }
5187
5188 /* Special version of append_flags_type_field to add a flag field.
5189    Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
5190    position BITPOS is called NAME.  */
5191
5192 void
5193 append_flags_type_flag (struct type *type, int bitpos, const char *name)
5194 {
5195   struct gdbarch *gdbarch = get_type_arch (type);
5196
5197   append_flags_type_field (type, bitpos, 1,
5198                            builtin_type (gdbarch)->builtin_bool,
5199                            name);
5200 }
5201
5202 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
5203    specified by CODE) associated with GDBARCH.  NAME is the type name.  */
5204
5205 struct type *
5206 arch_composite_type (struct gdbarch *gdbarch, const char *name,
5207                      enum type_code code)
5208 {
5209   struct type *t;
5210
5211   gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION);
5212   t = arch_type (gdbarch, code, 0, NULL);
5213   TYPE_NAME (t) = name;
5214   INIT_CPLUS_SPECIFIC (t);
5215   return t;
5216 }
5217
5218 /* Add new field with name NAME and type FIELD to composite type T.
5219    Do not set the field's position or adjust the type's length;
5220    the caller should do so.  Return the new field.  */
5221
5222 struct field *
5223 append_composite_type_field_raw (struct type *t, const char *name,
5224                                  struct type *field)
5225 {
5226   struct field *f;
5227
5228   TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
5229   TYPE_FIELDS (t) = XRESIZEVEC (struct field, TYPE_FIELDS (t),
5230                                 TYPE_NFIELDS (t));
5231   f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
5232   memset (f, 0, sizeof f[0]);
5233   FIELD_TYPE (f[0]) = field;
5234   FIELD_NAME (f[0]) = name;
5235   return f;
5236 }
5237
5238 /* Add new field with name NAME and type FIELD to composite type T.
5239    ALIGNMENT (if non-zero) specifies the minimum field alignment.  */
5240
5241 void
5242 append_composite_type_field_aligned (struct type *t, const char *name,
5243                                      struct type *field, int alignment)
5244 {
5245   struct field *f = append_composite_type_field_raw (t, name, field);
5246
5247   if (TYPE_CODE (t) == TYPE_CODE_UNION)
5248     {
5249       if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
5250         TYPE_LENGTH (t) = TYPE_LENGTH (field);
5251     }
5252   else if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
5253     {
5254       TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
5255       if (TYPE_NFIELDS (t) > 1)
5256         {
5257           SET_FIELD_BITPOS (f[0],
5258                             (FIELD_BITPOS (f[-1])
5259                              + (TYPE_LENGTH (FIELD_TYPE (f[-1]))
5260                                 * TARGET_CHAR_BIT)));
5261
5262           if (alignment)
5263             {
5264               int left;
5265
5266               alignment *= TARGET_CHAR_BIT;
5267               left = FIELD_BITPOS (f[0]) % alignment;
5268
5269               if (left)
5270                 {
5271                   SET_FIELD_BITPOS (f[0], FIELD_BITPOS (f[0]) + (alignment - left));
5272                   TYPE_LENGTH (t) += (alignment - left) / TARGET_CHAR_BIT;
5273                 }
5274             }
5275         }
5276     }
5277 }
5278
5279 /* Add new field with name NAME and type FIELD to composite type T.  */
5280
5281 void
5282 append_composite_type_field (struct type *t, const char *name,
5283                              struct type *field)
5284 {
5285   append_composite_type_field_aligned (t, name, field, 0);
5286 }
5287
5288 static struct gdbarch_data *gdbtypes_data;
5289
5290 const struct builtin_type *
5291 builtin_type (struct gdbarch *gdbarch)
5292 {
5293   return (const struct builtin_type *) gdbarch_data (gdbarch, gdbtypes_data);
5294 }
5295
5296 static void *
5297 gdbtypes_post_init (struct gdbarch *gdbarch)
5298 {
5299   struct builtin_type *builtin_type
5300     = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type);
5301
5302   /* Basic types.  */
5303   builtin_type->builtin_void
5304     = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
5305   builtin_type->builtin_char
5306     = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
5307                          !gdbarch_char_signed (gdbarch), "char");
5308   TYPE_NOSIGN (builtin_type->builtin_char) = 1;
5309   builtin_type->builtin_signed_char
5310     = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
5311                          0, "signed char");
5312   builtin_type->builtin_unsigned_char
5313     = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
5314                          1, "unsigned char");
5315   builtin_type->builtin_short
5316     = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
5317                          0, "short");
5318   builtin_type->builtin_unsigned_short
5319     = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
5320                          1, "unsigned short");
5321   builtin_type->builtin_int
5322     = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
5323                          0, "int");
5324   builtin_type->builtin_unsigned_int
5325     = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
5326                          1, "unsigned int");
5327   builtin_type->builtin_long
5328     = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
5329                          0, "long");
5330   builtin_type->builtin_unsigned_long
5331     = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
5332                          1, "unsigned long");
5333   builtin_type->builtin_long_long
5334     = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
5335                          0, "long long");
5336   builtin_type->builtin_unsigned_long_long
5337     = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
5338                          1, "unsigned long long");
5339   builtin_type->builtin_float
5340     = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
5341                        "float", gdbarch_float_format (gdbarch));
5342   builtin_type->builtin_double
5343     = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
5344                        "double", gdbarch_double_format (gdbarch));
5345   builtin_type->builtin_long_double
5346     = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
5347                        "long double", gdbarch_long_double_format (gdbarch));
5348   builtin_type->builtin_complex
5349     = arch_complex_type (gdbarch, "complex",
5350                          builtin_type->builtin_float);
5351   builtin_type->builtin_double_complex
5352     = arch_complex_type (gdbarch, "double complex",
5353                          builtin_type->builtin_double);
5354   builtin_type->builtin_string
5355     = arch_type (gdbarch, TYPE_CODE_STRING, TARGET_CHAR_BIT, "string");
5356   builtin_type->builtin_bool
5357     = arch_type (gdbarch, TYPE_CODE_BOOL, TARGET_CHAR_BIT, "bool");
5358
5359   /* The following three are about decimal floating point types, which
5360      are 32-bits, 64-bits and 128-bits respectively.  */
5361   builtin_type->builtin_decfloat
5362     = arch_decfloat_type (gdbarch, 32, "_Decimal32");
5363   builtin_type->builtin_decdouble
5364     = arch_decfloat_type (gdbarch, 64, "_Decimal64");
5365   builtin_type->builtin_declong
5366     = arch_decfloat_type (gdbarch, 128, "_Decimal128");
5367
5368   /* "True" character types.  */
5369   builtin_type->builtin_true_char
5370     = arch_character_type (gdbarch, TARGET_CHAR_BIT, 0, "true character");
5371   builtin_type->builtin_true_unsigned_char
5372     = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "true character");
5373
5374   /* Fixed-size integer types.  */
5375   builtin_type->builtin_int0
5376     = arch_integer_type (gdbarch, 0, 0, "int0_t");
5377   builtin_type->builtin_int8
5378     = arch_integer_type (gdbarch, 8, 0, "int8_t");
5379   builtin_type->builtin_uint8
5380     = arch_integer_type (gdbarch, 8, 1, "uint8_t");
5381   builtin_type->builtin_int16
5382     = arch_integer_type (gdbarch, 16, 0, "int16_t");
5383   builtin_type->builtin_uint16
5384     = arch_integer_type (gdbarch, 16, 1, "uint16_t");
5385   builtin_type->builtin_int24
5386     = arch_integer_type (gdbarch, 24, 0, "int24_t");
5387   builtin_type->builtin_uint24
5388     = arch_integer_type (gdbarch, 24, 1, "uint24_t");
5389   builtin_type->builtin_int32
5390     = arch_integer_type (gdbarch, 32, 0, "int32_t");
5391   builtin_type->builtin_uint32
5392     = arch_integer_type (gdbarch, 32, 1, "uint32_t");
5393   builtin_type->builtin_int64
5394     = arch_integer_type (gdbarch, 64, 0, "int64_t");
5395   builtin_type->builtin_uint64
5396     = arch_integer_type (gdbarch, 64, 1, "uint64_t");
5397   builtin_type->builtin_int128
5398     = arch_integer_type (gdbarch, 128, 0, "int128_t");
5399   builtin_type->builtin_uint128
5400     = arch_integer_type (gdbarch, 128, 1, "uint128_t");
5401   TYPE_INSTANCE_FLAGS (builtin_type->builtin_int8) |=
5402     TYPE_INSTANCE_FLAG_NOTTEXT;
5403   TYPE_INSTANCE_FLAGS (builtin_type->builtin_uint8) |=
5404     TYPE_INSTANCE_FLAG_NOTTEXT;
5405
5406   /* Wide character types.  */
5407   builtin_type->builtin_char16
5408     = arch_integer_type (gdbarch, 16, 1, "char16_t");
5409   builtin_type->builtin_char32
5410     = arch_integer_type (gdbarch, 32, 1, "char32_t");
5411   builtin_type->builtin_wchar
5412     = arch_integer_type (gdbarch, gdbarch_wchar_bit (gdbarch),
5413                          !gdbarch_wchar_signed (gdbarch), "wchar_t");
5414
5415   /* Default data/code pointer types.  */
5416   builtin_type->builtin_data_ptr
5417     = lookup_pointer_type (builtin_type->builtin_void);
5418   builtin_type->builtin_func_ptr
5419     = lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
5420   builtin_type->builtin_func_func
5421     = lookup_function_type (builtin_type->builtin_func_ptr);
5422
5423   /* This type represents a GDB internal function.  */
5424   builtin_type->internal_fn
5425     = arch_type (gdbarch, TYPE_CODE_INTERNAL_FUNCTION, 0,
5426                  "<internal function>");
5427
5428   /* This type represents an xmethod.  */
5429   builtin_type->xmethod
5430     = arch_type (gdbarch, TYPE_CODE_XMETHOD, 0, "<xmethod>");
5431
5432   return builtin_type;
5433 }
5434
5435 /* This set of objfile-based types is intended to be used by symbol
5436    readers as basic types.  */
5437
5438 static const struct objfile_data *objfile_type_data;
5439
5440 const struct objfile_type *
5441 objfile_type (struct objfile *objfile)
5442 {
5443   struct gdbarch *gdbarch;
5444   struct objfile_type *objfile_type
5445     = (struct objfile_type *) objfile_data (objfile, objfile_type_data);
5446
5447   if (objfile_type)
5448     return objfile_type;
5449
5450   objfile_type = OBSTACK_CALLOC (&objfile->objfile_obstack,
5451                                  1, struct objfile_type);
5452
5453   /* Use the objfile architecture to determine basic type properties.  */
5454   gdbarch = get_objfile_arch (objfile);
5455
5456   /* Basic types.  */
5457   objfile_type->builtin_void
5458     = init_type (objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
5459   objfile_type->builtin_char
5460     = init_integer_type (objfile, TARGET_CHAR_BIT,
5461                          !gdbarch_char_signed (gdbarch), "char");
5462   TYPE_NOSIGN (objfile_type->builtin_char) = 1;
5463   objfile_type->builtin_signed_char
5464     = init_integer_type (objfile, TARGET_CHAR_BIT,
5465                          0, "signed char");
5466   objfile_type->builtin_unsigned_char
5467     = init_integer_type (objfile, TARGET_CHAR_BIT,
5468                          1, "unsigned char");
5469   objfile_type->builtin_short
5470     = init_integer_type (objfile, gdbarch_short_bit (gdbarch),
5471                          0, "short");
5472   objfile_type->builtin_unsigned_short
5473     = init_integer_type (objfile, gdbarch_short_bit (gdbarch),
5474                          1, "unsigned short");
5475   objfile_type->builtin_int
5476     = init_integer_type (objfile, gdbarch_int_bit (gdbarch),
5477                          0, "int");
5478   objfile_type->builtin_unsigned_int
5479     = init_integer_type (objfile, gdbarch_int_bit (gdbarch),
5480                          1, "unsigned int");
5481   objfile_type->builtin_long
5482     = init_integer_type (objfile, gdbarch_long_bit (gdbarch),
5483                          0, "long");
5484   objfile_type->builtin_unsigned_long
5485     = init_integer_type (objfile, gdbarch_long_bit (gdbarch),
5486                          1, "unsigned long");
5487   objfile_type->builtin_long_long
5488     = init_integer_type (objfile, gdbarch_long_long_bit (gdbarch),
5489                          0, "long long");
5490   objfile_type->builtin_unsigned_long_long
5491     = init_integer_type (objfile, gdbarch_long_long_bit (gdbarch),
5492                          1, "unsigned long long");
5493   objfile_type->builtin_float
5494     = init_float_type (objfile, gdbarch_float_bit (gdbarch),
5495                        "float", gdbarch_float_format (gdbarch));
5496   objfile_type->builtin_double
5497     = init_float_type (objfile, gdbarch_double_bit (gdbarch),
5498                        "double", gdbarch_double_format (gdbarch));
5499   objfile_type->builtin_long_double
5500     = init_float_type (objfile, gdbarch_long_double_bit (gdbarch),
5501                        "long double", gdbarch_long_double_format (gdbarch));
5502
5503   /* This type represents a type that was unrecognized in symbol read-in.  */
5504   objfile_type->builtin_error
5505     = init_type (objfile, TYPE_CODE_ERROR, 0, "<unknown type>");
5506
5507   /* The following set of types is used for symbols with no
5508      debug information.  */
5509   objfile_type->nodebug_text_symbol
5510     = init_type (objfile, TYPE_CODE_FUNC, TARGET_CHAR_BIT,
5511                  "<text variable, no debug info>");
5512   objfile_type->nodebug_text_gnu_ifunc_symbol
5513     = init_type (objfile, TYPE_CODE_FUNC, TARGET_CHAR_BIT,
5514                  "<text gnu-indirect-function variable, no debug info>");
5515   TYPE_GNU_IFUNC (objfile_type->nodebug_text_gnu_ifunc_symbol) = 1;
5516   objfile_type->nodebug_got_plt_symbol
5517     = init_pointer_type (objfile, gdbarch_addr_bit (gdbarch),
5518                          "<text from jump slot in .got.plt, no debug info>",
5519                          objfile_type->nodebug_text_symbol);
5520   objfile_type->nodebug_data_symbol
5521     = init_nodebug_var_type (objfile, "<data variable, no debug info>");
5522   objfile_type->nodebug_unknown_symbol
5523     = init_nodebug_var_type (objfile, "<variable (not text or data), no debug info>");
5524   objfile_type->nodebug_tls_symbol
5525     = init_nodebug_var_type (objfile, "<thread local variable, no debug info>");
5526
5527   /* NOTE: on some targets, addresses and pointers are not necessarily
5528      the same.
5529
5530      The upshot is:
5531      - gdb's `struct type' always describes the target's
5532        representation.
5533      - gdb's `struct value' objects should always hold values in
5534        target form.
5535      - gdb's CORE_ADDR values are addresses in the unified virtual
5536        address space that the assembler and linker work with.  Thus,
5537        since target_read_memory takes a CORE_ADDR as an argument, it
5538        can access any memory on the target, even if the processor has
5539        separate code and data address spaces.
5540
5541      In this context, objfile_type->builtin_core_addr is a bit odd:
5542      it's a target type for a value the target will never see.  It's
5543      only used to hold the values of (typeless) linker symbols, which
5544      are indeed in the unified virtual address space.  */
5545
5546   objfile_type->builtin_core_addr
5547     = init_integer_type (objfile, gdbarch_addr_bit (gdbarch), 1,
5548                          "__CORE_ADDR");
5549
5550   set_objfile_data (objfile, objfile_type_data, objfile_type);
5551   return objfile_type;
5552 }
5553
5554 void
5555 _initialize_gdbtypes (void)
5556 {
5557   gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
5558   objfile_type_data = register_objfile_data ();
5559
5560   add_setshow_zuinteger_cmd ("overload", no_class, &overload_debug,
5561                              _("Set debugging of C++ overloading."),
5562                              _("Show debugging of C++ overloading."),
5563                              _("When enabled, ranking of the "
5564                                "functions is displayed."),
5565                              NULL,
5566                              show_overload_debug,
5567                              &setdebuglist, &showdebuglist);
5568
5569   /* Add user knob for controlling resolution of opaque types.  */
5570   add_setshow_boolean_cmd ("opaque-type-resolution", class_support,
5571                            &opaque_type_resolution,
5572                            _("Set resolution of opaque struct/class/union"
5573                              " types (if set before loading symbols)."),
5574                            _("Show resolution of opaque struct/class/union"
5575                              " types (if set before loading symbols)."),
5576                            NULL, NULL,
5577                            show_opaque_type_resolution,
5578                            &setlist, &showlist);
5579
5580   /* Add an option to permit non-strict type checking.  */
5581   add_setshow_boolean_cmd ("type", class_support,
5582                            &strict_type_checking,
5583                            _("Set strict type checking."),
5584                            _("Show strict type checking."),
5585                            NULL, NULL,
5586                            show_strict_type_checking,
5587                            &setchecklist, &showchecklist);
5588 }