/* Internal type definitions for GDB.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
- 2002, 2003, 2004, 2006, 2007, 2008, 2009 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.
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_MODULE, /* Fortran module. */
+
/* Internal function type. */
TYPE_CODE_INTERNAL_FUNCTION
};
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),
/* 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)
/* Type owner. If TYPE_OBJFILE_OWNED is true, the type is owned by
the objfile retrieved as TYPE_OBJFILE. Otherweise, the type is
#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
{
FIELD_LOC_KIND_BITPOS, /* bitpos */
FIELD_LOC_KIND_PHYSADDR, /* physaddr */
- FIELD_LOC_KIND_PHYSNAME, /* physname */
- FIELD_LOC_KIND_DWARF_BLOCK /* dwarf_block */
+ 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
+{
+ TYPE_SPECIFIC_NONE,
+ TYPE_SPECIFIC_CPLUS_STUFF,
+ TYPE_SPECIFIC_GNAT_STUFF,
+ TYPE_SPECIFIC_FLOATFORMAT,
+ TYPE_SPECIFIC_CALLING_CONVENTION
+};
+
/* This structure is space-critical.
Its layout has been tweaked to reduce the space used. */
struct main_type
{
- /* Code for kind of type */
+ /* Code for kind of type. */
ENUM_BITFIELD(type_code) code : 8;
unsigned int flag_varargs : 1;
unsigned int flag_vector : 1;
unsigned int flag_stub_supported : 1;
- unsigned int flag_nottext : 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. */
union type_owner
{
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;
+
+ /* 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;
- int bitpos;
+ /* 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. */
- /* 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. */
+ unsigned int bitsize : 29;
- CORE_ADDR physaddr;
- char *physname;
+ /* 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. */
- /* The field location can be computed by evaluating the following DWARF
- block. This can be used in Fortran variable-length arrays, for
- instance. */
+ struct type *type;
- struct dwarf2_locexpr_baton *dwarf_block;
- }
- loc;
+ /* Name of field, value or argument.
+ NULL for range bounds, array domains, and member function
+ arguments. */
- /* 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;
+ char *name;
+ } *fields;
- /* Discriminant for union field_location. */
- ENUM_BITFIELD(field_loc_kind) loc_kind : 2;
+ /* Union member used for range types. */
- /* 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. */
+ struct range_bounds
+ {
+ /* Low bound of range. */
- unsigned int bitsize : 29;
+ 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;
}
*localtype_ptr;
- /* 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;
+ /* 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
calls check_typedef, TYPE_LENGTH (VALUE_TYPE (X)) is safe. */
#define TYPE_LENGTH(thistype) (thistype)->length
/* 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_IS_UNDEFINED(arraytype) \
- (TYPE_FIELD_ARTIFICIAL(TYPE_INDEX_TYPE((arraytype)),1))
+ TYPE_HIGH_BOUND_UNDEFINED(TYPE_INDEX_TYPE(arraytype))
#define TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED(arraytype) \
- (TYPE_FIELD_ARTIFICIAL(TYPE_INDEX_TYPE((arraytype)),0))
+ TYPE_LOW_BOUND_UNDEFINED(TYPE_INDEX_TYPE(arraytype))
#define TYPE_ARRAY_UPPER_BOUND_VALUE(arraytype) \
(TYPE_HIGH_BOUND(TYPE_INDEX_TYPE((arraytype))))
#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 FIELD_BITPOS(thisfld) ((thisfld).loc.bitpos)
#define FIELD_STATIC_PHYSNAME(thisfld) ((thisfld).loc.physname)
#define FIELD_STATIC_PHYSADDR(thisfld) ((thisfld).loc.physaddr)
-#define FIELD_DWARF_BLOCK(thisfld) ((thisfld).loc.dwarf_block)
#define SET_FIELD_BITPOS(thisfld, bitpos) \
(FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_BITPOS, \
FIELD_BITPOS (thisfld) = (bitpos))
#define SET_FIELD_PHYSADDR(thisfld, addr) \
(FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_PHYSADDR, \
FIELD_STATIC_PHYSADDR (thisfld) = (addr))
-#define SET_FIELD_DWARF_BLOCK(thisfld, addr) \
- (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_DWARF_BLOCK, \
- FIELD_DWARF_BLOCK (thisfld) = (addr))
#define FIELD_ARTIFICIAL(thisfld) ((thisfld).artificial)
#define FIELD_BITSIZE(thisfld) ((thisfld).bitsize)
-#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_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_DWARF_BLOCK(thistype, n) FIELD_DWARF_BLOCK (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
#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
{
/* Integral types. */
- /* Implicit size/sign (based on the the architecture's ABI). */
+ /* Implicit size/sign (based on the architecture's ABI). */
struct type *builtin_void;
struct type *builtin_char;
struct type *builtin_short;
struct type *builtin_int128;
struct type *builtin_uint128;
+ /* Wide character types. */
+ struct type *builtin_char16;
+ struct type *builtin_char32;
/* Pointer types. */
/* 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_ibm_long_double[BFD_ENDIAN_UNKNOWN];
-/* 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_OWNED (t) \
/* Helper functions to construct a struct or record type. An
initially empty type is created using arch_composite_type().
- Fields are then added using append_struct_type_field(). A union
+ 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. */
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 arch_flag_type(). Flags are then added using
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_typename (const struct language_defn *,
struct gdbarch *, char *,
- struct block *, int);
+ const struct block *, int);
extern struct type *lookup_template_type (char *, struct type *,
struct block *);
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 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);
OSDN Git Service
