1 /* Internal type definitions for GDB.
2 Copyright (C) 1992 Free Software Foundation, Inc.
3 Contributed by Cygnus Support, using pieces from other GDB modules.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 #if !defined (GDBTYPES_H)
24 /* Codes for `fundamental types'. This is a monstrosity based on the
25 bogus notion that there are certain compiler-independent
26 `fundamental types'. None of these is well-defined (how big is
27 FT_SHORT? Does it depend on the language? How does the
28 language-specific code know which type to correlate to FT_SHORT?) */
33 #define FT_SIGNED_CHAR 3
34 #define FT_UNSIGNED_CHAR 4
36 #define FT_SIGNED_SHORT 6
37 #define FT_UNSIGNED_SHORT 7
39 #define FT_SIGNED_INTEGER 9
40 #define FT_UNSIGNED_INTEGER 10
42 #define FT_SIGNED_LONG 12
43 #define FT_UNSIGNED_LONG 13
44 #define FT_LONG_LONG 14
45 #define FT_SIGNED_LONG_LONG 15
46 #define FT_UNSIGNED_LONG_LONG 16
48 #define FT_DBL_PREC_FLOAT 18
49 #define FT_EXT_PREC_FLOAT 19
51 #define FT_DBL_PREC_COMPLEX 21
52 #define FT_EXT_PREC_COMPLEX 22
54 #define FT_FIXED_DECIMAL 24
55 #define FT_FLOAT_DECIMAL 25
57 #define FT_UNSIGNED_BYTE 27
59 #define FT_NUM_MEMBERS 28 /* Highest FT_* above, plus one. */
61 /* Some macros for char-based bitfields. */
63 #define B_SET(a,x) ((a)[(x)>>3] |= (1 << ((x)&7)))
64 #define B_CLR(a,x) ((a)[(x)>>3] &= ~(1 << ((x)&7)))
65 #define B_TST(a,x) ((a)[(x)>>3] & (1 << ((x)&7)))
66 #define B_TYPE unsigned char
67 #define B_BYTES(x) ( 1 + ((x)>>3) )
68 #define B_CLRALL(a,x) memset ((a), 0, B_BYTES(x))
70 /* Different kinds of data types are distinguished by the `code' field. */
74 TYPE_CODE_UNDEF, /* Not used; catches errors */
75 TYPE_CODE_PTR, /* Pointer type */
76 TYPE_CODE_ARRAY, /* Array type with lower & upper bounds. */
77 TYPE_CODE_STRUCT, /* C struct or Pascal record */
78 TYPE_CODE_UNION, /* C union or Pascal variant part */
79 TYPE_CODE_ENUM, /* Enumeration type */
80 TYPE_CODE_FUNC, /* Function type */
81 TYPE_CODE_INT, /* Integer type */
83 /* Floating type. This is *NOT* a complex type. Complex types, when
84 we have them, will have their own type code (or TYPE_CODE_ERROR if
85 we can parse a complex type but not manipulate it). There are parts
86 of GDB which bogusly assume that TYPE_CODE_FLT can mean complex. */
89 /* Void type. The length field specifies the length (probably always
90 one) which is used in pointer arithmetic involving pointers to
91 this type, but actually dereferencing such a pointer is invalid;
92 a void type has no length and no actual representation in memory
93 or registers. A pointer to a void type is a generic pointer. */
96 TYPE_CODE_SET, /* Pascal sets */
97 TYPE_CODE_RANGE, /* Range (integers within spec'd bounds) */
99 /* A string type which is like an array of character but prints
100 differently (at least for CHILL). It does not contain a length
101 field as Pascal strings (for many Pascals, anyway) do; if we want
102 to deal with such strings, we should use a new type code. */
105 /* String of bits; like TYPE_CODE_SET but prints differently (at least
109 /* Unknown type. The length field is valid if we were able to
110 deduce that much about the type, or 0 if we don't even know that. */
114 TYPE_CODE_MEMBER, /* Member type */
115 TYPE_CODE_METHOD, /* Method type */
116 TYPE_CODE_REF, /* C++ Reference types */
118 TYPE_CODE_CHAR, /* *real* character type */
120 /* Boolean type. 0 is false, 1 is true, and other values are non-boolean
121 (e.g. FORTRAN "logical" used as unsigned int). */
125 /* For now allow source to use TYPE_CODE_CLASS for C++ classes, as an
126 alias for TYPE_CODE_STRUCT. This is for DWARF, which has a distinct
127 "class" attribute. Perhaps we should actually have a separate TYPE_CODE
128 so that we can print "class" or "struct" depending on what the debug
129 info said. It's not clear we should bother. */
131 #define TYPE_CODE_CLASS TYPE_CODE_STRUCT
133 /* Some bits for the type's flags word. */
135 /* Unsigned integer type. If this is not set for a TYPE_CODE_INT, the
138 #define TYPE_FLAG_UNSIGNED (1 << 0)
140 /* This appears in a type's flags word if it is a stub type (e.g., if
141 someone referenced a type that wasn't defined in a source file
142 via (struct sir_not_appearing_in_this_film *)). */
144 #define TYPE_FLAG_STUB (1 << 2)
146 /* The target type of this type is a stub type, and this type needs to
147 be updated if it gets un-stubbed in check_stub_type. Currently only
148 used for arrays, in which TYPE_LENGTH of the array gets set based
149 on the TYPE_LENGTH of the target type. */
151 #define TYPE_FLAG_TARGET_STUB (1 << 3)
156 /* Code for kind of type */
160 /* Name of this type, or NULL if none.
162 This is used for printing only, except by poorly designed C++ code.
163 For looking up a name, look for a symbol in the VAR_NAMESPACE. */
167 /* Tag name for this type, or NULL if none. This means that the
168 name of the type consists of a keyword followed by the tag name.
169 Which keyword is determined by the type code ("struct" for
170 TYPE_CODE_STRUCT, etc.). As far as I know C/C++ are the only languages
173 This is used for printing only, except by poorly designed C++ code.
174 For looking up a name, look for a symbol in the STRUCT_NAMESPACE.
175 One more legitimate use is that if TYPE_FLAG_STUB is set, this is
176 the name to use to look for definitions in other files. */
180 /* Length, in units of TARGET_CHAR_BIT bits,
181 of storage for a value of this type */
185 /* Every type is now associated with a particular objfile, and the
186 type is allocated on the type_obstack for that objfile. One problem
187 however, is that there are times when gdb allocates new types while
188 it is not in the process of reading symbols from a particular objfile.
189 Fortunately, these happen when the type being created is a derived
190 type of an existing type, such as in lookup_pointer_type(). So
191 we can just allocate the new type using the same objfile as the
192 existing type, but to do this we need a backpointer to the objfile
193 from the existing type. Yes this is somewhat ugly, but without
194 major overhaul of the internal type system, it can't be avoided
197 struct objfile *objfile;
199 /* For a pointer type, describes the type of object pointed to.
200 For an array type, describes the type of the elements.
201 For a function or method type, describes the type of the return value.
202 For a range type, describes the type of the full range.
205 struct type *target_type;
207 /* Type that is a pointer to this type.
208 NULL if no such pointer-to type is known yet.
209 The debugger may add the address of such a type
210 if it has to construct one later. */
212 struct type *pointer_type;
214 /* C++: also need a reference type. */
216 struct type *reference_type;
218 /* Type that is a function returning this type.
219 NULL if no such function type is known here.
220 The debugger may add the address of such a type
221 if it has to construct one later. */
223 struct type *function_type;
225 /* Flags about this type. */
229 /* Number of fields described for this type */
233 /* For structure and union types, a description of each field.
234 For set and pascal array types, there is one "field",
235 whose type is the domain type of the set or array.
236 For range types, there are two "fields",
237 the minimum and maximum values (both inclusive).
238 For enum types, each possible value is described by one "field".
239 For C++ classes, there is one field for each base class (if it is
240 a derived class) plus one field for each class data member. Member
241 functions are recorded elsewhere.
243 Using a pointer to a separate array of fields
244 allows all types to have the same size, which is useful
245 because we can allocate the space for a type before
246 we know what to put in it. */
251 /* Position of this field, counting in bits from start of
252 containing structure. For a function type, this is the
253 position in the argument list of this argument.
254 For a range bound or enum value, this is the value itself.
255 (FIXME: What about ranges larger than host int size?)
256 For BITS_BIG_ENDIAN=1 targets, it is the bit offset to the MSB.
257 For BITS_BIG_ENDIAN=0 targets, it is the bit offset to the LSB. */
261 /* Size of this field, in bits, or zero if not packed.
262 For an unpacked field, the field's type's length
263 says how many bytes the field occupies. */
264 /* FIXME: This is abused by TYPE_FIELD_STATIC_PHYSNAME to contain
265 a pointer, so it has to be long. */
269 /* In a struct or enum type, type of this field.
270 In a function type, type of this argument.
271 In an array type, the domain-type of the array. */
275 /* Name of field, value or argument.
276 NULL for range bounds and array domains. */
282 /* For types with virtual functions, VPTR_BASETYPE is the base class which
283 defined the virtual function table pointer.
285 For types that are pointer to member types, VPTR_BASETYPE
286 is the type that this pointer is a member of.
290 struct type *vptr_basetype;
292 /* Field number of the virtual function table pointer in
293 VPTR_BASETYPE. If -1, we were unable to find the virtual
294 function table pointer in initial symbol reading, and
295 fill_in_vptr_fieldno should be called to find it if possible.
297 Unused if this type does not have virtual functions. */
301 /* Slot to point to additional language-specific fields of this type. */
306 /* ARG_TYPES is for TYPE_CODE_METHOD and TYPE_CODE_FUNC. */
308 struct type **arg_types;
310 /* CPLUS_STUFF is for TYPE_CODE_STRUCT. It is initialized to point to
311 cplus_struct_default, a default static instance of a struct
312 cplus_struct_type. */
314 struct cplus_struct_type *cplus_stuff;
319 #define NULL_TYPE ((struct type *) 0)
321 /* C++ language-specific information for TYPE_CODE_STRUCT and TYPE_CODE_UNION
324 struct cplus_struct_type
326 /* Number of base classes this type derives from. The baseclasses are
327 stored in the first N_BASECLASSES fields (i.e. the `fields' field of
328 the struct type). I think only the `type' field of such a field has
333 /* Number of methods with unique names. All overloaded methods with
334 the same name count only once. */
338 /* Number of methods described for this type plus all the
339 methods that it derives from. */
341 int nfn_fields_total;
343 /* For derived classes, the number of base classes is given by n_baseclasses
344 and virtual_field_bits is a bit vector containing one bit per base class.
345 If the base class is virtual, the corresponding bit will be set.
350 class C : public B, public virtual A {};
352 B is a baseclass of C; A is a virtual baseclass for C.
353 This is a C++ 2.0 language feature. */
355 B_TYPE *virtual_field_bits;
357 /* For classes with private fields, the number of fields is given by
358 nfields and private_field_bits is a bit vector containing one bit
360 If the field is private, the corresponding bit will be set. */
362 B_TYPE *private_field_bits;
364 /* For classes with protected fields, the number of fields is given by
365 nfields and protected_field_bits is a bit vector containing one bit
367 If the field is private, the corresponding bit will be set. */
369 B_TYPE *protected_field_bits;
371 /* for classes with fields to be ignored, either this is optimized out
372 or this field has length 0 */
374 B_TYPE *ignore_field_bits;
376 /* For classes, structures, and unions, a description of each field,
377 which consists of an overloaded name, followed by the types of
378 arguments that the method expects, and then the name after it
379 has been renamed to make it distinct.
381 fn_fieldlists points to an array of nfn_fields of these. */
386 /* The overloaded name. */
390 /* The number of methods with this name. */
394 /* The list of methods. */
399 /* If is_stub is clear, this is the mangled name which we can
400 look up to find the address of the method (FIXME: it would
401 be cleaner to have a pointer to the struct symbol here
404 /* If is_stub is set, this is the portion of the mangled
405 name which specifies the arguments. For example, "ii",
406 if there are two int arguments, or "" if there are no
407 arguments. See gdb_mangle_name for the conversion from this
408 format to the one used if is_stub is clear. */
412 /* The return value of the method */
416 /* The argument list. Only valid if is_stub is clear. Contains
417 the type of each argument, including `this', and ending with
418 a NULL pointer after the last argument. Should not contain
419 a `this' pointer for static member functions. */
423 /* For virtual functions.
424 First baseclass that defines this virtual function. */
426 struct type *fcontext;
430 unsigned int is_const : 1;
431 unsigned int is_volatile : 1;
432 unsigned int is_private : 1;
433 unsigned int is_protected : 1;
435 /* A stub method only has some fields valid (but they are enough
436 to reconstruct the rest of the fields). */
437 unsigned int is_stub : 1;
440 unsigned int dummy : 3;
442 /* Index into that baseclass's virtual function table,
443 minus 2; else if static: VOFFSET_STATIC; else: 0. */
445 unsigned int voffset : 24;
447 # define VOFFSET_STATIC 1
455 /* The default value of TYPE_CPLUS_SPECIFIC(T) points to the
456 this shared static structure. */
458 extern const struct cplus_struct_type cplus_struct_default;
461 allocate_cplus_struct_type PARAMS ((struct type *));
463 #define INIT_CPLUS_SPECIFIC(type) \
464 (TYPE_CPLUS_SPECIFIC(type)=(struct cplus_struct_type*)&cplus_struct_default)
465 #define ALLOCATE_CPLUS_STRUCT_TYPE(type) allocate_cplus_struct_type (type)
466 #define HAVE_CPLUS_STRUCT(type) \
467 (TYPE_CPLUS_SPECIFIC(type) != &cplus_struct_default)
469 #define TYPE_NAME(thistype) (thistype)->name
470 #define TYPE_TAG_NAME(type) ((type)->tag_name)
471 #define TYPE_TARGET_TYPE(thistype) (thistype)->target_type
472 #define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type
473 #define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type
474 #define TYPE_FUNCTION_TYPE(thistype) (thistype)->function_type
475 #define TYPE_LENGTH(thistype) (thistype)->length
476 #define TYPE_OBJFILE(thistype) (thistype)->objfile
477 #define TYPE_FLAGS(thistype) (thistype)->flags
478 #define TYPE_UNSIGNED(thistype) ((thistype)->flags & TYPE_FLAG_UNSIGNED)
479 #define TYPE_CODE(thistype) (thistype)->code
480 #define TYPE_NFIELDS(thistype) (thistype)->nfields
481 #define TYPE_FIELDS(thistype) (thistype)->fields
483 #define TYPE_LOW_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 0)
484 #define TYPE_HIGH_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 1)
485 /* If TYPE_DUMMY_RANGE is true for a range type, it was allocated
486 by force_to_range_type. */
487 #define TYPE_DUMMY_RANGE(type) ((type)->vptr_fieldno)
491 #define TYPE_VPTR_BASETYPE(thistype) (thistype)->vptr_basetype
492 #define TYPE_DOMAIN_TYPE(thistype) (thistype)->vptr_basetype
493 #define TYPE_VPTR_FIELDNO(thistype) (thistype)->vptr_fieldno
494 #define TYPE_FN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fields
495 #define TYPE_NFN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields
496 #define TYPE_NFN_FIELDS_TOTAL(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields_total
497 #define TYPE_TYPE_SPECIFIC(thistype) (thistype)->type_specific
498 #define TYPE_ARG_TYPES(thistype) (thistype)->type_specific.arg_types
499 #define TYPE_CPLUS_SPECIFIC(thistype) (thistype)->type_specific.cplus_stuff
500 #define TYPE_BASECLASS(thistype,index) (thistype)->fields[index].type
501 #define TYPE_N_BASECLASSES(thistype) TYPE_CPLUS_SPECIFIC(thistype)->n_baseclasses
502 #define TYPE_BASECLASS_NAME(thistype,index) (thistype)->fields[index].name
503 #define TYPE_BASECLASS_BITPOS(thistype,index) (thistype)->fields[index].bitpos
504 #define BASETYPE_VIA_PUBLIC(thistype, index) (!TYPE_FIELD_PRIVATE(thistype, index))
505 #define BASETYPE_VIA_VIRTUAL(thistype, index) \
506 B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (index))
508 #define TYPE_FIELD(thistype, n) (thistype)->fields[n]
509 #define TYPE_FIELD_TYPE(thistype, n) (thistype)->fields[n].type
510 #define TYPE_FIELD_NAME(thistype, n) (thistype)->fields[n].name
511 #define TYPE_FIELD_VALUE(thistype, n) (* (int*) &(thistype)->fields[n].type)
512 #define TYPE_FIELD_BITPOS(thistype, n) (thistype)->fields[n].bitpos
513 #define TYPE_FIELD_BITSIZE(thistype, n) (thistype)->fields[n].bitsize
514 #define TYPE_FIELD_PACKED(thistype, n) (thistype)->fields[n].bitsize
516 #define TYPE_FIELD_PRIVATE_BITS(thistype) \
517 TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits
518 #define TYPE_FIELD_PROTECTED_BITS(thistype) \
519 TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits
520 #define TYPE_FIELD_IGNORE_BITS(thistype) \
521 TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits
522 #define TYPE_FIELD_VIRTUAL_BITS(thistype) \
523 TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits
524 #define SET_TYPE_FIELD_PRIVATE(thistype, n) \
525 B_SET (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n))
526 #define SET_TYPE_FIELD_PROTECTED(thistype, n) \
527 B_SET (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n))
528 #define SET_TYPE_FIELD_IGNORE(thistype, n) \
529 B_SET (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n))
530 #define SET_TYPE_FIELD_VIRTUAL(thistype, n) \
531 B_SET (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
532 #define TYPE_FIELD_PRIVATE(thistype, n) \
533 (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits == NULL ? 0 \
534 : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n)))
535 #define TYPE_FIELD_PROTECTED(thistype, n) \
536 (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits == NULL ? 0 \
537 : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n)))
538 #define TYPE_FIELD_IGNORE(thistype, n) \
539 (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits == NULL ? 0 \
540 : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n)))
541 #define TYPE_FIELD_VIRTUAL(thistype, n) \
542 B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
544 #define TYPE_FIELD_STATIC(thistype, n) ((thistype)->fields[n].bitpos == -1)
545 #define TYPE_FIELD_STATIC_PHYSNAME(thistype, n) ((char *)(thistype)->fields[n].bitsize)
547 #define TYPE_FN_FIELDLISTS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists
548 #define TYPE_FN_FIELDLIST(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n]
549 #define TYPE_FN_FIELDLIST1(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].fn_fields
550 #define TYPE_FN_FIELDLIST_NAME(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].name
551 #define TYPE_FN_FIELDLIST_LENGTH(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].length
553 #define TYPE_FN_FIELD(thisfn, n) (thisfn)[n]
554 #define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname
555 #define TYPE_FN_FIELD_TYPE(thisfn, n) (thisfn)[n].type
556 #define TYPE_FN_FIELD_ARGS(thisfn, n) TYPE_ARG_TYPES ((thisfn)[n].type)
557 #define TYPE_FN_FIELD_CONST(thisfn, n) ((thisfn)[n].is_const)
558 #define TYPE_FN_FIELD_VOLATILE(thisfn, n) ((thisfn)[n].is_volatile)
559 #define TYPE_FN_FIELD_PRIVATE(thisfn, n) ((thisfn)[n].is_private)
560 #define TYPE_FN_FIELD_PROTECTED(thisfn, n) ((thisfn)[n].is_protected)
561 #define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub)
562 #define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext)
563 #define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
564 #define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1)
565 #define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)
567 extern struct type *builtin_type_void;
568 extern struct type *builtin_type_char;
569 extern struct type *builtin_type_short;
570 extern struct type *builtin_type_int;
571 extern struct type *builtin_type_long;
572 extern struct type *builtin_type_signed_char;
573 extern struct type *builtin_type_unsigned_char;
574 extern struct type *builtin_type_unsigned_short;
575 extern struct type *builtin_type_unsigned_int;
576 extern struct type *builtin_type_unsigned_long;
577 extern struct type *builtin_type_float;
578 extern struct type *builtin_type_double;
579 extern struct type *builtin_type_long_double;
580 extern struct type *builtin_type_complex;
581 extern struct type *builtin_type_double_complex;
582 extern struct type *builtin_type_string;
584 /* This type represents a type that was unrecognized in symbol
587 extern struct type *builtin_type_error;
589 extern struct type *builtin_type_long_long;
590 extern struct type *builtin_type_unsigned_long_long;
594 extern struct type *builtin_type_m2_char;
595 extern struct type *builtin_type_m2_int;
596 extern struct type *builtin_type_m2_card;
597 extern struct type *builtin_type_m2_real;
598 extern struct type *builtin_type_m2_bool;
602 extern struct type *builtin_type_chill_bool;
603 extern struct type *builtin_type_chill_char;
604 extern struct type *builtin_type_chill_long;
605 extern struct type *builtin_type_chill_ulong;
606 extern struct type *builtin_type_chill_real;
608 /* Maximum and minimum values of built-in types */
610 #define MAX_OF_TYPE(t) \
611 TYPE_UNSIGNED(t) ? UMAX_OF_SIZE(TYPE_LENGTH(t)) \
612 : MAX_OF_SIZE(TYPE_LENGTH(t))
614 #define MIN_OF_TYPE(t) \
615 TYPE_UNSIGNED(t) ? UMIN_OF_SIZE(TYPE_LENGTH(t)) \
616 : MIN_OF_SIZE(TYPE_LENGTH(t))
618 /* Allocate space for storing data associated with a particular type.
619 We ensure that the space is allocated using the same mechanism that
620 was used to allocate the space for the type structure itself. I.E.
621 if the type is on an objfile's type_obstack, then the space for data
622 associated with that type will also be allocated on the type_obstack.
623 If the type is not associated with any particular objfile (such as
624 builtin types), then the data space will be allocated with xmalloc,
625 the same as for the type structure. */
627 #define TYPE_ALLOC(t,size) \
628 (TYPE_OBJFILE (t) != NULL \
629 ? obstack_alloc (&TYPE_OBJFILE (t) -> type_obstack, size) \
633 alloc_type PARAMS ((struct objfile *));
636 init_type PARAMS ((enum type_code, int, int, char *, struct objfile *));
639 lookup_reference_type PARAMS ((struct type *));
642 make_reference_type PARAMS ((struct type *, struct type **));
645 lookup_member_type PARAMS ((struct type *, struct type *));
648 smash_to_method_type PARAMS ((struct type *, struct type *, struct type *,
652 smash_to_member_type PARAMS ((struct type *, struct type *, struct type *));
655 allocate_stub_method PARAMS ((struct type *));
658 type_name_no_tag PARAMS ((const struct type *));
661 lookup_struct_elt_type PARAMS ((struct type *, char *, int));
664 make_pointer_type PARAMS ((struct type *, struct type **));
667 lookup_pointer_type PARAMS ((struct type *));
670 make_function_type PARAMS ((struct type *, struct type **));
673 lookup_function_type PARAMS ((struct type *));
676 create_range_type PARAMS ((struct type *, struct type *, int, int));
679 create_array_type PARAMS ((struct type *, struct type *, struct type *));
682 create_string_type PARAMS ((struct type *, struct type *));
685 create_set_type PARAMS ((struct type *, struct type *));
688 lookup_unsigned_typename PARAMS ((char *));
691 lookup_signed_typename PARAMS ((char *));
694 check_stub_type PARAMS ((struct type *));
697 check_stub_method PARAMS ((struct type *, int, int));
700 lookup_primitive_typename PARAMS ((char *));
703 gdb_mangle_name PARAMS ((struct type *, int, int));
706 builtin_type PARAMS ((char **));
709 lookup_typename PARAMS ((char *, struct block *, int));
712 lookup_template_type PARAMS ((char *, struct type *, struct block *));
715 lookup_fundamental_type PARAMS ((struct objfile *, int));
718 fill_in_vptr_fieldno PARAMS ((struct type *));
721 extern void recursive_dump_type PARAMS ((struct type *, int));
727 print_scalar_formatted PARAMS ((char *, struct type *, int, int, GDB_FILE *));
730 extern void maintenance_print_type PARAMS ((char *, int));
733 #endif /* GDBTYPES_H */