Remove obsolete TYPE_FLAG_... values
[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   /* C++ fancies.  */
2752
2753   if (name && strcmp (name, "char") == 0)
2754     TYPE_NOSIGN (type) = 1;
2755
2756   return type;
2757 }
2758
2759 /* Allocate a TYPE_CODE_INT type structure associated with OBJFILE.
2760    BIT is the type size in bits.  If UNSIGNED_P is non-zero, set
2761    the type's TYPE_UNSIGNED flag.  NAME is the type name.  */
2762
2763 struct type *
2764 init_integer_type (struct objfile *objfile,
2765                    int bit, int unsigned_p, const char *name)
2766 {
2767   struct type *t;
2768
2769   t = init_type (objfile, TYPE_CODE_INT, bit / TARGET_CHAR_BIT, name);
2770   if (unsigned_p)
2771     TYPE_UNSIGNED (t) = 1;
2772
2773   return t;
2774 }
2775
2776 /* Allocate a TYPE_CODE_CHAR type structure associated with OBJFILE.
2777    BIT is the type size in bits.  If UNSIGNED_P is non-zero, set
2778    the type's TYPE_UNSIGNED flag.  NAME is the type name.  */
2779
2780 struct type *
2781 init_character_type (struct objfile *objfile,
2782                      int bit, int unsigned_p, const char *name)
2783 {
2784   struct type *t;
2785
2786   t = init_type (objfile, TYPE_CODE_CHAR, bit / TARGET_CHAR_BIT, name);
2787   if (unsigned_p)
2788     TYPE_UNSIGNED (t) = 1;
2789
2790   return t;
2791 }
2792
2793 /* Allocate a TYPE_CODE_BOOL type structure associated with OBJFILE.
2794    BIT is the type size in bits.  If UNSIGNED_P is non-zero, set
2795    the type's TYPE_UNSIGNED flag.  NAME is the type name.  */
2796
2797 struct type *
2798 init_boolean_type (struct objfile *objfile,
2799                    int bit, int unsigned_p, const char *name)
2800 {
2801   struct type *t;
2802
2803   t = init_type (objfile, TYPE_CODE_BOOL, bit / TARGET_CHAR_BIT, name);
2804   if (unsigned_p)
2805     TYPE_UNSIGNED (t) = 1;
2806
2807   return t;
2808 }
2809
2810 /* Allocate a TYPE_CODE_FLT type structure associated with OBJFILE.
2811    BIT is the type size in bits; if BIT equals -1, the size is
2812    determined by the floatformat.  NAME is the type name.  Set the
2813    TYPE_FLOATFORMAT from FLOATFORMATS.  */
2814
2815 struct type *
2816 init_float_type (struct objfile *objfile,
2817                  int bit, const char *name,
2818                  const struct floatformat **floatformats)
2819 {
2820   struct type *t;
2821
2822   bit = verify_floatformat (bit, floatformats);
2823   t = init_type (objfile, TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, name);
2824   TYPE_FLOATFORMAT (t) = floatformats;
2825
2826   return t;
2827 }
2828
2829 /* Allocate a TYPE_CODE_DECFLOAT type structure associated with OBJFILE.
2830    BIT is the type size in bits.  NAME is the type name.  */
2831
2832 struct type *
2833 init_decfloat_type (struct objfile *objfile, int bit, const char *name)
2834 {
2835   struct type *t;
2836
2837   t = init_type (objfile, TYPE_CODE_DECFLOAT, bit / TARGET_CHAR_BIT, name);
2838   return t;
2839 }
2840
2841 /* Allocate a TYPE_CODE_COMPLEX type structure associated with OBJFILE.
2842    NAME is the type name.  TARGET_TYPE is the component float type.  */
2843
2844 struct type *
2845 init_complex_type (struct objfile *objfile,
2846                    const char *name, struct type *target_type)
2847 {
2848   struct type *t;
2849
2850   t = init_type (objfile, TYPE_CODE_COMPLEX,
2851                  2 * TYPE_LENGTH (target_type), name);
2852   TYPE_TARGET_TYPE (t) = target_type;
2853   return t;
2854 }
2855
2856 /* Allocate a TYPE_CODE_PTR type structure associated with OBJFILE.
2857    BIT is the pointer type size in bits.  NAME is the type name.
2858    TARGET_TYPE is the pointer target type.  Always sets the pointer type's
2859    TYPE_UNSIGNED flag.  */
2860
2861 struct type *
2862 init_pointer_type (struct objfile *objfile,
2863                    int bit, const char *name, struct type *target_type)
2864 {
2865   struct type *t;
2866
2867   t = init_type (objfile, TYPE_CODE_PTR, bit / TARGET_CHAR_BIT, name);
2868   TYPE_TARGET_TYPE (t) = target_type;
2869   TYPE_UNSIGNED (t) = 1;
2870   return t;
2871 }
2872
2873 \f
2874 /* Queries on types.  */
2875
2876 int
2877 can_dereference (struct type *t)
2878 {
2879   /* FIXME: Should we return true for references as well as
2880      pointers?  */
2881   t = check_typedef (t);
2882   return
2883     (t != NULL
2884      && TYPE_CODE (t) == TYPE_CODE_PTR
2885      && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
2886 }
2887
2888 int
2889 is_integral_type (struct type *t)
2890 {
2891   t = check_typedef (t);
2892   return
2893     ((t != NULL)
2894      && ((TYPE_CODE (t) == TYPE_CODE_INT)
2895          || (TYPE_CODE (t) == TYPE_CODE_ENUM)
2896          || (TYPE_CODE (t) == TYPE_CODE_FLAGS)
2897          || (TYPE_CODE (t) == TYPE_CODE_CHAR)
2898          || (TYPE_CODE (t) == TYPE_CODE_RANGE)
2899          || (TYPE_CODE (t) == TYPE_CODE_BOOL)));
2900 }
2901
2902 /* Return true if TYPE is scalar.  */
2903
2904 int
2905 is_scalar_type (struct type *type)
2906 {
2907   type = check_typedef (type);
2908
2909   switch (TYPE_CODE (type))
2910     {
2911     case TYPE_CODE_ARRAY:
2912     case TYPE_CODE_STRUCT:
2913     case TYPE_CODE_UNION:
2914     case TYPE_CODE_SET:
2915     case TYPE_CODE_STRING:
2916       return 0;
2917     default:
2918       return 1;
2919     }
2920 }
2921
2922 /* Return true if T is scalar, or a composite type which in practice has
2923    the memory layout of a scalar type.  E.g., an array or struct with only
2924    one scalar element inside it, or a union with only scalar elements.  */
2925
2926 int
2927 is_scalar_type_recursive (struct type *t)
2928 {
2929   t = check_typedef (t);
2930
2931   if (is_scalar_type (t))
2932     return 1;
2933   /* Are we dealing with an array or string of known dimensions?  */
2934   else if ((TYPE_CODE (t) == TYPE_CODE_ARRAY
2935             || TYPE_CODE (t) == TYPE_CODE_STRING) && TYPE_NFIELDS (t) == 1
2936            && TYPE_CODE (TYPE_INDEX_TYPE (t)) == TYPE_CODE_RANGE)
2937     {
2938       LONGEST low_bound, high_bound;
2939       struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t));
2940
2941       get_discrete_bounds (TYPE_INDEX_TYPE (t), &low_bound, &high_bound);
2942
2943       return high_bound == low_bound && is_scalar_type_recursive (elt_type);
2944     }
2945   /* Are we dealing with a struct with one element?  */
2946   else if (TYPE_CODE (t) == TYPE_CODE_STRUCT && TYPE_NFIELDS (t) == 1)
2947     return is_scalar_type_recursive (TYPE_FIELD_TYPE (t, 0));
2948   else if (TYPE_CODE (t) == TYPE_CODE_UNION)
2949     {
2950       int i, n = TYPE_NFIELDS (t);
2951
2952       /* If all elements of the union are scalar, then the union is scalar.  */
2953       for (i = 0; i < n; i++)
2954         if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t, i)))
2955           return 0;
2956
2957       return 1;
2958     }
2959
2960   return 0;
2961 }
2962
2963 /* Return true is T is a class or a union.  False otherwise.  */
2964
2965 int
2966 class_or_union_p (const struct type *t)
2967 {
2968   return (TYPE_CODE (t) == TYPE_CODE_STRUCT
2969           || TYPE_CODE (t) == TYPE_CODE_UNION);
2970 }
2971
2972 /* A helper function which returns true if types A and B represent the
2973    "same" class type.  This is true if the types have the same main
2974    type, or the same name.  */
2975
2976 int
2977 class_types_same_p (const struct type *a, const struct type *b)
2978 {
2979   return (TYPE_MAIN_TYPE (a) == TYPE_MAIN_TYPE (b)
2980           || (TYPE_NAME (a) && TYPE_NAME (b)
2981               && !strcmp (TYPE_NAME (a), TYPE_NAME (b))));
2982 }
2983
2984 /* If BASE is an ancestor of DCLASS return the distance between them.
2985    otherwise return -1;
2986    eg:
2987
2988    class A {};
2989    class B: public A {};
2990    class C: public B {};
2991    class D: C {};
2992
2993    distance_to_ancestor (A, A, 0) = 0
2994    distance_to_ancestor (A, B, 0) = 1
2995    distance_to_ancestor (A, C, 0) = 2
2996    distance_to_ancestor (A, D, 0) = 3
2997
2998    If PUBLIC is 1 then only public ancestors are considered,
2999    and the function returns the distance only if BASE is a public ancestor
3000    of DCLASS.
3001    Eg:
3002
3003    distance_to_ancestor (A, D, 1) = -1.  */
3004
3005 static int
3006 distance_to_ancestor (struct type *base, struct type *dclass, int is_public)
3007 {
3008   int i;
3009   int d;
3010
3011   base = check_typedef (base);
3012   dclass = check_typedef (dclass);
3013
3014   if (class_types_same_p (base, dclass))
3015     return 0;
3016
3017   for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
3018     {
3019       if (is_public && ! BASETYPE_VIA_PUBLIC (dclass, i))
3020         continue;
3021
3022       d = distance_to_ancestor (base, TYPE_BASECLASS (dclass, i), is_public);
3023       if (d >= 0)
3024         return 1 + d;
3025     }
3026
3027   return -1;
3028 }
3029
3030 /* Check whether BASE is an ancestor or base class or DCLASS
3031    Return 1 if so, and 0 if not.
3032    Note: If BASE and DCLASS are of the same type, this function
3033    will return 1. So for some class A, is_ancestor (A, A) will
3034    return 1.  */
3035
3036 int
3037 is_ancestor (struct type *base, struct type *dclass)
3038 {
3039   return distance_to_ancestor (base, dclass, 0) >= 0;
3040 }
3041
3042 /* Like is_ancestor, but only returns true when BASE is a public
3043    ancestor of DCLASS.  */
3044
3045 int
3046 is_public_ancestor (struct type *base, struct type *dclass)
3047 {
3048   return distance_to_ancestor (base, dclass, 1) >= 0;
3049 }
3050
3051 /* A helper function for is_unique_ancestor.  */
3052
3053 static int
3054 is_unique_ancestor_worker (struct type *base, struct type *dclass,
3055                            int *offset,
3056                            const gdb_byte *valaddr, int embedded_offset,
3057                            CORE_ADDR address, struct value *val)
3058 {
3059   int i, count = 0;
3060
3061   base = check_typedef (base);
3062   dclass = check_typedef (dclass);
3063
3064   for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i)
3065     {
3066       struct type *iter;
3067       int this_offset;
3068
3069       iter = check_typedef (TYPE_BASECLASS (dclass, i));
3070
3071       this_offset = baseclass_offset (dclass, i, valaddr, embedded_offset,
3072                                       address, val);
3073
3074       if (class_types_same_p (base, iter))
3075         {
3076           /* If this is the first subclass, set *OFFSET and set count
3077              to 1.  Otherwise, if this is at the same offset as
3078              previous instances, do nothing.  Otherwise, increment
3079              count.  */
3080           if (*offset == -1)
3081             {
3082               *offset = this_offset;
3083               count = 1;
3084             }
3085           else if (this_offset == *offset)
3086             {
3087               /* Nothing.  */
3088             }
3089           else
3090             ++count;
3091         }
3092       else
3093         count += is_unique_ancestor_worker (base, iter, offset,
3094                                             valaddr,
3095                                             embedded_offset + this_offset,
3096                                             address, val);
3097     }
3098
3099   return count;
3100 }
3101
3102 /* Like is_ancestor, but only returns true if BASE is a unique base
3103    class of the type of VAL.  */
3104
3105 int
3106 is_unique_ancestor (struct type *base, struct value *val)
3107 {
3108   int offset = -1;
3109
3110   return is_unique_ancestor_worker (base, value_type (val), &offset,
3111                                     value_contents_for_printing (val),
3112                                     value_embedded_offset (val),
3113                                     value_address (val), val) == 1;
3114 }
3115
3116 \f
3117 /* Overload resolution.  */
3118
3119 /* Return the sum of the rank of A with the rank of B.  */
3120
3121 struct rank
3122 sum_ranks (struct rank a, struct rank b)
3123 {
3124   struct rank c;
3125   c.rank = a.rank + b.rank;
3126   c.subrank = a.subrank + b.subrank;
3127   return c;
3128 }
3129
3130 /* Compare rank A and B and return:
3131    0 if a = b
3132    1 if a is better than b
3133   -1 if b is better than a.  */
3134
3135 int
3136 compare_ranks (struct rank a, struct rank b)
3137 {
3138   if (a.rank == b.rank)
3139     {
3140       if (a.subrank == b.subrank)
3141         return 0;
3142       if (a.subrank < b.subrank)
3143         return 1;
3144       if (a.subrank > b.subrank)
3145         return -1;
3146     }
3147
3148   if (a.rank < b.rank)
3149     return 1;
3150
3151   /* a.rank > b.rank */
3152   return -1;
3153 }
3154
3155 /* Functions for overload resolution begin here.  */
3156
3157 /* Compare two badness vectors A and B and return the result.
3158    0 => A and B are identical
3159    1 => A and B are incomparable
3160    2 => A is better than B
3161    3 => A is worse than B  */
3162
3163 int
3164 compare_badness (struct badness_vector *a, struct badness_vector *b)
3165 {
3166   int i;
3167   int tmp;
3168   short found_pos = 0;          /* any positives in c? */
3169   short found_neg = 0;          /* any negatives in c? */
3170
3171   /* differing lengths => incomparable */
3172   if (a->length != b->length)
3173     return 1;
3174
3175   /* Subtract b from a */
3176   for (i = 0; i < a->length; i++)
3177     {
3178       tmp = compare_ranks (b->rank[i], a->rank[i]);
3179       if (tmp > 0)
3180         found_pos = 1;
3181       else if (tmp < 0)
3182         found_neg = 1;
3183     }
3184
3185   if (found_pos)
3186     {
3187       if (found_neg)
3188         return 1;               /* incomparable */
3189       else
3190         return 3;               /* A > B */
3191     }
3192   else
3193     /* no positives */
3194     {
3195       if (found_neg)
3196         return 2;               /* A < B */
3197       else
3198         return 0;               /* A == B */
3199     }
3200 }
3201
3202 /* Rank a function by comparing its parameter types (PARMS, length
3203    NPARMS), to the types of an argument list (ARGS, length NARGS).
3204    Return a pointer to a badness vector.  This has NARGS + 1
3205    entries.  */
3206
3207 struct badness_vector *
3208 rank_function (struct type **parms, int nparms, 
3209                struct value **args, int nargs)
3210 {
3211   int i;
3212   struct badness_vector *bv = XNEW (struct badness_vector);
3213   int min_len = nparms < nargs ? nparms : nargs;
3214
3215   bv->length = nargs + 1;       /* add 1 for the length-match rank.  */
3216   bv->rank = XNEWVEC (struct rank, nargs + 1);
3217
3218   /* First compare the lengths of the supplied lists.
3219      If there is a mismatch, set it to a high value.  */
3220
3221   /* pai/1997-06-03 FIXME: when we have debug info about default
3222      arguments and ellipsis parameter lists, we should consider those
3223      and rank the length-match more finely.  */
3224
3225   LENGTH_MATCH (bv) = (nargs != nparms)
3226                       ? LENGTH_MISMATCH_BADNESS
3227                       : EXACT_MATCH_BADNESS;
3228
3229   /* Now rank all the parameters of the candidate function.  */
3230   for (i = 1; i <= min_len; i++)
3231     bv->rank[i] = rank_one_type (parms[i - 1], value_type (args[i - 1]),
3232                                  args[i - 1]);
3233
3234   /* If more arguments than parameters, add dummy entries.  */
3235   for (i = min_len + 1; i <= nargs; i++)
3236     bv->rank[i] = TOO_FEW_PARAMS_BADNESS;
3237
3238   return bv;
3239 }
3240
3241 /* Compare the names of two integer types, assuming that any sign
3242    qualifiers have been checked already.  We do it this way because
3243    there may be an "int" in the name of one of the types.  */
3244
3245 static int
3246 integer_types_same_name_p (const char *first, const char *second)
3247 {
3248   int first_p, second_p;
3249
3250   /* If both are shorts, return 1; if neither is a short, keep
3251      checking.  */
3252   first_p = (strstr (first, "short") != NULL);
3253   second_p = (strstr (second, "short") != NULL);
3254   if (first_p && second_p)
3255     return 1;
3256   if (first_p || second_p)
3257     return 0;
3258
3259   /* Likewise for long.  */
3260   first_p = (strstr (first, "long") != NULL);
3261   second_p = (strstr (second, "long") != NULL);
3262   if (first_p && second_p)
3263     return 1;
3264   if (first_p || second_p)
3265     return 0;
3266
3267   /* Likewise for char.  */
3268   first_p = (strstr (first, "char") != NULL);
3269   second_p = (strstr (second, "char") != NULL);
3270   if (first_p && second_p)
3271     return 1;
3272   if (first_p || second_p)
3273     return 0;
3274
3275   /* They must both be ints.  */
3276   return 1;
3277 }
3278
3279 /* Compares type A to type B returns 1 if the represent the same type
3280    0 otherwise.  */
3281
3282 int
3283 types_equal (struct type *a, struct type *b)
3284 {
3285   /* Identical type pointers.  */
3286   /* However, this still doesn't catch all cases of same type for b
3287      and a.  The reason is that builtin types are different from
3288      the same ones constructed from the object.  */
3289   if (a == b)
3290     return 1;
3291
3292   /* Resolve typedefs */
3293   if (TYPE_CODE (a) == TYPE_CODE_TYPEDEF)
3294     a = check_typedef (a);
3295   if (TYPE_CODE (b) == TYPE_CODE_TYPEDEF)
3296     b = check_typedef (b);
3297
3298   /* If after resolving typedefs a and b are not of the same type
3299      code then they are not equal.  */
3300   if (TYPE_CODE (a) != TYPE_CODE (b))
3301     return 0;
3302
3303   /* If a and b are both pointers types or both reference types then
3304      they are equal of the same type iff the objects they refer to are
3305      of the same type.  */
3306   if (TYPE_CODE (a) == TYPE_CODE_PTR
3307       || TYPE_CODE (a) == TYPE_CODE_REF)
3308     return types_equal (TYPE_TARGET_TYPE (a),
3309                         TYPE_TARGET_TYPE (b));
3310
3311   /* Well, damnit, if the names are exactly the same, I'll say they
3312      are exactly the same.  This happens when we generate method
3313      stubs.  The types won't point to the same address, but they
3314      really are the same.  */
3315
3316   if (TYPE_NAME (a) && TYPE_NAME (b)
3317       && strcmp (TYPE_NAME (a), TYPE_NAME (b)) == 0)
3318     return 1;
3319
3320   /* Check if identical after resolving typedefs.  */
3321   if (a == b)
3322     return 1;
3323
3324   /* Two function types are equal if their argument and return types
3325      are equal.  */
3326   if (TYPE_CODE (a) == TYPE_CODE_FUNC)
3327     {
3328       int i;
3329
3330       if (TYPE_NFIELDS (a) != TYPE_NFIELDS (b))
3331         return 0;
3332       
3333       if (!types_equal (TYPE_TARGET_TYPE (a), TYPE_TARGET_TYPE (b)))
3334         return 0;
3335
3336       for (i = 0; i < TYPE_NFIELDS (a); ++i)
3337         if (!types_equal (TYPE_FIELD_TYPE (a, i), TYPE_FIELD_TYPE (b, i)))
3338           return 0;
3339
3340       return 1;
3341     }
3342
3343   return 0;
3344 }
3345 \f
3346 /* Deep comparison of types.  */
3347
3348 /* An entry in the type-equality bcache.  */
3349
3350 typedef struct type_equality_entry
3351 {
3352   struct type *type1, *type2;
3353 } type_equality_entry_d;
3354
3355 DEF_VEC_O (type_equality_entry_d);
3356
3357 /* A helper function to compare two strings.  Returns 1 if they are
3358    the same, 0 otherwise.  Handles NULLs properly.  */
3359
3360 static int
3361 compare_maybe_null_strings (const char *s, const char *t)
3362 {
3363   if (s == NULL && t != NULL)
3364     return 0;
3365   else if (s != NULL && t == NULL)
3366     return 0;
3367   else if (s == NULL && t== NULL)
3368     return 1;
3369   return strcmp (s, t) == 0;
3370 }
3371
3372 /* A helper function for check_types_worklist that checks two types for
3373    "deep" equality.  Returns non-zero if the types are considered the
3374    same, zero otherwise.  */
3375
3376 static int
3377 check_types_equal (struct type *type1, struct type *type2,
3378                    VEC (type_equality_entry_d) **worklist)
3379 {
3380   type1 = check_typedef (type1);
3381   type2 = check_typedef (type2);
3382
3383   if (type1 == type2)
3384     return 1;
3385
3386   if (TYPE_CODE (type1) != TYPE_CODE (type2)
3387       || TYPE_LENGTH (type1) != TYPE_LENGTH (type2)
3388       || TYPE_UNSIGNED (type1) != TYPE_UNSIGNED (type2)
3389       || TYPE_NOSIGN (type1) != TYPE_NOSIGN (type2)
3390       || TYPE_VARARGS (type1) != TYPE_VARARGS (type2)
3391       || TYPE_VECTOR (type1) != TYPE_VECTOR (type2)
3392       || TYPE_NOTTEXT (type1) != TYPE_NOTTEXT (type2)
3393       || TYPE_INSTANCE_FLAGS (type1) != TYPE_INSTANCE_FLAGS (type2)
3394       || TYPE_NFIELDS (type1) != TYPE_NFIELDS (type2))
3395     return 0;
3396
3397   if (!compare_maybe_null_strings (TYPE_TAG_NAME (type1),
3398                                    TYPE_TAG_NAME (type2)))
3399     return 0;
3400   if (!compare_maybe_null_strings (TYPE_NAME (type1), TYPE_NAME (type2)))
3401     return 0;
3402
3403   if (TYPE_CODE (type1) == TYPE_CODE_RANGE)
3404     {
3405       if (memcmp (TYPE_RANGE_DATA (type1), TYPE_RANGE_DATA (type2),
3406                   sizeof (*TYPE_RANGE_DATA (type1))) != 0)
3407         return 0;
3408     }
3409   else
3410     {
3411       int i;
3412
3413       for (i = 0; i < TYPE_NFIELDS (type1); ++i)
3414         {
3415           const struct field *field1 = &TYPE_FIELD (type1, i);
3416           const struct field *field2 = &TYPE_FIELD (type2, i);
3417           struct type_equality_entry entry;
3418
3419           if (FIELD_ARTIFICIAL (*field1) != FIELD_ARTIFICIAL (*field2)
3420               || FIELD_BITSIZE (*field1) != FIELD_BITSIZE (*field2)
3421               || FIELD_LOC_KIND (*field1) != FIELD_LOC_KIND (*field2))
3422             return 0;
3423           if (!compare_maybe_null_strings (FIELD_NAME (*field1),
3424                                            FIELD_NAME (*field2)))
3425             return 0;
3426           switch (FIELD_LOC_KIND (*field1))
3427             {
3428             case FIELD_LOC_KIND_BITPOS:
3429               if (FIELD_BITPOS (*field1) != FIELD_BITPOS (*field2))
3430                 return 0;
3431               break;
3432             case FIELD_LOC_KIND_ENUMVAL:
3433               if (FIELD_ENUMVAL (*field1) != FIELD_ENUMVAL (*field2))
3434                 return 0;
3435               break;
3436             case FIELD_LOC_KIND_PHYSADDR:
3437               if (FIELD_STATIC_PHYSADDR (*field1)
3438                   != FIELD_STATIC_PHYSADDR (*field2))
3439                 return 0;
3440               break;
3441             case FIELD_LOC_KIND_PHYSNAME:
3442               if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1),
3443                                                FIELD_STATIC_PHYSNAME (*field2)))
3444                 return 0;
3445               break;
3446             case FIELD_LOC_KIND_DWARF_BLOCK:
3447               {
3448                 struct dwarf2_locexpr_baton *block1, *block2;
3449
3450                 block1 = FIELD_DWARF_BLOCK (*field1);
3451                 block2 = FIELD_DWARF_BLOCK (*field2);
3452                 if (block1->per_cu != block2->per_cu
3453                     || block1->size != block2->size
3454                     || memcmp (block1->data, block2->data, block1->size) != 0)
3455                   return 0;
3456               }
3457               break;
3458             default:
3459               internal_error (__FILE__, __LINE__, _("Unsupported field kind "
3460                                                     "%d by check_types_equal"),
3461                               FIELD_LOC_KIND (*field1));
3462             }
3463
3464           entry.type1 = FIELD_TYPE (*field1);
3465           entry.type2 = FIELD_TYPE (*field2);
3466           VEC_safe_push (type_equality_entry_d, *worklist, &entry);
3467         }
3468     }
3469
3470   if (TYPE_TARGET_TYPE (type1) != NULL)
3471     {
3472       struct type_equality_entry entry;
3473
3474       if (TYPE_TARGET_TYPE (type2) == NULL)
3475         return 0;
3476
3477       entry.type1 = TYPE_TARGET_TYPE (type1);
3478       entry.type2 = TYPE_TARGET_TYPE (type2);
3479       VEC_safe_push (type_equality_entry_d, *worklist, &entry);
3480     }
3481   else if (TYPE_TARGET_TYPE (type2) != NULL)
3482     return 0;
3483
3484   return 1;
3485 }
3486
3487 /* Check types on a worklist for equality.  Returns zero if any pair
3488    is not equal, non-zero if they are all considered equal.  */
3489
3490 static int
3491 check_types_worklist (VEC (type_equality_entry_d) **worklist,
3492                       struct bcache *cache)
3493 {
3494   while (!VEC_empty (type_equality_entry_d, *worklist))
3495     {
3496       struct type_equality_entry entry;
3497       int added;
3498
3499       entry = *VEC_last (type_equality_entry_d, *worklist);
3500       VEC_pop (type_equality_entry_d, *worklist);
3501
3502       /* If the type pair has already been visited, we know it is
3503          ok.  */
3504       bcache_full (&entry, sizeof (entry), cache, &added);
3505       if (!added)
3506         continue;
3507
3508       if (check_types_equal (entry.type1, entry.type2, worklist) == 0)
3509         return 0;
3510     }
3511
3512   return 1;
3513 }
3514
3515 /* Return non-zero if types TYPE1 and TYPE2 are equal, as determined by a
3516    "deep comparison".  Otherwise return zero.  */
3517
3518 int
3519 types_deeply_equal (struct type *type1, struct type *type2)
3520 {
3521   struct gdb_exception except = exception_none;
3522   int result = 0;
3523   struct bcache *cache;
3524   VEC (type_equality_entry_d) *worklist = NULL;
3525   struct type_equality_entry entry;
3526
3527   gdb_assert (type1 != NULL && type2 != NULL);
3528
3529   /* Early exit for the simple case.  */
3530   if (type1 == type2)
3531     return 1;
3532
3533   cache = bcache_xmalloc (NULL, NULL);
3534
3535   entry.type1 = type1;
3536   entry.type2 = type2;
3537   VEC_safe_push (type_equality_entry_d, worklist, &entry);
3538
3539   /* check_types_worklist calls several nested helper functions, some
3540      of which can raise a GDB exception, so we just check and rethrow
3541      here.  If there is a GDB exception, a comparison is not capable
3542      (or trusted), so exit.  */
3543   TRY
3544     {
3545       result = check_types_worklist (&worklist, cache);
3546     }
3547   CATCH (ex, RETURN_MASK_ALL)
3548     {
3549       except = ex;
3550     }
3551   END_CATCH
3552
3553   bcache_xfree (cache);
3554   VEC_free (type_equality_entry_d, worklist);
3555
3556   /* Rethrow if there was a problem.  */
3557   if (except.reason < 0)
3558     throw_exception (except);
3559
3560   return result;
3561 }
3562
3563 /* Allocated status of type TYPE.  Return zero if type TYPE is allocated.
3564    Otherwise return one.  */
3565
3566 int
3567 type_not_allocated (const struct type *type)
3568 {
3569   struct dynamic_prop *prop = TYPE_ALLOCATED_PROP (type);
3570
3571   return (prop && TYPE_DYN_PROP_KIND (prop) == PROP_CONST
3572          && !TYPE_DYN_PROP_ADDR (prop));
3573 }
3574
3575 /* Associated status of type TYPE.  Return zero if type TYPE is associated.
3576    Otherwise return one.  */
3577
3578 int
3579 type_not_associated (const struct type *type)
3580 {
3581   struct dynamic_prop *prop = TYPE_ASSOCIATED_PROP (type);
3582
3583   return (prop && TYPE_DYN_PROP_KIND (prop) == PROP_CONST
3584          && !TYPE_DYN_PROP_ADDR (prop));
3585 }
3586 \f
3587 /* Compare one type (PARM) for compatibility with another (ARG).
3588  * PARM is intended to be the parameter type of a function; and
3589  * ARG is the supplied argument's type.  This function tests if
3590  * the latter can be converted to the former.
3591  * VALUE is the argument's value or NULL if none (or called recursively)
3592  *
3593  * Return 0 if they are identical types;
3594  * Otherwise, return an integer which corresponds to how compatible
3595  * PARM is to ARG.  The higher the return value, the worse the match.
3596  * Generally the "bad" conversions are all uniformly assigned a 100.  */
3597
3598 struct rank
3599 rank_one_type (struct type *parm, struct type *arg, struct value *value)
3600 {
3601   struct rank rank = {0,0};
3602
3603   if (types_equal (parm, arg))
3604     return EXACT_MATCH_BADNESS;
3605
3606   /* Resolve typedefs */
3607   if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF)
3608     parm = check_typedef (parm);
3609   if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
3610     arg = check_typedef (arg);
3611
3612   /* See through references, since we can almost make non-references
3613      references.  */
3614   if (TYPE_CODE (arg) == TYPE_CODE_REF)
3615     return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL),
3616                        REFERENCE_CONVERSION_BADNESS));
3617   if (TYPE_CODE (parm) == TYPE_CODE_REF)
3618     return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL),
3619                        REFERENCE_CONVERSION_BADNESS));
3620   if (overload_debug)
3621   /* Debugging only.  */
3622     fprintf_filtered (gdb_stderr, 
3623                       "------ Arg is %s [%d], parm is %s [%d]\n",
3624                       TYPE_NAME (arg), TYPE_CODE (arg), 
3625                       TYPE_NAME (parm), TYPE_CODE (parm));
3626
3627   /* x -> y means arg of type x being supplied for parameter of type y.  */
3628
3629   switch (TYPE_CODE (parm))
3630     {
3631     case TYPE_CODE_PTR:
3632       switch (TYPE_CODE (arg))
3633         {
3634         case TYPE_CODE_PTR:
3635
3636           /* Allowed pointer conversions are:
3637              (a) pointer to void-pointer conversion.  */
3638           if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID)
3639             return VOID_PTR_CONVERSION_BADNESS;
3640
3641           /* (b) pointer to ancestor-pointer conversion.  */
3642           rank.subrank = distance_to_ancestor (TYPE_TARGET_TYPE (parm),
3643                                                TYPE_TARGET_TYPE (arg),
3644                                                0);
3645           if (rank.subrank >= 0)
3646             return sum_ranks (BASE_PTR_CONVERSION_BADNESS, rank);
3647
3648           return INCOMPATIBLE_TYPE_BADNESS;
3649         case TYPE_CODE_ARRAY:
3650           if (types_equal (TYPE_TARGET_TYPE (parm),
3651                            TYPE_TARGET_TYPE (arg)))
3652             return EXACT_MATCH_BADNESS;
3653           return INCOMPATIBLE_TYPE_BADNESS;
3654         case TYPE_CODE_FUNC:
3655           return rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL);
3656         case TYPE_CODE_INT:
3657           if (value != NULL && TYPE_CODE (value_type (value)) == TYPE_CODE_INT)
3658             {
3659               if (value_as_long (value) == 0)
3660                 {
3661                   /* Null pointer conversion: allow it to be cast to a pointer.
3662                      [4.10.1 of C++ standard draft n3290]  */
3663                   return NULL_POINTER_CONVERSION_BADNESS;
3664                 }
3665               else
3666                 {
3667                   /* If type checking is disabled, allow the conversion.  */
3668                   if (!strict_type_checking)
3669                     return NS_INTEGER_POINTER_CONVERSION_BADNESS;
3670                 }
3671             }
3672           /* fall through  */
3673         case TYPE_CODE_ENUM:
3674         case TYPE_CODE_FLAGS:
3675         case TYPE_CODE_CHAR:
3676         case TYPE_CODE_RANGE:
3677         case TYPE_CODE_BOOL:
3678         default:
3679           return INCOMPATIBLE_TYPE_BADNESS;
3680         }
3681     case TYPE_CODE_ARRAY:
3682       switch (TYPE_CODE (arg))
3683         {
3684         case TYPE_CODE_PTR:
3685         case TYPE_CODE_ARRAY:
3686           return rank_one_type (TYPE_TARGET_TYPE (parm), 
3687                                 TYPE_TARGET_TYPE (arg), NULL);
3688         default:
3689           return INCOMPATIBLE_TYPE_BADNESS;
3690         }
3691     case TYPE_CODE_FUNC:
3692       switch (TYPE_CODE (arg))
3693         {
3694         case TYPE_CODE_PTR:     /* funcptr -> func */
3695           return rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL);
3696         default:
3697           return INCOMPATIBLE_TYPE_BADNESS;
3698         }
3699     case TYPE_CODE_INT:
3700       switch (TYPE_CODE (arg))
3701         {
3702         case TYPE_CODE_INT:
3703           if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
3704             {
3705               /* Deal with signed, unsigned, and plain chars and
3706                  signed and unsigned ints.  */
3707               if (TYPE_NOSIGN (parm))
3708                 {
3709                   /* This case only for character types.  */
3710                   if (TYPE_NOSIGN (arg))
3711                     return EXACT_MATCH_BADNESS; /* plain char -> plain char */
3712                   else          /* signed/unsigned char -> plain char */
3713                     return INTEGER_CONVERSION_BADNESS;
3714                 }
3715               else if (TYPE_UNSIGNED (parm))
3716                 {
3717                   if (TYPE_UNSIGNED (arg))
3718                     {
3719                       /* unsigned int -> unsigned int, or 
3720                          unsigned long -> unsigned long */
3721                       if (integer_types_same_name_p (TYPE_NAME (parm), 
3722                                                      TYPE_NAME (arg)))
3723                         return EXACT_MATCH_BADNESS;
3724                       else if (integer_types_same_name_p (TYPE_NAME (arg), 
3725                                                           "int")
3726                                && integer_types_same_name_p (TYPE_NAME (parm),
3727                                                              "long"))
3728                         /* unsigned int -> unsigned long */
3729                         return INTEGER_PROMOTION_BADNESS;
3730                       else
3731                         /* unsigned long -> unsigned int */
3732                         return INTEGER_CONVERSION_BADNESS;
3733                     }
3734                   else
3735                     {
3736                       if (integer_types_same_name_p (TYPE_NAME (arg), 
3737                                                      "long")
3738                           && integer_types_same_name_p (TYPE_NAME (parm), 
3739                                                         "int"))
3740                         /* signed long -> unsigned int */
3741                         return INTEGER_CONVERSION_BADNESS;
3742                       else
3743                         /* signed int/long -> unsigned int/long */
3744                         return INTEGER_CONVERSION_BADNESS;
3745                     }
3746                 }
3747               else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
3748                 {
3749                   if (integer_types_same_name_p (TYPE_NAME (parm), 
3750                                                  TYPE_NAME (arg)))
3751                     return EXACT_MATCH_BADNESS;
3752                   else if (integer_types_same_name_p (TYPE_NAME (arg), 
3753                                                       "int")
3754                            && integer_types_same_name_p (TYPE_NAME (parm), 
3755                                                          "long"))
3756                     return INTEGER_PROMOTION_BADNESS;
3757                   else
3758                     return INTEGER_CONVERSION_BADNESS;
3759                 }
3760               else
3761                 return INTEGER_CONVERSION_BADNESS;
3762             }
3763           else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
3764             return INTEGER_PROMOTION_BADNESS;
3765           else
3766             return INTEGER_CONVERSION_BADNESS;
3767         case TYPE_CODE_ENUM:
3768         case TYPE_CODE_FLAGS:
3769         case TYPE_CODE_CHAR:
3770         case TYPE_CODE_RANGE:
3771         case TYPE_CODE_BOOL:
3772           if (TYPE_DECLARED_CLASS (arg))
3773             return INCOMPATIBLE_TYPE_BADNESS;
3774           return INTEGER_PROMOTION_BADNESS;
3775         case TYPE_CODE_FLT:
3776           return INT_FLOAT_CONVERSION_BADNESS;
3777         case TYPE_CODE_PTR:
3778           return NS_POINTER_CONVERSION_BADNESS;
3779         default:
3780           return INCOMPATIBLE_TYPE_BADNESS;
3781         }
3782       break;
3783     case TYPE_CODE_ENUM:
3784       switch (TYPE_CODE (arg))
3785         {
3786         case TYPE_CODE_INT:
3787         case TYPE_CODE_CHAR:
3788         case TYPE_CODE_RANGE:
3789         case TYPE_CODE_BOOL:
3790         case TYPE_CODE_ENUM:
3791           if (TYPE_DECLARED_CLASS (parm) || TYPE_DECLARED_CLASS (arg))
3792             return INCOMPATIBLE_TYPE_BADNESS;
3793           return INTEGER_CONVERSION_BADNESS;
3794         case TYPE_CODE_FLT:
3795           return INT_FLOAT_CONVERSION_BADNESS;
3796         default:
3797           return INCOMPATIBLE_TYPE_BADNESS;
3798         }
3799       break;
3800     case TYPE_CODE_CHAR:
3801       switch (TYPE_CODE (arg))
3802         {
3803         case TYPE_CODE_RANGE:
3804         case TYPE_CODE_BOOL:
3805         case TYPE_CODE_ENUM:
3806           if (TYPE_DECLARED_CLASS (arg))
3807             return INCOMPATIBLE_TYPE_BADNESS;
3808           return INTEGER_CONVERSION_BADNESS;
3809         case TYPE_CODE_FLT:
3810           return INT_FLOAT_CONVERSION_BADNESS;
3811         case TYPE_CODE_INT:
3812           if (TYPE_LENGTH (arg) > TYPE_LENGTH (parm))
3813             return INTEGER_CONVERSION_BADNESS;
3814           else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
3815             return INTEGER_PROMOTION_BADNESS;
3816           /* >>> !! else fall through !! <<< */
3817         case TYPE_CODE_CHAR:
3818           /* Deal with signed, unsigned, and plain chars for C++ and
3819              with int cases falling through from previous case.  */
3820           if (TYPE_NOSIGN (parm))
3821             {
3822               if (TYPE_NOSIGN (arg))
3823                 return EXACT_MATCH_BADNESS;
3824               else
3825                 return INTEGER_CONVERSION_BADNESS;
3826             }
3827           else if (TYPE_UNSIGNED (parm))
3828             {
3829               if (TYPE_UNSIGNED (arg))
3830                 return EXACT_MATCH_BADNESS;
3831               else
3832                 return INTEGER_PROMOTION_BADNESS;
3833             }
3834           else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
3835             return EXACT_MATCH_BADNESS;
3836           else
3837             return INTEGER_CONVERSION_BADNESS;
3838         default:
3839           return INCOMPATIBLE_TYPE_BADNESS;
3840         }
3841       break;
3842     case TYPE_CODE_RANGE:
3843       switch (TYPE_CODE (arg))
3844         {
3845         case TYPE_CODE_INT:
3846         case TYPE_CODE_CHAR:
3847         case TYPE_CODE_RANGE:
3848         case TYPE_CODE_BOOL:
3849         case TYPE_CODE_ENUM:
3850           return INTEGER_CONVERSION_BADNESS;
3851         case TYPE_CODE_FLT:
3852           return INT_FLOAT_CONVERSION_BADNESS;
3853         default:
3854           return INCOMPATIBLE_TYPE_BADNESS;
3855         }
3856       break;
3857     case TYPE_CODE_BOOL:
3858       switch (TYPE_CODE (arg))
3859         {
3860           /* n3290 draft, section 4.12.1 (conv.bool):
3861
3862              "A prvalue of arithmetic, unscoped enumeration, pointer, or
3863              pointer to member type can be converted to a prvalue of type
3864              bool.  A zero value, null pointer value, or null member pointer
3865              value is converted to false; any other value is converted to
3866              true.  A prvalue of type std::nullptr_t can be converted to a
3867              prvalue of type bool; the resulting value is false."  */
3868         case TYPE_CODE_INT:
3869         case TYPE_CODE_CHAR:
3870         case TYPE_CODE_ENUM:
3871         case TYPE_CODE_FLT:
3872         case TYPE_CODE_MEMBERPTR:
3873         case TYPE_CODE_PTR:
3874           return BOOL_CONVERSION_BADNESS;
3875         case TYPE_CODE_RANGE:
3876           return INCOMPATIBLE_TYPE_BADNESS;
3877         case TYPE_CODE_BOOL:
3878           return EXACT_MATCH_BADNESS;
3879         default:
3880           return INCOMPATIBLE_TYPE_BADNESS;
3881         }
3882       break;
3883     case TYPE_CODE_FLT:
3884       switch (TYPE_CODE (arg))
3885         {
3886         case TYPE_CODE_FLT:
3887           if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
3888             return FLOAT_PROMOTION_BADNESS;
3889           else if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
3890             return EXACT_MATCH_BADNESS;
3891           else
3892             return FLOAT_CONVERSION_BADNESS;
3893         case TYPE_CODE_INT:
3894         case TYPE_CODE_BOOL:
3895         case TYPE_CODE_ENUM:
3896         case TYPE_CODE_RANGE:
3897         case TYPE_CODE_CHAR:
3898           return INT_FLOAT_CONVERSION_BADNESS;
3899         default:
3900           return INCOMPATIBLE_TYPE_BADNESS;
3901         }
3902       break;
3903     case TYPE_CODE_COMPLEX:
3904       switch (TYPE_CODE (arg))
3905         {               /* Strictly not needed for C++, but...  */
3906         case TYPE_CODE_FLT:
3907           return FLOAT_PROMOTION_BADNESS;
3908         case TYPE_CODE_COMPLEX:
3909           return EXACT_MATCH_BADNESS;
3910         default:
3911           return INCOMPATIBLE_TYPE_BADNESS;
3912         }
3913       break;
3914     case TYPE_CODE_STRUCT:
3915       switch (TYPE_CODE (arg))
3916         {
3917         case TYPE_CODE_STRUCT:
3918           /* Check for derivation */
3919           rank.subrank = distance_to_ancestor (parm, arg, 0);
3920           if (rank.subrank >= 0)
3921             return sum_ranks (BASE_CONVERSION_BADNESS, rank);
3922           /* else fall through */
3923         default:
3924           return INCOMPATIBLE_TYPE_BADNESS;
3925         }
3926       break;
3927     case TYPE_CODE_UNION:
3928       switch (TYPE_CODE (arg))
3929         {
3930         case TYPE_CODE_UNION:
3931         default:
3932           return INCOMPATIBLE_TYPE_BADNESS;
3933         }
3934       break;
3935     case TYPE_CODE_MEMBERPTR:
3936       switch (TYPE_CODE (arg))
3937         {
3938         default:
3939           return INCOMPATIBLE_TYPE_BADNESS;
3940         }
3941       break;
3942     case TYPE_CODE_METHOD:
3943       switch (TYPE_CODE (arg))
3944         {
3945
3946         default:
3947           return INCOMPATIBLE_TYPE_BADNESS;
3948         }
3949       break;
3950     case TYPE_CODE_REF:
3951       switch (TYPE_CODE (arg))
3952         {
3953
3954         default:
3955           return INCOMPATIBLE_TYPE_BADNESS;
3956         }
3957
3958       break;
3959     case TYPE_CODE_SET:
3960       switch (TYPE_CODE (arg))
3961         {
3962           /* Not in C++ */
3963         case TYPE_CODE_SET:
3964           return rank_one_type (TYPE_FIELD_TYPE (parm, 0), 
3965                                 TYPE_FIELD_TYPE (arg, 0), NULL);
3966         default:
3967           return INCOMPATIBLE_TYPE_BADNESS;
3968         }
3969       break;
3970     case TYPE_CODE_VOID:
3971     default:
3972       return INCOMPATIBLE_TYPE_BADNESS;
3973     }                           /* switch (TYPE_CODE (arg)) */
3974 }
3975
3976 /* End of functions for overload resolution.  */
3977 \f
3978 /* Routines to pretty-print types.  */
3979
3980 static void
3981 print_bit_vector (B_TYPE *bits, int nbits)
3982 {
3983   int bitno;
3984
3985   for (bitno = 0; bitno < nbits; bitno++)
3986     {
3987       if ((bitno % 8) == 0)
3988         {
3989           puts_filtered (" ");
3990         }
3991       if (B_TST (bits, bitno))
3992         printf_filtered (("1"));
3993       else
3994         printf_filtered (("0"));
3995     }
3996 }
3997
3998 /* Note the first arg should be the "this" pointer, we may not want to
3999    include it since we may get into a infinitely recursive
4000    situation.  */
4001
4002 static void
4003 print_args (struct field *args, int nargs, int spaces)
4004 {
4005   if (args != NULL)
4006     {
4007       int i;
4008
4009       for (i = 0; i < nargs; i++)
4010         {
4011           printfi_filtered (spaces, "[%d] name '%s'\n", i,
4012                             args[i].name != NULL ? args[i].name : "<NULL>");
4013           recursive_dump_type (args[i].type, spaces + 2);
4014         }
4015     }
4016 }
4017
4018 int
4019 field_is_static (struct field *f)
4020 {
4021   /* "static" fields are the fields whose location is not relative
4022      to the address of the enclosing struct.  It would be nice to
4023      have a dedicated flag that would be set for static fields when
4024      the type is being created.  But in practice, checking the field
4025      loc_kind should give us an accurate answer.  */
4026   return (FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSNAME
4027           || FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSADDR);
4028 }
4029
4030 static void
4031 dump_fn_fieldlists (struct type *type, int spaces)
4032 {
4033   int method_idx;
4034   int overload_idx;
4035   struct fn_field *f;
4036
4037   printfi_filtered (spaces, "fn_fieldlists ");
4038   gdb_print_host_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
4039   printf_filtered ("\n");
4040   for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
4041     {
4042       f = TYPE_FN_FIELDLIST1 (type, method_idx);
4043       printfi_filtered (spaces + 2, "[%d] name '%s' (",
4044                         method_idx,
4045                         TYPE_FN_FIELDLIST_NAME (type, method_idx));
4046       gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
4047                               gdb_stdout);
4048       printf_filtered (_(") length %d\n"),
4049                        TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
4050       for (overload_idx = 0;
4051            overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
4052            overload_idx++)
4053         {
4054           printfi_filtered (spaces + 4, "[%d] physname '%s' (",
4055                             overload_idx,
4056                             TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
4057           gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
4058                                   gdb_stdout);
4059           printf_filtered (")\n");
4060           printfi_filtered (spaces + 8, "type ");
4061           gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx), 
4062                                   gdb_stdout);
4063           printf_filtered ("\n");
4064
4065           recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
4066                                spaces + 8 + 2);
4067
4068           printfi_filtered (spaces + 8, "args ");
4069           gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx), 
4070                                   gdb_stdout);
4071           printf_filtered ("\n");
4072           print_args (TYPE_FN_FIELD_ARGS (f, overload_idx),
4073                       TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, overload_idx)),
4074                       spaces + 8 + 2);
4075           printfi_filtered (spaces + 8, "fcontext ");
4076           gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
4077                                   gdb_stdout);
4078           printf_filtered ("\n");
4079
4080           printfi_filtered (spaces + 8, "is_const %d\n",
4081                             TYPE_FN_FIELD_CONST (f, overload_idx));
4082           printfi_filtered (spaces + 8, "is_volatile %d\n",
4083                             TYPE_FN_FIELD_VOLATILE (f, overload_idx));
4084           printfi_filtered (spaces + 8, "is_private %d\n",
4085                             TYPE_FN_FIELD_PRIVATE (f, overload_idx));
4086           printfi_filtered (spaces + 8, "is_protected %d\n",
4087                             TYPE_FN_FIELD_PROTECTED (f, overload_idx));
4088           printfi_filtered (spaces + 8, "is_stub %d\n",
4089                             TYPE_FN_FIELD_STUB (f, overload_idx));
4090           printfi_filtered (spaces + 8, "voffset %u\n",
4091                             TYPE_FN_FIELD_VOFFSET (f, overload_idx));
4092         }
4093     }
4094 }
4095
4096 static void
4097 print_cplus_stuff (struct type *type, int spaces)
4098 {
4099   printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type));
4100   printfi_filtered (spaces, "vptr_basetype ");
4101   gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
4102   puts_filtered ("\n");
4103   if (TYPE_VPTR_BASETYPE (type) != NULL)
4104     recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
4105
4106   printfi_filtered (spaces, "n_baseclasses %d\n",
4107                     TYPE_N_BASECLASSES (type));
4108   printfi_filtered (spaces, "nfn_fields %d\n",
4109                     TYPE_NFN_FIELDS (type));
4110   if (TYPE_N_BASECLASSES (type) > 0)
4111     {
4112       printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
4113                         TYPE_N_BASECLASSES (type));
4114       gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type), 
4115                               gdb_stdout);
4116       printf_filtered (")");
4117
4118       print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
4119                         TYPE_N_BASECLASSES (type));
4120       puts_filtered ("\n");
4121     }
4122   if (TYPE_NFIELDS (type) > 0)
4123     {
4124       if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
4125         {
4126           printfi_filtered (spaces, 
4127                             "private_field_bits (%d bits at *",
4128                             TYPE_NFIELDS (type));
4129           gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type), 
4130                                   gdb_stdout);
4131           printf_filtered (")");
4132           print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
4133                             TYPE_NFIELDS (type));
4134           puts_filtered ("\n");
4135         }
4136       if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
4137         {
4138           printfi_filtered (spaces, 
4139                             "protected_field_bits (%d bits at *",
4140                             TYPE_NFIELDS (type));
4141           gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type), 
4142                                   gdb_stdout);
4143           printf_filtered (")");
4144           print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
4145                             TYPE_NFIELDS (type));
4146           puts_filtered ("\n");
4147         }
4148     }
4149   if (TYPE_NFN_FIELDS (type) > 0)
4150     {
4151       dump_fn_fieldlists (type, spaces);
4152     }
4153 }
4154
4155 /* Print the contents of the TYPE's type_specific union, assuming that
4156    its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF.  */
4157
4158 static void
4159 print_gnat_stuff (struct type *type, int spaces)
4160 {
4161   struct type *descriptive_type = TYPE_DESCRIPTIVE_TYPE (type);
4162
4163   if (descriptive_type == NULL)
4164     printfi_filtered (spaces + 2, "no descriptive type\n");
4165   else
4166     {
4167       printfi_filtered (spaces + 2, "descriptive type\n");
4168       recursive_dump_type (descriptive_type, spaces + 4);
4169     }
4170 }
4171
4172 static struct obstack dont_print_type_obstack;
4173
4174 void
4175 recursive_dump_type (struct type *type, int spaces)
4176 {
4177   int idx;
4178
4179   if (spaces == 0)
4180     obstack_begin (&dont_print_type_obstack, 0);
4181
4182   if (TYPE_NFIELDS (type) > 0
4183       || (HAVE_CPLUS_STRUCT (type) && TYPE_NFN_FIELDS (type) > 0))
4184     {
4185       struct type **first_dont_print
4186         = (struct type **) obstack_base (&dont_print_type_obstack);
4187
4188       int i = (struct type **) 
4189         obstack_next_free (&dont_print_type_obstack) - first_dont_print;
4190
4191       while (--i >= 0)
4192         {
4193           if (type == first_dont_print[i])
4194             {
4195               printfi_filtered (spaces, "type node ");
4196               gdb_print_host_address (type, gdb_stdout);
4197               printf_filtered (_(" <same as already seen type>\n"));
4198               return;
4199             }
4200         }
4201
4202       obstack_ptr_grow (&dont_print_type_obstack, type);
4203     }
4204
4205   printfi_filtered (spaces, "type node ");
4206   gdb_print_host_address (type, gdb_stdout);
4207   printf_filtered ("\n");
4208   printfi_filtered (spaces, "name '%s' (",
4209                     TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
4210   gdb_print_host_address (TYPE_NAME (type), gdb_stdout);
4211   printf_filtered (")\n");
4212   printfi_filtered (spaces, "tagname '%s' (",
4213                     TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : "<NULL>");
4214   gdb_print_host_address (TYPE_TAG_NAME (type), gdb_stdout);
4215   printf_filtered (")\n");
4216   printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
4217   switch (TYPE_CODE (type))
4218     {
4219     case TYPE_CODE_UNDEF:
4220       printf_filtered ("(TYPE_CODE_UNDEF)");
4221       break;
4222     case TYPE_CODE_PTR:
4223       printf_filtered ("(TYPE_CODE_PTR)");
4224       break;
4225     case TYPE_CODE_ARRAY:
4226       printf_filtered ("(TYPE_CODE_ARRAY)");
4227       break;
4228     case TYPE_CODE_STRUCT:
4229       printf_filtered ("(TYPE_CODE_STRUCT)");
4230       break;
4231     case TYPE_CODE_UNION:
4232       printf_filtered ("(TYPE_CODE_UNION)");
4233       break;
4234     case TYPE_CODE_ENUM:
4235       printf_filtered ("(TYPE_CODE_ENUM)");
4236       break;
4237     case TYPE_CODE_FLAGS:
4238       printf_filtered ("(TYPE_CODE_FLAGS)");
4239       break;
4240     case TYPE_CODE_FUNC:
4241       printf_filtered ("(TYPE_CODE_FUNC)");
4242       break;
4243     case TYPE_CODE_INT:
4244       printf_filtered ("(TYPE_CODE_INT)");
4245       break;
4246     case TYPE_CODE_FLT:
4247       printf_filtered ("(TYPE_CODE_FLT)");
4248       break;
4249     case TYPE_CODE_VOID:
4250       printf_filtered ("(TYPE_CODE_VOID)");
4251       break;
4252     case TYPE_CODE_SET:
4253       printf_filtered ("(TYPE_CODE_SET)");
4254       break;
4255     case TYPE_CODE_RANGE:
4256       printf_filtered ("(TYPE_CODE_RANGE)");
4257       break;
4258     case TYPE_CODE_STRING:
4259       printf_filtered ("(TYPE_CODE_STRING)");
4260       break;
4261     case TYPE_CODE_ERROR:
4262       printf_filtered ("(TYPE_CODE_ERROR)");
4263       break;
4264     case TYPE_CODE_MEMBERPTR:
4265       printf_filtered ("(TYPE_CODE_MEMBERPTR)");
4266       break;
4267     case TYPE_CODE_METHODPTR:
4268       printf_filtered ("(TYPE_CODE_METHODPTR)");
4269       break;
4270     case TYPE_CODE_METHOD:
4271       printf_filtered ("(TYPE_CODE_METHOD)");
4272       break;
4273     case TYPE_CODE_REF:
4274       printf_filtered ("(TYPE_CODE_REF)");
4275       break;
4276     case TYPE_CODE_CHAR:
4277       printf_filtered ("(TYPE_CODE_CHAR)");
4278       break;
4279     case TYPE_CODE_BOOL:
4280       printf_filtered ("(TYPE_CODE_BOOL)");
4281       break;
4282     case TYPE_CODE_COMPLEX:
4283       printf_filtered ("(TYPE_CODE_COMPLEX)");
4284       break;
4285     case TYPE_CODE_TYPEDEF:
4286       printf_filtered ("(TYPE_CODE_TYPEDEF)");
4287       break;
4288     case TYPE_CODE_NAMESPACE:
4289       printf_filtered ("(TYPE_CODE_NAMESPACE)");
4290       break;
4291     default:
4292       printf_filtered ("(UNKNOWN TYPE CODE)");
4293       break;
4294     }
4295   puts_filtered ("\n");
4296   printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
4297   if (TYPE_OBJFILE_OWNED (type))
4298     {
4299       printfi_filtered (spaces, "objfile ");
4300       gdb_print_host_address (TYPE_OWNER (type).objfile, gdb_stdout);
4301     }
4302   else
4303     {
4304       printfi_filtered (spaces, "gdbarch ");
4305       gdb_print_host_address (TYPE_OWNER (type).gdbarch, gdb_stdout);
4306     }
4307   printf_filtered ("\n");
4308   printfi_filtered (spaces, "target_type ");
4309   gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout);
4310   printf_filtered ("\n");
4311   if (TYPE_TARGET_TYPE (type) != NULL)
4312     {
4313       recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
4314     }
4315   printfi_filtered (spaces, "pointer_type ");
4316   gdb_print_host_address (TYPE_POINTER_TYPE (type), gdb_stdout);
4317   printf_filtered ("\n");
4318   printfi_filtered (spaces, "reference_type ");
4319   gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
4320   printf_filtered ("\n");
4321   printfi_filtered (spaces, "type_chain ");
4322   gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);
4323   printf_filtered ("\n");
4324   printfi_filtered (spaces, "instance_flags 0x%x", 
4325                     TYPE_INSTANCE_FLAGS (type));
4326   if (TYPE_CONST (type))
4327     {
4328       puts_filtered (" TYPE_CONST");
4329     }
4330   if (TYPE_VOLATILE (type))
4331     {
4332       puts_filtered (" TYPE_VOLATILE");
4333     }
4334   if (TYPE_CODE_SPACE (type))
4335     {
4336       puts_filtered (" TYPE_CODE_SPACE");
4337     }
4338   if (TYPE_DATA_SPACE (type))
4339     {
4340       puts_filtered (" TYPE_DATA_SPACE");
4341     }
4342   if (TYPE_ADDRESS_CLASS_1 (type))
4343     {
4344       puts_filtered (" TYPE_ADDRESS_CLASS_1");
4345     }
4346   if (TYPE_ADDRESS_CLASS_2 (type))
4347     {
4348       puts_filtered (" TYPE_ADDRESS_CLASS_2");
4349     }
4350   if (TYPE_RESTRICT (type))
4351     {
4352       puts_filtered (" TYPE_RESTRICT");
4353     }
4354   if (TYPE_ATOMIC (type))
4355     {
4356       puts_filtered (" TYPE_ATOMIC");
4357     }
4358   puts_filtered ("\n");
4359
4360   printfi_filtered (spaces, "flags");
4361   if (TYPE_UNSIGNED (type))
4362     {
4363       puts_filtered (" TYPE_UNSIGNED");
4364     }
4365   if (TYPE_NOSIGN (type))
4366     {
4367       puts_filtered (" TYPE_NOSIGN");
4368     }
4369   if (TYPE_STUB (type))
4370     {
4371       puts_filtered (" TYPE_STUB");
4372     }
4373   if (TYPE_TARGET_STUB (type))
4374     {
4375       puts_filtered (" TYPE_TARGET_STUB");
4376     }
4377   if (TYPE_STATIC (type))
4378     {
4379       puts_filtered (" TYPE_STATIC");
4380     }
4381   if (TYPE_PROTOTYPED (type))
4382     {
4383       puts_filtered (" TYPE_PROTOTYPED");
4384     }
4385   if (TYPE_INCOMPLETE (type))
4386     {
4387       puts_filtered (" TYPE_INCOMPLETE");
4388     }
4389   if (TYPE_VARARGS (type))
4390     {
4391       puts_filtered (" TYPE_VARARGS");
4392     }
4393   /* This is used for things like AltiVec registers on ppc.  Gcc emits
4394      an attribute for the array type, which tells whether or not we
4395      have a vector, instead of a regular array.  */
4396   if (TYPE_VECTOR (type))
4397     {
4398       puts_filtered (" TYPE_VECTOR");
4399     }
4400   if (TYPE_FIXED_INSTANCE (type))
4401     {
4402       puts_filtered (" TYPE_FIXED_INSTANCE");
4403     }
4404   if (TYPE_STUB_SUPPORTED (type))
4405     {
4406       puts_filtered (" TYPE_STUB_SUPPORTED");
4407     }
4408   if (TYPE_NOTTEXT (type))
4409     {
4410       puts_filtered (" TYPE_NOTTEXT");
4411     }
4412   puts_filtered ("\n");
4413   printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
4414   gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
4415   puts_filtered ("\n");
4416   for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
4417     {
4418       if (TYPE_CODE (type) == TYPE_CODE_ENUM)
4419         printfi_filtered (spaces + 2,
4420                           "[%d] enumval %s type ",
4421                           idx, plongest (TYPE_FIELD_ENUMVAL (type, idx)));
4422       else
4423         printfi_filtered (spaces + 2,
4424                           "[%d] bitpos %s bitsize %d type ",
4425                           idx, plongest (TYPE_FIELD_BITPOS (type, idx)),
4426                           TYPE_FIELD_BITSIZE (type, idx));
4427       gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
4428       printf_filtered (" name '%s' (",
4429                        TYPE_FIELD_NAME (type, idx) != NULL
4430                        ? TYPE_FIELD_NAME (type, idx)
4431                        : "<NULL>");
4432       gdb_print_host_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
4433       printf_filtered (")\n");
4434       if (TYPE_FIELD_TYPE (type, idx) != NULL)
4435         {
4436           recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
4437         }
4438     }
4439   if (TYPE_CODE (type) == TYPE_CODE_RANGE)
4440     {
4441       printfi_filtered (spaces, "low %s%s  high %s%s\n",
4442                         plongest (TYPE_LOW_BOUND (type)), 
4443                         TYPE_LOW_BOUND_UNDEFINED (type) ? " (undefined)" : "",
4444                         plongest (TYPE_HIGH_BOUND (type)),
4445                         TYPE_HIGH_BOUND_UNDEFINED (type) 
4446                         ? " (undefined)" : "");
4447     }
4448
4449   switch (TYPE_SPECIFIC_FIELD (type))
4450     {
4451       case TYPE_SPECIFIC_CPLUS_STUFF:
4452         printfi_filtered (spaces, "cplus_stuff ");
4453         gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), 
4454                                 gdb_stdout);
4455         puts_filtered ("\n");
4456         print_cplus_stuff (type, spaces);
4457         break;
4458
4459       case TYPE_SPECIFIC_GNAT_STUFF:
4460         printfi_filtered (spaces, "gnat_stuff ");
4461         gdb_print_host_address (TYPE_GNAT_SPECIFIC (type), gdb_stdout);
4462         puts_filtered ("\n");
4463         print_gnat_stuff (type, spaces);
4464         break;
4465
4466       case TYPE_SPECIFIC_FLOATFORMAT:
4467         printfi_filtered (spaces, "floatformat ");
4468         if (TYPE_FLOATFORMAT (type) == NULL)
4469           puts_filtered ("(null)");
4470         else
4471           {
4472             puts_filtered ("{ ");
4473             if (TYPE_FLOATFORMAT (type)[0] == NULL
4474                 || TYPE_FLOATFORMAT (type)[0]->name == NULL)
4475               puts_filtered ("(null)");
4476             else
4477               puts_filtered (TYPE_FLOATFORMAT (type)[0]->name);
4478
4479             puts_filtered (", ");
4480             if (TYPE_FLOATFORMAT (type)[1] == NULL
4481                 || TYPE_FLOATFORMAT (type)[1]->name == NULL)
4482               puts_filtered ("(null)");
4483             else
4484               puts_filtered (TYPE_FLOATFORMAT (type)[1]->name);
4485
4486             puts_filtered (" }");
4487           }
4488         puts_filtered ("\n");
4489         break;
4490
4491       case TYPE_SPECIFIC_FUNC:
4492         printfi_filtered (spaces, "calling_convention %d\n",
4493                           TYPE_CALLING_CONVENTION (type));
4494         /* tail_call_list is not printed.  */
4495         break;
4496
4497       case TYPE_SPECIFIC_SELF_TYPE:
4498         printfi_filtered (spaces, "self_type ");
4499         gdb_print_host_address (TYPE_SELF_TYPE (type), gdb_stdout);
4500         puts_filtered ("\n");
4501         break;
4502     }
4503
4504   if (spaces == 0)
4505     obstack_free (&dont_print_type_obstack, NULL);
4506 }
4507 \f
4508 /* Trivial helpers for the libiberty hash table, for mapping one
4509    type to another.  */
4510
4511 struct type_pair
4512 {
4513   struct type *old, *newobj;
4514 };
4515
4516 static hashval_t
4517 type_pair_hash (const void *item)
4518 {
4519   const struct type_pair *pair = (const struct type_pair *) item;
4520
4521   return htab_hash_pointer (pair->old);
4522 }
4523
4524 static int
4525 type_pair_eq (const void *item_lhs, const void *item_rhs)
4526 {
4527   const struct type_pair *lhs = (const struct type_pair *) item_lhs;
4528   const struct type_pair *rhs = (const struct type_pair *) item_rhs;
4529
4530   return lhs->old == rhs->old;
4531 }
4532
4533 /* Allocate the hash table used by copy_type_recursive to walk
4534    types without duplicates.  We use OBJFILE's obstack, because
4535    OBJFILE is about to be deleted.  */
4536
4537 htab_t
4538 create_copied_types_hash (struct objfile *objfile)
4539 {
4540   return htab_create_alloc_ex (1, type_pair_hash, type_pair_eq,
4541                                NULL, &objfile->objfile_obstack,
4542                                hashtab_obstack_allocate,
4543                                dummy_obstack_deallocate);
4544 }
4545
4546 /* Recursively copy (deep copy) a dynamic attribute list of a type.  */
4547
4548 static struct dynamic_prop_list *
4549 copy_dynamic_prop_list (struct obstack *objfile_obstack,
4550                         struct dynamic_prop_list *list)
4551 {
4552   struct dynamic_prop_list *copy = list;
4553   struct dynamic_prop_list **node_ptr = &copy;
4554
4555   while (*node_ptr != NULL)
4556     {
4557       struct dynamic_prop_list *node_copy;
4558
4559       node_copy = ((struct dynamic_prop_list *)
4560                    obstack_copy (objfile_obstack, *node_ptr,
4561                                  sizeof (struct dynamic_prop_list)));
4562       node_copy->prop = (*node_ptr)->prop;
4563       *node_ptr = node_copy;
4564
4565       node_ptr = &node_copy->next;
4566     }
4567
4568   return copy;
4569 }
4570
4571 /* Recursively copy (deep copy) TYPE, if it is associated with
4572    OBJFILE.  Return a new type owned by the gdbarch associated with the type, a
4573    saved type if we have already visited TYPE (using COPIED_TYPES), or TYPE if
4574    it is not associated with OBJFILE.  */
4575
4576 struct type *
4577 copy_type_recursive (struct objfile *objfile, 
4578                      struct type *type,
4579                      htab_t copied_types)
4580 {
4581   struct type_pair *stored, pair;
4582   void **slot;
4583   struct type *new_type;
4584
4585   if (! TYPE_OBJFILE_OWNED (type))
4586     return type;
4587
4588   /* This type shouldn't be pointing to any types in other objfiles;
4589      if it did, the type might disappear unexpectedly.  */
4590   gdb_assert (TYPE_OBJFILE (type) == objfile);
4591
4592   pair.old = type;
4593   slot = htab_find_slot (copied_types, &pair, INSERT);
4594   if (*slot != NULL)
4595     return ((struct type_pair *) *slot)->newobj;
4596
4597   new_type = alloc_type_arch (get_type_arch (type));
4598
4599   /* We must add the new type to the hash table immediately, in case
4600      we encounter this type again during a recursive call below.  */
4601   stored = XOBNEW (&objfile->objfile_obstack, struct type_pair);
4602   stored->old = type;
4603   stored->newobj = new_type;
4604   *slot = stored;
4605
4606   /* Copy the common fields of types.  For the main type, we simply
4607      copy the entire thing and then update specific fields as needed.  */
4608   *TYPE_MAIN_TYPE (new_type) = *TYPE_MAIN_TYPE (type);
4609   TYPE_OBJFILE_OWNED (new_type) = 0;
4610   TYPE_OWNER (new_type).gdbarch = get_type_arch (type);
4611
4612   if (TYPE_NAME (type))
4613     TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type));
4614   if (TYPE_TAG_NAME (type))
4615     TYPE_TAG_NAME (new_type) = xstrdup (TYPE_TAG_NAME (type));
4616
4617   TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
4618   TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
4619
4620   /* Copy the fields.  */
4621   if (TYPE_NFIELDS (type))
4622     {
4623       int i, nfields;
4624
4625       nfields = TYPE_NFIELDS (type);
4626       TYPE_FIELDS (new_type) = XCNEWVEC (struct field, nfields);
4627       for (i = 0; i < nfields; i++)
4628         {
4629           TYPE_FIELD_ARTIFICIAL (new_type, i) = 
4630             TYPE_FIELD_ARTIFICIAL (type, i);
4631           TYPE_FIELD_BITSIZE (new_type, i) = TYPE_FIELD_BITSIZE (type, i);
4632           if (TYPE_FIELD_TYPE (type, i))
4633             TYPE_FIELD_TYPE (new_type, i)
4634               = copy_type_recursive (objfile, TYPE_FIELD_TYPE (type, i),
4635                                      copied_types);
4636           if (TYPE_FIELD_NAME (type, i))
4637             TYPE_FIELD_NAME (new_type, i) = 
4638               xstrdup (TYPE_FIELD_NAME (type, i));
4639           switch (TYPE_FIELD_LOC_KIND (type, i))
4640             {
4641             case FIELD_LOC_KIND_BITPOS:
4642               SET_FIELD_BITPOS (TYPE_FIELD (new_type, i),
4643                                 TYPE_FIELD_BITPOS (type, i));
4644               break;
4645             case FIELD_LOC_KIND_ENUMVAL:
4646               SET_FIELD_ENUMVAL (TYPE_FIELD (new_type, i),
4647                                  TYPE_FIELD_ENUMVAL (type, i));
4648               break;
4649             case FIELD_LOC_KIND_PHYSADDR:
4650               SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i),
4651                                   TYPE_FIELD_STATIC_PHYSADDR (type, i));
4652               break;
4653             case FIELD_LOC_KIND_PHYSNAME:
4654               SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i),
4655                                   xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type,
4656                                                                        i)));
4657               break;
4658             default:
4659               internal_error (__FILE__, __LINE__,
4660                               _("Unexpected type field location kind: %d"),
4661                               TYPE_FIELD_LOC_KIND (type, i));
4662             }
4663         }
4664     }
4665
4666   /* For range types, copy the bounds information.  */
4667   if (TYPE_CODE (type) == TYPE_CODE_RANGE)
4668     {
4669       TYPE_RANGE_DATA (new_type) = XNEW (struct range_bounds);
4670       *TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type);
4671     }
4672
4673   if (TYPE_DYN_PROP_LIST (type) != NULL)
4674     TYPE_DYN_PROP_LIST (new_type)
4675       = copy_dynamic_prop_list (&objfile->objfile_obstack,
4676                                 TYPE_DYN_PROP_LIST (type));
4677
4678
4679   /* Copy pointers to other types.  */
4680   if (TYPE_TARGET_TYPE (type))
4681     TYPE_TARGET_TYPE (new_type) = 
4682       copy_type_recursive (objfile, 
4683                            TYPE_TARGET_TYPE (type),
4684                            copied_types);
4685
4686   /* Maybe copy the type_specific bits.
4687
4688      NOTE drow/2005-12-09: We do not copy the C++-specific bits like
4689      base classes and methods.  There's no fundamental reason why we
4690      can't, but at the moment it is not needed.  */
4691
4692   switch (TYPE_SPECIFIC_FIELD (type))
4693     {
4694     case TYPE_SPECIFIC_NONE:
4695       break;
4696     case TYPE_SPECIFIC_FUNC:
4697       INIT_FUNC_SPECIFIC (new_type);
4698       TYPE_CALLING_CONVENTION (new_type) = TYPE_CALLING_CONVENTION (type);
4699       TYPE_NO_RETURN (new_type) = TYPE_NO_RETURN (type);
4700       TYPE_TAIL_CALL_LIST (new_type) = NULL;
4701       break;
4702     case TYPE_SPECIFIC_FLOATFORMAT:
4703       TYPE_FLOATFORMAT (new_type) = TYPE_FLOATFORMAT (type);
4704       break;
4705     case TYPE_SPECIFIC_CPLUS_STUFF:
4706       INIT_CPLUS_SPECIFIC (new_type);
4707       break;
4708     case TYPE_SPECIFIC_GNAT_STUFF:
4709       INIT_GNAT_SPECIFIC (new_type);
4710       break;
4711     case TYPE_SPECIFIC_SELF_TYPE:
4712       set_type_self_type (new_type,
4713                           copy_type_recursive (objfile, TYPE_SELF_TYPE (type),
4714                                                copied_types));
4715       break;
4716     default:
4717       gdb_assert_not_reached ("bad type_specific_kind");
4718     }
4719
4720   return new_type;
4721 }
4722
4723 /* Make a copy of the given TYPE, except that the pointer & reference
4724    types are not preserved.
4725    
4726    This function assumes that the given type has an associated objfile.
4727    This objfile is used to allocate the new type.  */
4728
4729 struct type *
4730 copy_type (const struct type *type)
4731 {
4732   struct type *new_type;
4733
4734   gdb_assert (TYPE_OBJFILE_OWNED (type));
4735
4736   new_type = alloc_type_copy (type);
4737   TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
4738   TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
4739   memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type),
4740           sizeof (struct main_type));
4741   if (TYPE_DYN_PROP_LIST (type) != NULL)
4742     TYPE_DYN_PROP_LIST (new_type)
4743       = copy_dynamic_prop_list (&TYPE_OBJFILE (type) -> objfile_obstack,
4744                                 TYPE_DYN_PROP_LIST (type));
4745
4746   return new_type;
4747 }
4748 \f
4749 /* Helper functions to initialize architecture-specific types.  */
4750
4751 /* Allocate a type structure associated with GDBARCH and set its
4752    CODE, LENGTH, and NAME fields.  */
4753
4754 struct type *
4755 arch_type (struct gdbarch *gdbarch,
4756            enum type_code code, int length, const char *name)
4757 {
4758   struct type *type;
4759
4760   type = alloc_type_arch (gdbarch);
4761   set_type_code (type, code);
4762   TYPE_LENGTH (type) = length;
4763
4764   if (name)
4765     TYPE_NAME (type) = gdbarch_obstack_strdup (gdbarch, name);
4766
4767   return type;
4768 }
4769
4770 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
4771    BIT is the type size in bits.  If UNSIGNED_P is non-zero, set
4772    the type's TYPE_UNSIGNED flag.  NAME is the type name.  */
4773
4774 struct type *
4775 arch_integer_type (struct gdbarch *gdbarch,
4776                    int bit, int unsigned_p, const char *name)
4777 {
4778   struct type *t;
4779
4780   t = arch_type (gdbarch, TYPE_CODE_INT, bit / TARGET_CHAR_BIT, name);
4781   if (unsigned_p)
4782     TYPE_UNSIGNED (t) = 1;
4783   if (name && strcmp (name, "char") == 0)
4784     TYPE_NOSIGN (t) = 1;
4785
4786   return t;
4787 }
4788
4789 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
4790    BIT is the type size in bits.  If UNSIGNED_P is non-zero, set
4791    the type's TYPE_UNSIGNED flag.  NAME is the type name.  */
4792
4793 struct type *
4794 arch_character_type (struct gdbarch *gdbarch,
4795                      int bit, int unsigned_p, const char *name)
4796 {
4797   struct type *t;
4798
4799   t = arch_type (gdbarch, TYPE_CODE_CHAR, bit / TARGET_CHAR_BIT, name);
4800   if (unsigned_p)
4801     TYPE_UNSIGNED (t) = 1;
4802
4803   return t;
4804 }
4805
4806 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
4807    BIT is the type size in bits.  If UNSIGNED_P is non-zero, set
4808    the type's TYPE_UNSIGNED flag.  NAME is the type name.  */
4809
4810 struct type *
4811 arch_boolean_type (struct gdbarch *gdbarch,
4812                    int bit, int unsigned_p, const char *name)
4813 {
4814   struct type *t;
4815
4816   t = arch_type (gdbarch, TYPE_CODE_BOOL, bit / TARGET_CHAR_BIT, name);
4817   if (unsigned_p)
4818     TYPE_UNSIGNED (t) = 1;
4819
4820   return t;
4821 }
4822
4823 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
4824    BIT is the type size in bits; if BIT equals -1, the size is
4825    determined by the floatformat.  NAME is the type name.  Set the
4826    TYPE_FLOATFORMAT from FLOATFORMATS.  */
4827
4828 struct type *
4829 arch_float_type (struct gdbarch *gdbarch,
4830                  int bit, const char *name,
4831                  const struct floatformat **floatformats)
4832 {
4833   struct type *t;
4834
4835   bit = verify_floatformat (bit, floatformats);
4836   t = arch_type (gdbarch, TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, name);
4837   TYPE_FLOATFORMAT (t) = floatformats;
4838
4839   return t;
4840 }
4841
4842 /* Allocate a TYPE_CODE_DECFLOAT type structure associated with GDBARCH.
4843    BIT is the type size in bits.  NAME is the type name.  */
4844
4845 struct type *
4846 arch_decfloat_type (struct gdbarch *gdbarch, int bit, const char *name)
4847 {
4848   struct type *t;
4849
4850   t = arch_type (gdbarch, TYPE_CODE_DECFLOAT, bit / TARGET_CHAR_BIT, name);
4851   return t;
4852 }
4853
4854 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
4855    NAME is the type name.  TARGET_TYPE is the component float type.  */
4856
4857 struct type *
4858 arch_complex_type (struct gdbarch *gdbarch,
4859                    const char *name, struct type *target_type)
4860 {
4861   struct type *t;
4862
4863   t = arch_type (gdbarch, TYPE_CODE_COMPLEX,
4864                  2 * TYPE_LENGTH (target_type), name);
4865   TYPE_TARGET_TYPE (t) = target_type;
4866   return t;
4867 }
4868
4869 /* Allocate a TYPE_CODE_PTR type structure associated with GDBARCH.
4870    BIT is the pointer type size in bits.  NAME is the type name.
4871    TARGET_TYPE is the pointer target type.  Always sets the pointer type's
4872    TYPE_UNSIGNED flag.  */
4873
4874 struct type *
4875 arch_pointer_type (struct gdbarch *gdbarch,
4876                    int bit, const char *name, struct type *target_type)
4877 {
4878   struct type *t;
4879
4880   t = arch_type (gdbarch, TYPE_CODE_PTR, bit / TARGET_CHAR_BIT, name);
4881   TYPE_TARGET_TYPE (t) = target_type;
4882   TYPE_UNSIGNED (t) = 1;
4883   return t;
4884 }
4885
4886 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
4887    NAME is the type name.  LENGTH is the size of the flag word in bytes.  */
4888
4889 struct type *
4890 arch_flags_type (struct gdbarch *gdbarch, const char *name, int length)
4891 {
4892   int max_nfields = length * TARGET_CHAR_BIT;
4893   struct type *type;
4894
4895   type = arch_type (gdbarch, TYPE_CODE_FLAGS, length, name);
4896   TYPE_UNSIGNED (type) = 1;
4897   TYPE_NFIELDS (type) = 0;
4898   /* Pre-allocate enough space assuming every field is one bit.  */
4899   TYPE_FIELDS (type)
4900     = (struct field *) TYPE_ZALLOC (type, max_nfields * sizeof (struct field));
4901
4902   return type;
4903 }
4904
4905 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
4906    position BITPOS is called NAME.  Pass NAME as "" for fields that
4907    should not be printed.  */
4908
4909 void
4910 append_flags_type_field (struct type *type, int start_bitpos, int nr_bits,
4911                          struct type *field_type, const char *name)
4912 {
4913   int type_bitsize = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
4914   int field_nr = TYPE_NFIELDS (type);
4915
4916   gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS);
4917   gdb_assert (TYPE_NFIELDS (type) + 1 <= type_bitsize);
4918   gdb_assert (start_bitpos >= 0 && start_bitpos < type_bitsize);
4919   gdb_assert (nr_bits >= 1 && nr_bits <= type_bitsize);
4920   gdb_assert (name != NULL);
4921
4922   TYPE_FIELD_NAME (type, field_nr) = xstrdup (name);
4923   TYPE_FIELD_TYPE (type, field_nr) = field_type;
4924   SET_FIELD_BITPOS (TYPE_FIELD (type, field_nr), start_bitpos);
4925   TYPE_FIELD_BITSIZE (type, field_nr) = nr_bits;
4926   ++TYPE_NFIELDS (type);
4927 }
4928
4929 /* Special version of append_flags_type_field to add a flag field.
4930    Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
4931    position BITPOS is called NAME.  */
4932
4933 void
4934 append_flags_type_flag (struct type *type, int bitpos, const char *name)
4935 {
4936   struct gdbarch *gdbarch = get_type_arch (type);
4937
4938   append_flags_type_field (type, bitpos, 1,
4939                            builtin_type (gdbarch)->builtin_bool,
4940                            name);
4941 }
4942
4943 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
4944    specified by CODE) associated with GDBARCH.  NAME is the type name.  */
4945
4946 struct type *
4947 arch_composite_type (struct gdbarch *gdbarch, const char *name,
4948                      enum type_code code)
4949 {
4950   struct type *t;
4951
4952   gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION);
4953   t = arch_type (gdbarch, code, 0, NULL);
4954   TYPE_TAG_NAME (t) = name;
4955   INIT_CPLUS_SPECIFIC (t);
4956   return t;
4957 }
4958
4959 /* Add new field with name NAME and type FIELD to composite type T.
4960    Do not set the field's position or adjust the type's length;
4961    the caller should do so.  Return the new field.  */
4962
4963 struct field *
4964 append_composite_type_field_raw (struct type *t, const char *name,
4965                                  struct type *field)
4966 {
4967   struct field *f;
4968
4969   TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
4970   TYPE_FIELDS (t) = XRESIZEVEC (struct field, TYPE_FIELDS (t),
4971                                 TYPE_NFIELDS (t));
4972   f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
4973   memset (f, 0, sizeof f[0]);
4974   FIELD_TYPE (f[0]) = field;
4975   FIELD_NAME (f[0]) = name;
4976   return f;
4977 }
4978
4979 /* Add new field with name NAME and type FIELD to composite type T.
4980    ALIGNMENT (if non-zero) specifies the minimum field alignment.  */
4981
4982 void
4983 append_composite_type_field_aligned (struct type *t, const char *name,
4984                                      struct type *field, int alignment)
4985 {
4986   struct field *f = append_composite_type_field_raw (t, name, field);
4987
4988   if (TYPE_CODE (t) == TYPE_CODE_UNION)
4989     {
4990       if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
4991         TYPE_LENGTH (t) = TYPE_LENGTH (field);
4992     }
4993   else if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
4994     {
4995       TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
4996       if (TYPE_NFIELDS (t) > 1)
4997         {
4998           SET_FIELD_BITPOS (f[0],
4999                             (FIELD_BITPOS (f[-1])
5000                              + (TYPE_LENGTH (FIELD_TYPE (f[-1]))
5001                                 * TARGET_CHAR_BIT)));
5002
5003           if (alignment)
5004             {
5005               int left;
5006
5007               alignment *= TARGET_CHAR_BIT;
5008               left = FIELD_BITPOS (f[0]) % alignment;
5009
5010               if (left)
5011                 {
5012                   SET_FIELD_BITPOS (f[0], FIELD_BITPOS (f[0]) + (alignment - left));
5013                   TYPE_LENGTH (t) += (alignment - left) / TARGET_CHAR_BIT;
5014                 }
5015             }
5016         }
5017     }
5018 }
5019
5020 /* Add new field with name NAME and type FIELD to composite type T.  */
5021
5022 void
5023 append_composite_type_field (struct type *t, const char *name,
5024                              struct type *field)
5025 {
5026   append_composite_type_field_aligned (t, name, field, 0);
5027 }
5028
5029 static struct gdbarch_data *gdbtypes_data;
5030
5031 const struct builtin_type *
5032 builtin_type (struct gdbarch *gdbarch)
5033 {
5034   return (const struct builtin_type *) gdbarch_data (gdbarch, gdbtypes_data);
5035 }
5036
5037 static void *
5038 gdbtypes_post_init (struct gdbarch *gdbarch)
5039 {
5040   struct builtin_type *builtin_type
5041     = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type);
5042
5043   /* Basic types.  */
5044   builtin_type->builtin_void
5045     = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
5046   builtin_type->builtin_char
5047     = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
5048                          !gdbarch_char_signed (gdbarch), "char");
5049   builtin_type->builtin_signed_char
5050     = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
5051                          0, "signed char");
5052   builtin_type->builtin_unsigned_char
5053     = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
5054                          1, "unsigned char");
5055   builtin_type->builtin_short
5056     = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
5057                          0, "short");
5058   builtin_type->builtin_unsigned_short
5059     = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
5060                          1, "unsigned short");
5061   builtin_type->builtin_int
5062     = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
5063                          0, "int");
5064   builtin_type->builtin_unsigned_int
5065     = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
5066                          1, "unsigned int");
5067   builtin_type->builtin_long
5068     = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
5069                          0, "long");
5070   builtin_type->builtin_unsigned_long
5071     = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
5072                          1, "unsigned long");
5073   builtin_type->builtin_long_long
5074     = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
5075                          0, "long long");
5076   builtin_type->builtin_unsigned_long_long
5077     = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
5078                          1, "unsigned long long");
5079   builtin_type->builtin_float
5080     = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
5081                        "float", gdbarch_float_format (gdbarch));
5082   builtin_type->builtin_double
5083     = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
5084                        "double", gdbarch_double_format (gdbarch));
5085   builtin_type->builtin_long_double
5086     = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
5087                        "long double", gdbarch_long_double_format (gdbarch));
5088   builtin_type->builtin_complex
5089     = arch_complex_type (gdbarch, "complex",
5090                          builtin_type->builtin_float);
5091   builtin_type->builtin_double_complex
5092     = arch_complex_type (gdbarch, "double complex",
5093                          builtin_type->builtin_double);
5094   builtin_type->builtin_string
5095     = arch_type (gdbarch, TYPE_CODE_STRING, 1, "string");
5096   builtin_type->builtin_bool
5097     = arch_type (gdbarch, TYPE_CODE_BOOL, 1, "bool");
5098
5099   /* The following three are about decimal floating point types, which
5100      are 32-bits, 64-bits and 128-bits respectively.  */
5101   builtin_type->builtin_decfloat
5102     = arch_decfloat_type (gdbarch, 32, "_Decimal32");
5103   builtin_type->builtin_decdouble
5104     = arch_decfloat_type (gdbarch, 64, "_Decimal64");
5105   builtin_type->builtin_declong
5106     = arch_decfloat_type (gdbarch, 128, "_Decimal128");
5107
5108   /* "True" character types.  */
5109   builtin_type->builtin_true_char
5110     = arch_character_type (gdbarch, TARGET_CHAR_BIT, 0, "true character");
5111   builtin_type->builtin_true_unsigned_char
5112     = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "true character");
5113
5114   /* Fixed-size integer types.  */
5115   builtin_type->builtin_int0
5116     = arch_integer_type (gdbarch, 0, 0, "int0_t");
5117   builtin_type->builtin_int8
5118     = arch_integer_type (gdbarch, 8, 0, "int8_t");
5119   builtin_type->builtin_uint8
5120     = arch_integer_type (gdbarch, 8, 1, "uint8_t");
5121   builtin_type->builtin_int16
5122     = arch_integer_type (gdbarch, 16, 0, "int16_t");
5123   builtin_type->builtin_uint16
5124     = arch_integer_type (gdbarch, 16, 1, "uint16_t");
5125   builtin_type->builtin_int32
5126     = arch_integer_type (gdbarch, 32, 0, "int32_t");
5127   builtin_type->builtin_uint32
5128     = arch_integer_type (gdbarch, 32, 1, "uint32_t");
5129   builtin_type->builtin_int64
5130     = arch_integer_type (gdbarch, 64, 0, "int64_t");
5131   builtin_type->builtin_uint64
5132     = arch_integer_type (gdbarch, 64, 1, "uint64_t");
5133   builtin_type->builtin_int128
5134     = arch_integer_type (gdbarch, 128, 0, "int128_t");
5135   builtin_type->builtin_uint128
5136     = arch_integer_type (gdbarch, 128, 1, "uint128_t");
5137   TYPE_INSTANCE_FLAGS (builtin_type->builtin_int8) |=
5138     TYPE_INSTANCE_FLAG_NOTTEXT;
5139   TYPE_INSTANCE_FLAGS (builtin_type->builtin_uint8) |=
5140     TYPE_INSTANCE_FLAG_NOTTEXT;
5141
5142   /* Wide character types.  */
5143   builtin_type->builtin_char16
5144     = arch_integer_type (gdbarch, 16, 0, "char16_t");
5145   builtin_type->builtin_char32
5146     = arch_integer_type (gdbarch, 32, 0, "char32_t");
5147         
5148
5149   /* Default data/code pointer types.  */
5150   builtin_type->builtin_data_ptr
5151     = lookup_pointer_type (builtin_type->builtin_void);
5152   builtin_type->builtin_func_ptr
5153     = lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
5154   builtin_type->builtin_func_func
5155     = lookup_function_type (builtin_type->builtin_func_ptr);
5156
5157   /* This type represents a GDB internal function.  */
5158   builtin_type->internal_fn
5159     = arch_type (gdbarch, TYPE_CODE_INTERNAL_FUNCTION, 0,
5160                  "<internal function>");
5161
5162   /* This type represents an xmethod.  */
5163   builtin_type->xmethod
5164     = arch_type (gdbarch, TYPE_CODE_XMETHOD, 0, "<xmethod>");
5165
5166   return builtin_type;
5167 }
5168
5169 /* This set of objfile-based types is intended to be used by symbol
5170    readers as basic types.  */
5171
5172 static const struct objfile_data *objfile_type_data;
5173
5174 const struct objfile_type *
5175 objfile_type (struct objfile *objfile)
5176 {
5177   struct gdbarch *gdbarch;
5178   struct objfile_type *objfile_type
5179     = (struct objfile_type *) objfile_data (objfile, objfile_type_data);
5180
5181   if (objfile_type)
5182     return objfile_type;
5183
5184   objfile_type = OBSTACK_CALLOC (&objfile->objfile_obstack,
5185                                  1, struct objfile_type);
5186
5187   /* Use the objfile architecture to determine basic type properties.  */
5188   gdbarch = get_objfile_arch (objfile);
5189
5190   /* Basic types.  */
5191   objfile_type->builtin_void
5192     = init_type (objfile, TYPE_CODE_VOID, 1, "void");
5193   objfile_type->builtin_char
5194     = init_integer_type (objfile, TARGET_CHAR_BIT,
5195                          !gdbarch_char_signed (gdbarch), "char");
5196   objfile_type->builtin_signed_char
5197     = init_integer_type (objfile, TARGET_CHAR_BIT,
5198                          0, "signed char");
5199   objfile_type->builtin_unsigned_char
5200     = init_integer_type (objfile, TARGET_CHAR_BIT,
5201                          1, "unsigned char");
5202   objfile_type->builtin_short
5203     = init_integer_type (objfile, gdbarch_short_bit (gdbarch),
5204                          0, "short");
5205   objfile_type->builtin_unsigned_short
5206     = init_integer_type (objfile, gdbarch_short_bit (gdbarch),
5207                          1, "unsigned short");
5208   objfile_type->builtin_int
5209     = init_integer_type (objfile, gdbarch_int_bit (gdbarch),
5210                          0, "int");
5211   objfile_type->builtin_unsigned_int
5212     = init_integer_type (objfile, gdbarch_int_bit (gdbarch),
5213                          1, "unsigned int");
5214   objfile_type->builtin_long
5215     = init_integer_type (objfile, gdbarch_long_bit (gdbarch),
5216                          0, "long");
5217   objfile_type->builtin_unsigned_long
5218     = init_integer_type (objfile, gdbarch_long_bit (gdbarch),
5219                          1, "unsigned long");
5220   objfile_type->builtin_long_long
5221     = init_integer_type (objfile, gdbarch_long_long_bit (gdbarch),
5222                          0, "long long");
5223   objfile_type->builtin_unsigned_long_long
5224     = init_integer_type (objfile, gdbarch_long_long_bit (gdbarch),
5225                          1, "unsigned long long");
5226   objfile_type->builtin_float
5227     = init_float_type (objfile, gdbarch_float_bit (gdbarch),
5228                        "float", gdbarch_float_format (gdbarch));
5229   objfile_type->builtin_double
5230     = init_float_type (objfile, gdbarch_double_bit (gdbarch),
5231                        "double", gdbarch_double_format (gdbarch));
5232   objfile_type->builtin_long_double
5233     = init_float_type (objfile, gdbarch_long_double_bit (gdbarch),
5234                        "long double", gdbarch_long_double_format (gdbarch));
5235
5236   /* This type represents a type that was unrecognized in symbol read-in.  */
5237   objfile_type->builtin_error
5238     = init_type (objfile, TYPE_CODE_ERROR, 0, "<unknown type>");
5239
5240   /* The following set of types is used for symbols with no
5241      debug information.  */
5242   objfile_type->nodebug_text_symbol
5243     = init_type (objfile, TYPE_CODE_FUNC, 1,
5244                  "<text variable, no debug info>");
5245   TYPE_TARGET_TYPE (objfile_type->nodebug_text_symbol)
5246     = objfile_type->builtin_int;
5247   objfile_type->nodebug_text_gnu_ifunc_symbol
5248     = init_type (objfile, TYPE_CODE_FUNC, 1,
5249                  "<text gnu-indirect-function variable, no debug info>");
5250   TYPE_TARGET_TYPE (objfile_type->nodebug_text_gnu_ifunc_symbol)
5251     = objfile_type->nodebug_text_symbol;
5252   TYPE_GNU_IFUNC (objfile_type->nodebug_text_gnu_ifunc_symbol) = 1;
5253   objfile_type->nodebug_got_plt_symbol
5254     = init_pointer_type (objfile, gdbarch_addr_bit (gdbarch),
5255                          "<text from jump slot in .got.plt, no debug info>",
5256                          objfile_type->nodebug_text_symbol);
5257   objfile_type->nodebug_data_symbol
5258     = init_integer_type (objfile, gdbarch_int_bit (gdbarch), 0,
5259                          "<data variable, no debug info>");
5260   objfile_type->nodebug_unknown_symbol
5261     = init_integer_type (objfile, TARGET_CHAR_BIT, 0,
5262                          "<variable (not text or data), no debug info>");
5263   objfile_type->nodebug_tls_symbol
5264     = init_integer_type (objfile, gdbarch_int_bit (gdbarch), 0,
5265                          "<thread local variable, no debug info>");
5266
5267   /* NOTE: on some targets, addresses and pointers are not necessarily
5268      the same.
5269
5270      The upshot is:
5271      - gdb's `struct type' always describes the target's
5272        representation.
5273      - gdb's `struct value' objects should always hold values in
5274        target form.
5275      - gdb's CORE_ADDR values are addresses in the unified virtual
5276        address space that the assembler and linker work with.  Thus,
5277        since target_read_memory takes a CORE_ADDR as an argument, it
5278        can access any memory on the target, even if the processor has
5279        separate code and data address spaces.
5280
5281      In this context, objfile_type->builtin_core_addr is a bit odd:
5282      it's a target type for a value the target will never see.  It's
5283      only used to hold the values of (typeless) linker symbols, which
5284      are indeed in the unified virtual address space.  */
5285
5286   objfile_type->builtin_core_addr
5287     = init_integer_type (objfile, gdbarch_addr_bit (gdbarch), 1,
5288                          "__CORE_ADDR");
5289
5290   set_objfile_data (objfile, objfile_type_data, objfile_type);
5291   return objfile_type;
5292 }
5293
5294 extern initialize_file_ftype _initialize_gdbtypes;
5295
5296 void
5297 _initialize_gdbtypes (void)
5298 {
5299   gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
5300   objfile_type_data = register_objfile_data ();
5301
5302   add_setshow_zuinteger_cmd ("overload", no_class, &overload_debug,
5303                              _("Set debugging of C++ overloading."),
5304                              _("Show debugging of C++ overloading."),
5305                              _("When enabled, ranking of the "
5306                                "functions is displayed."),
5307                              NULL,
5308                              show_overload_debug,
5309                              &setdebuglist, &showdebuglist);
5310
5311   /* Add user knob for controlling resolution of opaque types.  */
5312   add_setshow_boolean_cmd ("opaque-type-resolution", class_support,
5313                            &opaque_type_resolution,
5314                            _("Set resolution of opaque struct/class/union"
5315                              " types (if set before loading symbols)."),
5316                            _("Show resolution of opaque struct/class/union"
5317                              " types (if set before loading symbols)."),
5318                            NULL, NULL,
5319                            show_opaque_type_resolution,
5320                            &setlist, &showlist);
5321
5322   /* Add an option to permit non-strict type checking.  */
5323   add_setshow_boolean_cmd ("type", class_support,
5324                            &strict_type_checking,
5325                            _("Set strict type checking."),
5326                            _("Show strict type checking."),
5327                            NULL, NULL,
5328                            show_strict_type_checking,
5329                            &setchecklist, &showchecklist);
5330 }