/* Internal type definitions for GDB.
- Copyright (C) 1992, 1993, 1994, 1996, 1998, 1999
- Free Software Foundation, Inc.
+
+ Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+ 2002, 2003, 2004, 2006, 2007 Free Software Foundation, Inc.
+
Contributed by Cygnus Support, using pieces from other GDB modules.
This file is part of GDB.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
#if !defined (GDBTYPES_H)
#define GDBTYPES_H 1
+#include "hashtab.h"
+
+/* Forward declarations for prototypes. */
+struct field;
+struct block;
+
/* Codes for `fundamental types'. This is a monstrosity based on the
bogus notion that there are certain compiler-independent
`fundamental types'. None of these is well-defined (how big is
{
TYPE_CODE_UNDEF, /* Not used; catches errors */
TYPE_CODE_PTR, /* Pointer type */
- TYPE_CODE_ARRAY, /* Array type with lower & upper bounds. */
+
+ /* Array type with lower & upper bounds.
+
+ Regardless of the language, GDB represents multidimensional
+ array types the way C does: as arrays of arrays. So an
+ instance of a GDB array type T can always be seen as a series
+ of instances of TYPE_TARGET_TYPE (T) laid out sequentially in
+ memory.
+
+ Row-major languages like C lay out multi-dimensional arrays so
+ that incrementing the rightmost index in a subscripting
+ expression results in the smallest change in the address of the
+ element referred to. Column-major languages like Fortran lay
+ them out so that incrementing the leftmost index results in the
+ smallest change.
+
+ This means that, in column-major languages, working our way
+ from type to target type corresponds to working through indices
+ from right to left, not left to right. */
+ TYPE_CODE_ARRAY,
+
TYPE_CODE_STRUCT, /* C struct or Pascal record */
TYPE_CODE_UNION, /* C union or Pascal variant part */
TYPE_CODE_ENUM, /* Enumeration type */
+ TYPE_CODE_FLAGS, /* Bit flags type */
TYPE_CODE_FUNC, /* Function type */
TYPE_CODE_INT, /* Integer type */
TYPE_CODE_RANGE, /* Range (integers within spec'd bounds) */
/* A string type which is like an array of character but prints
- differently (at least for CHILL). It does not contain a length
- field as Pascal strings (for many Pascals, anyway) do; if we want
- to deal with such strings, we should use a new type code. */
+ differently (at least for (the deleted) CHILL). It does not
+ contain a length field as Pascal strings (for many Pascals,
+ anyway) do; if we want to deal with such strings, we should use
+ a new type code. */
TYPE_CODE_STRING,
- /* String of bits; like TYPE_CODE_SET but prints differently (at least
- for CHILL). */
+ /* String of bits; like TYPE_CODE_SET but prints differently (at
+ least for (the deleted) CHILL). */
TYPE_CODE_BITSTRING,
/* Unknown type. The length field is valid if we were able to
TYPE_CODE_ERROR,
/* C++ */
- TYPE_CODE_MEMBER, /* Member type */
TYPE_CODE_METHOD, /* Method type */
+
+ /* Pointer-to-member-function type. This describes how to access a
+ particular member function of a class (possibly a virtual
+ member function). The representation may vary between different
+ C++ ABIs. */
+ TYPE_CODE_METHODPTR,
+
+ /* Pointer-to-member type. This is the offset within a class to some
+ particular data member. The only currently supported representation
+ uses an unbiased offset, with -1 representing NULL; this is used
+ by the Itanium C++ ABI (used by GCC on all platforms). */
+ TYPE_CODE_MEMBERPTR,
+
TYPE_CODE_REF, /* C++ Reference types */
TYPE_CODE_CHAR, /* *real* character type */
TYPE_CODE_TYPEDEF,
TYPE_CODE_TEMPLATE, /* C++ template */
- TYPE_CODE_TEMPLATE_ARG /* C++ template arg */
+ TYPE_CODE_TEMPLATE_ARG, /* C++ template arg */
+ TYPE_CODE_NAMESPACE /* C++ namespace. */
};
/* For now allow source to use TYPE_CODE_CLASS for C++ classes, as an
#define TYPE_CODE_CLASS TYPE_CODE_STRUCT
-/* Some bits for the type's flags word. */
+/* Some bits for the type's flags word, and macros to test them. */
/* Unsigned integer type. If this is not set for a TYPE_CODE_INT, the
type is signed (unless TYPE_FLAG_NOSIGN (below) is set). */
#define TYPE_FLAG_UNSIGNED (1 << 0)
+#define TYPE_UNSIGNED(t) (TYPE_FLAGS (t) & TYPE_FLAG_UNSIGNED)
/* No sign for this type. In C++, "char", "signed char", and "unsigned
char" are distinct types; so we need an extra flag to indicate the
- absence ofa sign! */
+ absence of a sign! */
#define TYPE_FLAG_NOSIGN (1 << 1)
+#define TYPE_NOSIGN(t) (TYPE_FLAGS (t) & TYPE_FLAG_NOSIGN)
/* This appears in a type's flags word if it is a stub type (e.g., if
someone referenced a type that wasn't defined in a source file
via (struct sir_not_appearing_in_this_film *)). */
#define TYPE_FLAG_STUB (1 << 2)
+#define TYPE_STUB(t) (TYPE_FLAGS (t) & TYPE_FLAG_STUB)
/* The target type of this type is a stub type, and this type needs to
be updated if it gets un-stubbed in check_typedef.
gets set based on the TYPE_LENGTH of the target type.
Also, set for TYPE_CODE_TYPEDEF. */
-#define TYPE_FLAG_TARGET_STUB (1 << 3)
+#define TYPE_FLAG_TARGET_STUB (1 << 3)
+#define TYPE_TARGET_STUB(t) (TYPE_FLAGS (t) & TYPE_FLAG_TARGET_STUB)
/* Static type. If this is set, the corresponding type had
* a static modifier.
* are indicated by other means (bitpos == -1)
*/
-#define TYPE_FLAG_STATIC (1 << 4)
+#define TYPE_FLAG_STATIC (1 << 4)
+#define TYPE_STATIC(t) (TYPE_FLAGS (t) & TYPE_FLAG_STATIC)
/* Constant type. If this is set, the corresponding type has a
* const modifier.
*/
-#define TYPE_FLAG_CONST (1 << 5)
+#define TYPE_FLAG_CONST (1 << 5)
+#define TYPE_CONST(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_FLAG_CONST)
/* Volatile type. If this is set, the corresponding type has a
* volatile modifier.
*/
-#define TYPE_FLAG_VOLATILE (1 << 6)
+#define TYPE_FLAG_VOLATILE (1 << 6)
+#define TYPE_VOLATILE(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_FLAG_VOLATILE)
/* This is a function type which appears to have a prototype. We need this
for function calls in order to tell us if it's necessary to coerce the args,
or to just do the standard conversions. This is used with a short field. */
-#define TYPE_FLAG_PROTOTYPED (1 << 7)
+#define TYPE_FLAG_PROTOTYPED (1 << 7)
+#define TYPE_PROTOTYPED(t) (TYPE_FLAGS (t) & TYPE_FLAG_PROTOTYPED)
/* This flag is used to indicate that processing for this type
is incomplete.
info; the incomplete type has to be marked so that the class and
the method can be assigned correct types.) */
-#define TYPE_FLAG_INCOMPLETE (1 << 8)
+#define TYPE_FLAG_INCOMPLETE (1 << 8)
+#define TYPE_INCOMPLETE(t) (TYPE_FLAGS (t) & TYPE_FLAG_INCOMPLETE)
+
+/* Instruction-space delimited type. This is for Harvard architectures
+ which have separate instruction and data address spaces (and perhaps
+ others).
+
+ GDB usually defines a flat address space that is a superset of the
+ architecture's two (or more) address spaces, but this is an extension
+ of the architecture's model.
+
+ If TYPE_FLAG_INST is set, an object of the corresponding type
+ resides in instruction memory, even if its address (in the extended
+ flat address space) does not reflect this.
+
+ Similarly, if TYPE_FLAG_DATA is set, then an object of the
+ corresponding type resides in the data memory space, even if
+ this is not indicated by its (flat address space) address.
+
+ If neither flag is set, the default space for functions / methods
+ is instruction space, and for data objects is data memory. */
+
+#define TYPE_FLAG_CODE_SPACE (1 << 9)
+#define TYPE_CODE_SPACE(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_FLAG_CODE_SPACE)
+
+#define TYPE_FLAG_DATA_SPACE (1 << 10)
+#define TYPE_DATA_SPACE(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_FLAG_DATA_SPACE)
+
+/* FIXME drow/2002-06-03: Only used for methods, but applies as well
+ to functions. */
+
+#define TYPE_FLAG_VARARGS (1 << 11)
+#define TYPE_VARARGS(t) (TYPE_FLAGS (t) & TYPE_FLAG_VARARGS)
+
+/* Identify a vector type. Gcc is handling this by adding an extra
+ attribute to the array type. We slurp that in as a new flag of a
+ type. This is used only in dwarf2read.c. */
+#define TYPE_FLAG_VECTOR (1 << 12)
+#define TYPE_VECTOR(t) (TYPE_FLAGS (t) & TYPE_FLAG_VECTOR)
+
+/* Address class flags. Some environments provide for pointers whose
+ size is different from that of a normal pointer or address types
+ where the bits are interpreted differently than normal addresses. The
+ TYPE_FLAG_ADDRESS_CLASS_n flags may be used in target specific
+ ways to represent these different types of address classes. */
+#define TYPE_FLAG_ADDRESS_CLASS_1 (1 << 13)
+#define TYPE_ADDRESS_CLASS_1(t) (TYPE_INSTANCE_FLAGS(t) \
+ & TYPE_FLAG_ADDRESS_CLASS_1)
+#define TYPE_FLAG_ADDRESS_CLASS_2 (1 << 14)
+#define TYPE_ADDRESS_CLASS_2(t) (TYPE_INSTANCE_FLAGS(t) \
+ & TYPE_FLAG_ADDRESS_CLASS_2)
+#define TYPE_FLAG_ADDRESS_CLASS_ALL (TYPE_FLAG_ADDRESS_CLASS_1 \
+ | TYPE_FLAG_ADDRESS_CLASS_2)
+#define TYPE_ADDRESS_CLASS_ALL(t) (TYPE_INSTANCE_FLAGS(t) \
+ & TYPE_FLAG_ADDRESS_CLASS_ALL)
+
+/* The debugging formats (especially STABS) do not contain enough information
+ to represent all Ada types---especially those whose size depends on
+ dynamic quantities. Therefore, the GNAT Ada compiler includes
+ extra information in the form of additional type definitions
+ connected by naming conventions. This flag indicates that the
+ type is an ordinary (unencoded) GDB type that has been created from
+ the necessary run-time information, and does not need further
+ interpretation. Optionally marks ordinary, fixed-size GDB type. */
+
+#define TYPE_FLAG_FIXED_INSTANCE (1 << 15)
+
+/* This debug target supports TYPE_STUB(t). In the unsupported case we have to
+ rely on NFIELDS to be zero etc., see TYPE_IS_OPAQUE ().
+ TYPE_STUB(t) with !TYPE_STUB_SUPPORTED(t) may exist if we only guessed
+ the TYPE_STUB(t) value (see dwarfread.c). */
+
+#define TYPE_FLAG_STUB_SUPPORTED (1 << 16)
+#define TYPE_STUB_SUPPORTED(t) (TYPE_FLAGS (t) & TYPE_FLAG_STUB_SUPPORTED)
+
+/* Array bound type. */
+enum array_bound_type
+{
+ BOUND_SIMPLE = 0,
+ BOUND_BY_VALUE_IN_REG,
+ BOUND_BY_REF_IN_REG,
+ BOUND_BY_VALUE_ON_STACK,
+ BOUND_BY_REF_ON_STACK,
+ BOUND_CANNOT_BE_DETERMINED
+};
+
+/* This structure is space-critical.
+ Its layout has been tweaked to reduce the space used. */
+
+struct main_type
+{
+ /* Code for kind of type */
+
+ ENUM_BITFIELD(type_code) code : 8;
+
+ /* Array bounds. These fields appear at this location because
+ they pack nicely here. */
+
+ ENUM_BITFIELD(array_bound_type) upper_bound_type : 4;
+ ENUM_BITFIELD(array_bound_type) lower_bound_type : 4;
+
+ /* Name of this type, or NULL if none.
+
+ This is used for printing only, except by poorly designed C++ code.
+ For looking up a name, look for a symbol in the VAR_DOMAIN. */
+
+ char *name;
+
+ /* Tag name for this type, or NULL if none. This means that the
+ name of the type consists of a keyword followed by the tag name.
+ Which keyword is determined by the type code ("struct" for
+ TYPE_CODE_STRUCT, etc.). As far as I know C/C++ are the only languages
+ with this feature.
+
+ This is used for printing only, except by poorly designed C++ code.
+ For looking up a name, look for a symbol in the STRUCT_DOMAIN.
+ One more legitimate use is that if TYPE_FLAG_STUB is set, this is
+ the name to use to look for definitions in other files. */
+
+ char *tag_name;
+
+ /* Every type is now associated with a particular objfile, and the
+ type is allocated on the objfile_obstack for that objfile. One problem
+ however, is that there are times when gdb allocates new types while
+ it is not in the process of reading symbols from a particular objfile.
+ Fortunately, these happen when the type being created is a derived
+ type of an existing type, such as in lookup_pointer_type(). So
+ we can just allocate the new type using the same objfile as the
+ existing type, but to do this we need a backpointer to the objfile
+ from the existing type. Yes this is somewhat ugly, but without
+ major overhaul of the internal type system, it can't be avoided
+ for now. */
+
+ struct objfile *objfile;
+
+ /* For a pointer type, describes the type of object pointed to.
+ For an array type, describes the type of the elements.
+ For a function or method type, describes the type of the return value.
+ For a range type, describes the type of the full range.
+ For a complex type, describes the type of each coordinate.
+ Unused otherwise. */
+
+ struct type *target_type;
+
+ /* Flags about this type. */
+
+ int flags;
+
+ /* Number of fields described for this type */
+
+ short nfields;
+
+ /* Field number of the virtual function table pointer in
+ VPTR_BASETYPE. If -1, we were unable to find the virtual
+ function table pointer in initial symbol reading, and
+ fill_in_vptr_fieldno should be called to find it if possible.
+
+ Unused if this type does not have virtual functions. */
+
+ short vptr_fieldno;
+ /* For structure and union types, a description of each field.
+ For set and pascal array types, there is one "field",
+ whose type is the domain type of the set or array.
+ For range types, there are two "fields",
+ the minimum and maximum values (both inclusive).
+ For enum types, each possible value is described by one "field".
+ For a function or method type, a "field" for each parameter.
+ For C++ classes, there is one field for each base class (if it is
+ a derived class) plus one field for each class data member. Member
+ functions are recorded elsewhere.
-struct type
- {
-
- /* Code for kind of type */
+ Using a pointer to a separate array of fields
+ allows all types to have the same size, which is useful
+ because we can allocate the space for a type before
+ we know what to put in it. */
- enum type_code code;
-
- /* Name of this type, or NULL if none.
-
- This is used for printing only, except by poorly designed C++ code.
- For looking up a name, look for a symbol in the VAR_NAMESPACE. */
-
- char *name;
-
- /* Tag name for this type, or NULL if none. This means that the
- name of the type consists of a keyword followed by the tag name.
- Which keyword is determined by the type code ("struct" for
- TYPE_CODE_STRUCT, etc.). As far as I know C/C++ are the only languages
- with this feature.
-
- This is used for printing only, except by poorly designed C++ code.
- For looking up a name, look for a symbol in the STRUCT_NAMESPACE.
- One more legitimate use is that if TYPE_FLAG_STUB is set, this is
- the name to use to look for definitions in other files. */
-
- char *tag_name;
-
- /* Length of storage for a value of this type. Various places pass
- this to memcpy and such, meaning it must be in units of
- HOST_CHAR_BIT. Various other places expect they can calculate
- addresses by adding it and such, meaning it must be in units of
- TARGET_CHAR_BIT. For some DSP targets, in which HOST_CHAR_BIT
- will (presumably) be 8 and TARGET_CHAR_BIT will be (say) 32, this
- is a problem. One fix would be to make this field in bits
- (requiring that it always be a multiple of HOST_CHAR_BIT and
- TARGET_CHAR_BIT)--the other choice would be to make it
- consistently in units of HOST_CHAR_BIT. */
-
- unsigned length;
-
- /* FIXME, these should probably be restricted to a Fortran-specific
- field in some fashion. */
-#define BOUND_CANNOT_BE_DETERMINED 5
-#define BOUND_BY_REF_ON_STACK 4
-#define BOUND_BY_VALUE_ON_STACK 3
-#define BOUND_BY_REF_IN_REG 2
-#define BOUND_BY_VALUE_IN_REG 1
-#define BOUND_SIMPLE 0
- int upper_bound_type;
- int lower_bound_type;
-
- /* Every type is now associated with a particular objfile, and the
- type is allocated on the type_obstack for that objfile. One problem
- however, is that there are times when gdb allocates new types while
- it is not in the process of reading symbols from a particular objfile.
- Fortunately, these happen when the type being created is a derived
- type of an existing type, such as in lookup_pointer_type(). So
- we can just allocate the new type using the same objfile as the
- existing type, but to do this we need a backpointer to the objfile
- from the existing type. Yes this is somewhat ugly, but without
- major overhaul of the internal type system, it can't be avoided
- for now. */
-
- struct objfile *objfile;
-
- /* For a pointer type, describes the type of object pointed to.
- For an array type, describes the type of the elements.
- For a function or method type, describes the type of the return value.
- For a range type, describes the type of the full range.
- For a complex type, describes the type of each coordinate.
- Unused otherwise. */
-
- struct type *target_type;
-
- /* Type that is a pointer to this type.
- NULL if no such pointer-to type is known yet.
- The debugger may add the address of such a type
- if it has to construct one later. */
-
- struct type *pointer_type;
-
- /* C++: also need a reference type. */
-
- struct type *reference_type;
-
- /* C-v variant chain. This points to a type that
- differs from this one only in a const or volatile
- attribute (or both). The various c-v variants
- are chained together in a ring. */
- struct type *cv_type;
-
- /* Flags about this type. */
-
- int flags;
-
- /* Number of fields described for this type */
-
- short nfields;
-
- /* For structure and union types, a description of each field.
- For set and pascal array types, there is one "field",
- whose type is the domain type of the set or array.
- For range types, there are two "fields",
- the minimum and maximum values (both inclusive).
- For enum types, each possible value is described by one "field".
- For a function type, a "field" for each parameter type.
- For C++ classes, there is one field for each base class (if it is
- a derived class) plus one field for each class data member. Member
- functions are recorded elsewhere.
-
- Using a pointer to a separate array of fields
- allows all types to have the same size, which is useful
- because we can allocate the space for a type before
- we know what to put in it. */
-
- struct field
- {
-
-
-
- union field_location
- {
- /* Position of this field, counting in bits from start of
- containing structure.
- For BITS_BIG_ENDIAN=1 targets, it is the bit offset to the MSB.
- For BITS_BIG_ENDIAN=0 targets, it is the bit offset to the LSB.
- For a function type, this is the position in the argument list
- of this argument.
- For a range bound or enum value, this is the value itself. */
-
- int bitpos;
+ struct field
+ {
+ union field_location
+ {
+ /* Position of this field, counting in bits from start of
+ containing structure.
+ For BITS_BIG_ENDIAN=1 targets, it is the bit offset to the MSB.
+ For BITS_BIG_ENDIAN=0 targets, it is the bit offset to the LSB.
+ For a range bound or enum value, this is the value itself. */
- /* For a static field, if TYPE_FIELD_STATIC_HAS_ADDR then physaddr
- is the location (in the target) of the static field.
- Otherwise, physname is the mangled label of the static field. */
+ int bitpos;
- CORE_ADDR physaddr;
- char *physname;
- }
- loc;
+ /* For a static field, if TYPE_FIELD_STATIC_HAS_ADDR then physaddr
+ is the location (in the target) of the static field.
+ Otherwise, physname is the mangled label of the static field. */
- /* Size of this field, in bits, or zero if not packed.
- For an unpacked field, the field's type's length
- says how many bytes the field occupies.
- A value of -1 or -2 indicates a static field; -1 means the location
- is specified by the label loc.physname; -2 means that loc.physaddr
- specifies the actual address. */
+ CORE_ADDR physaddr;
+ char *physname;
+ }
+ loc;
- int bitsize;
+ /* For a function or member type, this is 1 if the argument is marked
+ artificial. Artificial arguments should not be shown to the
+ user. */
+ unsigned int artificial : 1;
- /* In a struct or union type, type of this field.
- In a function type, type of this argument.
- In an array type, the domain-type of the array. */
+ /* This flag is zero for non-static fields, 1 for fields whose location
+ is specified by the label loc.physname, and 2 for fields whose location
+ is specified by loc.physaddr. */
- struct type *type;
+ unsigned int static_kind : 2;
- /* Name of field, value or argument.
- NULL for range bounds and array domains. */
+ /* Size of this field, in bits, or zero if not packed.
+ For an unpacked field, the field's type's length
+ says how many bytes the field occupies. */
- char *name;
+ unsigned int bitsize : 29;
- }
- *fields;
+ /* In a struct or union type, type of this field.
+ In a function or member type, type of this argument.
+ In an array type, the domain-type of the array. */
- /* For types with virtual functions (TYPE_CODE_STRUCT), VPTR_BASETYPE
- is the base class which defined the virtual function table pointer.
+ struct type *type;
- For types that are pointer to member types (TYPE_CODE_MEMBER),
- VPTR_BASETYPE is the type that this pointer is a member of.
+ /* Name of field, value or argument.
+ NULL for range bounds, array domains, and member function
+ arguments. */
- For method types (TYPE_CODE_METHOD), VPTR_BASETYPE is the aggregate
- type that contains the method.
+ char *name;
- Unused otherwise. */
+ } *fields;
- struct type *vptr_basetype;
+ /* For types with virtual functions (TYPE_CODE_STRUCT), VPTR_BASETYPE
+ is the base class which defined the virtual function table pointer.
- /* Field number of the virtual function table pointer in
- VPTR_BASETYPE. If -1, we were unable to find the virtual
- function table pointer in initial symbol reading, and
- fill_in_vptr_fieldno should be called to find it if possible.
+ For types that are pointer to member types (TYPE_CODE_METHODPTR,
+ TYPE_CODE_MEMBERPTR), VPTR_BASETYPE is the type that this pointer
+ is a member of.
- Unused if this type does not have virtual functions. */
+ For method types (TYPE_CODE_METHOD), VPTR_BASETYPE is the aggregate
+ type that contains the method.
- int vptr_fieldno;
+ Unused otherwise. */
- /* Slot to point to additional language-specific fields of this type. */
+ struct type *vptr_basetype;
- union type_specific
- {
+ /* Slot to point to additional language-specific fields of this type. */
- /* ARG_TYPES is for TYPE_CODE_METHOD.
- Contains the type of each argument, ending with a void type
- after the last argument for normal member functions or a NULL
- pointer after the last argument for functions with variable
- arguments. */
+ union type_specific
+ {
+ /* CPLUS_STUFF is for TYPE_CODE_STRUCT. It is initialized to point to
+ cplus_struct_default, a default static instance of a struct
+ cplus_struct_type. */
- struct type **arg_types;
+ struct cplus_struct_type *cplus_stuff;
- /* CPLUS_STUFF is for TYPE_CODE_STRUCT. It is initialized to point to
- cplus_struct_default, a default static instance of a struct
- cplus_struct_type. */
+ /* FLOATFORMAT is for TYPE_CODE_FLT. It is a pointer to two
+ floatformat objects that describe the floating-point value
+ that resides within the type. The first is for big endian
+ targets and the second is for little endian targets. */
- struct cplus_struct_type *cplus_stuff;
+ const struct floatformat **floatformat;
+ } type_specific;
+};
- }
- type_specific;
- };
+/* A ``struct type'' describes a particular instance of a type, with
+ some particular qualification. */
+struct type
+{
+ /* Type that is a pointer to this type.
+ NULL if no such pointer-to type is known yet.
+ The debugger may add the address of such a type
+ if it has to construct one later. */
+
+ struct type *pointer_type;
+
+ /* C++: also need a reference type. */
+
+ struct type *reference_type;
+
+ /* Variant chain. This points to a type that differs from this one only
+ in qualifiers and length. Currently, the possible qualifiers are
+ const, volatile, code-space, data-space, and address class. The
+ length may differ only when one of the address class flags are set.
+ The variants are linked in a circular ring and share MAIN_TYPE. */
+ struct type *chain;
+
+ /* Flags specific to this instance of the type, indicating where
+ on the ring we are. */
+ int instance_flags;
+
+ /* Length of storage for a value of this type. This is what
+ sizeof(type) would return; use it for address arithmetic,
+ memory reads and writes, etc. This size includes padding. For
+ example, an i386 extended-precision floating point value really
+ only occupies ten bytes, but most ABI's declare its size to be
+ 12 bytes, to preserve alignment. A `struct type' representing
+ such a floating-point type would have a `length' value of 12,
+ even though the last two bytes are unused.
+
+ There's a bit of a host/target mess here, if you're concerned
+ about machines whose bytes aren't eight bits long, or who don't
+ have byte-addressed memory. Various places pass this to memcpy
+ and such, meaning it must be in units of host bytes. Various
+ other places expect they can calculate addresses by adding it
+ and such, meaning it must be in units of target bytes. For
+ some DSP targets, in which HOST_CHAR_BIT will (presumably) be 8
+ and TARGET_CHAR_BIT will be (say) 32, this is a problem.
+
+ One fix would be to make this field in bits (requiring that it
+ always be a multiple of HOST_CHAR_BIT and TARGET_CHAR_BIT) ---
+ the other choice would be to make it consistently in units of
+ HOST_CHAR_BIT. However, this would still fail to address
+ machines based on a ternary or decimal representation. */
+
+ unsigned length;
+
+ /* Core type, shared by a group of qualified types. */
+ struct main_type *main_type;
+};
#define NULL_TYPE ((struct type *) 0)
struct type *type;
- /* The argument list. Only valid if is_stub is clear. Contains
- the type of each argument, including `this', and ending with
- a NULL pointer after the last argument. Should not contain
- a `this' pointer for static member functions. */
-
- struct type **args;
-
/* For virtual functions.
First baseclass that defines this virtual function. */
unsigned int is_final:1;
unsigned int is_synchronized:1;
unsigned int is_native:1;
+ unsigned int is_artificial:1;
/* A stub method only has some fields valid (but they are enough
to reconstruct the rest of the fields). */
unsigned int is_inlined:1;
/* Unused. */
- unsigned int dummy:4;
+ unsigned int dummy:3;
/* Index into that baseclass's virtual function table,
minus 2; else if static: VOFFSET_STATIC; else: 0. */
extern const struct cplus_struct_type cplus_struct_default;
-extern void
-allocate_cplus_struct_type PARAMS ((struct type *));
+extern void allocate_cplus_struct_type (struct type *);
#define INIT_CPLUS_SPECIFIC(type) \
(TYPE_CPLUS_SPECIFIC(type)=(struct cplus_struct_type*)&cplus_struct_default)
#define HAVE_CPLUS_STRUCT(type) \
(TYPE_CPLUS_SPECIFIC(type) != &cplus_struct_default)
-#define TYPE_NAME(thistype) (thistype)->name
-#define TYPE_TAG_NAME(type) ((type)->tag_name)
-#define TYPE_TARGET_TYPE(thistype) (thistype)->target_type
+#define TYPE_INSTANCE_FLAGS(thistype) (thistype)->instance_flags
+#define TYPE_MAIN_TYPE(thistype) (thistype)->main_type
+#define TYPE_NAME(thistype) TYPE_MAIN_TYPE(thistype)->name
+#define TYPE_TAG_NAME(type) TYPE_MAIN_TYPE(type)->tag_name
+#define TYPE_TARGET_TYPE(thistype) TYPE_MAIN_TYPE(thistype)->target_type
#define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type
#define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type
-#define TYPE_CV_TYPE(thistype) (thistype)->cv_type
+#define TYPE_CHAIN(thistype) (thistype)->chain
/* Note that if thistype is a TYPEDEF type, you have to call check_typedef.
But check_typedef does set the TYPE_LENGTH of the TYPEDEF type,
so you only have to call check_typedef once. Since allocate_value
calls check_typedef, TYPE_LENGTH (VALUE_TYPE (X)) is safe. */
#define TYPE_LENGTH(thistype) (thistype)->length
-#define TYPE_OBJFILE(thistype) (thistype)->objfile
-#define TYPE_FLAGS(thistype) (thistype)->flags
-#define TYPE_UNSIGNED(thistype) ((thistype)->flags & TYPE_FLAG_UNSIGNED)
-#define TYPE_NOSIGN(thistype) ((thistype)->flags & TYPE_FLAG_NOSIGN)
-#define TYPE_CONST(thistype) ((thistype)->flags & TYPE_FLAG_CONST)
-#define TYPE_VOLATILE(thistype) ((thistype)->flags & TYPE_FLAG_VOLATILE)
-#define TYPE_INCOMPLETE(thistype) ((thistype)->flags & TYPE_FLAG_INCOMPLETE)
-/* Note that TYPE_CODE can be TYPE_CODE_TYPEDEF, so if you wan the real
+#define TYPE_OBJFILE(thistype) TYPE_MAIN_TYPE(thistype)->objfile
+#define TYPE_FLAGS(thistype) TYPE_MAIN_TYPE(thistype)->flags
+/* Note that TYPE_CODE can be TYPE_CODE_TYPEDEF, so if you want the real
type, you need to do TYPE_CODE (check_type (this_type)). */
-#define TYPE_CODE(thistype) (thistype)->code
-#define TYPE_NFIELDS(thistype) (thistype)->nfields
-#define TYPE_FIELDS(thistype) (thistype)->fields
+#define TYPE_CODE(thistype) TYPE_MAIN_TYPE(thistype)->code
+#define TYPE_NFIELDS(thistype) TYPE_MAIN_TYPE(thistype)->nfields
+#define TYPE_FIELDS(thistype) TYPE_MAIN_TYPE(thistype)->fields
#define TYPE_TEMPLATE_ARGS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->template_args
#define TYPE_INSTANTIATIONS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->instantiations
/* Moto-specific stuff for FORTRAN arrays */
-#define TYPE_ARRAY_UPPER_BOUND_TYPE(thistype) (thistype)->upper_bound_type
-#define TYPE_ARRAY_LOWER_BOUND_TYPE(thistype) (thistype)->lower_bound_type
+#define TYPE_ARRAY_UPPER_BOUND_TYPE(thistype) \
+ TYPE_MAIN_TYPE(thistype)->upper_bound_type
+#define TYPE_ARRAY_LOWER_BOUND_TYPE(thistype) \
+ TYPE_MAIN_TYPE(thistype)->lower_bound_type
#define TYPE_ARRAY_UPPER_BOUND_VALUE(arraytype) \
(TYPE_FIELD_BITPOS((TYPE_FIELD_TYPE((arraytype),0)),1))
/* C++ */
-#define TYPE_VPTR_BASETYPE(thistype) (thistype)->vptr_basetype
-#define TYPE_DOMAIN_TYPE(thistype) (thistype)->vptr_basetype
-#define TYPE_VPTR_FIELDNO(thistype) (thistype)->vptr_fieldno
+#define TYPE_VPTR_BASETYPE(thistype) TYPE_MAIN_TYPE(thistype)->vptr_basetype
+#define TYPE_DOMAIN_TYPE(thistype) TYPE_MAIN_TYPE(thistype)->vptr_basetype
+#define TYPE_VPTR_FIELDNO(thistype) TYPE_MAIN_TYPE(thistype)->vptr_fieldno
#define TYPE_FN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fields
#define TYPE_NFN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields
#define TYPE_NFN_FIELDS_TOTAL(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields_total
#define TYPE_NTEMPLATE_ARGS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->ntemplate_args
#define TYPE_NINSTANTIATIONS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->ninstantiations
#define TYPE_DECLARED_TYPE(thistype) TYPE_CPLUS_SPECIFIC(thistype)->declared_type
-#define TYPE_TYPE_SPECIFIC(thistype) (thistype)->type_specific
-#define TYPE_ARG_TYPES(thistype) (thistype)->type_specific.arg_types
-#define TYPE_CPLUS_SPECIFIC(thistype) (thistype)->type_specific.cplus_stuff
-#define TYPE_BASECLASS(thistype,index) (thistype)->fields[index].type
+#define TYPE_TYPE_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific
+#define TYPE_CPLUS_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff
+#define TYPE_FLOATFORMAT(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.floatformat
+#define TYPE_BASECLASS(thistype,index) TYPE_MAIN_TYPE(thistype)->fields[index].type
#define TYPE_N_BASECLASSES(thistype) TYPE_CPLUS_SPECIFIC(thistype)->n_baseclasses
-#define TYPE_BASECLASS_NAME(thistype,index) (thistype)->fields[index].name
+#define TYPE_BASECLASS_NAME(thistype,index) TYPE_MAIN_TYPE(thistype)->fields[index].name
#define TYPE_BASECLASS_BITPOS(thistype,index) TYPE_FIELD_BITPOS(thistype,index)
#define BASETYPE_VIA_PUBLIC(thistype, index) \
((!TYPE_FIELD_PRIVATE(thistype, index)) && (!TYPE_FIELD_PROTECTED(thistype, index)))
#define FIELD_TYPE(thisfld) ((thisfld).type)
#define FIELD_NAME(thisfld) ((thisfld).name)
#define FIELD_BITPOS(thisfld) ((thisfld).loc.bitpos)
+#define FIELD_ARTIFICIAL(thisfld) ((thisfld).artificial)
#define FIELD_BITSIZE(thisfld) ((thisfld).bitsize)
+#define FIELD_STATIC_KIND(thisfld) ((thisfld).static_kind)
#define FIELD_PHYSNAME(thisfld) ((thisfld).loc.physname)
#define FIELD_PHYSADDR(thisfld) ((thisfld).loc.physaddr)
#define SET_FIELD_PHYSNAME(thisfld, name) \
- ((thisfld).bitsize = -1, FIELD_PHYSNAME(thisfld) = (name))
+ ((thisfld).static_kind = 1, FIELD_PHYSNAME(thisfld) = (name))
#define SET_FIELD_PHYSADDR(thisfld, name) \
- ((thisfld).bitsize = -2, FIELD_PHYSADDR(thisfld) = (name))
-#define TYPE_FIELD(thistype, n) (thistype)->fields[n]
+ ((thisfld).static_kind = 2, FIELD_PHYSADDR(thisfld) = (name))
+#define TYPE_FIELD(thistype, n) TYPE_MAIN_TYPE(thistype)->fields[n]
#define TYPE_FIELD_TYPE(thistype, n) FIELD_TYPE(TYPE_FIELD(thistype, n))
#define TYPE_FIELD_NAME(thistype, n) FIELD_NAME(TYPE_FIELD(thistype, n))
#define TYPE_FIELD_BITPOS(thistype, n) FIELD_BITPOS(TYPE_FIELD(thistype,n))
+#define TYPE_FIELD_ARTIFICIAL(thistype, n) FIELD_ARTIFICIAL(TYPE_FIELD(thistype,n))
#define TYPE_FIELD_BITSIZE(thistype, n) FIELD_BITSIZE(TYPE_FIELD(thistype,n))
#define TYPE_FIELD_PACKED(thistype, n) (FIELD_BITSIZE(TYPE_FIELD(thistype,n))!=0)
#define TYPE_TEMPLATE_ARG(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->template_args[n]
(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \
: B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n)))
-#define TYPE_FIELD_STATIC(thistype, n) ((thistype)->fields[n].bitsize < 0)
-#define TYPE_FIELD_STATIC_HAS_ADDR(thistype, n) ((thistype)->fields[n].bitsize == -2)
+#define TYPE_FIELD_STATIC(thistype, n) (TYPE_MAIN_TYPE (thistype)->fields[n].static_kind != 0)
+#define TYPE_FIELD_STATIC_KIND(thistype, n) TYPE_MAIN_TYPE (thistype)->fields[n].static_kind
+#define TYPE_FIELD_STATIC_HAS_ADDR(thistype, n) (TYPE_MAIN_TYPE (thistype)->fields[n].static_kind == 2)
#define TYPE_FIELD_STATIC_PHYSNAME(thistype, n) FIELD_PHYSNAME(TYPE_FIELD(thistype, n))
#define TYPE_FIELD_STATIC_PHYSADDR(thistype, n) FIELD_PHYSADDR(TYPE_FIELD(thistype, n))
#define TYPE_FN_FIELD(thisfn, n) (thisfn)[n]
#define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname
#define TYPE_FN_FIELD_TYPE(thisfn, n) (thisfn)[n].type
-#define TYPE_FN_FIELD_ARGS(thisfn, n) TYPE_ARG_TYPES ((thisfn)[n].type)
+#define TYPE_FN_FIELD_ARGS(thisfn, n) TYPE_FIELDS ((thisfn)[n].type)
#define TYPE_FN_FIELD_CONST(thisfn, n) ((thisfn)[n].is_const)
#define TYPE_FN_FIELD_VOLATILE(thisfn, n) ((thisfn)[n].is_volatile)
#define TYPE_FN_FIELD_PRIVATE(thisfn, n) ((thisfn)[n].is_private)
#define TYPE_FN_FIELD_FINAL(thisfn, n) ((thisfn)[n].is_final)
#define TYPE_FN_FIELD_SYNCHRONIZED(thisfn, n) ((thisfn)[n].is_synchronized)
#define TYPE_FN_FIELD_NATIVE(thisfn, n) ((thisfn)[n].is_native)
+#define TYPE_FN_FIELD_ARTIFICIAL(thisfn, n) ((thisfn)[n].is_artificial)
#define TYPE_FN_FIELD_ABSTRACT(thisfn, n) ((thisfn)[n].is_abstract)
#define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub)
#define TYPE_FN_FIELD_INLINED(thisfn, n) ((thisfn)[n].is_inlined)
#define TYPE_IS_OPAQUE(thistype) (((TYPE_CODE (thistype) == TYPE_CODE_STRUCT) || \
(TYPE_CODE (thistype) == TYPE_CODE_UNION)) && \
(TYPE_NFIELDS (thistype) == 0) && \
- (TYPE_CPLUS_SPECIFIC (thistype) && (TYPE_NFN_FIELDS (thistype) == 0)))
-
-
+ (TYPE_CPLUS_SPECIFIC (thistype) && (TYPE_NFN_FIELDS (thistype) == 0)) && \
+ (TYPE_STUB (thistype) || !TYPE_STUB_SUPPORTED (thistype)))
+
+struct builtin_type
+{
+ /* Address/pointer types. */
+
+ /* `pointer to data' type. Some target platforms use an implicitly
+ {sign,zero} -extended 32-bit ABI pointer on a 64-bit ISA. */
+ struct type *builtin_data_ptr;
+
+ /* `pointer to function (returning void)' type. Harvard
+ architectures mean that ABI function and code pointers are not
+ interconvertible. Similarly, since ANSI, C standards have
+ explicitly said that pointers to functions and pointers to data
+ are not interconvertible --- that is, you can't cast a function
+ pointer to void * and back, and expect to get the same value.
+ However, all function pointer types are interconvertible, so void
+ (*) () can server as a generic function pointer. */
+ struct type *builtin_func_ptr;
+
+ /* The target CPU's address type. This is the ISA address size. */
+ struct type *builtin_core_addr;
+
+ /* Integral types. */
+
+ /* We use this for the '/c' print format, because c_char is just a
+ one-byte integral type, which languages less laid back than C
+ will print as ... well, a one-byte integral type. */
+ struct type *builtin_true_char;
+
+ /* Implicit size/sign (based on the the architecture's ABI). */
+ struct type *builtin_void;
+ struct type *builtin_char;
+ struct type *builtin_short;
+ struct type *builtin_int;
+ struct type *builtin_long;
+ struct type *builtin_signed_char;
+ struct type *builtin_unsigned_char;
+ struct type *builtin_unsigned_short;
+ struct type *builtin_unsigned_int;
+ struct type *builtin_unsigned_long;
+ struct type *builtin_float;
+ struct type *builtin_double;
+ struct type *builtin_long_double;
+ struct type *builtin_complex;
+ struct type *builtin_double_complex;
+ struct type *builtin_string;
+ struct type *builtin_bool;
+ struct type *builtin_long_long;
+ struct type *builtin_unsigned_long_long;
+};
+
+/* Return the type table for the specified architecture. */
+extern const struct builtin_type *builtin_type (struct gdbarch *gdbarch);
/* Implicit sizes */
extern struct type *builtin_type_void;
extern struct type *builtin_type_string;
extern struct type *builtin_type_bool;
-/* Explicit sizes - see <intypes.h> for naming schema */
+/* Address/pointer types: */
+/* (C) Language `pointer to data' type. Some target platforms use an
+ implicitly {sign,zero} -extended 32 bit C language pointer on a 64
+ bit ISA. */
+extern struct type *builtin_type_void_data_ptr;
+
+/* (C) Language `pointer to function returning void' type. Since
+ ANSI, C standards have explicitly said that pointers to functions
+ and pointers to data are not interconvertible --- that is, you
+ can't cast a function pointer to void * and back, and expect to get
+ the same value. However, all function pointer types are
+ interconvertible, so void (*) () can server as a generic function
+ pointer. */
+extern struct type *builtin_type_void_func_ptr;
+
+/* The target CPU's address type. This is the ISA address size. */
+extern struct type *builtin_type_CORE_ADDR;
+/* The symbol table address type. Some object file formats have a 32
+ bit address type even though the TARGET has a 64 bit pointer type
+ (cf MIPS). */
+extern struct type *builtin_type_bfd_vma;
+
+/* Explicit sizes - see C9X <intypes.h> for naming scheme. The "int0"
+ is for when an architecture needs to describe a register that has
+ no size. */
+extern struct type *builtin_type_int0;
extern struct type *builtin_type_int8;
extern struct type *builtin_type_uint8;
extern struct type *builtin_type_int16;
extern struct type *builtin_type_uint32;
extern struct type *builtin_type_int64;
extern struct type *builtin_type_uint64;
+extern struct type *builtin_type_int128;
+extern struct type *builtin_type_uint128;
+
+/* Explicit floating-point formats. See "floatformat.h". */
+extern const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN];
+extern const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN];
+extern const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN];
+extern const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN];
+extern const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN];
+extern const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN];
+extern const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN];
+extern const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN];
+extern const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN];
+extern const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN];
+
+extern struct type *builtin_type_ieee_single;
+extern struct type *builtin_type_ieee_double;
+extern struct type *builtin_type_i387_ext;
+extern struct type *builtin_type_m68881_ext;
+extern struct type *builtin_type_arm_ext;
+extern struct type *builtin_type_ia64_spill;
+extern struct type *builtin_type_ia64_quad;
/* We use this for the '/c' print format, because builtin_type_char is
just a one-byte integral type, which languages less laid back than
extern struct type *builtin_type_m2_real;
extern struct type *builtin_type_m2_bool;
-/* Chill types */
-
-extern struct type *builtin_type_chill_bool;
-extern struct type *builtin_type_chill_char;
-extern struct type *builtin_type_chill_long;
-extern struct type *builtin_type_chill_ulong;
-extern struct type *builtin_type_chill_real;
-
/* Fortran (F77) types */
extern struct type *builtin_type_f_character;
extern struct type *builtin_type_f_integer;
+extern struct type *builtin_type_f_integer_s2;
extern struct type *builtin_type_f_logical;
extern struct type *builtin_type_f_logical_s1;
extern struct type *builtin_type_f_logical_s2;
-extern struct type *builtin_type_f_integer;
-extern struct type *builtin_type_f_integer_s2;
extern struct type *builtin_type_f_real;
extern struct type *builtin_type_f_real_s8;
extern struct type *builtin_type_f_real_s16;
/* Maximum and minimum values of built-in types */
#define MAX_OF_TYPE(t) \
- TYPE_UNSIGNED(t) ? UMAX_OF_SIZE(TYPE_LENGTH(t)) \
- : MAX_OF_SIZE(TYPE_LENGTH(t))
+ (TYPE_UNSIGNED(t) ? UMAX_OF_SIZE(TYPE_LENGTH(t)) \
+ : MAX_OF_SIZE(TYPE_LENGTH(t)))
#define MIN_OF_TYPE(t) \
- TYPE_UNSIGNED(t) ? UMIN_OF_SIZE(TYPE_LENGTH(t)) \
- : MIN_OF_SIZE(TYPE_LENGTH(t))
+ (TYPE_UNSIGNED(t) ? UMIN_OF_SIZE(TYPE_LENGTH(t)) \
+ : MIN_OF_SIZE(TYPE_LENGTH(t)))
/* Allocate space for storing data associated with a particular type.
We ensure that the space is allocated using the same mechanism that
was used to allocate the space for the type structure itself. I.E.
- if the type is on an objfile's type_obstack, then the space for data
- associated with that type will also be allocated on the type_obstack.
+ if the type is on an objfile's objfile_obstack, then the space for data
+ associated with that type will also be allocated on the objfile_obstack.
If the type is not associated with any particular objfile (such as
builtin types), then the data space will be allocated with xmalloc,
the same as for the type structure. */
#define TYPE_ALLOC(t,size) \
(TYPE_OBJFILE (t) != NULL \
- ? obstack_alloc (&TYPE_OBJFILE (t) -> type_obstack, size) \
+ ? obstack_alloc (&TYPE_OBJFILE (t) -> objfile_obstack, size) \
: xmalloc (size))
-extern struct type *
- alloc_type PARAMS ((struct objfile *));
+#define TYPE_ZALLOC(t,size) \
+ (TYPE_OBJFILE (t) != NULL \
+ ? memset (obstack_alloc (&TYPE_OBJFILE (t)->objfile_obstack, size), \
+ 0, size) \
+ : xzalloc (size))
-extern struct type *
- init_type PARAMS ((enum type_code, int, int, char *, struct objfile *));
+extern struct type *alloc_type (struct objfile *);
-extern struct type *
- lookup_reference_type PARAMS ((struct type *));
+extern struct type *init_type (enum type_code, int, int, char *,
+ struct objfile *);
-extern struct type *
- make_reference_type PARAMS ((struct type *, struct type **));
+/* Helper functions to construct a struct or record type. An
+ initially empty type is created using init_composite_type().
+ Fields are then added using append_struct_type_field(). A union
+ type has its size set to the largest field. A struct type has each
+ field packed against the previous. */
-extern struct type *
- make_cv_type PARAMS ((int, int, struct type *, struct type **));
+extern struct type *init_composite_type (char *name, enum type_code code);
+extern void append_composite_type_field (struct type *t, char *name,
+ struct type *field);
-extern struct type *
- lookup_member_type PARAMS ((struct type *, struct type *));
+/* Helper functions to construct a bit flags type. An initially empty
+ type is created using init_flag_type(). Flags are then added using
+ append_flag_type_flag(). */
+extern struct type *init_flags_type (char *name, int length);
+extern void append_flags_type_flag (struct type *type, int bitpos, char *name);
-extern void
-smash_to_method_type PARAMS ((struct type *, struct type *, struct type *,
- struct type **));
+extern struct type *init_vector_type (struct type *elt_type, int n);
-extern void
-smash_to_member_type PARAMS ((struct type *, struct type *, struct type *));
+extern struct type *lookup_reference_type (struct type *);
-extern struct type *
- allocate_stub_method PARAMS ((struct type *));
+extern struct type *make_reference_type (struct type *, struct type **);
-extern char *
- type_name_no_tag PARAMS ((const struct type *));
+extern struct type *make_cv_type (int, int, struct type *, struct type **);
-extern struct type *
- lookup_struct_elt_type PARAMS ((struct type *, char *, int));
+extern void replace_type (struct type *, struct type *);
-extern struct type *
- make_pointer_type PARAMS ((struct type *, struct type **));
+extern int address_space_name_to_int (char *);
-extern struct type *
- lookup_pointer_type PARAMS ((struct type *));
+extern const char *address_space_int_to_name (int);
-extern struct type *
- make_function_type PARAMS ((struct type *, struct type **));
+extern struct type *make_type_with_address_space (struct type *type,
+ int space_identifier);
-extern struct type *
- lookup_function_type PARAMS ((struct type *));
+extern struct type *lookup_memberptr_type (struct type *, struct type *);
-extern struct type *
- create_range_type PARAMS ((struct type *, struct type *, int, int));
+extern struct type *lookup_methodptr_type (struct type *);
-extern struct type *
- create_array_type PARAMS ((struct type *, struct type *, struct type *));
+extern void smash_to_method_type (struct type *type, struct type *domain,
+ struct type *to_type, struct field *args,
+ int nargs, int varargs);
-extern struct type *
- create_string_type PARAMS ((struct type *, struct type *));
+extern void smash_to_memberptr_type (struct type *, struct type *,
+ struct type *);
-extern struct type *create_set_type PARAMS ((struct type *, struct type *));
+extern struct type *allocate_stub_method (struct type *);
-extern int chill_varying_type PARAMS ((struct type *));
+extern char *type_name_no_tag (const struct type *);
-extern struct type *
- lookup_unsigned_typename PARAMS ((char *));
+extern struct type *lookup_struct_elt_type (struct type *, char *, int);
-extern struct type *
- lookup_signed_typename PARAMS ((char *));
+extern struct type *make_pointer_type (struct type *, struct type **);
-extern struct type *
- check_typedef PARAMS ((struct type *));
+extern struct type *lookup_pointer_type (struct type *);
-#define CHECK_TYPEDEF(TYPE) (TYPE) = check_typedef (TYPE)
+extern struct type *make_function_type (struct type *, struct type **);
+
+extern struct type *lookup_function_type (struct type *);
+
+extern struct type *create_range_type (struct type *, struct type *, int,
+ int);
-extern void
-check_stub_method PARAMS ((struct type *, int, int));
+extern struct type *create_array_type (struct type *, struct type *,
+ struct type *);
-extern struct type *
- lookup_primitive_typename PARAMS ((char *));
+extern struct type *create_string_type (struct type *, struct type *);
-extern char *
- gdb_mangle_name PARAMS ((struct type *, int, int));
+extern struct type *create_set_type (struct type *, struct type *);
-extern struct type *
- builtin_type PARAMS ((char **));
+extern struct type *lookup_unsigned_typename (char *);
-extern struct type *
- lookup_typename PARAMS ((char *, struct block *, int));
+extern struct type *lookup_signed_typename (char *);
-extern struct type *
- lookup_template_type PARAMS ((char *, struct type *, struct block *));
+extern struct type *check_typedef (struct type *);
-extern struct type *
- lookup_fundamental_type PARAMS ((struct objfile *, int));
+#define CHECK_TYPEDEF(TYPE) (TYPE) = check_typedef (TYPE)
+
+extern void check_stub_method_group (struct type *, int);
+
+extern char *gdb_mangle_name (struct type *, int, int);
+
+extern struct type *lookup_typename (char *, struct block *, int);
-extern void
-fill_in_vptr_fieldno PARAMS ((struct type *));
+extern struct type *lookup_template_type (char *, struct type *,
+ struct block *);
-extern int get_destructor_fn_field PARAMS ((struct type *, int *, int *));
+extern struct type *lookup_fundamental_type (struct objfile *, int);
-extern int get_discrete_bounds PARAMS ((struct type *, LONGEST *, LONGEST *));
+extern void fill_in_vptr_fieldno (struct type *);
-extern int
-is_ancestor PARAMS ((struct type *, struct type *));
+extern int get_destructor_fn_field (struct type *, int *, int *);
-extern int
-has_vtable PARAMS ((struct type *));
+extern int get_discrete_bounds (struct type *, LONGEST *, LONGEST *);
-extern struct type *
- primary_base_class PARAMS ((struct type *));
+extern int is_ancestor (struct type *, struct type *);
-extern struct type **
- virtual_base_list PARAMS ((struct type *));
+extern int has_vtable (struct type *);
-extern int
-virtual_base_list_length PARAMS ((struct type *));
-extern int
-virtual_base_list_length_skip_primaries PARAMS ((struct type *));
+extern struct type *primary_base_class (struct type *);
-extern int
-virtual_base_index PARAMS ((struct type *, struct type *));
-extern int
-virtual_base_index_skip_primaries PARAMS ((struct type *, struct type *));
+extern struct type **virtual_base_list (struct type *);
+extern int virtual_base_list_length (struct type *);
+extern int virtual_base_list_length_skip_primaries (struct type *);
-extern int
-class_index_in_primary_list PARAMS ((struct type *));
+extern int virtual_base_index (struct type *, struct type *);
+extern int virtual_base_index_skip_primaries (struct type *, struct type *);
-extern int
-count_virtual_fns PARAMS ((struct type *));
+
+extern int class_index_in_primary_list (struct type *);
+
+extern int count_virtual_fns (struct type *);
/* Constants for HP/Taligent ANSI C++ runtime model */
#define TOO_FEW_PARAMS_BADNESS 100
/* Badness if no conversion among types */
#define INCOMPATIBLE_TYPE_BADNESS 100
-/* Badness of coercing large integer to smaller size */
-#define INTEGER_COERCION_BADNESS 100
-/* Badness of coercing large floating type to smaller size */
-#define FLOAT_COERCION_BADNESS 100
/* Badness of integral promotion */
#define INTEGER_PROMOTION_BADNESS 1
#define POINTER_CONVERSION_BADNESS 2
/* Badness of conversion of pointer to void pointer */
#define VOID_PTR_CONVERSION_BADNESS 2
-/* Badness of convering derived to base class */
+/* Badness of converting derived to base class */
#define BASE_CONVERSION_BADNESS 2
+/* Badness of converting from non-reference to reference */
+#define REFERENCE_CONVERSION_BADNESS 2
/* Non-standard conversions allowed by the debugger */
/* Converting a pointer to an int is usually OK */
#define NS_POINTER_CONVERSION_BADNESS 10
-extern int
-compare_badness PARAMS ((struct badness_vector *, struct badness_vector *));
+extern int compare_badness (struct badness_vector *, struct badness_vector *);
-extern struct badness_vector *
- rank_function PARAMS ((struct type **, int, struct type **, int));
+extern struct badness_vector *rank_function (struct type **, int,
+ struct type **, int);
-extern int
-rank_one_type PARAMS ((struct type *, struct type *));
+extern int rank_one_type (struct type *, struct type *);
-extern void recursive_dump_type PARAMS ((struct type *, int));
+extern void recursive_dump_type (struct type *, int);
/* printcmd.c */
-extern void
-print_scalar_formatted PARAMS ((char *, struct type *, int, int, GDB_FILE *));
+extern void print_scalar_formatted (const void *, struct type *, int, int,
+ struct ui_file *);
+
+extern int can_dereference (struct type *);
-extern int can_dereference PARAMS ((struct type *));
+extern int is_integral_type (struct type *);
-extern void maintenance_print_type PARAMS ((char *, int));
+extern void maintenance_print_type (char *, int);
-/* typeprint.c */
+extern htab_t create_copied_types_hash (struct objfile *objfile);
-extern void print_type_scalar PARAMS ((struct type *, LONGEST, GDB_FILE *));
+extern struct type *copy_type_recursive (struct objfile *objfile,
+ struct type *type,
+ htab_t copied_types);
#endif /* GDBTYPES_H */
projects / deliverable / binutils-gdb.git / blobdiff