X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgdbtypes.h;h=4c754d6ca44b68ffab97993d910713cabb2b3e96;hb=25caa7a88bd2a350f5b93c30b18be0e13cb31906;hp=981dbec4b7ca6f782cacd68950db78950ed18ff3;hpb=ee3a7b7f0d021019dd51b6c86375aaa399f63f13;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index 981dbec4b7..4c754d6ca4 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -1,5 +1,5 @@ /* Internal type definitions for GDB. - Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001 + Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. Contributed by Cygnus Support, using pieces from other GDB modules. @@ -23,6 +23,9 @@ #if !defined (GDBTYPES_H) #define GDBTYPES_H 1 +/* Forward declarations for prototypes. */ +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 @@ -98,13 +101,14 @@ enum type_code 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 @@ -139,24 +143,27 @@ enum type_code #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 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. @@ -164,7 +171,8 @@ enum type_code 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. @@ -172,26 +180,30 @@ enum type_code * 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. @@ -201,217 +213,292 @@ enum type_code 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) - - -struct type - { - - /* Code for kind of type */ - - 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 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) + +struct main_type +{ + /* Code for kind of type */ + + 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. 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; + + /* 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 - { + 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; + + /* 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 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. + + 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 range bound or enum value, this is the value itself. */ + int bitpos; + /* 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. */ - 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. */ + CORE_ADDR physaddr; + char *physname; + } + loc; - int bitpos; + /* 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; - /* 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. */ + /* 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. */ - CORE_ADDR physaddr; - char *physname; - } - loc; + unsigned int static_kind : 2; - /* 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. */ + /* 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. */ - int bitsize; + unsigned int bitsize : 29; - /* 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. */ + /* 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. */ - struct type *type; + struct type *type; - /* Name of field, value or argument. - NULL for range bounds and array domains. */ + /* Name of field, value or argument. + NULL for range bounds, array domains, and member function + arguments. */ - char *name; + char *name; - } - *fields; + } *fields; - /* For types with virtual functions (TYPE_CODE_STRUCT), VPTR_BASETYPE - is the base class which defined the virtual function table pointer. + /* For types with virtual functions (TYPE_CODE_STRUCT), VPTR_BASETYPE + is the base class which defined the virtual function table pointer. - For types that are pointer to member types (TYPE_CODE_MEMBER), - VPTR_BASETYPE is the type that this pointer is a member of. + For types that are pointer to member types (TYPE_CODE_MEMBER), + VPTR_BASETYPE is the type that this pointer is a member of. - For method types (TYPE_CODE_METHOD), VPTR_BASETYPE is the aggregate - type that contains the method. + For method types (TYPE_CODE_METHOD), VPTR_BASETYPE is the aggregate + type that contains the method. - Unused otherwise. */ + Unused otherwise. */ - struct type *vptr_basetype; + struct type *vptr_basetype; - /* 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. + /* 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. */ + Unused if this type does not have virtual functions. */ - int vptr_fieldno; + int vptr_fieldno; - /* Slot to point to additional language-specific fields of this type. */ + /* Slot to point to additional language-specific fields of this type. */ - union type_specific - { + 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. */ - /* 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. */ + struct cplus_struct_type *cplus_stuff; - struct type **arg_types; + /* FLOATFORMAT is for TYPE_CODE_FLT. It is a pointer to the + floatformat object that describes the floating-point value + that resides within the type. */ - /* 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. */ + const struct floatformat *floatformat; + } type_specific; +}; - struct cplus_struct_type *cplus_stuff; +/* 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. */ - } - type_specific; - }; + 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. Currently, the possible qualifiers are const, volatile, + code-space, and data-space. 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; + + /* Core type, shared by a group of qualified types. */ + struct main_type *main_type; +}; #define NULL_TYPE ((struct type *) 0) @@ -528,13 +615,6 @@ struct cplus_struct_type 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. */ @@ -552,6 +632,7 @@ struct cplus_struct_type 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). */ @@ -561,7 +642,7 @@ struct cplus_struct_type 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. */ @@ -663,29 +744,26 @@ extern void allocate_cplus_struct_type (struct type *); #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_LENGTH(thistype) TYPE_MAIN_TYPE(thistype)->length +#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 @@ -695,8 +773,10 @@ extern void allocate_cplus_struct_type (struct type *); /* 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)) @@ -706,21 +786,21 @@ extern void allocate_cplus_struct_type (struct type *); /* 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))) @@ -732,17 +812,20 @@ extern void allocate_cplus_struct_type (struct type *); #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] @@ -777,8 +860,9 @@ extern void allocate_cplus_struct_type (struct type *); (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)) @@ -791,7 +875,7 @@ extern void allocate_cplus_struct_type (struct type *); #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) @@ -801,6 +885,7 @@ extern void allocate_cplus_struct_type (struct type *); #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) @@ -846,9 +931,10 @@ extern struct type *builtin_type_string; extern struct type *builtin_type_bool; /* Address/pointer types: */ -/* (C) Language pointer 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_ptr; +/* (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 @@ -875,14 +961,44 @@ extern struct type *builtin_type_int32; 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; /* SIMD types. We inherit these names from GCC. */ extern struct type *builtin_type_v4sf; extern struct type *builtin_type_v4si; +extern struct type *builtin_type_v16qi; extern struct type *builtin_type_v8qi; +extern struct type *builtin_type_v8hi; extern struct type *builtin_type_v4hi; extern struct type *builtin_type_v2si; +/* Type for 64 bit vectors. */ +extern struct type *builtin_type_vec64; +extern struct type *builtin_type_vec64i; + +/* Type for 128 bit vectors. */ +extern struct type *builtin_type_vec128; +extern struct type *builtin_type_vec128i; + +/* Explicit floating-point formats. See "floatformat.h". */ +extern struct type *builtin_type_ieee_single_big; +extern struct type *builtin_type_ieee_single_little; +extern struct type *builtin_type_ieee_double_big; +extern struct type *builtin_type_ieee_double_little; +extern struct type *builtin_type_ieee_double_littlebyte_bigword; +extern struct type *builtin_type_i387_ext; +extern struct type *builtin_type_m68881_ext; +extern struct type *builtin_type_i960_ext; +extern struct type *builtin_type_m88110_ext; +extern struct type *builtin_type_m88110_harris_ext; +extern struct type *builtin_type_arm_ext_big; +extern struct type *builtin_type_arm_ext_littlebyte_bigword; +extern struct type *builtin_type_ia64_spill_big; +extern struct type *builtin_type_ia64_spill_little; +extern struct type *builtin_type_ia64_quad_big; +extern struct type *builtin_type_ia64_quad_little; + /* 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 C will print as ... well, a one-byte integral type. */ @@ -904,14 +1020,6 @@ extern struct type *builtin_type_m2_card; 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; @@ -960,17 +1068,37 @@ extern struct type *alloc_type (struct objfile *); extern struct type *init_type (enum type_code, int, int, char *, struct objfile *); +/* 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 *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_reference_type (struct type *); extern struct type *make_reference_type (struct type *, struct type **); extern struct type *make_cv_type (int, int, struct type *, struct type **); +extern void replace_type (struct type *, struct type *); + +extern int address_space_name_to_int (char *); + +extern const char *address_space_int_to_name (int); + +extern struct type *make_type_with_address_space (struct type *type, + int space_identifier); + extern struct type *lookup_member_type (struct type *, struct type *); extern void -smash_to_method_type (struct type *, struct type *, struct type *, - struct type **); +smash_to_method_type (struct type *type, struct type *domain, + struct type *to_type, struct field *args, + int nargs, int varargs); extern void smash_to_member_type (struct type *, struct type *, struct type *); @@ -999,8 +1127,6 @@ extern struct type *create_string_type (struct type *, struct type *); extern struct type *create_set_type (struct type *, struct type *); -extern int chill_varying_type (struct type *); - extern struct type *lookup_unsigned_typename (char *); extern struct type *lookup_signed_typename (char *); @@ -1009,7 +1135,7 @@ extern struct type *check_typedef (struct type *); #define CHECK_TYPEDEF(TYPE) (TYPE) = check_typedef (TYPE) -extern void check_stub_method (struct type *, int, int); +extern void check_stub_method_group (struct type *, int); extern struct type *lookup_primitive_typename (char *);