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