GDB (API)
/tmp/gdb-7.10/gdb/gdbtypes.h
Go to the documentation of this file.
1 
2 /* Internal type definitions for GDB.
3 
4  Copyright (C) 1992-2015 Free Software Foundation, Inc.
5 
6  Contributed by Cygnus Support, using pieces from other GDB modules.
7 
8  This file is part of GDB.
9 
10  This program is free software; you can redistribute it and/or modify
11  it under the terms of the GNU General Public License as published by
12  the Free Software Foundation; either version 3 of the License, or
13  (at your option) any later version.
14 
15  This program is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  GNU General Public License for more details.
19 
20  You should have received a copy of the GNU General Public License
21  along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 
23 #if !defined (GDBTYPES_H)
24 #define GDBTYPES_H 1
25 
26 /* * \page gdbtypes GDB Types
27 
28  GDB represents all the different kinds of types in programming
29  languages using a common representation defined in gdbtypes.h.
30 
31  The main data structure is main_type; it consists of a code (such
32  as #TYPE_CODE_ENUM for enumeration types), a number of
33  generally-useful fields such as the printable name, and finally a
34  field main_type::type_specific that is a union of info specific to
35  particular languages or other special cases (such as calling
36  convention).
37 
38  The available type codes are defined in enum #type_code. The enum
39  includes codes both for types that are common across a variety
40  of languages, and for types that are language-specific.
41 
42  Most accesses to type fields go through macros such as
43  #TYPE_CODE(thistype) and #TYPE_FN_FIELD_CONST(thisfn, n). These are
44  written such that they can be used as both rvalues and lvalues.
45  */
46 
47 #include "hashtab.h"
48 
49 /* Forward declarations for prototypes. */
50 struct field;
51 struct block;
52 struct value_print_options;
53 struct language_defn;
54 
55 /* These declarations are DWARF-specific as some of the gdbtypes.h data types
56  are already DWARF-specific. */
57 
58 /* * Offset relative to the start of its containing CU (compilation
59  unit). */
60 typedef struct
61 {
62  unsigned int cu_off;
63 } cu_offset;
64 
65 /* * Offset relative to the start of its .debug_info or .debug_types
66  section. */
67 
68 typedef struct
69 {
70  unsigned int sect_off;
71 } sect_offset;
72 
73 /* Some macros for char-based bitfields. */
74 
75 #define B_SET(a,x) ((a)[(x)>>3] |= (1 << ((x)&7)))
76 #define B_CLR(a,x) ((a)[(x)>>3] &= ~(1 << ((x)&7)))
77 #define B_TST(a,x) ((a)[(x)>>3] & (1 << ((x)&7)))
78 #define B_TYPE unsigned char
79 #define B_BYTES(x) ( 1 + ((x)>>3) )
80 #define B_CLRALL(a,x) memset ((a), 0, B_BYTES(x))
81 
82 /* * Different kinds of data types are distinguished by the `code'
83  field. */
84 
86  {
91  /* * Array type with lower & upper bounds.
92 
93  Regardless of the language, GDB represents multidimensional
94  array types the way C does: as arrays of arrays. So an
95  instance of a GDB array type T can always be seen as a series
96  of instances of TYPE_TARGET_TYPE (T) laid out sequentially in
97  memory.
98 
99  Row-major languages like C lay out multi-dimensional arrays so
100  that incrementing the rightmost index in a subscripting
101  expression results in the smallest change in the address of the
102  element referred to. Column-major languages like Fortran lay
103  them out so that incrementing the leftmost index results in the
104  smallest change.
105 
106  This means that, in column-major languages, working our way
107  from type to target type corresponds to working through indices
108  from right to left, not left to right. */
110 
118  /* * Floating type. This is *NOT* a complex type. Beware, there
119  are parts of GDB which bogusly assume that TYPE_CODE_FLT can
120  mean complex. */
122 
123  /* * Void type. The length field specifies the length (probably
124  always one) which is used in pointer arithmetic involving
125  pointers to this type, but actually dereferencing such a
126  pointer is invalid; a void type has no length and no actual
127  representation in memory or registers. A pointer to a void
128  type is a generic pointer. */
130 
134  /* * A string type which is like an array of character but prints
135  differently. It does not contain a length field as Pascal
136  strings (for many Pascals, anyway) do; if we want to deal with
137  such strings, we should use a new type code. */
139 
140  /* * Unknown type. The length field is valid if we were able to
141  deduce that much about the type, or 0 if we don't even know
142  that. */
144 
145  /* C++ */
148  /* * Pointer-to-member-function type. This describes how to access a
149  particular member function of a class (possibly a virtual
150  member function). The representation may vary between different
151  C++ ABIs. */
153 
154  /* * Pointer-to-member type. This is the offset within a class to
155  some particular data member. The only currently supported
156  representation uses an unbiased offset, with -1 representing
157  NULL; this is used by the Itanium C++ ABI (used by GCC on all
158  platforms). */
160 
165  /* * Boolean type. 0 is false, 1 is true, and other values are
166  non-boolean (e.g. FORTRAN "logical" used as unsigned int). */
168 
169  /* Fortran */
173 
180  /* * Internal function type. */
182 
183  /* * Methods implemented in extension languages. */
185  };
186 
187 /* * Some constants representing each bit field in the main_type. See
188  the bit-field-specific macros, below, for documentation of each
189  constant in this enum. These enum values are only used with
190  init_type. Note that the values are chosen not to conflict with
191  type_instance_flag_value; this lets init_type error-check its
192  input. */
193 
195 {
196  TYPE_FLAG_UNSIGNED = (1 << 9),
197  TYPE_FLAG_NOSIGN = (1 << 10),
198  TYPE_FLAG_STUB = (1 << 11),
200  TYPE_FLAG_STATIC = (1 << 13),
201  TYPE_FLAG_PROTOTYPED = (1 << 14),
202  TYPE_FLAG_INCOMPLETE = (1 << 15),
203  TYPE_FLAG_VARARGS = (1 << 16),
204  TYPE_FLAG_VECTOR = (1 << 17),
207  TYPE_FLAG_GNU_IFUNC = (1 << 20),
208 
209  /* * Used for error-checking. */
211 };
212 
213 /* * Some bits for the type's instance_flags word. See the macros
214  below for documentation on each bit. Note that if you add a value
215  here, you must update the enum type_flag_value as well. */
216 
218 {
228 };
229 
230 /* * Unsigned integer type. If this is not set for a TYPE_CODE_INT,
231  the type is signed (unless TYPE_FLAG_NOSIGN (below) is set). */
232 
233 #define TYPE_UNSIGNED(t) (TYPE_MAIN_TYPE (t)->flag_unsigned)
234 
235 /* * No sign for this type. In C++, "char", "signed char", and
236  "unsigned char" are distinct types; so we need an extra flag to
237  indicate the absence of a sign! */
238 
239 #define TYPE_NOSIGN(t) (TYPE_MAIN_TYPE (t)->flag_nosign)
240 
241 /* * This appears in a type's flags word if it is a stub type (e.g.,
242  if someone referenced a type that wasn't defined in a source file
243  via (struct sir_not_appearing_in_this_film *)). */
244 
245 #define TYPE_STUB(t) (TYPE_MAIN_TYPE (t)->flag_stub)
246 
247 /* * The target type of this type is a stub type, and this type needs
248  to be updated if it gets un-stubbed in check_typedef. Used for
249  arrays and ranges, in which TYPE_LENGTH of the array/range gets set
250  based on the TYPE_LENGTH of the target type. Also, set for
251  TYPE_CODE_TYPEDEF. */
252 
253 #define TYPE_TARGET_STUB(t) (TYPE_MAIN_TYPE (t)->flag_target_stub)
254 
255 /* * Static type. If this is set, the corresponding type had
256  a static modifier.
257  Note: This may be unnecessary, since static data members
258  are indicated by other means (bitpos == -1). */
259 
260 #define TYPE_STATIC(t) (TYPE_MAIN_TYPE (t)->flag_static)
261 
262 /* * This is a function type which appears to have a prototype. We
263  need this for function calls in order to tell us if it's necessary
264  to coerce the args, or to just do the standard conversions. This
265  is used with a short field. */
266 
267 #define TYPE_PROTOTYPED(t) (TYPE_MAIN_TYPE (t)->flag_prototyped)
268 
269 /* * This flag is used to indicate that processing for this type
270  is incomplete.
271 
272  (Mostly intended for HP platforms, where class methods, for
273  instance, can be encountered before their classes in the debug
274  info; the incomplete type has to be marked so that the class and
275  the method can be assigned correct types.) */
276 
277 #define TYPE_INCOMPLETE(t) (TYPE_MAIN_TYPE (t)->flag_incomplete)
278 
279 /* * FIXME drow/2002-06-03: Only used for methods, but applies as well
280  to functions. */
281 
282 #define TYPE_VARARGS(t) (TYPE_MAIN_TYPE (t)->flag_varargs)
283 
284 /* * Identify a vector type. Gcc is handling this by adding an extra
285  attribute to the array type. We slurp that in as a new flag of a
286  type. This is used only in dwarf2read.c. */
287 #define TYPE_VECTOR(t) (TYPE_MAIN_TYPE (t)->flag_vector)
288 
289 /* * The debugging formats (especially STABS) do not contain enough
290  information to represent all Ada types---especially those whose
291  size depends on dynamic quantities. Therefore, the GNAT Ada
292  compiler includes extra information in the form of additional type
293  definitions connected by naming conventions. This flag indicates
294  that the type is an ordinary (unencoded) GDB type that has been
295  created from the necessary run-time information, and does not need
296  further interpretation. Optionally marks ordinary, fixed-size GDB
297  type. */
298 
299 #define TYPE_FIXED_INSTANCE(t) (TYPE_MAIN_TYPE (t)->flag_fixed_instance)
300 
301 /* * This debug target supports TYPE_STUB(t). In the unsupported case
302  we have to rely on NFIELDS to be zero etc., see TYPE_IS_OPAQUE().
303  TYPE_STUB(t) with !TYPE_STUB_SUPPORTED(t) may exist if we only
304  guessed the TYPE_STUB(t) value (see dwarfread.c). */
305 
306 #define TYPE_STUB_SUPPORTED(t) (TYPE_MAIN_TYPE (t)->flag_stub_supported)
307 
308 /* * Not textual. By default, GDB treats all single byte integers as
309  characters (or elements of strings) unless this flag is set. */
310 
311 #define TYPE_NOTTEXT(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_NOTTEXT)
312 
313 /* * Used only for TYPE_CODE_FUNC where it specifies the real function
314  address is returned by this function call. TYPE_TARGET_TYPE
315  determines the final returned function type to be presented to
316  user. */
317 
318 #define TYPE_GNU_IFUNC(t) (TYPE_MAIN_TYPE (t)->flag_gnu_ifunc)
319 
320 /* * Type owner. If TYPE_OBJFILE_OWNED is true, the type is owned by
321  the objfile retrieved as TYPE_OBJFILE. Otherweise, the type is
322  owned by an architecture; TYPE_OBJFILE is NULL in this case. */
323 
324 #define TYPE_OBJFILE_OWNED(t) (TYPE_MAIN_TYPE (t)->flag_objfile_owned)
325 #define TYPE_OWNER(t) TYPE_MAIN_TYPE(t)->owner
326 #define TYPE_OBJFILE(t) (TYPE_OBJFILE_OWNED(t)? TYPE_OWNER(t).objfile : NULL)
327 
328 /* * True if this type was declared using the "class" keyword. This is
329  only valid for C++ structure and enum types. If false, a structure
330  was declared as a "struct"; if true it was declared "class". For
331  enum types, this is true when "enum class" or "enum struct" was
332  used to declare the type.. */
333 
334 #define TYPE_DECLARED_CLASS(t) (TYPE_MAIN_TYPE (t)->flag_declared_class)
335 
336 /* * True if this type is a "flag" enum. A flag enum is one where all
337  the values are pairwise disjoint when "and"ed together. This
338  affects how enum values are printed. */
339 
340 #define TYPE_FLAG_ENUM(t) (TYPE_MAIN_TYPE (t)->flag_flag_enum)
341 
342 /* * Constant type. If this is set, the corresponding type has a
343  const modifier. */
344 
345 #define TYPE_CONST(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_CONST)
346 
347 /* * Volatile type. If this is set, the corresponding type has a
348  volatile modifier. */
349 
350 #define TYPE_VOLATILE(t) \
351  (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_VOLATILE)
352 
353 /* * Restrict type. If this is set, the corresponding type has a
354  restrict modifier. */
355 
356 #define TYPE_RESTRICT(t) \
357  (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_RESTRICT)
358 
359 /* * Atomic type. If this is set, the corresponding type has an
360  _Atomic modifier. */
361 
362 #define TYPE_ATOMIC(t) \
363  (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_ATOMIC)
364 
365 /* * Instruction-space delimited type. This is for Harvard architectures
366  which have separate instruction and data address spaces (and perhaps
367  others).
368 
369  GDB usually defines a flat address space that is a superset of the
370  architecture's two (or more) address spaces, but this is an extension
371  of the architecture's model.
372 
373  If TYPE_FLAG_INST is set, an object of the corresponding type
374  resides in instruction memory, even if its address (in the extended
375  flat address space) does not reflect this.
376 
377  Similarly, if TYPE_FLAG_DATA is set, then an object of the
378  corresponding type resides in the data memory space, even if
379  this is not indicated by its (flat address space) address.
380 
381  If neither flag is set, the default space for functions / methods
382  is instruction space, and for data objects is data memory. */
383 
384 #define TYPE_CODE_SPACE(t) \
385  (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_CODE_SPACE)
386 
387 #define TYPE_DATA_SPACE(t) \
388  (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_DATA_SPACE)
389 
390 /* * Address class flags. Some environments provide for pointers
391  whose size is different from that of a normal pointer or address
392  types where the bits are interpreted differently than normal
393  addresses. The TYPE_FLAG_ADDRESS_CLASS_n flags may be used in
394  target specific ways to represent these different types of address
395  classes. */
396 
397 #define TYPE_ADDRESS_CLASS_1(t) (TYPE_INSTANCE_FLAGS(t) \
398  & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
399 #define TYPE_ADDRESS_CLASS_2(t) (TYPE_INSTANCE_FLAGS(t) \
400  & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2)
401 #define TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL \
402  (TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2)
403 #define TYPE_ADDRESS_CLASS_ALL(t) (TYPE_INSTANCE_FLAGS(t) \
404  & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
405 
407 {
408  PROP_UNDEFINED, /* Not defined. */
409  PROP_CONST, /* Constant. */
410  PROP_ADDR_OFFSET, /* Address offset. */
411  PROP_LOCEXPR, /* Location expression. */
412  PROP_LOCLIST /* Location list. */
413 };
414 
416 {
417  /* Storage for constant property. */
418 
419  LONGEST const_val;
420 
421  /* Storage for dynamic property. */
422 
423  void *baton;
424 };
425 
426 /* * Used to store a dynamic property. */
427 
429 {
430  /* Determine which field of the union dynamic_prop.data is used. */
432 
433  /* Storage for dynamic or static value. */
435 };
436 
437 /* * Define a type's dynamic property node kind. */
439 {
440  /* A property providing a type's data location.
441  Evaluating this field yields to the location of an object's data. */
443 };
444 
445 /* * List for dynamic type attributes. */
447 {
448  /* The kind of dynamic prop in this node. */
450 
451  /* The dynamic property itself. */
453 
454  /* A pointer to the next dynamic property. */
456 };
457 
458 /* * Determine which field of the union main_type.fields[x].loc is
459  used. */
460 
462  {
468  };
469 
470 /* * A discriminant to determine which field in the
471  main_type.type_specific union is being used, if any.
472 
473  For types such as TYPE_CODE_FLT, the use of this
474  discriminant is really redundant, as we know from the type code
475  which field is going to be used. As such, it would be possible to
476  reduce the size of this enum in order to save a bit or two for
477  other fields of struct main_type. But, since we still have extra
478  room , and for the sake of clarity and consistency, we treat all fields
479  of the union the same way. */
480 
482 {
487  /* Note: This is used by TYPE_CODE_FUNC and TYPE_CODE_METHOD. */
490 };
491 
493 {
494  struct objfile *objfile;
495  struct gdbarch *gdbarch;
496 };
497 
499 {
500  /* * Position of this field, counting in bits from start of
501  containing structure. For gdbarch_bits_big_endian=1
502  targets, it is the bit offset to the MSB. For
503  gdbarch_bits_big_endian=0 targets, it is the bit offset to
504  the LSB. */
505 
506  int bitpos;
507 
508  /* * Enum value. */
509  LONGEST enumval;
510 
511  /* * For a static field, if TYPE_FIELD_STATIC_HAS_ADDR then
512  physaddr is the location (in the target) of the static
513  field. Otherwise, physname is the mangled label of the
514  static field. */
515 
516  CORE_ADDR physaddr;
517  const char *physname;
518 
519  /* * The field location can be computed by evaluating the
520  following DWARF block. Its DATA is allocated on
521  objfile_obstack - no CU load is needed to access it. */
522 
523  struct dwarf2_locexpr_baton *dwarf_block;
524 };
525 
526 struct field
527 {
529 
530  /* * For a function or member type, this is 1 if the argument is
531  marked artificial. Artificial arguments should not be shown
532  to the user. For TYPE_CODE_RANGE it is set if the specific
533  bound is not defined. */
534 
535  unsigned int artificial : 1;
536 
537  /* * Discriminant for union field_location. */
538 
539  ENUM_BITFIELD(field_loc_kind) loc_kind : 3;
540 
541  /* * Size of this field, in bits, or zero if not packed.
542  If non-zero in an array type, indicates the element size in
543  bits (used only in Ada at the moment).
544  For an unpacked field, the field's type's length
545  says how many bytes the field occupies. */
546 
547  unsigned int bitsize : 28;
548 
549  /* * In a struct or union type, type of this field.
550  - In a function or member type, type of this argument.
551  - In an array type, the domain-type of the array. */
552 
553  struct type *type;
554 
555  /* * Name of field, value or argument.
556  NULL for range bounds, array domains, and member function
557  arguments. */
558 
559  const char *name;
560 };
561 
563 {
564  /* * Low bound of range. */
565 
566  struct dynamic_prop low;
567 
568  /* * High bound of range. */
569 
570  struct dynamic_prop high;
571 
572  /* True if HIGH range bound contains the number of elements in the
573  subrange. This affects how the final hight bound is computed. */
574 
575  int flag_upper_bound_is_count : 1;
576 
577  /* True if LOW or/and HIGH are resolved into a static bound from
578  a dynamic one. */
579 
580  int flag_bound_evaluated : 1;
581 };
582 
584 {
585  /* * CPLUS_STUFF is for TYPE_CODE_STRUCT. It is initialized to
586  point to cplus_struct_default, a default static instance of a
587  struct cplus_struct_type. */
588 
590 
591  /* * GNAT_STUFF is for types for which the GNAT Ada compiler
592  provides additional information. */
593 
595 
596  /* * FLOATFORMAT is for TYPE_CODE_FLT. It is a pointer to two
597  floatformat objects that describe the floating-point value
598  that resides within the type. The first is for big endian
599  targets and the second is for little endian targets. */
600 
601  const struct floatformat **floatformat;
602 
603  /* * For TYPE_CODE_FUNC and TYPE_CODE_METHOD types. */
604 
606 
607  /* * For types that are pointer to member types (TYPE_CODE_METHODPTR,
608  TYPE_CODE_MEMBERPTR), SELF_TYPE is the type that this pointer
609  is a member of. */
610 
611  struct type *self_type;
612 };
613 
614 /* * Main structure representing a type in GDB.
615 
616  This structure is space-critical. Its layout has been tweaked to
617  reduce the space used. */
618 
619 struct main_type
620 {
621  /* * Code for kind of type. */
622 
623  ENUM_BITFIELD(type_code) code : 8;
624 
625  /* * Flags about this type. These fields appear at this location
626  because they packs nicely here. See the TYPE_* macros for
627  documentation about these fields. */
628 
629  unsigned int flag_unsigned : 1;
630  unsigned int flag_nosign : 1;
631  unsigned int flag_stub : 1;
632  unsigned int flag_target_stub : 1;
633  unsigned int flag_static : 1;
634  unsigned int flag_prototyped : 1;
635  unsigned int flag_incomplete : 1;
636  unsigned int flag_varargs : 1;
637  unsigned int flag_vector : 1;
638  unsigned int flag_stub_supported : 1;
639  unsigned int flag_gnu_ifunc : 1;
640  unsigned int flag_fixed_instance : 1;
641  unsigned int flag_objfile_owned : 1;
642 
643  /* * True if this type was declared with "class" rather than
644  "struct". */
645 
646  unsigned int flag_declared_class : 1;
647 
648  /* * True if this is an enum type with disjoint values. This
649  affects how the enum is printed. */
650 
651  unsigned int flag_flag_enum : 1;
652 
653  /* * A discriminant telling us which field of the type_specific
654  union is being used for this type, if any. */
655 
656  ENUM_BITFIELD(type_specific_kind) type_specific_field : 3;
657 
658  /* * Number of fields described for this type. This field appears
659  at this location because it packs nicely here. */
660 
661  short nfields;
662 
663  /* * Name of this type, or NULL if none.
664 
665  This is used for printing only, except by poorly designed C++
666  code. For looking up a name, look for a symbol in the
667  VAR_DOMAIN. This is generally allocated in the objfile's
668  obstack. However coffread.c uses malloc. */
669 
670  const char *name;
671 
672  /* * Tag name for this type, or NULL if none. This means that the
673  name of the type consists of a keyword followed by the tag name.
674  Which keyword is determined by the type code ("struct" for
675  TYPE_CODE_STRUCT, etc.). As far as I know C/C++ are the only
676  languages with this feature.
677 
678  This is used for printing only, except by poorly designed C++ code.
679  For looking up a name, look for a symbol in the STRUCT_DOMAIN.
680  One more legitimate use is that if TYPE_FLAG_STUB is set, this is
681  the name to use to look for definitions in other files. */
682 
683  const char *tag_name;
684 
685  /* * Every type is now associated with a particular objfile, and the
686  type is allocated on the objfile_obstack for that objfile. One
687  problem however, is that there are times when gdb allocates new
688  types while it is not in the process of reading symbols from a
689  particular objfile. Fortunately, these happen when the type
690  being created is a derived type of an existing type, such as in
691  lookup_pointer_type(). So we can just allocate the new type
692  using the same objfile as the existing type, but to do this we
693  need a backpointer to the objfile from the existing type. Yes
694  this is somewhat ugly, but without major overhaul of the internal
695  type system, it can't be avoided for now. */
696 
697  union type_owner owner;
698 
699  /* * For a pointer type, describes the type of object pointed to.
700  - For an array type, describes the type of the elements.
701  - For a function or method type, describes the type of the return value.
702  - For a range type, describes the type of the full range.
703  - For a complex type, describes the type of each coordinate.
704  - For a special record or union type encoding a dynamic-sized type
705  in GNAT, a memoized pointer to a corresponding static version of
706  the type.
707  - Unused otherwise. */
708 
709  struct type *target_type;
710 
711  /* * For structure and union types, a description of each field.
712  For set and pascal array types, there is one "field",
713  whose type is the domain type of the set or array.
714  For range types, there are two "fields",
715  the minimum and maximum values (both inclusive).
716  For enum types, each possible value is described by one "field".
717  For a function or method type, a "field" for each parameter.
718  For C++ classes, there is one field for each base class (if it is
719  a derived class) plus one field for each class data member. Member
720  functions are recorded elsewhere.
721 
722  Using a pointer to a separate array of fields
723  allows all types to have the same size, which is useful
724  because we can allocate the space for a type before
725  we know what to put in it. */
726 
727  union
728  {
729  struct field *fields;
730 
731  /* * Union member used for range types. */
732 
734 
735  } flds_bnds;
736 
737  /* * Slot to point to additional language-specific fields of this
738  type. */
739 
741 
742  /* * Contains all dynamic type properties. */
744 };
745 
746 /* * A ``struct type'' describes a particular instance of a type, with
747  some particular qualification. */
748 
749 struct type
750 {
751  /* * Type that is a pointer to this type.
752  NULL if no such pointer-to type is known yet.
753  The debugger may add the address of such a type
754  if it has to construct one later. */
755 
757 
758  /* * C++: also need a reference type. */
759 
761 
762  /* * Variant chain. This points to a type that differs from this
763  one only in qualifiers and length. Currently, the possible
764  qualifiers are const, volatile, code-space, data-space, and
765  address class. The length may differ only when one of the
766  address class flags are set. The variants are linked in a
767  circular ring and share MAIN_TYPE. */
768 
769  struct type *chain;
770 
771  /* * Flags specific to this instance of the type, indicating where
772  on the ring we are.
773 
774  For TYPE_CODE_TYPEDEF the flags of the typedef type should be
775  binary or-ed with the target type, with a special case for
776  address class and space class. For example if this typedef does
777  not specify any new qualifiers, TYPE_INSTANCE_FLAGS is 0 and the
778  instance flags are completely inherited from the target type. No
779  qualifiers can be cleared by the typedef. See also
780  check_typedef. */
782 
783  /* * Length of storage for a value of this type. This is what
784  sizeof(type) would return; use it for address arithmetic, memory
785  reads and writes, etc. This size includes padding. For example,
786  an i386 extended-precision floating point value really only
787  occupies ten bytes, but most ABI's declare its size to be 12
788  bytes, to preserve alignment. A `struct type' representing such
789  a floating-point type would have a `length' value of 12, even
790  though the last two bytes are unused.
791 
792  There's a bit of a host/target mess here, if you're concerned
793  about machines whose bytes aren't eight bits long, or who don't
794  have byte-addressed memory. Various places pass this to memcpy
795  and such, meaning it must be in units of host bytes. Various
796  other places expect they can calculate addresses by adding it
797  and such, meaning it must be in units of target bytes. For
798  some DSP targets, in which HOST_CHAR_BIT will (presumably) be 8
799  and TARGET_CHAR_BIT will be (say) 32, this is a problem.
800 
801  One fix would be to make this field in bits (requiring that it
802  always be a multiple of HOST_CHAR_BIT and TARGET_CHAR_BIT) ---
803  the other choice would be to make it consistently in units of
804  HOST_CHAR_BIT. However, this would still fail to address
805  machines based on a ternary or decimal representation. */
806 
807  unsigned length;
808 
809  /* * Core type, shared by a group of qualified types. */
810 
812 };
813 
814 #define NULL_TYPE ((struct type *) 0)
815 
817 {
818 
819  /* * The overloaded name.
820  This is generally allocated in the objfile's obstack.
821  However stabsread.c sometimes uses malloc. */
822 
823  const char *name;
824 
825  /* * The number of methods with this name. */
826 
827  int length;
828 
829  /* * The list of methods. */
830 
832 };
833 
834 
835 
836 struct fn_field
837 {
838  /* * If is_stub is clear, this is the mangled name which we can look
839  up to find the address of the method (FIXME: it would be cleaner
840  to have a pointer to the struct symbol here instead).
841 
842  If is_stub is set, this is the portion of the mangled name which
843  specifies the arguments. For example, "ii", if there are two int
844  arguments, or "" if there are no arguments. See gdb_mangle_name
845  for the conversion from this format to the one used if is_stub is
846  clear. */
847 
848  const char *physname;
849 
850  /* * The function type for the method.
851 
852  (This comment used to say "The return value of the method", but
853  that's wrong. The function type is expected here, i.e. something
854  with TYPE_CODE_METHOD, and *not* the return-value type). */
855 
856  struct type *type;
857 
858  /* * For virtual functions. First baseclass that defines this
859  virtual function. */
860 
861  struct type *fcontext;
862 
863  /* Attributes. */
864 
865  unsigned int is_const:1;
866  unsigned int is_volatile:1;
867  unsigned int is_private:1;
868  unsigned int is_protected:1;
869  unsigned int is_public:1;
870  unsigned int is_abstract:1;
871  unsigned int is_static:1;
872  unsigned int is_final:1;
873  unsigned int is_synchronized:1;
874  unsigned int is_native:1;
875  unsigned int is_artificial:1;
876 
877  /* * A stub method only has some fields valid (but they are enough
878  to reconstruct the rest of the fields). */
879 
880  unsigned int is_stub:1;
881 
882  /* * True if this function is a constructor, false otherwise. */
883 
884  unsigned int is_constructor : 1;
885 
886  /* * Unused. */
887 
888  unsigned int dummy:3;
889 
890  /* * Index into that baseclass's virtual function table, minus 2;
891  else if static: VOFFSET_STATIC; else: 0. */
892 
893  unsigned int voffset:16;
894 
895 #define VOFFSET_STATIC 1
896 
897 };
898 
900 {
901  /* * Unqualified name to be prefixed by owning class qualified
902  name. */
903 
904  const char *name;
905 
906  /* * Type this typedef named NAME represents. */
907 
908  struct type *type;
909 };
910 
911 /* * C++ language-specific information for TYPE_CODE_STRUCT and
912  TYPE_CODE_UNION nodes. */
913 
915  {
916  /* * Number of base classes this type derives from. The
917  baseclasses are stored in the first N_BASECLASSES fields
918  (i.e. the `fields' field of the struct type). The only fields
919  of struct field that are used are: type, name, loc.bitpos. */
920 
922 
923  /* * Field number of the virtual function table pointer in VPTR_BASETYPE.
924  All access to this field must be through TYPE_VPTR_FIELDNO as one
925  thing it does is check whether the field has been initialized.
926  Initially TYPE_RAW_CPLUS_SPECIFIC has the value of cplus_struct_default,
927  which for portability reasons doesn't initialize this field.
928  TYPE_VPTR_FIELDNO returns -1 for this case.
929 
930  If -1, we were unable to find the virtual function table pointer in
931  initial symbol reading, and get_vptr_fieldno should be called to find
932  it if possible. get_vptr_fieldno will update this field if possible.
933  Otherwise the value is left at -1.
934 
935  Unused if this type does not have virtual functions. */
936 
938 
939  /* * Number of methods with unique names. All overloaded methods
940  with the same name count only once. */
941 
942  short nfn_fields;
943 
944  /* * Number of template arguments. */
945 
946  unsigned short n_template_arguments;
947 
948  /* * One if this struct is a dynamic class, as defined by the
949  Itanium C++ ABI: if it requires a virtual table pointer,
950  because it or any of its base classes have one or more virtual
951  member functions or virtual base classes. Minus one if not
952  dynamic. Zero if not yet computed. */
953 
954  int is_dynamic : 2;
955 
956  /* * Non-zero if this type came from a Java CU. */
957 
958  unsigned int is_java : 1;
959 
960  /* * The base class which defined the virtual function table pointer. */
961 
963 
964  /* * For derived classes, the number of base classes is given by
965  n_baseclasses and virtual_field_bits is a bit vector containing
966  one bit per base class. If the base class is virtual, the
967  corresponding bit will be set.
968  I.E, given:
969 
970  class A{};
971  class B{};
972  class C : public B, public virtual A {};
973 
974  B is a baseclass of C; A is a virtual baseclass for C.
975  This is a C++ 2.0 language feature. */
976 
978 
979  /* * For classes with private fields, the number of fields is
980  given by nfields and private_field_bits is a bit vector
981  containing one bit per field.
982 
983  If the field is private, the corresponding bit will be set. */
984 
986 
987  /* * For classes with protected fields, the number of fields is
988  given by nfields and protected_field_bits is a bit vector
989  containing one bit per field.
990 
991  If the field is private, the corresponding bit will be set. */
992 
994 
995  /* * For classes with fields to be ignored, either this is
996  optimized out or this field has length 0. */
997 
999 
1000  /* * For classes, structures, and unions, a description of each
1001  field, which consists of an overloaded name, followed by the
1002  types of arguments that the method expects, and then the name
1003  after it has been renamed to make it distinct.
1004 
1005  fn_fieldlists points to an array of nfn_fields of these. */
1006 
1008 
1009  /* * typedefs defined inside this class. typedef_field points to
1010  an array of typedef_field_count elements. */
1011 
1013 
1015 
1016  /* * The template arguments. This is an array with
1017  N_TEMPLATE_ARGUMENTS elements. This is NULL for non-template
1018  classes. */
1019 
1020  struct symbol **template_arguments;
1021  };
1022 
1023 /* * Struct used to store conversion rankings. */
1024 
1025 struct rank
1026  {
1027  short rank;
1028 
1029  /* * When two conversions are of the same type and therefore have
1030  the same rank, subrank is used to differentiate the two.
1031 
1032  Eg: Two derived-class-pointer to base-class-pointer conversions
1033  would both have base pointer conversion rank, but the
1034  conversion with the shorter distance to the ancestor is
1035  preferable. 'subrank' would be used to reflect that. */
1036 
1037  short subrank;
1038  };
1039 
1040 /* * Struct used for ranking a function for overload resolution. */
1041 
1043  {
1044  int length;
1045  struct rank *rank;
1046  };
1047 
1048 /* * GNAT Ada-specific information for various Ada types. */
1049 
1051  {
1052  /* * Parallel type used to encode information about dynamic types
1053  used in Ada (such as variant records, variable-size array,
1054  etc). */
1056  };
1057 
1058 /* * For TYPE_CODE_FUNC and TYPE_CODE_METHOD types. */
1059 
1061  {
1062  /* * The calling convention for targets supporting multiple ABIs.
1063  Right now this is only fetched from the Dwarf-2
1064  DW_AT_calling_convention attribute. The value is one of the
1065  DW_CC enum dwarf_calling_convention constants. */
1066 
1067  unsigned calling_convention : 8;
1068 
1069  /* * Whether this function normally returns to its caller. It is
1070  set from the DW_AT_noreturn attribute if set on the
1071  DW_TAG_subprogram. */
1072 
1073  unsigned int is_noreturn : 1;
1074 
1075  /* * Only those DW_TAG_GNU_call_site's in this function that have
1076  DW_AT_GNU_tail_call set are linked in this list. Function
1077  without its tail call list complete
1078  (DW_AT_GNU_all_tail_call_sites or its superset
1079  DW_AT_GNU_all_call_sites) has TAIL_CALL_LIST NULL, even if some
1080  DW_TAG_GNU_call_site's exist in such function. */
1081 
1083 
1084  /* * For method types (TYPE_CODE_METHOD), the aggregate type that
1085  contains the method. */
1086 
1087  struct type *self_type;
1088  };
1089 
1090 /* struct call_site_parameter can be referenced in callees by several ways. */
1091 
1093 {
1094  /* * Use field call_site_parameter.u.dwarf_reg. */
1096 
1097  /* * Use field call_site_parameter.u.fb_offset. */
1099 
1100  /* * Use field call_site_parameter.u.param_offset. */
1102 };
1103 
1105 {
1107 
1108  /* * Discriminant for union field_location. */
1109 
1110  ENUM_BITFIELD(field_loc_kind) loc_kind : 3;
1111 };
1112 
1114 {
1115  /* * DW_TAG_formal_parameter's DW_AT_location's DW_OP_regX
1116  as DWARF register number, for register passed
1117  parameters. */
1118 
1120 
1121  /* * Offset from the callee's frame base, for stack passed
1122  parameters. This equals offset from the caller's stack
1123  pointer. */
1124 
1125  CORE_ADDR fb_offset;
1126 
1127  /* * Offset relative to the start of this PER_CU to
1128  DW_TAG_formal_parameter which is referenced by both
1129  caller and the callee. */
1130 
1132 };
1133 
1135 {
1136  ENUM_BITFIELD (call_site_parameter_kind) kind : 2;
1137 
1139 
1140  /* * DW_TAG_formal_parameter's DW_AT_GNU_call_site_value. It
1141  is never NULL. */
1142 
1143  const gdb_byte *value;
1144  size_t value_size;
1145 
1146  /* * DW_TAG_formal_parameter's DW_AT_GNU_call_site_data_value.
1147  It may be NULL if not provided by DWARF. */
1148 
1149  const gdb_byte *data_value;
1150  size_t data_value_size;
1151 };
1152 
1153 /* * A place where a function gets called from, represented by
1154  DW_TAG_GNU_call_site. It can be looked up from
1155  symtab->call_site_htab. */
1156 
1158  {
1159  /* * Address of the first instruction after this call. It must be
1160  the first field as we overload core_addr_hash and core_addr_eq
1161  for it. */
1162 
1163  CORE_ADDR pc;
1164 
1165  /* * List successor with head in FUNC_TYPE.TAIL_CALL_LIST. */
1166 
1167  struct call_site *tail_call_next;
1168 
1169  /* * Describe DW_AT_GNU_call_site_target. Missing attribute uses
1170  FIELD_LOC_KIND_DWARF_BLOCK with FIELD_DWARF_BLOCK == NULL. */
1171 
1172  struct call_site_target target;
1173 
1174  /* * Size of the PARAMETER array. */
1175 
1177 
1178  /* * CU of the function where the call is located. It gets used
1179  for DWARF blocks execution in the parameter array below. */
1180 
1181  struct dwarf2_per_cu_data *per_cu;
1182 
1183  /* * Describe DW_TAG_GNU_call_site's DW_TAG_formal_parameter. */
1184 
1185  struct call_site_parameter parameter[1];
1186  };
1187 
1188 /* * The default value of TYPE_CPLUS_SPECIFIC(T) points to this shared
1189  static structure. */
1190 
1191 extern const struct cplus_struct_type cplus_struct_default;
1192 
1193 extern void allocate_cplus_struct_type (struct type *);
1194 
1195 #define INIT_CPLUS_SPECIFIC(type) \
1196  (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CPLUS_STUFF, \
1197  TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type*) \
1198  &cplus_struct_default)
1199 
1200 #define ALLOCATE_CPLUS_STRUCT_TYPE(type) allocate_cplus_struct_type (type)
1201 
1202 #define HAVE_CPLUS_STRUCT(type) \
1203  (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_CPLUS_STUFF \
1204  && TYPE_RAW_CPLUS_SPECIFIC (type) != &cplus_struct_default)
1205 
1206 extern const struct gnat_aux_type gnat_aux_default;
1207 
1208 extern void allocate_gnat_aux_type (struct type *);
1209 
1210 #define INIT_GNAT_SPECIFIC(type) \
1211  (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_GNAT_STUFF, \
1212  TYPE_GNAT_SPECIFIC (type) = (struct gnat_aux_type *) &gnat_aux_default)
1213 #define ALLOCATE_GNAT_AUX_TYPE(type) allocate_gnat_aux_type (type)
1214 /* * A macro that returns non-zero if the type-specific data should be
1215  read as "gnat-stuff". */
1216 #define HAVE_GNAT_AUX_INFO(type) \
1217  (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_GNAT_STUFF)
1218 
1219 #define INIT_FUNC_SPECIFIC(type) \
1220  (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FUNC, \
1221  TYPE_MAIN_TYPE (type)->type_specific.func_stuff \
1222  = TYPE_ZALLOC (type, \
1223  sizeof (*TYPE_MAIN_TYPE (type)->type_specific.func_stuff)))
1224 
1225 #define TYPE_INSTANCE_FLAGS(thistype) (thistype)->instance_flags
1226 #define TYPE_MAIN_TYPE(thistype) (thistype)->main_type
1227 #define TYPE_NAME(thistype) TYPE_MAIN_TYPE(thistype)->name
1228 #define TYPE_TAG_NAME(type) TYPE_MAIN_TYPE(type)->tag_name
1229 #define TYPE_TARGET_TYPE(thistype) TYPE_MAIN_TYPE(thistype)->target_type
1230 #define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type
1231 #define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type
1232 #define TYPE_CHAIN(thistype) (thistype)->chain
1233 /* * Note that if thistype is a TYPEDEF type, you have to call check_typedef.
1234  But check_typedef does set the TYPE_LENGTH of the TYPEDEF type,
1235  so you only have to call check_typedef once. Since allocate_value
1236  calls check_typedef, TYPE_LENGTH (VALUE_TYPE (X)) is safe. */
1237 #define TYPE_LENGTH(thistype) (thistype)->length
1238 /* * Note that TYPE_CODE can be TYPE_CODE_TYPEDEF, so if you want the real
1239  type, you need to do TYPE_CODE (check_type (this_type)). */
1240 #define TYPE_CODE(thistype) TYPE_MAIN_TYPE(thistype)->code
1241 #define TYPE_NFIELDS(thistype) TYPE_MAIN_TYPE(thistype)->nfields
1242 #define TYPE_FIELDS(thistype) TYPE_MAIN_TYPE(thistype)->flds_bnds.fields
1243 
1244 #define TYPE_INDEX_TYPE(type) TYPE_FIELD_TYPE (type, 0)
1245 #define TYPE_RANGE_DATA(thistype) TYPE_MAIN_TYPE(thistype)->flds_bnds.bounds
1246 #define TYPE_LOW_BOUND(range_type) \
1247  TYPE_RANGE_DATA(range_type)->low.data.const_val
1248 #define TYPE_HIGH_BOUND(range_type) \
1249  TYPE_RANGE_DATA(range_type)->high.data.const_val
1250 #define TYPE_LOW_BOUND_UNDEFINED(range_type) \
1251  (TYPE_RANGE_DATA(range_type)->low.kind == PROP_UNDEFINED)
1252 #define TYPE_HIGH_BOUND_UNDEFINED(range_type) \
1253  (TYPE_RANGE_DATA(range_type)->high.kind == PROP_UNDEFINED)
1254 #define TYPE_HIGH_BOUND_KIND(range_type) \
1255  TYPE_RANGE_DATA(range_type)->high.kind
1256 #define TYPE_LOW_BOUND_KIND(range_type) \
1257  TYPE_RANGE_DATA(range_type)->low.kind
1258 
1259 /* Property accessors for the type data location. */
1260 #define TYPE_DATA_LOCATION(thistype) \
1261  get_dyn_prop (DYN_PROP_DATA_LOCATION, thistype)
1262 #define TYPE_DATA_LOCATION_BATON(thistype) \
1263  TYPE_DATA_LOCATION (thistype)->data.baton
1264 #define TYPE_DATA_LOCATION_ADDR(thistype) \
1265  TYPE_DATA_LOCATION (thistype)->data.const_val
1266 #define TYPE_DATA_LOCATION_KIND(thistype) \
1267  TYPE_DATA_LOCATION (thistype)->kind
1268 
1269 /* Attribute accessors for dynamic properties. */
1270 #define TYPE_DYN_PROP_LIST(thistype) \
1271  TYPE_MAIN_TYPE(thistype)->dyn_prop_list
1272 #define TYPE_DYN_PROP_BATON(dynprop) \
1273  dynprop->data.baton
1274 #define TYPE_DYN_PROP_ADDR(dynprop) \
1275  dynprop->data.const_val
1276 #define TYPE_DYN_PROP_KIND(dynprop) \
1277  dynprop->kind
1278 
1279 
1280 /* Moto-specific stuff for FORTRAN arrays. */
1281 
1282 #define TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED(arraytype) \
1283  TYPE_HIGH_BOUND_UNDEFINED(TYPE_INDEX_TYPE(arraytype))
1284 #define TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED(arraytype) \
1285  TYPE_LOW_BOUND_UNDEFINED(TYPE_INDEX_TYPE(arraytype))
1286 
1287 #define TYPE_ARRAY_UPPER_BOUND_VALUE(arraytype) \
1288  (TYPE_HIGH_BOUND(TYPE_INDEX_TYPE((arraytype))))
1289 
1290 #define TYPE_ARRAY_LOWER_BOUND_VALUE(arraytype) \
1291  (TYPE_LOW_BOUND(TYPE_INDEX_TYPE((arraytype))))
1292 
1293 /* C++ */
1294 
1295 #define TYPE_SELF_TYPE(thistype) internal_type_self_type (thistype)
1296 /* Do not call this, use TYPE_SELF_TYPE. */
1297 extern struct type *internal_type_self_type (struct type *);
1298 extern void set_type_self_type (struct type *, struct type *);
1299 
1300 extern int internal_type_vptr_fieldno (struct type *);
1301 extern void set_type_vptr_fieldno (struct type *, int);
1302 extern struct type *internal_type_vptr_basetype (struct type *);
1303 extern void set_type_vptr_basetype (struct type *, struct type *);
1304 #define TYPE_VPTR_FIELDNO(thistype) internal_type_vptr_fieldno (thistype)
1305 #define TYPE_VPTR_BASETYPE(thistype) internal_type_vptr_basetype (thistype)
1306 
1307 #define TYPE_NFN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields
1308 #define TYPE_SPECIFIC_FIELD(thistype) \
1309  TYPE_MAIN_TYPE(thistype)->type_specific_field
1310 /* We need this tap-dance with the TYPE_RAW_SPECIFIC because of the case
1311  where we're trying to print an Ada array using the C language.
1312  In that case, there is no "cplus_stuff", but the C language assumes
1313  that there is. What we do, in that case, is pretend that there is
1314  an implicit one which is the default cplus stuff. */
1315 #define TYPE_CPLUS_SPECIFIC(thistype) \
1316  (!HAVE_CPLUS_STRUCT(thistype) \
1317  ? (struct cplus_struct_type*)&cplus_struct_default \
1318  : TYPE_RAW_CPLUS_SPECIFIC(thistype))
1319 #define TYPE_RAW_CPLUS_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff
1320 #define TYPE_FLOATFORMAT(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.floatformat
1321 #define TYPE_GNAT_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.gnat_stuff
1322 #define TYPE_DESCRIPTIVE_TYPE(thistype) TYPE_GNAT_SPECIFIC(thistype)->descriptive_type
1323 #define TYPE_CALLING_CONVENTION(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.func_stuff->calling_convention
1324 #define TYPE_NO_RETURN(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.func_stuff->is_noreturn
1325 #define TYPE_TAIL_CALL_LIST(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.func_stuff->tail_call_list
1326 #define TYPE_BASECLASS(thistype,index) TYPE_FIELD_TYPE(thistype, index)
1327 #define TYPE_N_BASECLASSES(thistype) TYPE_CPLUS_SPECIFIC(thistype)->n_baseclasses
1328 #define TYPE_BASECLASS_NAME(thistype,index) TYPE_FIELD_NAME(thistype, index)
1329 #define TYPE_BASECLASS_BITPOS(thistype,index) TYPE_FIELD_BITPOS(thistype,index)
1330 #define BASETYPE_VIA_PUBLIC(thistype, index) \
1331  ((!TYPE_FIELD_PRIVATE(thistype, index)) && (!TYPE_FIELD_PROTECTED(thistype, index)))
1332 #define TYPE_CPLUS_DYNAMIC(thistype) TYPE_CPLUS_SPECIFIC (thistype)->is_dynamic
1333 #define TYPE_CPLUS_REALLY_JAVA(thistype) TYPE_CPLUS_SPECIFIC (thistype)->is_java
1334 
1335 #define BASETYPE_VIA_VIRTUAL(thistype, index) \
1336  (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \
1337  : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (index)))
1338 
1339 #define FIELD_TYPE(thisfld) ((thisfld).type)
1340 #define FIELD_NAME(thisfld) ((thisfld).name)
1341 #define FIELD_LOC_KIND(thisfld) ((thisfld).loc_kind)
1342 #define FIELD_BITPOS_LVAL(thisfld) ((thisfld).loc.bitpos)
1343 #define FIELD_BITPOS(thisfld) (FIELD_BITPOS_LVAL (thisfld) + 0)
1344 #define FIELD_ENUMVAL_LVAL(thisfld) ((thisfld).loc.enumval)
1345 #define FIELD_ENUMVAL(thisfld) (FIELD_ENUMVAL_LVAL (thisfld) + 0)
1346 #define FIELD_STATIC_PHYSNAME(thisfld) ((thisfld).loc.physname)
1347 #define FIELD_STATIC_PHYSADDR(thisfld) ((thisfld).loc.physaddr)
1348 #define FIELD_DWARF_BLOCK(thisfld) ((thisfld).loc.dwarf_block)
1349 #define SET_FIELD_BITPOS(thisfld, bitpos) \
1350  (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_BITPOS, \
1351  FIELD_BITPOS_LVAL (thisfld) = (bitpos))
1352 #define SET_FIELD_ENUMVAL(thisfld, enumval) \
1353  (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_ENUMVAL, \
1354  FIELD_ENUMVAL_LVAL (thisfld) = (enumval))
1355 #define SET_FIELD_PHYSNAME(thisfld, name) \
1356  (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_PHYSNAME, \
1357  FIELD_STATIC_PHYSNAME (thisfld) = (name))
1358 #define SET_FIELD_PHYSADDR(thisfld, addr) \
1359  (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_PHYSADDR, \
1360  FIELD_STATIC_PHYSADDR (thisfld) = (addr))
1361 #define SET_FIELD_DWARF_BLOCK(thisfld, addr) \
1362  (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_DWARF_BLOCK, \
1363  FIELD_DWARF_BLOCK (thisfld) = (addr))
1364 #define FIELD_ARTIFICIAL(thisfld) ((thisfld).artificial)
1365 #define FIELD_BITSIZE(thisfld) ((thisfld).bitsize)
1366 
1367 #define TYPE_FIELD(thistype, n) TYPE_MAIN_TYPE(thistype)->flds_bnds.fields[n]
1368 #define TYPE_FIELD_TYPE(thistype, n) FIELD_TYPE(TYPE_FIELD(thistype, n))
1369 #define TYPE_FIELD_NAME(thistype, n) FIELD_NAME(TYPE_FIELD(thistype, n))
1370 #define TYPE_FIELD_LOC_KIND(thistype, n) FIELD_LOC_KIND (TYPE_FIELD (thistype, n))
1371 #define TYPE_FIELD_BITPOS(thistype, n) FIELD_BITPOS (TYPE_FIELD (thistype, n))
1372 #define TYPE_FIELD_ENUMVAL(thistype, n) FIELD_ENUMVAL (TYPE_FIELD (thistype, n))
1373 #define TYPE_FIELD_STATIC_PHYSNAME(thistype, n) FIELD_STATIC_PHYSNAME (TYPE_FIELD (thistype, n))
1374 #define TYPE_FIELD_STATIC_PHYSADDR(thistype, n) FIELD_STATIC_PHYSADDR (TYPE_FIELD (thistype, n))
1375 #define TYPE_FIELD_DWARF_BLOCK(thistype, n) FIELD_DWARF_BLOCK (TYPE_FIELD (thistype, n))
1376 #define TYPE_FIELD_ARTIFICIAL(thistype, n) FIELD_ARTIFICIAL(TYPE_FIELD(thistype,n))
1377 #define TYPE_FIELD_BITSIZE(thistype, n) FIELD_BITSIZE(TYPE_FIELD(thistype,n))
1378 #define TYPE_FIELD_PACKED(thistype, n) (FIELD_BITSIZE(TYPE_FIELD(thistype,n))!=0)
1379 
1380 #define TYPE_FIELD_PRIVATE_BITS(thistype) \
1381  TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits
1382 #define TYPE_FIELD_PROTECTED_BITS(thistype) \
1383  TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits
1384 #define TYPE_FIELD_IGNORE_BITS(thistype) \
1385  TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits
1386 #define TYPE_FIELD_VIRTUAL_BITS(thistype) \
1387  TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits
1388 #define SET_TYPE_FIELD_PRIVATE(thistype, n) \
1389  B_SET (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n))
1390 #define SET_TYPE_FIELD_PROTECTED(thistype, n) \
1391  B_SET (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n))
1392 #define SET_TYPE_FIELD_IGNORE(thistype, n) \
1393  B_SET (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n))
1394 #define SET_TYPE_FIELD_VIRTUAL(thistype, n) \
1395  B_SET (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
1396 #define TYPE_FIELD_PRIVATE(thistype, n) \
1397  (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits == NULL ? 0 \
1398  : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n)))
1399 #define TYPE_FIELD_PROTECTED(thistype, n) \
1400  (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits == NULL ? 0 \
1401  : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n)))
1402 #define TYPE_FIELD_IGNORE(thistype, n) \
1403  (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits == NULL ? 0 \
1404  : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n)))
1405 #define TYPE_FIELD_VIRTUAL(thistype, n) \
1406  (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \
1407  : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n)))
1408 
1409 #define TYPE_FN_FIELDLISTS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists
1410 #define TYPE_FN_FIELDLIST(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n]
1411 #define TYPE_FN_FIELDLIST1(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].fn_fields
1412 #define TYPE_FN_FIELDLIST_NAME(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].name
1413 #define TYPE_FN_FIELDLIST_LENGTH(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].length
1414 
1415 #define TYPE_N_TEMPLATE_ARGUMENTS(thistype) \
1416  TYPE_CPLUS_SPECIFIC (thistype)->n_template_arguments
1417 #define TYPE_TEMPLATE_ARGUMENTS(thistype) \
1418  TYPE_CPLUS_SPECIFIC (thistype)->template_arguments
1419 #define TYPE_TEMPLATE_ARGUMENT(thistype, n) \
1420  TYPE_CPLUS_SPECIFIC (thistype)->template_arguments[n]
1421 
1422 #define TYPE_FN_FIELD(thisfn, n) (thisfn)[n]
1423 #define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname
1424 #define TYPE_FN_FIELD_TYPE(thisfn, n) (thisfn)[n].type
1425 #define TYPE_FN_FIELD_ARGS(thisfn, n) TYPE_FIELDS ((thisfn)[n].type)
1426 #define TYPE_FN_FIELD_CONST(thisfn, n) ((thisfn)[n].is_const)
1427 #define TYPE_FN_FIELD_VOLATILE(thisfn, n) ((thisfn)[n].is_volatile)
1428 #define TYPE_FN_FIELD_PRIVATE(thisfn, n) ((thisfn)[n].is_private)
1429 #define TYPE_FN_FIELD_PROTECTED(thisfn, n) ((thisfn)[n].is_protected)
1430 #define TYPE_FN_FIELD_PUBLIC(thisfn, n) ((thisfn)[n].is_public)
1431 #define TYPE_FN_FIELD_STATIC(thisfn, n) ((thisfn)[n].is_static)
1432 #define TYPE_FN_FIELD_FINAL(thisfn, n) ((thisfn)[n].is_final)
1433 #define TYPE_FN_FIELD_SYNCHRONIZED(thisfn, n) ((thisfn)[n].is_synchronized)
1434 #define TYPE_FN_FIELD_NATIVE(thisfn, n) ((thisfn)[n].is_native)
1435 #define TYPE_FN_FIELD_ARTIFICIAL(thisfn, n) ((thisfn)[n].is_artificial)
1436 #define TYPE_FN_FIELD_ABSTRACT(thisfn, n) ((thisfn)[n].is_abstract)
1437 #define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub)
1438 #define TYPE_FN_FIELD_CONSTRUCTOR(thisfn, n) ((thisfn)[n].is_constructor)
1439 #define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext)
1440 #define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
1441 #define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1)
1442 #define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)
1443 
1444 #define TYPE_TYPEDEF_FIELD_ARRAY(thistype) \
1445  TYPE_CPLUS_SPECIFIC (thistype)->typedef_field
1446 #define TYPE_TYPEDEF_FIELD(thistype, n) \
1447  TYPE_CPLUS_SPECIFIC (thistype)->typedef_field[n]
1448 #define TYPE_TYPEDEF_FIELD_NAME(thistype, n) \
1449  TYPE_TYPEDEF_FIELD (thistype, n).name
1450 #define TYPE_TYPEDEF_FIELD_TYPE(thistype, n) \
1451  TYPE_TYPEDEF_FIELD (thistype, n).type
1452 #define TYPE_TYPEDEF_FIELD_COUNT(thistype) \
1453  TYPE_CPLUS_SPECIFIC (thistype)->typedef_field_count
1454 
1455 #define TYPE_IS_OPAQUE(thistype) \
1456  (((TYPE_CODE (thistype) == TYPE_CODE_STRUCT) \
1457  || (TYPE_CODE (thistype) == TYPE_CODE_UNION)) \
1458  && (TYPE_NFIELDS (thistype) == 0) \
1459  && (!HAVE_CPLUS_STRUCT (thistype) \
1460  || TYPE_NFN_FIELDS (thistype) == 0) \
1461  && (TYPE_STUB (thistype) || !TYPE_STUB_SUPPORTED (thistype)))
1462 
1463 /* * A helper macro that returns the name of a type or "unnamed type"
1464  if the type has no name. */
1465 
1466 #define TYPE_SAFE_NAME(type) \
1467  (TYPE_NAME (type) ? TYPE_NAME (type) : _("<unnamed type>"))
1468 
1469 /* * A helper macro that returns the name of an error type. If the
1470  type has a name, it is used; otherwise, a default is used. */
1471 
1472 #define TYPE_ERROR_NAME(type) \
1473  (TYPE_NAME (type) ? TYPE_NAME (type) : _("<error type>"))
1474 
1476 {
1477  /* Integral types. */
1478 
1479  /* Implicit size/sign (based on the architecture's ABI). */
1502 
1503  /* "True" character types.
1504  We use these for the '/c' print format, because c_char is just a
1505  one-byte integral type, which languages less laid back than C
1506  will print as ... well, a one-byte integral type. */
1509 
1510  /* Explicit sizes - see C9X <intypes.h> for naming scheme. The "int0"
1511  is for when an architecture needs to describe a register that has
1512  no size. */
1524 
1525  /* Wide character types. */
1528 
1529  /* Pointer types. */
1530 
1531  /* * `pointer to data' type. Some target platforms use an implicitly
1532  {sign,zero} -extended 32-bit ABI pointer on a 64-bit ISA. */
1534 
1535  /* * `pointer to function (returning void)' type. Harvard
1536  architectures mean that ABI function and code pointers are not
1537  interconvertible. Similarly, since ANSI, C standards have
1538  explicitly said that pointers to functions and pointers to data
1539  are not interconvertible --- that is, you can't cast a function
1540  pointer to void * and back, and expect to get the same value.
1541  However, all function pointer types are interconvertible, so void
1542  (*) () can server as a generic function pointer. */
1543 
1545 
1546  /* * `function returning pointer to function (returning void)' type.
1547  The final void return type is not significant for it. */
1548 
1550 
1551  /* Special-purpose types. */
1552 
1553  /* * This type is used to represent a GDB internal function. */
1554 
1556 
1557  /* * This type is used to represent an xmethod. */
1558  struct type *xmethod;
1559 };
1560 
1561 /* * Return the type table for the specified architecture. */
1562 
1563 extern const struct builtin_type *builtin_type (struct gdbarch *gdbarch);
1564 
1565 /* * Per-objfile types used by symbol readers. */
1566 
1568 {
1569  /* Basic types based on the objfile architecture. */
1585 
1586  /* * This type is used to represent symbol addresses. */
1588 
1589  /* * This type represents a type that was unrecognized in symbol
1590  read-in. */
1592 
1593  /* * Types used for symbols with no debug information. */
1600 };
1601 
1602 /* * Return the type table for the specified objfile. */
1603 
1604 extern const struct objfile_type *objfile_type (struct objfile *objfile);
1605 
1606 /* Explicit floating-point formats. See "floatformat.h". */
1607 extern const struct floatformat *floatformats_ieee_half[BFD_ENDIAN_UNKNOWN];
1608 extern const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN];
1609 extern const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN];
1610 extern const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN];
1611 extern const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN];
1612 extern const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN];
1613 extern const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN];
1614 extern const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN];
1615 extern const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN];
1616 extern const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN];
1617 extern const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN];
1618 extern const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN];
1619 
1620 
1621 /* * Allocate space for storing data associated with a particular
1622  type. We ensure that the space is allocated using the same
1623  mechanism that was used to allocate the space for the type
1624  structure itself. I.e. if the type is on an objfile's
1625  objfile_obstack, then the space for data associated with that type
1626  will also be allocated on the objfile_obstack. If the type is not
1627  associated with any particular objfile (such as builtin types),
1628  then the data space will be allocated with xmalloc, the same as for
1629  the type structure. */
1630 
1631 #define TYPE_ALLOC(t,size) \
1632  (TYPE_OBJFILE_OWNED (t) \
1633  ? obstack_alloc (&TYPE_OBJFILE (t) -> objfile_obstack, size) \
1634  : xmalloc (size))
1635 
1636 #define TYPE_ZALLOC(t,size) \
1637  (TYPE_OBJFILE_OWNED (t) \
1638  ? memset (obstack_alloc (&TYPE_OBJFILE (t)->objfile_obstack, size), \
1639  0, size) \
1640  : xzalloc (size))
1641 
1642 /* Use alloc_type to allocate a type owned by an objfile. Use
1643  alloc_type_arch to allocate a type owned by an architecture. Use
1644  alloc_type_copy to allocate a type with the same owner as a
1645  pre-existing template type, no matter whether objfile or
1646  gdbarch. */
1647 extern struct type *alloc_type (struct objfile *);
1648 extern struct type *alloc_type_arch (struct gdbarch *);
1649 extern struct type *alloc_type_copy (const struct type *);
1650 
1651 /* * Return the type's architecture. For types owned by an
1652  architecture, that architecture is returned. For types owned by an
1653  objfile, that objfile's architecture is returned. */
1654 
1655 extern struct gdbarch *get_type_arch (const struct type *);
1656 
1657 /* * This returns the target type (or NULL) of TYPE, also skipping
1658  past typedefs. */
1659 
1660 extern struct type *get_target_type (struct type *type);
1661 
1662 /* * Helper function to construct objfile-owned types. */
1663 
1664 extern struct type *init_type (enum type_code, int, int, const char *,
1665  struct objfile *);
1666 
1667 /* Helper functions to construct architecture-owned types. */
1668 extern struct type *arch_type (struct gdbarch *, enum type_code, int, char *);
1669 extern struct type *arch_integer_type (struct gdbarch *, int, int, char *);
1670 extern struct type *arch_character_type (struct gdbarch *, int, int, char *);
1671 extern struct type *arch_boolean_type (struct gdbarch *, int, int, char *);
1672 extern struct type *arch_float_type (struct gdbarch *, int, char *,
1673  const struct floatformat **);
1674 extern struct type *arch_complex_type (struct gdbarch *, char *,
1675  struct type *);
1676 
1677 /* Helper functions to construct a struct or record type. An
1678  initially empty type is created using arch_composite_type().
1679  Fields are then added using append_composite_type_field*(). A union
1680  type has its size set to the largest field. A struct type has each
1681  field packed against the previous. */
1682 
1683 extern struct type *arch_composite_type (struct gdbarch *gdbarch,
1684  char *name, enum type_code code);
1685 extern void append_composite_type_field (struct type *t, char *name,
1686  struct type *field);
1687 extern void append_composite_type_field_aligned (struct type *t,
1688  char *name,
1689  struct type *field,
1690  int alignment);
1691 struct field *append_composite_type_field_raw (struct type *t, char *name,
1692  struct type *field);
1693 
1694 /* Helper functions to construct a bit flags type. An initially empty
1695  type is created using arch_flag_type(). Flags are then added using
1696  append_flag_type_flag(). */
1697 extern struct type *arch_flags_type (struct gdbarch *gdbarch,
1698  char *name, int length);
1699 extern void append_flags_type_flag (struct type *type, int bitpos, char *name);
1700 
1701 extern void make_vector_type (struct type *array_type);
1702 extern struct type *init_vector_type (struct type *elt_type, int n);
1703 
1704 extern struct type *lookup_reference_type (struct type *);
1705 
1706 extern struct type *make_reference_type (struct type *, struct type **);
1707 
1708 extern struct type *make_cv_type (int, int, struct type *, struct type **);
1709 
1710 extern struct type *make_restrict_type (struct type *);
1711 
1712 extern struct type *make_unqualified_type (struct type *);
1713 
1714 extern struct type *make_atomic_type (struct type *);
1715 
1716 extern void replace_type (struct type *, struct type *);
1717 
1718 extern int address_space_name_to_int (struct gdbarch *, char *);
1719 
1720 extern const char *address_space_int_to_name (struct gdbarch *, int);
1721 
1722 extern struct type *make_type_with_address_space (struct type *type,
1723  int space_identifier);
1724 
1725 extern struct type *lookup_memberptr_type (struct type *, struct type *);
1726 
1727 extern struct type *lookup_methodptr_type (struct type *);
1728 
1729 extern void smash_to_method_type (struct type *type, struct type *self_type,
1730  struct type *to_type, struct field *args,
1731  int nargs, int varargs);
1732 
1733 extern void smash_to_memberptr_type (struct type *, struct type *,
1734  struct type *);
1735 
1736 extern void smash_to_methodptr_type (struct type *, struct type *);
1737 
1738 extern struct type *allocate_stub_method (struct type *);
1739 
1740 extern const char *type_name_no_tag (const struct type *);
1741 
1742 extern const char *type_name_no_tag_or_error (struct type *type);
1743 
1744 extern struct type *lookup_struct_elt_type (struct type *, const char *, int);
1745 
1746 extern struct type *make_pointer_type (struct type *, struct type **);
1747 
1748 extern struct type *lookup_pointer_type (struct type *);
1749 
1750 extern struct type *make_function_type (struct type *, struct type **);
1751 
1752 extern struct type *lookup_function_type (struct type *);
1753 
1754 extern struct type *lookup_function_type_with_arguments (struct type *,
1755  int,
1756  struct type **);
1757 
1758 extern struct type *create_static_range_type (struct type *, struct type *,
1759  LONGEST, LONGEST);
1760 
1761 
1762 extern struct type *create_array_type_with_stride
1763  (struct type *, struct type *, struct type *, unsigned int);
1764 
1765 extern struct type *create_range_type (struct type *, struct type *,
1766  const struct dynamic_prop *,
1767  const struct dynamic_prop *);
1768 
1769 extern struct type *create_array_type (struct type *, struct type *,
1770  struct type *);
1771 
1772 extern struct type *lookup_array_range_type (struct type *, LONGEST, LONGEST);
1773 
1774 extern struct type *create_string_type (struct type *, struct type *,
1775  struct type *);
1776 extern struct type *lookup_string_range_type (struct type *, LONGEST, LONGEST);
1777 
1778 extern struct type *create_set_type (struct type *, struct type *);
1779 
1780 extern struct type *lookup_unsigned_typename (const struct language_defn *,
1781  struct gdbarch *, const char *);
1782 
1783 extern struct type *lookup_signed_typename (const struct language_defn *,
1784  struct gdbarch *, const char *);
1785 
1786 extern void get_unsigned_type_max (struct type *, ULONGEST *);
1787 
1788 extern void get_signed_type_minmax (struct type *, LONGEST *, LONGEST *);
1789 
1790 /* * Resolve all dynamic values of a type e.g. array bounds to static values.
1791  ADDR specifies the location of the variable the type is bound to.
1792  If TYPE has no dynamic properties return TYPE; otherwise a new type with
1793  static properties is returned. */
1794 extern struct type *resolve_dynamic_type (struct type *type,
1795  const gdb_byte *valaddr,
1796  CORE_ADDR addr);
1797 
1798 /* * Predicate if the type has dynamic values, which are not resolved yet. */
1799 extern int is_dynamic_type (struct type *type);
1800 
1801 /* * Return the dynamic property of the requested KIND from TYPE's
1802  list of dynamic properties. */
1803 extern struct dynamic_prop *get_dyn_prop
1804  (enum dynamic_prop_node_kind kind, const struct type *type);
1805 
1806 /* * Given a dynamic property PROP of a given KIND, add this dynamic
1807  property to the given TYPE.
1808 
1809  This function assumes that TYPE is objfile-owned, and that OBJFILE
1810  is the TYPE's objfile. */
1811 extern void add_dyn_prop
1812  (enum dynamic_prop_node_kind kind, struct dynamic_prop prop,
1813  struct type *type, struct objfile *objfile);
1814 
1815 extern struct type *check_typedef (struct type *);
1816 
1817 #define CHECK_TYPEDEF(TYPE) \
1818  do { \
1819  (TYPE) = check_typedef (TYPE); \
1820  } while (0)
1821 
1822 extern void check_stub_method_group (struct type *, int);
1823 
1824 extern char *gdb_mangle_name (struct type *, int, int);
1825 
1826 extern struct type *lookup_typename (const struct language_defn *,
1827  struct gdbarch *, const char *,
1828  const struct block *, int);
1829 
1830 extern struct type *lookup_template_type (char *, struct type *,
1831  const struct block *);
1832 
1833 extern int get_vptr_fieldno (struct type *, struct type **);
1834 
1835 extern int get_discrete_bounds (struct type *, LONGEST *, LONGEST *);
1836 
1837 extern int get_array_bounds (struct type *type, LONGEST *low_bound,
1838  LONGEST *high_bound);
1839 
1840 extern int discrete_position (struct type *type, LONGEST val, LONGEST *pos);
1841 
1842 extern int class_types_same_p (const struct type *, const struct type *);
1843 
1844 extern int is_ancestor (struct type *, struct type *);
1845 
1846 extern int is_public_ancestor (struct type *, struct type *);
1847 
1848 extern int is_unique_ancestor (struct type *, struct value *);
1849 
1850 /* Overload resolution */
1851 
1852 #define LENGTH_MATCH(bv) ((bv)->rank[0])
1853 
1854 /* * Badness if parameter list length doesn't match arg list length. */
1855 extern const struct rank LENGTH_MISMATCH_BADNESS;
1856 
1857 /* * Dummy badness value for nonexistent parameter positions. */
1858 extern const struct rank TOO_FEW_PARAMS_BADNESS;
1859 /* * Badness if no conversion among types. */
1860 extern const struct rank INCOMPATIBLE_TYPE_BADNESS;
1861 
1862 /* * Badness of an exact match. */
1863 extern const struct rank EXACT_MATCH_BADNESS;
1864 
1865 /* * Badness of integral promotion. */
1866 extern const struct rank INTEGER_PROMOTION_BADNESS;
1867 /* * Badness of floating promotion. */
1868 extern const struct rank FLOAT_PROMOTION_BADNESS;
1869 /* * Badness of converting a derived class pointer
1870  to a base class pointer. */
1871 extern const struct rank BASE_PTR_CONVERSION_BADNESS;
1872 /* * Badness of integral conversion. */
1873 extern const struct rank INTEGER_CONVERSION_BADNESS;
1874 /* * Badness of floating conversion. */
1875 extern const struct rank FLOAT_CONVERSION_BADNESS;
1876 /* * Badness of integer<->floating conversions. */
1877 extern const struct rank INT_FLOAT_CONVERSION_BADNESS;
1878 /* * Badness of conversion of pointer to void pointer. */
1879 extern const struct rank VOID_PTR_CONVERSION_BADNESS;
1880 /* * Badness of conversion to boolean. */
1881 extern const struct rank BOOL_CONVERSION_BADNESS;
1882 /* * Badness of converting derived to base class. */
1883 extern const struct rank BASE_CONVERSION_BADNESS;
1884 /* * Badness of converting from non-reference to reference. */
1885 extern const struct rank REFERENCE_CONVERSION_BADNESS;
1886 /* * Badness of converting integer 0 to NULL pointer. */
1887 extern const struct rank NULL_POINTER_CONVERSION;
1888 
1889 /* Non-standard conversions allowed by the debugger */
1890 
1891 /* * Converting a pointer to an int is usually OK. */
1892 extern const struct rank NS_POINTER_CONVERSION_BADNESS;
1893 
1894 /* * Badness of converting a (non-zero) integer constant
1895  to a pointer. */
1896 extern const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS;
1897 
1898 extern struct rank sum_ranks (struct rank a, struct rank b);
1899 extern int compare_ranks (struct rank a, struct rank b);
1900 
1901 extern int compare_badness (struct badness_vector *, struct badness_vector *);
1902 
1903 extern struct badness_vector *rank_function (struct type **, int,
1904  struct value **, int);
1905 
1906 extern struct rank rank_one_type (struct type *, struct type *,
1907  struct value *);
1908 
1909 extern void recursive_dump_type (struct type *, int);
1910 
1911 extern int field_is_static (struct field *);
1912 
1913 /* printcmd.c */
1914 
1915 extern void print_scalar_formatted (const void *, struct type *,
1916  const struct value_print_options *,
1917  int, struct ui_file *);
1918 
1919 extern int can_dereference (struct type *);
1920 
1921 extern int is_integral_type (struct type *);
1922 
1923 extern int is_scalar_type_recursive (struct type *);
1924 
1925 extern int class_or_union_p (const struct type *);
1926 
1927 extern void maintenance_print_type (char *, int);
1928 
1929 extern htab_t create_copied_types_hash (struct objfile *objfile);
1930 
1931 extern struct type *copy_type_recursive (struct objfile *objfile,
1932  struct type *type,
1933  htab_t copied_types);
1934 
1935 extern struct type *copy_type (const struct type *type);
1936 
1937 extern int types_equal (struct type *, struct type *);
1938 
1939 extern int types_deeply_equal (struct type *, struct type *);
1940 
1941 #endif /* GDBTYPES_H */
const struct floatformat * floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN]
B_TYPE * private_field_bits
Definition: gdbtypes.h:985
const struct floatformat * floatformats_vax_d[BFD_ENDIAN_UNKNOWN]
struct type * xmethod
Definition: gdbtypes.h:1558
const struct rank NS_POINTER_CONVERSION_BADNESS
struct rank sum_ranks(struct rank a, struct rank b)
void get_unsigned_type_max(struct type *, ULONGEST *)
struct dwarf2_per_cu_data * per_cu
Definition: gdbtypes.h:1181
type_code
Definition: gdbtypes.h:85
struct type * builtin_declong
Definition: gdbtypes.h:1501
const struct objfile_type * objfile_type(struct objfile *objfile)
#define B_TYPE
Definition: gdbtypes.h:78
union dynamic_prop_data data
Definition: gdbtypes.h:434
struct call_site * tail_call_list
Definition: gdbtypes.h:1082
struct type * builtin_func_ptr
Definition: gdbtypes.h:1544
struct type * builtin_long_double
Definition: gdbtypes.h:1492
LONGEST enumval
Definition: gdbtypes.h:509
struct type * builtin_true_unsigned_char
Definition: gdbtypes.h:1508
void maintenance_print_type(char *, int)
const struct floatformat * floatformats_ieee_half[BFD_ENDIAN_UNKNOWN]
struct type * builtin_void
Definition: gdbtypes.h:1570
int is_public_ancestor(struct type *, struct type *)
struct fn_field * fn_fields
Definition: gdbtypes.h:831
union field_location loc
Definition: gdbtypes.h:528
struct type * builtin_unsigned_int
Definition: gdbtypes.h:1488
const struct cplus_struct_type cplus_struct_default
struct badness_vector * rank_function(struct type **, int, struct value **, int)
struct type * builtin_double_complex
Definition: gdbtypes.h:1494
const struct rank REFERENCE_CONVERSION_BADNESS
struct typedef_field * typedef_field
Definition: gdbtypes.h:1012
field_loc_kind
Definition: gdbtypes.h:461
struct type * make_cv_type(int, int, struct type *, struct type **)
const struct gnat_aux_type gnat_aux_default
const struct rank BASE_PTR_CONVERSION_BADNESS
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
struct type * builtin_double
Definition: gdbtypes.h:1583
const struct rank INCOMPATIBLE_TYPE_BADNESS
struct type * builtin_long_double
Definition: gdbtypes.h:1584
const struct rank LENGTH_MISMATCH_BADNESS
void append_flags_type_flag(struct type *type, int bitpos, char *name)
const struct floatformat * floatformats_vax_f[BFD_ENDIAN_UNKNOWN]
unsigned typedef_field_count
Definition: gdbtypes.h:1014
int class_types_same_p(const struct type *, const struct type *)
const char * type_name_no_tag_or_error(struct type *type)
cu_offset param_offset
Definition: gdbtypes.h:1131
struct rank rank_one_type(struct type *, struct type *, struct value *)
struct type * builtin_func_func
Definition: gdbtypes.h:1549
int is_scalar_type_recursive(struct type *)
struct type * arch_boolean_type(struct gdbarch *, int, int, char *)
struct type * self_type
Definition: gdbtypes.h:1087
char * gdb_mangle_name(struct type *, int, int)
struct type * arch_integer_type(struct gdbarch *, int, int, char *)
struct dynamic_prop prop
Definition: gdbtypes.h:452
void append_composite_type_field_aligned(struct type *t, char *name, struct type *field, int alignment)
struct type * builtin_uint8
Definition: gdbtypes.h:1515
struct type * builtin_float
Definition: gdbtypes.h:1582
struct type * builtin_uint16
Definition: gdbtypes.h:1517
struct type * create_array_type(struct type *, struct type *, struct type *)
unsigned int bitsize
Definition: gdbtypes.h:547
struct rank * rank
Definition: gdbtypes.h:1045
int discrete_position(struct type *type, LONGEST val, LONGEST *pos)
short rank
Definition: gdbtypes.h:1027
struct type * lookup_methodptr_type(struct type *)
struct type * allocate_stub_method(struct type *)
const struct floatformat * floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN]
struct type * nodebug_data_symbol
Definition: gdbtypes.h:1597
int instance_flags
Definition: gdbtypes.h:781
struct type * lookup_reference_type(struct type *)
unsigned int sect_off
Definition: gdbtypes.h:70
void replace_type(struct type *, struct type *)
struct type * builtin_short
Definition: gdbtypes.h:1572
struct type * copy_type_recursive(struct objfile *objfile, struct type *type, htab_t copied_types)
struct type * builtin_core_addr
Definition: gdbtypes.h:1587
struct type * builtin_long_long
Definition: gdbtypes.h:1575
struct type * pointer_type
Definition: gdbtypes.h:756
struct type * builtin_complex
Definition: gdbtypes.h:1493
int compare_badness(struct badness_vector *, struct badness_vector *)
struct type * builtin_long
Definition: gdbtypes.h:1574
const struct rank FLOAT_PROMOTION_BADNESS
struct type * arch_float_type(struct gdbarch *, int, char *, const struct floatformat **)
struct dwarf2_locexpr_baton * dwarf_block
Definition: gdbtypes.h:523
void set_type_self_type(struct type *, struct type *)
struct type * reference_type
Definition: gdbtypes.h:760
struct type * copy_type(const struct type *type)
struct type * fcontext
Definition: gdbtypes.h:861
struct dynamic_prop_list * dyn_prop_list
Definition: gdbtypes.h:743
struct type * builtin_signed_char
Definition: gdbtypes.h:1576
struct type * internal_type_vptr_basetype(struct type *)
struct type * builtin_int32
Definition: gdbtypes.h:1518
struct type * create_set_type(struct type *, struct type *)
struct type * builtin_short
Definition: gdbtypes.h:1482
struct type * builtin_char16
Definition: gdbtypes.h:1526
unsigned short n_template_arguments
Definition: gdbtypes.h:946
struct type * make_function_type(struct type *, struct type **)
CORE_ADDR physaddr
Definition: gdbtypes.h:516
int get_discrete_bounds(struct type *, LONGEST *, LONGEST *)
struct type * nodebug_text_gnu_ifunc_symbol
Definition: gdbtypes.h:1595
struct type * chain
Definition: gdbtypes.h:769
struct objfile * objfile
Definition: gdbtypes.h:494
struct cplus_struct_type * cplus_stuff
Definition: gdbtypes.h:589
struct type * builtin_int128
Definition: gdbtypes.h:1522
const struct rank EXACT_MATCH_BADNESS
dynamic_prop_kind
Definition: gdbtypes.h:406
struct type * init_type(enum type_code, int, int, const char *, struct objfile *)
enum dynamic_prop_node_kind prop_kind
Definition: gdbtypes.h:449
struct type * builtin_decdouble
Definition: gdbtypes.h:1500
struct type * builtin_unsigned_long_long
Definition: gdbtypes.h:1581
struct type * builtin_unsigned_long
Definition: gdbtypes.h:1489
struct type * builtin_char32
Definition: gdbtypes.h:1527
void recursive_dump_type(struct type *, int)
int can_dereference(struct type *)
void add_dyn_prop(enum dynamic_prop_node_kind kind, struct dynamic_prop prop, struct type *type, struct objfile *objfile)
struct gnat_aux_type * gnat_stuff
Definition: gdbtypes.h:594
short vptr_fieldno
Definition: gdbtypes.h:937
call_site_parameter_kind
Definition: gdbtypes.h:1092
short subrank
Definition: gdbtypes.h:1037
struct type * lookup_function_type(struct type *)
const struct rank INTEGER_PROMOTION_BADNESS
struct type * builtin_char
Definition: gdbtypes.h:1571
const struct rank BASE_CONVERSION_BADNESS
CORE_ADDR pc
Definition: gdbtypes.h:1163
const char * name
Definition: gdbtypes.h:904
struct type * builtin_int16
Definition: gdbtypes.h:1516
const char * name
Definition: gdbtypes.h:823
struct type * builtin_unsigned_long
Definition: gdbtypes.h:1580
struct type * nodebug_tls_symbol
Definition: gdbtypes.h:1599
struct type * make_type_with_address_space(struct type *type, int space_identifier)
struct type * create_array_type_with_stride(struct type *, struct type *, struct type *, unsigned int)
htab_t create_copied_types_hash(struct objfile *objfile)
struct type * make_unqualified_type(struct type *)
Definition: gdbtypes.h:749
struct func_type * func_stuff
Definition: gdbtypes.h:605
void smash_to_methodptr_type(struct type *, struct type *)
struct type * resolve_dynamic_type(struct type *type, const gdb_byte *valaddr, CORE_ADDR addr)
struct type * builtin_int0
Definition: gdbtypes.h:1513
struct type * make_reference_type(struct type *, struct type **)
__extension__ enum field_loc_kind loc_kind
Definition: gdbtypes.h:539
const struct floatformat * floatformats_ieee_double[BFD_ENDIAN_UNKNOWN]
struct type * builtin_uint32
Definition: gdbtypes.h:1519
B_TYPE * ignore_field_bits
Definition: gdbtypes.h:998
struct dynamic_prop * get_dyn_prop(enum dynamic_prop_node_kind kind, const struct type *type)
struct gdbarch * gdbarch
Definition: gdbtypes.h:495
struct type * alloc_type_arch(struct gdbarch *)
struct type * builtin_decfloat
Definition: gdbtypes.h:1499
const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS
struct type * nodebug_got_plt_symbol
Definition: gdbtypes.h:1596
struct type * type
Definition: gdbtypes.h:908
struct type * builtin_long
Definition: gdbtypes.h:1484
void append_composite_type_field(struct type *t, char *name, struct type *field)
const struct floatformat ** floatformat
Definition: gdbtypes.h:601
const struct rank BOOL_CONVERSION_BADNESS
struct type * builtin_unsigned_char
Definition: gdbtypes.h:1486
unsigned int artificial
Definition: gdbtypes.h:535
struct type * arch_character_type(struct gdbarch *, int, int, char *)
const char * type_name_no_tag(const struct type *)
const struct rank VOID_PTR_CONVERSION_BADNESS
struct type * create_static_range_type(struct type *, struct type *, LONGEST, LONGEST)
LONGEST const_val
Definition: gdbtypes.h:419
const struct floatformat * floatformats_ieee_single[BFD_ENDIAN_UNKNOWN]
struct type * builtin_bool
Definition: gdbtypes.h:1496
struct type * builtin_uint128
Definition: gdbtypes.h:1523
struct type * builtin_unsigned_long_long
Definition: gdbtypes.h:1498
struct type * alloc_type(struct objfile *)
struct type * builtin_signed_char
Definition: gdbtypes.h:1485
struct type * builtin_unsigned_short
Definition: gdbtypes.h:1578
type_instance_flag_value
Definition: gdbtypes.h:217
struct type * create_string_type(struct type *, struct type *, struct type *)
struct type * make_pointer_type(struct type *, struct type **)
int is_ancestor(struct type *, struct type *)
struct type * builtin_string
Definition: gdbtypes.h:1495
const struct rank INT_FLOAT_CONVERSION_BADNESS
struct type * builtin_int
Definition: gdbtypes.h:1573
struct type * lookup_array_range_type(struct type *, LONGEST, LONGEST)
const struct floatformat * floatformats_i387_ext[BFD_ENDIAN_UNKNOWN]
struct type * builtin_unsigned_short
Definition: gdbtypes.h:1487
struct type * init_vector_type(struct type *elt_type, int n)
void print_scalar_formatted(const void *, struct type *, const struct value_print_options *, int, struct ui_file *)
struct type * lookup_typename(const struct language_defn *, struct gdbarch *, const char *, const struct block *, int)
struct type * nodebug_unknown_symbol
Definition: gdbtypes.h:1598
int address_space_name_to_int(struct gdbarch *, char *)
const struct rank FLOAT_CONVERSION_BADNESS
unsigned length
Definition: gdbtypes.h:807
struct type * lookup_signed_typename(const struct language_defn *, struct gdbarch *, const char *)
const char * address_space_int_to_name(struct gdbarch *, int)
int get_vptr_fieldno(struct type *, struct type **)
struct type * builtin_char
Definition: gdbtypes.h:1481
struct type * make_restrict_type(struct type *)
struct type * get_target_type(struct type *type)
const struct floatformat * floatformats_arm_ext[BFD_ENDIAN_UNKNOWN]
const struct floatformat * floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN]
const char * physname
Definition: gdbtypes.h:848
struct type * builtin_double
Definition: gdbtypes.h:1491
int is_integral_type(struct type *)
struct type * internal_fn
Definition: gdbtypes.h:1555
struct type * lookup_struct_elt_type(struct type *, const char *, int)
struct type * alloc_type_copy(const struct type *)
type_specific_kind
Definition: gdbtypes.h:481
struct fn_fieldlist * fn_fieldlists
Definition: gdbtypes.h:1007
struct type * lookup_string_range_type(struct type *, LONGEST, LONGEST)
void check_stub_method_group(struct type *, int)
struct type * lookup_memberptr_type(struct type *, struct type *)
struct type * make_atomic_type(struct type *)
const struct rank TOO_FEW_PARAMS_BADNESS
struct type * builtin_true_char
Definition: gdbtypes.h:1507
const char * physname
Definition: gdbtypes.h:517
unsigned int cu_off
Definition: gdbtypes.h:62
struct type * builtin_data_ptr
Definition: gdbtypes.h:1533
const char * name
Definition: gdbtypes.h:559
struct gdbarch * get_type_arch(const struct type *)
struct symbol ** template_arguments
Definition: gdbtypes.h:1020
int compare_ranks(struct rank a, struct rank b)
void allocate_cplus_struct_type(struct type *)
unsigned parameter_count
Definition: gdbtypes.h:1176
struct field * fields
Definition: gdbtypes.h:729
void smash_to_method_type(struct type *type, struct type *self_type, struct type *to_type, struct field *args, int nargs, int varargs)
const struct floatformat * floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN]
int get_array_bounds(struct type *type, LONGEST *low_bound, LONGEST *high_bound)
void smash_to_memberptr_type(struct type *, struct type *, struct type *)
void get_signed_type_minmax(struct type *, LONGEST *, LONGEST *)
struct type * nodebug_text_symbol
Definition: gdbtypes.h:1594
struct main_type * main_type
Definition: gdbtypes.h:811
struct type * lookup_unsigned_typename(const struct language_defn *, struct gdbarch *, const char *)
int class_or_union_p(const struct type *)
void set_type_vptr_fieldno(struct type *, int)
enum dynamic_prop_kind kind
Definition: gdbtypes.h:431
struct type * arch_composite_type(struct gdbarch *gdbarch, char *name, enum type_code code)
B_TYPE * protected_field_bits
Definition: gdbtypes.h:993
struct type * builtin_long_long
Definition: gdbtypes.h:1497
struct type * lookup_pointer_type(struct type *)
struct type * builtin_unsigned_int
Definition: gdbtypes.h:1579
short n_baseclasses
Definition: gdbtypes.h:921
B_TYPE * virtual_field_bits
Definition: gdbtypes.h:977
struct type * builtin_int64
Definition: gdbtypes.h:1520
struct call_site * tail_call_next
Definition: gdbtypes.h:1167
struct type * check_typedef(struct type *)
struct field * append_composite_type_field_raw(struct type *t, char *name, struct type *field)
struct type * self_type
Definition: gdbtypes.h:611
struct type * descriptive_type
Definition: gdbtypes.h:1055
struct type * arch_type(struct gdbarch *, enum type_code, int, char *)
struct type * lookup_template_type(char *, struct type *, const struct block *)
int is_unique_ancestor(struct type *, struct value *)
int is_dynamic_type(struct type *type)
int types_equal(struct type *, struct type *)
struct type * arch_flags_type(struct gdbarch *gdbarch, char *name, int length)
struct type * builtin_uint64
Definition: gdbtypes.h:1521
struct type * type
Definition: gdbtypes.h:856
struct type * vptr_basetype
Definition: gdbtypes.h:962
int field_is_static(struct field *)
struct type * builtin_int8
Definition: gdbtypes.h:1514
const struct floatformat * floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN]
struct type * builtin_void
Definition: gdbtypes.h:1480
type_flag_value
Definition: gdbtypes.h:194
dynamic_prop_node_kind
Definition: gdbtypes.h:438
struct range_bounds * bounds
Definition: gdbtypes.h:733
int types_deeply_equal(struct type *, struct type *)
struct type * create_range_type(struct type *, struct type *, const struct dynamic_prop *, const struct dynamic_prop *)
struct dynamic_prop_list * next
Definition: gdbtypes.h:455
struct type * internal_type_self_type(struct type *)
struct type * builtin_unsigned_char
Definition: gdbtypes.h:1577
struct type * builtin_error
Definition: gdbtypes.h:1591
struct type * arch_complex_type(struct gdbarch *, char *, struct type *)
struct type * builtin_float
Definition: gdbtypes.h:1490
const struct rank NULL_POINTER_CONVERSION
void set_type_vptr_basetype(struct type *, struct type *)
struct type * builtin_int
Definition: gdbtypes.h:1483
void allocate_gnat_aux_type(struct type *)
const struct rank INTEGER_CONVERSION_BADNESS
struct type * lookup_function_type_with_arguments(struct type *, int, struct type **)
void make_vector_type(struct type *array_type)
int internal_type_vptr_fieldno(struct type *)