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
};
#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.
*/
{
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
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. */
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;
CORE_ADDR physaddr;
char *physname;
-
- /* The field location can be computed by evaluating the following DWARF
- block. This can be used in Fortran variable-length arrays, for
- instance. */
-
- struct dwarf2_locexpr_baton *dwarf_block;
}
loc;
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 */
+ /* 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.
}
*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
*/
}
*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;
};
/* Struct used in computing virtual base list */
#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)->flds_bnds.fields
-#define TYPE_TEMPLATE_ARGS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->template_args
#define TYPE_INDEX_TYPE(type) TYPE_FIELD_TYPE (type, 0)
#define TYPE_RANGE_DATA(thistype) TYPE_MAIN_TYPE(thistype)->flds_bnds.bounds
#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 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_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_LOCALTYPE_FILE(thistype) (TYPE_CPLUS_SPECIFIC(thistype)->localtype_ptr->file)
#define TYPE_LOCALTYPE_LINE(thistype) (TYPE_CPLUS_SPECIFIC(thistype)->localtype_ptr->line)
+#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)) && \
+ (!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. */
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.
/* 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 int get_discrete_bounds (struct type *, LONGEST *, LONGEST *);
+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])
projects / deliverable / binutils-gdb.git / blobdiff