/* Internal type definitions for GDB.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
- 2002, 2003, 2004, 2006, 2007, 2008 Free Software Foundation, Inc.
+ 2002, 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011
+ Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
/* Forward declarations for prototypes. */
struct field;
struct block;
+struct value_print_options;
+struct language_defn;
/* Some macros for char-based bitfields. */
TYPE_CODE_VOID,
TYPE_CODE_SET, /* Pascal sets */
- TYPE_CODE_RANGE, /* Range (integers within spec'd bounds) */
+ 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 (the deleted) CHILL). It does not
TYPE_CODE_COMPLEX, /* Complex float */
TYPE_CODE_TYPEDEF,
- TYPE_CODE_TEMPLATE, /* C++ template */
- TYPE_CODE_TEMPLATE_ARG, /* C++ template arg */
TYPE_CODE_NAMESPACE, /* C++ namespace. */
- TYPE_CODE_DECFLOAT /* Decimal floating point. */
+ TYPE_CODE_DECFLOAT, /* Decimal floating point. */
+
+ TYPE_CODE_MODULE, /* Fortran module. */
+
+ /* Internal function type. */
+ TYPE_CODE_INTERNAL_FUNCTION
};
/* For now allow source to use TYPE_CODE_CLASS for C++ classes, as an
enum type_flag_value
{
- TYPE_FLAG_UNSIGNED = (1 << 6),
- TYPE_FLAG_NOSIGN = (1 << 7),
- TYPE_FLAG_STUB = (1 << 8),
- TYPE_FLAG_TARGET_STUB = (1 << 9),
- TYPE_FLAG_STATIC = (1 << 10),
- TYPE_FLAG_PROTOTYPED = (1 << 11),
- TYPE_FLAG_INCOMPLETE = (1 << 12),
- TYPE_FLAG_VARARGS = (1 << 13),
- TYPE_FLAG_VECTOR = (1 << 14),
- TYPE_FLAG_FIXED_INSTANCE = (1 << 15),
- TYPE_FLAG_STUB_SUPPORTED = (1 << 16),
- TYPE_FLAG_NOTTEXT = (1 << 17),
+ TYPE_FLAG_UNSIGNED = (1 << 7),
+ TYPE_FLAG_NOSIGN = (1 << 8),
+ TYPE_FLAG_STUB = (1 << 9),
+ TYPE_FLAG_TARGET_STUB = (1 << 10),
+ TYPE_FLAG_STATIC = (1 << 11),
+ TYPE_FLAG_PROTOTYPED = (1 << 12),
+ TYPE_FLAG_INCOMPLETE = (1 << 13),
+ TYPE_FLAG_VARARGS = (1 << 14),
+ TYPE_FLAG_VECTOR = (1 << 15),
+ TYPE_FLAG_FIXED_INSTANCE = (1 << 16),
+ TYPE_FLAG_STUB_SUPPORTED = (1 << 17),
+ TYPE_FLAG_GNU_IFUNC = (1 << 18),
/* Used for error-checking. */
TYPE_FLAG_MIN = TYPE_FLAG_UNSIGNED
TYPE_INSTANCE_FLAG_CODE_SPACE = (1 << 2),
TYPE_INSTANCE_FLAG_DATA_SPACE = (1 << 3),
TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1 = (1 << 4),
- TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2 = (1 << 5)
+ TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2 = (1 << 5),
+ TYPE_INSTANCE_FLAG_NOTTEXT = (1 << 6),
};
/* Unsigned integer type. If this is not set for a TYPE_CODE_INT, the
- type is signed (unless TYPE_FLAG_NOSIGN (below) is set). */
+ type is signed (unless TYPE_FLAG_NOSIGN (below) is set). */
#define TYPE_UNSIGNED(t) (TYPE_MAIN_TYPE (t)->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! */
+ absence of a sign! */
#define TYPE_NOSIGN(t) (TYPE_MAIN_TYPE (t)->flag_nosign)
be updated if it gets un-stubbed in check_typedef.
Used for arrays and ranges, in which TYPE_LENGTH of the array/range
gets set based on the TYPE_LENGTH of the target type.
- Also, set for TYPE_CODE_TYPEDEF. */
+ Also, set for TYPE_CODE_TYPEDEF. */
#define TYPE_TARGET_STUB(t) (TYPE_MAIN_TYPE (t)->flag_target_stub)
/* Static type. If this is set, the corresponding type had
- * a static modifier.
- * Note: This may be unnecessary, since static data members
- * are indicated by other means (bitpos == -1)
- */
+ a static modifier.
+ Note: This may be unnecessary, since static data members
+ are indicated by other means (bitpos == -1). */
#define TYPE_STATIC(t) (TYPE_MAIN_TYPE (t)->flag_static)
-/* 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. */
+/* 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_PROTOTYPED(t) (TYPE_MAIN_TYPE (t)->flag_prototyped)
(Mostly intended for HP platforms, where class methods, for
instance, can be encountered before their classes in the debug
info; the incomplete type has to be marked so that the class and
- the method can be assigned correct types.) */
+ the method can be assigned correct types.) */
#define TYPE_INCOMPLETE(t) (TYPE_MAIN_TYPE (t)->flag_incomplete)
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. */
+ interpretation. Optionally marks ordinary, fixed-size GDB type. */
#define TYPE_FIXED_INSTANCE(t) (TYPE_MAIN_TYPE (t)->flag_fixed_instance)
/* Not textual. By default, GDB treats all single byte integers as
characters (or elements of strings) unless this flag is set. */
-#define TYPE_NOTTEXT(t) (TYPE_MAIN_TYPE (t)->flag_nottext)
+#define TYPE_NOTTEXT(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_NOTTEXT)
+
+/* Used only for TYPE_CODE_FUNC where it specifies the real function
+ address is returned by this function call. TYPE_TARGET_TYPE determines the
+ final returned function type to be presented to user. */
+
+#define TYPE_GNU_IFUNC(t) (TYPE_MAIN_TYPE (t)->flag_gnu_ifunc)
+
+/* Type owner. If TYPE_OBJFILE_OWNED is true, the type is owned by
+ the objfile retrieved as TYPE_OBJFILE. Otherweise, the type is
+ owned by an architecture; TYPE_OBJFILE is NULL in this case. */
+
+#define TYPE_OBJFILE_OWNED(t) (TYPE_MAIN_TYPE (t)->flag_objfile_owned)
+#define TYPE_OWNER(t) TYPE_MAIN_TYPE(t)->owner
+#define TYPE_OBJFILE(t) (TYPE_OBJFILE_OWNED(t)? TYPE_OWNER(t).objfile : NULL)
+
+/* True if this type was declared using the "class" keyword. This is
+ only valid for C++ structure types, and only used for displaying
+ the type. If false, the structure was declared as a "struct". */
+
+#define TYPE_DECLARED_CLASS(t) (TYPE_MAIN_TYPE (t)->flag_declared_class)
/* Constant type. If this is set, the corresponding type has a
- * const modifier.
- */
+ const modifier. */
#define TYPE_CONST(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_CONST)
/* Volatile type. If this is set, the corresponding type has a
- * volatile modifier.
- */
+ volatile modifier. */
-#define TYPE_VOLATILE(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_VOLATILE)
+#define TYPE_VOLATILE(t) \
+ (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_VOLATILE)
/* Instruction-space delimited type. This is for Harvard architectures
which have separate instruction and data address spaces (and perhaps
#define TYPE_ADDRESS_CLASS_ALL(t) (TYPE_INSTANCE_FLAGS(t) \
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
+/* Determine which field of the union main_type.fields[x].loc is used. */
-/* Array bound type. */
-enum array_bound_type
+enum field_loc_kind
+ {
+ FIELD_LOC_KIND_BITPOS, /* bitpos */
+ FIELD_LOC_KIND_PHYSADDR, /* physaddr */
+ FIELD_LOC_KIND_PHYSNAME /* physname */
+ };
+
+/* A discriminant to determine which field in the main_type.type_specific
+ union is being used, if any.
+
+ For types such as TYPE_CODE_FLT or TYPE_CODE_FUNC, the use of this
+ discriminant is really redundant, as we know from the type code
+ which field is going to be used. As such, it would be possible to
+ reduce the size of this enum in order to save a bit or two for
+ other fields of struct main_type. But, since we still have extra
+ room , and for the sake of clarity and consistency, we treat all fields
+ of the union the same way. */
+
+enum type_specific_kind
{
- 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
+ TYPE_SPECIFIC_NONE,
+ TYPE_SPECIFIC_CPLUS_STUFF,
+ TYPE_SPECIFIC_GNAT_STUFF,
+ TYPE_SPECIFIC_FLOATFORMAT,
+ TYPE_SPECIFIC_CALLING_CONVENTION
};
/* This structure is space-critical.
struct main_type
{
- /* Code for kind of 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;
-
/* Flags about this type. These fields appear at this location
because they packs nicely here. See the TYPE_* macros for
documentation about these fields. */
unsigned int flag_varargs : 1;
unsigned int flag_vector : 1;
unsigned int flag_stub_supported : 1;
- unsigned int flag_nottext : 1;
+ unsigned int flag_gnu_ifunc : 1;
unsigned int flag_fixed_instance : 1;
+ unsigned int flag_objfile_owned : 1;
+ /* True if this type was declared with "class" rather than
+ "struct". */
+ unsigned int flag_declared_class : 1;
+
+ /* A discriminant telling us which field of the type_specific union
+ is being used for this type, if any. */
+ ENUM_BITFIELD(type_specific_kind) type_specific_field : 3;
/* Number of fields described for this type. This field appears at
this location because it packs nicely here. */
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. */
+ for now. */
- struct objfile *objfile;
+ union type_owner
+ {
+ struct objfile *objfile;
+ struct gdbarch *gdbarch;
+ } owner;
/* 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.
+ For a special record or union type encoding a dynamic-sized type
+ in GNAT, a memoized pointer to a corresponding static version of
+ the type.
Unused otherwise. */
struct type *target_type;
because we can allocate the space for a type before
we know what to put in it. */
- struct field
+ union
{
- union field_location
+ struct field
{
- /* Position of this field, counting in bits from start of
- containing structure.
- For gdbarch_bits_big_endian=1 targets, it is the bit offset to the MSB.
- For gdbarch_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. */
+ union field_location
+ {
+ /* Position of this field, counting in bits from start of
+ containing structure. For gdbarch_bits_big_endian=1
+ targets, it is the bit offset to the MSB. For
+ gdbarch_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;
- 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. */
- /* 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. */
+ CORE_ADDR physaddr;
+ char *physname;
+ }
+ loc;
+
+ /* For a function or member type, this is 1 if the argument is marked
+ artificial. Artificial arguments should not be shown to the
+ user. For TYPE_CODE_RANGE it is set if the specific bound is not
+ defined. */
+ unsigned int artificial : 1;
+
+ /* Discriminant for union field_location. */
+ ENUM_BITFIELD(field_loc_kind) loc_kind : 2;
+
+ /* Size of this field, in bits, or zero if not packed.
+ If non-zero in an array type, indicates the element size in
+ bits (used only in Ada at the moment).
+ For an unpacked field, the field's type's length
+ says how many bytes the field occupies. */
+
+ unsigned int bitsize : 29;
- CORE_ADDR physaddr;
- char *physname;
- }
- loc;
+ /* 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 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;
+ struct type *type;
- /* 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. */
+ /* Name of field, value or argument.
+ NULL for range bounds, array domains, and member function
+ arguments. */
- unsigned int static_kind : 2;
+ char *name;
+ } *fields;
- /* 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. */
+ /* Union member used for range types. */
- unsigned int bitsize : 29;
+ struct range_bounds
+ {
+ /* Low bound of range. */
+
+ LONGEST low;
- /* 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. */
+ /* High bound of range. */
- struct type *type;
+ LONGEST high;
- /* Name of field, value or argument.
- NULL for range bounds, array domains, and member function
- arguments. */
+ /* Flags indicating whether the values of low and high are
+ valid. When true, the respective range value is
+ undefined. Currently used only for FORTRAN arrays. */
+
+ char low_undefined;
+ char high_undefined;
- char *name;
+ } *bounds;
- } *fields;
+ } flds_bnds;
/* For types with virtual functions (TYPE_CODE_STRUCT), VPTR_BASETYPE
is the base class which defined the virtual function table pointer.
{
/* 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. */
+ cplus_struct_type. */
struct cplus_struct_type *cplus_stuff;
+ /* GNAT_STUFF is for types for which the GNAT Ada compiler
+ provides additional information. */
+ struct gnat_aux_type *gnat_stuff;
+
/* 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
struct type *chain;
/* Flags specific to this instance of the type, indicating where
- on the ring we are. */
+ on the ring we are.
+
+ For TYPE_CODE_TYPEDEF the flags of the typedef type should be binary
+ or-ed with the target type, with a special case for address class and
+ space class. For example if this typedef does not specify any new
+ qualifiers, TYPE_INSTANCE_FLAGS is 0 and the instance flags are
+ completely inherited from the target type. No qualifiers can be cleared
+ by the typedef. See also check_typedef. */
int instance_flags;
/* Length of storage for a value of this type. This is what
short n_baseclasses;
/* Number of methods with unique names. All overloaded methods with
- the same name count only once. */
+ the same name count only once. */
short nfn_fields;
short nfn_fields_total;
- /* The "declared_type" field contains a code saying how the
- user really declared this type, e.g., "class s", "union s",
- "struct s".
- The 3 above things come out from the C++ compiler looking like classes,
- but we keep track of the real declaration so we can give
- the correct information on "ptype". (Note: TEMPLATE may not
- belong in this list...) */
-
-#define DECLARED_TYPE_CLASS 0
-#define DECLARED_TYPE_UNION 1
-#define DECLARED_TYPE_STRUCT 2
-#define DECLARED_TYPE_TEMPLATE 3
- short declared_type; /* One of the above codes */
-
- /* For derived classes, the number of base classes is given by n_baseclasses
- and virtual_field_bits is a bit vector containing one bit per base class.
- If the base class is virtual, the corresponding bit will be set.
+ /* Number of template arguments. */
+ unsigned short n_template_arguments;
+
+ /* One if this struct is a dynamic class, as defined by the
+ Itanium C++ ABI: if it requires a virtual table pointer,
+ because it or any of its base classes have one or more virtual
+ member functions or virtual base classes. Minus one if not
+ dynamic. Zero if not yet computed. */
+ int is_dynamic : 2;
+
+ /* For derived classes, the number of base classes is given by
+ n_baseclasses and virtual_field_bits is a bit vector containing
+ one bit per base class. If the base class is virtual, the
+ corresponding bit will be set.
I.E, given:
class A{};
class C : public B, public virtual A {};
B is a baseclass of C; A is a virtual baseclass for C.
- This is a C++ 2.0 language feature. */
+ This is a C++ 2.0 language feature. */
B_TYPE *virtual_field_bits;
/* For classes with private fields, the number of fields is given by
nfields and private_field_bits is a bit vector containing one bit
per field.
- If the field is private, the corresponding bit will be set. */
+ If the field is private, the corresponding bit will be set. */
B_TYPE *private_field_bits;
/* For classes with protected fields, the number of fields is given by
nfields and protected_field_bits is a bit vector containing one bit
per field.
- If the field is private, the corresponding bit will be set. */
+ If the field is private, the corresponding bit will be set. */
B_TYPE *protected_field_bits;
- /* for classes with fields to be ignored, either this is optimized out
- or this field has length 0 */
+ /* For classes with fields to be ignored, either this is optimized out
+ or this field has length 0. */
B_TYPE *ignore_field_bits;
arguments that the method expects, and then the name after it
has been renamed to make it distinct.
- fn_fieldlists points to an array of nfn_fields of these. */
+ fn_fieldlists points to an array of nfn_fields of these. */
struct fn_fieldlist
{
/* The function type for the method.
(This comment used to say "The return value of the method",
- but that's wrong. The function type
+ but that's wrong. The function type
is expected here, i.e. something with TYPE_CODE_FUNC,
- and *not* the return-value type). */
+ and *not* the return-value type). */
struct type *type;
/* For virtual functions.
- First baseclass that defines this virtual function. */
+ First baseclass that defines this virtual function. */
struct type *fcontext;
- /* Attributes. */
+ /* Attributes. */
unsigned int is_const:1;
unsigned int is_volatile:1;
}
*fn_fieldlists;
- /* If this "struct type" describes a template, then it
- * has arguments. "template_args" points to an array of
- * template arg descriptors, of length "ntemplate_args".
- * The only real information in each of these template arg descriptors
- * is a name. "type" will typically just point to a "struct type" with
- * the placeholder TYPE_CODE_TEMPLATE_ARG type.
- */
- short ntemplate_args;
- struct template_arg
- {
- char *name;
- struct type *type;
- }
- *template_args;
-
/* Pointer to information about enclosing scope, if this is a
- * local type. If it is not a local type, this is NULL
- */
+ local type. If it is not a local type, this is NULL. */
struct local_type_info
{
char *file;
int line;
}
*localtype_ptr;
+
+ /* typedefs defined inside this class. TYPEDEF_FIELD points to an array of
+ TYPEDEF_FIELD_COUNT elements. */
+ struct typedef_field
+ {
+ /* Unqualified name to be prefixed by owning class qualified name. */
+ const char *name;
+
+ /* Type this typedef named NAME represents. */
+ struct type *type;
+ }
+ *typedef_field;
+ unsigned typedef_field_count;
+
+ /* The template arguments. This is an array with
+ N_TEMPLATE_ARGUMENTS elements. This is NULL for non-template
+ classes. */
+ struct symbol **template_arguments;
};
-/* Struct used in computing virtual base list */
+/* Struct used in computing virtual base list. */
struct vbase
{
struct type *vbasetype; /* pointer to virtual base */
struct vbase *next; /* next in chain */
};
-/* Struct used for ranking a function for overload resolution */
+/* Struct used to store conversion rankings. */
+struct rank
+ {
+ short rank;
+
+ /* When two conversions are of the same type and therefore have the same
+ rank, subrank is used to differentiate the two.
+ Eg: Two derived-class-pointer to base-class-pointer conversions would
+ both have base pointer conversion rank, but the conversion with the
+ shorter distance to the ancestor is preferable. 'subrank' would be used
+ to reflect that. */
+ short subrank;
+ };
+
+/* Struct used for ranking a function for overload resolution. */
struct badness_vector
{
int length;
- int *rank;
+ struct rank *rank;
+ };
+
+/* GNAT Ada-specific information for various Ada types. */
+struct gnat_aux_type
+ {
+ /* Parallel type used to encode information about dynamic types
+ used in Ada (such as variant records, variable-size array,
+ etc). */
+ struct type* descriptive_type;
};
/* The default value of TYPE_CPLUS_SPECIFIC(T) points to the
- this shared static structure. */
+ this shared static structure. */
extern const struct cplus_struct_type cplus_struct_default;
extern void allocate_cplus_struct_type (struct type *);
#define INIT_CPLUS_SPECIFIC(type) \
- (TYPE_CPLUS_SPECIFIC(type)=(struct cplus_struct_type*)&cplus_struct_default)
+ (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CPLUS_STUFF, \
+ TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type*) \
+ &cplus_struct_default)
+
#define ALLOCATE_CPLUS_STRUCT_TYPE(type) allocate_cplus_struct_type (type)
+
#define HAVE_CPLUS_STRUCT(type) \
- (TYPE_CPLUS_SPECIFIC(type) != &cplus_struct_default)
+ (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_CPLUS_STUFF \
+ && TYPE_RAW_CPLUS_SPECIFIC (type) != &cplus_struct_default)
+
+extern const struct gnat_aux_type gnat_aux_default;
+
+extern void allocate_gnat_aux_type (struct type *);
+
+#define INIT_GNAT_SPECIFIC(type) \
+ (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_GNAT_STUFF, \
+ TYPE_GNAT_SPECIFIC (type) = (struct gnat_aux_type *) &gnat_aux_default)
+#define ALLOCATE_GNAT_AUX_TYPE(type) allocate_gnat_aux_type (type)
+/* A macro that returns non-zero if the type-specific data should be
+ read as "gnat-stuff". */
+#define HAVE_GNAT_AUX_INFO(type) \
+ (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_GNAT_STUFF)
#define TYPE_INSTANCE_FLAGS(thistype) (thistype)->instance_flags
#define TYPE_MAIN_TYPE(thistype) (thistype)->main_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) TYPE_MAIN_TYPE(thistype)->objfile
/* 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)). */
+ type, you need to do TYPE_CODE (check_type (this_type)). */
#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_FIELDS(thistype) TYPE_MAIN_TYPE(thistype)->flds_bnds.fields
#define TYPE_INDEX_TYPE(type) TYPE_FIELD_TYPE (type, 0)
-#define TYPE_LOW_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 0)
-#define TYPE_HIGH_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 1)
+#define TYPE_RANGE_DATA(thistype) TYPE_MAIN_TYPE(thistype)->flds_bnds.bounds
+#define TYPE_LOW_BOUND(range_type) TYPE_RANGE_DATA(range_type)->low
+#define TYPE_HIGH_BOUND(range_type) TYPE_RANGE_DATA(range_type)->high
+#define TYPE_LOW_BOUND_UNDEFINED(range_type) \
+ TYPE_RANGE_DATA(range_type)->low_undefined
+#define TYPE_HIGH_BOUND_UNDEFINED(range_type) \
+ TYPE_RANGE_DATA(range_type)->high_undefined
-/* Moto-specific stuff for FORTRAN arrays */
+/* Moto-specific stuff for FORTRAN arrays. */
-#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_IS_UNDEFINED(arraytype) \
+ TYPE_HIGH_BOUND_UNDEFINED(TYPE_INDEX_TYPE(arraytype))
+#define TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED(arraytype) \
+ TYPE_LOW_BOUND_UNDEFINED(TYPE_INDEX_TYPE(arraytype))
#define TYPE_ARRAY_UPPER_BOUND_VALUE(arraytype) \
- (TYPE_FIELD_BITPOS((TYPE_FIELD_TYPE((arraytype),0)),1))
+ (TYPE_HIGH_BOUND(TYPE_INDEX_TYPE((arraytype))))
#define TYPE_ARRAY_LOWER_BOUND_VALUE(arraytype) \
- (TYPE_FIELD_BITPOS((TYPE_FIELD_TYPE((arraytype),0)),0))
+ (TYPE_LOW_BOUND(TYPE_INDEX_TYPE((arraytype))))
/* C++ */
#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_DECLARED_TYPE(thistype) TYPE_CPLUS_SPECIFIC(thistype)->declared_type
+#define TYPE_SPECIFIC_FIELD(thistype) \
+ TYPE_MAIN_TYPE(thistype)->type_specific_field
#define TYPE_TYPE_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific
-#define TYPE_CPLUS_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff
+/* We need this tap-dance with the TYPE_RAW_SPECIFIC because of the case
+ where we're trying to print an Ada array using the C language.
+ In that case, there is no "cplus_stuff", but the C language assumes
+ that there is. What we do, in that case, is pretend that there is
+ an implicit one which is the default cplus stuff. */
+#define TYPE_CPLUS_SPECIFIC(thistype) \
+ (!HAVE_CPLUS_STRUCT(thistype) \
+ ? (struct cplus_struct_type*)&cplus_struct_default \
+ : TYPE_RAW_CPLUS_SPECIFIC(thistype))
+#define TYPE_RAW_CPLUS_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff
#define TYPE_FLOATFORMAT(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.floatformat
+#define TYPE_GNAT_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.gnat_stuff
+#define TYPE_DESCRIPTIVE_TYPE(thistype) TYPE_GNAT_SPECIFIC(thistype)->descriptive_type
#define TYPE_CALLING_CONVENTION(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.calling_convention
-#define TYPE_BASECLASS(thistype,index) TYPE_MAIN_TYPE(thistype)->fields[index].type
+#define TYPE_BASECLASS(thistype,index) TYPE_FIELD_TYPE(thistype, index)
#define TYPE_N_BASECLASSES(thistype) TYPE_CPLUS_SPECIFIC(thistype)->n_baseclasses
-#define TYPE_BASECLASS_NAME(thistype,index) TYPE_MAIN_TYPE(thistype)->fields[index].name
+#define TYPE_BASECLASS_NAME(thistype,index) TYPE_FIELD_NAME(thistype, index)
#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 TYPE_CPLUS_DYNAMIC(thistype) TYPE_CPLUS_SPECIFIC (thistype)->is_dynamic
#define BASETYPE_VIA_VIRTUAL(thistype, index) \
(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \
#define FIELD_TYPE(thisfld) ((thisfld).type)
#define FIELD_NAME(thisfld) ((thisfld).name)
+#define FIELD_LOC_KIND(thisfld) ((thisfld).loc_kind)
#define FIELD_BITPOS(thisfld) ((thisfld).loc.bitpos)
+#define FIELD_STATIC_PHYSNAME(thisfld) ((thisfld).loc.physname)
+#define FIELD_STATIC_PHYSADDR(thisfld) ((thisfld).loc.physaddr)
+#define SET_FIELD_BITPOS(thisfld, bitpos) \
+ (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_BITPOS, \
+ FIELD_BITPOS (thisfld) = (bitpos))
+#define SET_FIELD_PHYSNAME(thisfld, name) \
+ (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_PHYSNAME, \
+ FIELD_STATIC_PHYSNAME (thisfld) = (name))
+#define SET_FIELD_PHYSADDR(thisfld, addr) \
+ (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_PHYSADDR, \
+ FIELD_STATIC_PHYSADDR (thisfld) = (addr))
#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).static_kind = 1, FIELD_PHYSNAME(thisfld) = (name))
-#define SET_FIELD_PHYSADDR(thisfld, name) \
- ((thisfld).static_kind = 2, FIELD_PHYSADDR(thisfld) = (name))
-#define TYPE_FIELD(thistype, n) TYPE_MAIN_TYPE(thistype)->fields[n]
+
+#define TYPE_FIELD(thistype, n) TYPE_MAIN_TYPE(thistype)->flds_bnds.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_LOC_KIND(thistype, n) FIELD_LOC_KIND (TYPE_FIELD (thistype, n))
+#define TYPE_FIELD_BITPOS(thistype, n) FIELD_BITPOS (TYPE_FIELD (thistype, n))
+#define TYPE_FIELD_STATIC_PHYSNAME(thistype, n) FIELD_STATIC_PHYSNAME (TYPE_FIELD (thistype, n))
+#define TYPE_FIELD_STATIC_PHYSADDR(thistype, n) FIELD_STATIC_PHYSADDR (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]
#define TYPE_FIELD_PRIVATE_BITS(thistype) \
TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits
(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) (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_FIELDLISTS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists
#define TYPE_FN_FIELDLIST(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n]
#define TYPE_FN_FIELDLIST1(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].fn_fields
#define TYPE_FN_FIELDLIST_NAME(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].name
#define TYPE_FN_FIELDLIST_LENGTH(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].length
+#define TYPE_N_TEMPLATE_ARGUMENTS(thistype) \
+ TYPE_CPLUS_SPECIFIC (thistype)->n_template_arguments
+#define TYPE_TEMPLATE_ARGUMENTS(thistype) \
+ TYPE_CPLUS_SPECIFIC (thistype)->template_arguments
+#define TYPE_TEMPLATE_ARGUMENT(thistype, n) \
+ TYPE_CPLUS_SPECIFIC (thistype)->template_arguments[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_LOCALTYPE_FILE(thistype) (TYPE_CPLUS_SPECIFIC(thistype)->localtype_ptr->file)
#define TYPE_LOCALTYPE_LINE(thistype) (TYPE_CPLUS_SPECIFIC(thistype)->localtype_ptr->line)
-#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_STUB (thistype) || !TYPE_STUB_SUPPORTED (thistype)))
+#define TYPE_TYPEDEF_FIELD_ARRAY(thistype) \
+ TYPE_CPLUS_SPECIFIC (thistype)->typedef_field
+#define TYPE_TYPEDEF_FIELD(thistype, n) \
+ TYPE_CPLUS_SPECIFIC (thistype)->typedef_field[n]
+#define TYPE_TYPEDEF_FIELD_NAME(thistype, n) \
+ TYPE_TYPEDEF_FIELD (thistype, n).name
+#define TYPE_TYPEDEF_FIELD_TYPE(thistype, n) \
+ TYPE_TYPEDEF_FIELD (thistype, n).type
+#define TYPE_TYPEDEF_FIELD_COUNT(thistype) \
+ TYPE_CPLUS_SPECIFIC (thistype)->typedef_field_count
+
+#define TYPE_IS_OPAQUE(thistype) \
+ (((TYPE_CODE (thistype) == TYPE_CODE_STRUCT) \
+ || (TYPE_CODE (thistype) == TYPE_CODE_UNION)) \
+ && (TYPE_NFIELDS (thistype) == 0) \
+ && (!HAVE_CPLUS_STRUCT (thistype) \
+ || TYPE_NFN_FIELDS (thistype) == 0) \
+ && (TYPE_STUB (thistype) || !TYPE_STUB_SUPPORTED (thistype)))
+
+/* A helper macro that returns the name of an error type. If the type
+ has a name, it is used; otherwise, a default is used. */
+#define TYPE_ERROR_NAME(type) \
+ (TYPE_NAME (type) ? TYPE_NAME (type) : _("<error type>"))
struct builtin_type
{
- /* Address/pointer types. */
+ /* Integral types. */
+
+ /* Implicit size/sign (based on 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;
+ struct type *builtin_decfloat;
+ struct type *builtin_decdouble;
+ struct type *builtin_declong;
+
+ /* "True" character types.
+ We use these 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;
+ struct type *builtin_true_unsigned_char;
+
+ /* 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. */
+ struct type *builtin_int0;
+ struct type *builtin_int8;
+ struct type *builtin_uint8;
+ struct type *builtin_int16;
+ struct type *builtin_uint16;
+ struct type *builtin_int32;
+ struct type *builtin_uint32;
+ struct type *builtin_int64;
+ struct type *builtin_uint64;
+ struct type *builtin_int128;
+ struct type *builtin_uint128;
+
+ /* Wide character types. */
+ struct type *builtin_char16;
+ struct type *builtin_char32;
+
+ /* Pointer types. */
/* `pointer to data' type. Some target platforms use an implicitly
{sign,zero} -extended 32-bit ABI pointer on a 64-bit ISA. */
(*) () 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;
+ /* `function returning pointer to function (returning void)' type.
+ The final void return type is not significant for it. */
+ struct type *builtin_func_func;
- /* Types used for symbols with no debug information. */
- struct type *nodebug_text_symbol;
- struct type *nodebug_data_symbol;
- struct type *nodebug_unknown_symbol;
- struct type *nodebug_tls_symbol;
+ /* Special-purpose types. */
+ /* This type is used to represent a GDB internal function. */
+ struct type *internal_fn;
+};
+
+/* Return the type table for the specified architecture. */
+extern const struct builtin_type *builtin_type (struct gdbarch *gdbarch);
- /* Integral types. */
- /* Implicit size/sign (based on the the architecture's ABI). */
+/* Per-objfile types used by symbol readers. */
+
+struct objfile_type
+{
+ /* Basic types based on the objfile architecture. */
struct type *builtin_void;
struct type *builtin_char;
struct type *builtin_short;
struct type *builtin_int;
struct type *builtin_long;
+ struct type *builtin_long_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_unsigned_long_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;
- struct type *builtin_decfloat;
- struct type *builtin_decdouble;
- struct type *builtin_declong;
-};
-/* Return the type table for the specified architecture. */
-extern const struct builtin_type *builtin_type (struct gdbarch *gdbarch);
+ /* This type is used to represent symbol addresses. */
+ struct type *builtin_core_addr;
-/* Compatibility macros to access types for the current architecture. */
-#define builtin_type_void_data_ptr \
- (builtin_type (current_gdbarch)->builtin_data_ptr)
-#define builtin_type_void_func_ptr \
- (builtin_type (current_gdbarch)->builtin_func_ptr)
-#define builtin_type_CORE_ADDR \
- (builtin_type (current_gdbarch)->builtin_core_addr)
-#define builtin_type_char \
- (builtin_type (current_gdbarch)->builtin_char)
-#define builtin_type_short \
- (builtin_type (current_gdbarch)->builtin_short)
-#define builtin_type_int \
- (builtin_type (current_gdbarch)->builtin_int)
-#define builtin_type_long \
- (builtin_type (current_gdbarch)->builtin_long)
-#define builtin_type_signed_char \
- (builtin_type (current_gdbarch)->builtin_signed_char)
-#define builtin_type_unsigned_char \
- (builtin_type (current_gdbarch)->builtin_unsigned_char)
-#define builtin_type_unsigned_short \
- (builtin_type (current_gdbarch)->builtin_unsigned_short)
-#define builtin_type_unsigned_int \
- (builtin_type (current_gdbarch)->builtin_unsigned_int)
-#define builtin_type_unsigned_long \
- (builtin_type (current_gdbarch)->builtin_unsigned_long)
-#define builtin_type_float \
- (builtin_type (current_gdbarch)->builtin_float)
-#define builtin_type_double \
- (builtin_type (current_gdbarch)->builtin_double)
-#define builtin_type_long_double \
- (builtin_type (current_gdbarch)->builtin_long_double)
-#define builtin_type_complex \
- (builtin_type (current_gdbarch)->builtin_complex)
-#define builtin_type_double_complex \
- (builtin_type (current_gdbarch)->builtin_double_complex)
-#define builtin_type_string \
- (builtin_type (current_gdbarch)->builtin_string)
-#define builtin_type_bool \
- (builtin_type (current_gdbarch)->builtin_bool)
-#define builtin_type_long_long \
- (builtin_type (current_gdbarch)->builtin_long_long)
-#define builtin_type_unsigned_long_long \
- (builtin_type (current_gdbarch)->builtin_unsigned_long_long)
+ /* This type represents a type that was unrecognized in symbol read-in. */
+ struct type *builtin_error;
-
-/* 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_uint16;
-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;
+ /* Types used for symbols with no debug information. */
+ struct type *nodebug_text_symbol;
+ struct type *nodebug_text_gnu_ifunc_symbol;
+ struct type *nodebug_got_plt_symbol;
+ struct type *nodebug_data_symbol;
+ struct type *nodebug_unknown_symbol;
+ struct type *nodebug_tls_symbol;
+};
+
+/* Return the type table for the specified objfile. */
+extern const struct objfile_type *objfile_type (struct objfile *objfile);
+
/* Explicit floating-point formats. See "floatformat.h". */
+extern const struct floatformat *floatformats_ieee_half[BFD_ENDIAN_UNKNOWN];
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_vax_d[BFD_ENDIAN_UNKNOWN];
extern const struct floatformat *floatformats_ibm_long_double[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;
-
-/* Platform-neutral void type. Never attempt to construct a pointer
- or reference type to this, because those cannot be platform-neutral.
- You must use builtin_type (...)->builtin_void in those cases. */
-extern struct type *builtin_type_void;
-
-/* Platform-neutral character types.
- We use these 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. */
-extern struct type *builtin_type_true_char;
-extern struct type *builtin_type_true_unsigned_char;
-
-
-/* This type represents a type that was unrecognized in symbol
- read-in. */
-extern struct type *builtin_type_error;
-
-
-/* Modula-2 types */
-
-struct builtin_m2_type
-{
- struct type *builtin_char;
- struct type *builtin_int;
- struct type *builtin_card;
- struct type *builtin_real;
- struct type *builtin_bool;
-};
-
-/* Return the Modula-2 type table for the specified architecture. */
-extern const struct builtin_m2_type *builtin_m2_type (struct gdbarch *gdbarch);
-
-/* Compatibility macros to access types for the current architecture. */
-#define builtin_type_m2_char \
- (builtin_m2_type (current_gdbarch)->builtin_char)
-#define builtin_type_m2_int \
- (builtin_m2_type (current_gdbarch)->builtin_int)
-#define builtin_type_m2_card \
- (builtin_m2_type (current_gdbarch)->builtin_card)
-#define builtin_type_m2_real \
- (builtin_m2_type (current_gdbarch)->builtin_real)
-#define builtin_type_m2_bool \
- (builtin_m2_type (current_gdbarch)->builtin_bool)
-
-
-/* Fortran (F77) types */
-
-struct builtin_f_type
-{
- struct type *builtin_character;
- struct type *builtin_integer;
- struct type *builtin_integer_s2;
- struct type *builtin_logical;
- struct type *builtin_logical_s1;
- struct type *builtin_logical_s2;
- struct type *builtin_real;
- struct type *builtin_real_s8;
- struct type *builtin_real_s16;
- struct type *builtin_complex_s8;
- struct type *builtin_complex_s16;
- struct type *builtin_complex_s32;
- struct type *builtin_void;
-};
-
-/* Return the Fortran type table for the specified architecture. */
-extern const struct builtin_f_type *builtin_f_type (struct gdbarch *gdbarch);
-
-/* Compatibility macros to access types for the current architecture. */
-#define builtin_type_f_character \
- (builtin_f_type (current_gdbarch)->builtin_character)
-#define builtin_type_f_integer \
- (builtin_f_type (current_gdbarch)->builtin_integer)
-#define builtin_type_f_integer_s2 \
- (builtin_f_type (current_gdbarch)->builtin_integer_s2)
-#define builtin_type_f_logical \
- (builtin_f_type (current_gdbarch)->builtin_logical)
-#define builtin_type_f_logical_s1 \
- (builtin_f_type (current_gdbarch)->builtin_logical_s1)
-#define builtin_type_f_logical_s2 \
- (builtin_f_type (current_gdbarch)->builtin_logical_s2)
-#define builtin_type_f_real \
- (builtin_f_type (current_gdbarch)->builtin_real)
-#define builtin_type_f_real_s8 \
- (builtin_f_type (current_gdbarch)->builtin_real_s8)
-#define builtin_type_f_real_s16 \
- (builtin_f_type (current_gdbarch)->builtin_real_s16)
-#define builtin_type_f_complex_s8 \
- (builtin_f_type (current_gdbarch)->builtin_complex_s8)
-#define builtin_type_f_complex_s16 \
- (builtin_f_type (current_gdbarch)->builtin_complex_s16)
-#define builtin_type_f_complex_s32 \
- (builtin_f_type (current_gdbarch)->builtin_complex_s32)
-
-
-/* RTTI for C++ */
-/* extern struct type *builtin_type_cxx_typeinfo; */
-
-/* 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)))
-
-#define MIN_OF_TYPE(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.
+ was used to allocate the space for the type structure itself. I.e.
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. */
+ the same as for the type structure. */
#define TYPE_ALLOC(t,size) \
- (TYPE_OBJFILE (t) != NULL \
+ (TYPE_OBJFILE_OWNED (t) \
? obstack_alloc (&TYPE_OBJFILE (t) -> objfile_obstack, size) \
: xmalloc (size))
#define TYPE_ZALLOC(t,size) \
- (TYPE_OBJFILE (t) != NULL \
+ (TYPE_OBJFILE_OWNED (t) \
? memset (obstack_alloc (&TYPE_OBJFILE (t)->objfile_obstack, size), \
0, size) \
: xzalloc (size))
+/* Use alloc_type to allocate a type owned by an objfile.
+ Use alloc_type_arch to allocate a type owned by an architecture.
+ Use alloc_type_copy to allocate a type with the same owner as a
+ pre-existing template type, no matter whether objfile or gdbarch. */
extern struct type *alloc_type (struct objfile *);
+extern struct type *alloc_type_arch (struct gdbarch *);
+extern struct type *alloc_type_copy (const struct type *);
+/* Return the type's architecture. For types owned by an architecture,
+ that architecture is returned. For types owned by an objfile, that
+ objfile's architecture is returned. */
+extern struct gdbarch *get_type_arch (const struct type *);
+
+/* Helper function to construct objfile-owned types. */
extern struct type *init_type (enum type_code, int, int, char *,
struct objfile *);
+/* Helper functions to construct architecture-owned types. */
+extern struct type *arch_type (struct gdbarch *, enum type_code, int, char *);
+extern struct type *arch_integer_type (struct gdbarch *, int, int, char *);
+extern struct type *arch_character_type (struct gdbarch *, int, int, char *);
+extern struct type *arch_boolean_type (struct gdbarch *, int, int, char *);
+extern struct type *arch_float_type (struct gdbarch *, int, char *,
+ const struct floatformat **);
+extern struct type *arch_complex_type (struct gdbarch *, char *,
+ 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
+ initially empty type is created using arch_composite_type().
+ Fields are then added using append_composite_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 struct type *arch_composite_type (struct gdbarch *gdbarch,
+ char *name, enum type_code code);
extern void append_composite_type_field (struct type *t, char *name,
struct type *field);
+extern void append_composite_type_field_aligned (struct type *t,
+ char *name,
+ struct type *field,
+ int alignment);
+struct field *append_composite_type_field_raw (struct type *t, char *name,
+ struct type *field);
/* Helper functions to construct a bit flags type. An initially empty
- type is created using init_flag_type(). Flags are then added using
+ type is created using arch_flag_type(). Flags are then added using
append_flag_type_flag(). */
-extern struct type *init_flags_type (char *name, int length);
+extern struct type *arch_flags_type (struct gdbarch *gdbarch,
+ char *name, int length);
extern void append_flags_type_flag (struct type *type, int bitpos, char *name);
extern void make_vector_type (struct type *array_type);
extern void replace_type (struct type *, struct type *);
-extern int address_space_name_to_int (char *);
+extern int address_space_name_to_int (struct gdbarch *, char *);
-extern const char *address_space_int_to_name (int);
+extern const char *address_space_int_to_name (struct gdbarch *, int);
extern struct type *make_type_with_address_space (struct type *type,
int space_identifier);
extern void smash_to_memberptr_type (struct type *, struct type *,
struct type *);
+extern void smash_to_methodptr_type (struct type *, struct type *);
+
extern struct type *allocate_stub_method (struct type *);
extern char *type_name_no_tag (const struct type *);
extern struct type *lookup_function_type (struct type *);
-extern struct type *create_range_type (struct type *, struct type *, int,
- int);
+extern struct type *create_range_type (struct type *, struct type *, LONGEST,
+ LONGEST);
extern struct type *create_array_type (struct type *, struct type *,
struct type *);
+extern struct type *lookup_array_range_type (struct type *, int, int);
-extern struct type *create_string_type (struct type *, struct type *);
+extern struct type *create_string_type (struct type *, struct type *,
+ struct type *);
+extern struct type *lookup_string_range_type (struct type *, int, int);
extern struct type *create_set_type (struct type *, struct type *);
-extern struct type *lookup_unsigned_typename (char *);
+extern struct type *lookup_unsigned_typename (const struct language_defn *,
+ struct gdbarch *,char *);
-extern struct type *lookup_signed_typename (char *);
+extern struct type *lookup_signed_typename (const struct language_defn *,
+ struct gdbarch *,char *);
extern struct type *check_typedef (struct type *);
-#define CHECK_TYPEDEF(TYPE) (TYPE) = check_typedef (TYPE)
+#define CHECK_TYPEDEF(TYPE) \
+ do { \
+ (TYPE) = check_typedef (TYPE); \
+ } while (0)
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 struct type *lookup_typename (const struct language_defn *,
+ struct gdbarch *, char *,
+ const struct block *, int);
extern struct type *lookup_template_type (char *, struct type *,
struct block *);
extern int get_vptr_fieldno (struct type *, struct type **);
-extern int get_destructor_fn_field (struct type *, int *, int *);
-
extern int get_discrete_bounds (struct type *, LONGEST *, LONGEST *);
+extern int get_array_bounds (struct type *type, LONGEST *low_bound,
+ LONGEST *high_bound);
+
+extern int class_types_same_p (const struct type *, const struct type *);
+
extern int is_ancestor (struct type *, struct type *);
+extern int is_public_ancestor (struct type *, struct type *);
+
+extern int is_unique_ancestor (struct type *, struct value *);
+
/* Overload resolution */
#define LENGTH_MATCH(bv) ((bv)->rank[0])
-/* Badness if parameter list length doesn't match arg list length */
-#define LENGTH_MISMATCH_BADNESS 100
-/* Dummy badness value for nonexistent parameter positions */
-#define TOO_FEW_PARAMS_BADNESS 100
-/* Badness if no conversion among types */
-#define INCOMPATIBLE_TYPE_BADNESS 100
-
-/* Badness of integral promotion */
-#define INTEGER_PROMOTION_BADNESS 1
-/* Badness of floating promotion */
-#define FLOAT_PROMOTION_BADNESS 1
-/* Badness of integral conversion */
-#define INTEGER_CONVERSION_BADNESS 2
-/* Badness of floating conversion */
-#define FLOAT_CONVERSION_BADNESS 2
-/* Badness of integer<->floating conversions */
-#define INT_FLOAT_CONVERSION_BADNESS 2
-/* Badness of converting to a boolean */
-#define BOOLEAN_CONVERSION_BADNESS 2
-/* Badness of pointer conversion */
-#define POINTER_CONVERSION_BADNESS 2
-/* Badness of conversion of pointer to void pointer */
-#define VOID_PTR_CONVERSION_BADNESS 2
-/* 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
+/* Badness if parameter list length doesn't match arg list length. */
+extern const struct rank LENGTH_MISMATCH_BADNESS;
+
+/* Dummy badness value for nonexistent parameter positions. */
+extern const struct rank TOO_FEW_PARAMS_BADNESS;
+/* Badness if no conversion among types. */
+extern const struct rank INCOMPATIBLE_TYPE_BADNESS;
+
+/* Badness of an exact match. */
+extern const struct rank EXACT_MATCH_BADNESS;
+
+/* Badness of integral promotion. */
+extern const struct rank INTEGER_PROMOTION_BADNESS;
+/* Badness of floating promotion. */
+extern const struct rank FLOAT_PROMOTION_BADNESS;
+/* Badness of converting a derived class pointer
+ to a base class pointer. */
+extern const struct rank BASE_PTR_CONVERSION_BADNESS;
+/* Badness of integral conversion. */
+extern const struct rank INTEGER_CONVERSION_BADNESS;
+/* Badness of floating conversion. */
+extern const struct rank FLOAT_CONVERSION_BADNESS;
+/* Badness of integer<->floating conversions. */
+extern const struct rank INT_FLOAT_CONVERSION_BADNESS;
+/* Badness of conversion of pointer to void pointer. */
+extern const struct rank VOID_PTR_CONVERSION_BADNESS;
+/* Badness of conversion of pointer to boolean. */
+extern const struct rank BOOL_PTR_CONVERSION_BADNESS;
+/* Badness of converting derived to base class. */
+extern const struct rank BASE_CONVERSION_BADNESS;
+/* Badness of converting from non-reference to reference. */
+extern const struct rank REFERENCE_CONVERSION_BADNESS;
/* Non-standard conversions allowed by the debugger */
-/* Converting a pointer to an int is usually OK */
-#define NS_POINTER_CONVERSION_BADNESS 10
+/* Converting a pointer to an int is usually OK. */
+extern const struct rank NS_POINTER_CONVERSION_BADNESS;
+extern struct rank sum_ranks (struct rank a, struct rank b);
+extern int compare_ranks (struct rank a, struct rank b);
+
extern int compare_badness (struct badness_vector *, struct badness_vector *);
extern struct badness_vector *rank_function (struct type **, int,
struct type **, int);
-extern int rank_one_type (struct type *, struct type *);
+extern struct rank rank_one_type (struct type *, struct type *);
extern void recursive_dump_type (struct type *, int);
+extern int field_is_static (struct field *);
+
/* printcmd.c */
-extern void print_scalar_formatted (const void *, struct type *, int, int,
- struct ui_file *);
+extern void print_scalar_formatted (const void *, struct type *,
+ const struct value_print_options *,
+ int, struct ui_file *);
extern int can_dereference (struct type *);
extern int is_integral_type (struct type *);
+extern int is_scalar_type_recursive (struct type *);
+
extern void maintenance_print_type (char *, int);
extern htab_t create_copied_types_hash (struct objfile *objfile);
struct type *type,
htab_t copied_types);
+extern struct type *copy_type (const struct type *type);
+
#endif /* GDBTYPES_H */