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