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