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