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