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