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