X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbtypes.h;h=28d42efb7285e1a94ade25a30ab334952bfabcee;hb=975f8708de015fb2b813edbf8b714f4777c57a41;hp=0dd7333371b642794cb5ceaac04923771d356a1a;hpb=b858499daf0a824a518bac8bc13495ad856ab10d;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index 0dd7333371..28d42efb72 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -1,7 +1,7 @@ /* Internal type definitions for GDB. - Copyright (C) 1992-2019 Free Software Foundation, Inc. + Copyright (C) 1992-2020 Free Software Foundation, Inc. Contributed by Cygnus Support, using pieces from other GDB modules. @@ -50,12 +50,16 @@ #include "gdbsupport/enum-flags.h" #include "gdbsupport/underlying.h" #include "gdbsupport/print-utils.h" +#include "dwarf2.h" +#include "gdb_obstack.h" /* Forward declarations for prototypes. */ struct field; struct block; struct value_print_options; struct language_defn; +struct dwarf2_per_cu_data; +struct dwarf2_per_objfile; /* These declarations are DWARF-specific as some of the gdbtypes.h data types are already DWARF-specific. */ @@ -119,9 +123,7 @@ enum type_code TYPE_CODE_FUNC, /**< Function type */ TYPE_CODE_INT, /**< Integer type */ - /* * Floating type. This is *NOT* a complex type. Beware, there - are parts of GDB which bogusly assume that TYPE_CODE_FLT can - mean complex. */ + /* * Floating type. This is *NOT* a complex type. */ TYPE_CODE_FLT, /* * Void type. The length field specifies the length (probably @@ -246,16 +248,6 @@ DEF_ENUM_FLAGS_TYPE (enum type_instance_flag_value, type_instance_flags); #define TYPE_PROTOTYPED(t) (TYPE_MAIN_TYPE (t)->flag_prototyped) -/* * This flag is used to indicate that processing for this type - is incomplete. - - (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.) */ - -#define TYPE_INCOMPLETE(t) (TYPE_MAIN_TYPE (t)->flag_incomplete) - /* * FIXME drow/2002-06-03: Only used for methods, but applies as well to functions. */ @@ -319,14 +311,6 @@ DEF_ENUM_FLAGS_TYPE (enum type_instance_flag_value, type_instance_flags); #define TYPE_FLAG_ENUM(t) (TYPE_MAIN_TYPE (t)->flag_flag_enum) -/* * True if this type is a discriminated union type. Only valid for - TYPE_CODE_UNION. A discriminated union stores a reference to the - discriminant field along with the discriminator values in a dynamic - property. */ - -#define TYPE_FLAG_DISCRIMINATED_UNION(t) \ - (TYPE_MAIN_TYPE (t)->flag_discriminated_union) - /* * Constant type. If this is set, the corresponding type has a const modifier. */ @@ -353,11 +337,19 @@ DEF_ENUM_FLAGS_TYPE (enum type_instance_flag_value, type_instance_flags); /* * True if this type represents either an lvalue or lvalue reference type. */ #define TYPE_IS_REFERENCE(t) \ - (TYPE_CODE (t) == TYPE_CODE_REF || TYPE_CODE (t) == TYPE_CODE_RVALUE_REF) + ((t)->code () == TYPE_CODE_REF || (t)->code () == TYPE_CODE_RVALUE_REF) /* * True if this type is allocatable. */ #define TYPE_IS_ALLOCATABLE(t) \ - (get_dyn_prop (DYN_PROP_ALLOCATED, t) != NULL) + ((t)->dyn_prop (DYN_PROP_ALLOCATED) != NULL) + +/* * True if this type has variant parts. */ +#define TYPE_HAS_VARIANT_PARTS(t) \ + ((t)->dyn_prop (DYN_PROP_VARIANT_PARTS) != nullptr) + +/* * True if this type has a dynamic length. */ +#define TYPE_HAS_DYNAMIC_LENGTH(t) \ + ((t)->dyn_prop (DYN_PROP_BYTE_SIZE) != nullptr) /* * Instruction-space delimited type. This is for Harvard architectures which have separate instruction and data address spaces (and perhaps @@ -400,46 +392,93 @@ DEF_ENUM_FLAGS_TYPE (enum type_instance_flag_value, type_instance_flags); #define TYPE_ADDRESS_CLASS_ALL(t) (TYPE_INSTANCE_FLAGS(t) \ & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL) -/* * Information needed for a discriminated union. A discriminated - union is handled somewhat differently from an ordinary union. +/* * Information about a single discriminant. */ - One field is designated as the discriminant. Only one other field - is active at a time; which one depends on the value of the - discriminant and the data in this structure. +struct discriminant_range +{ + /* * The range of values for the variant. This is an inclusive + range. */ + ULONGEST low, high; + + /* * Return true if VALUE is contained in this range. IS_UNSIGNED + is true if this should be an unsigned comparison; false for + signed. */ + bool contains (ULONGEST value, bool is_unsigned) const + { + if (is_unsigned) + return value >= low && value <= high; + LONGEST valuel = (LONGEST) value; + return valuel >= (LONGEST) low && valuel <= (LONGEST) high; + } +}; - Additionally, it is possible to have a univariant discriminated - union. In this case, the union has just a single field, which is - assumed to be the only active variant -- in this case no - discriminant is provided. */ +struct variant_part; -struct discriminant_info +/* * A single variant. A variant has a list of discriminant values. + When the discriminator matches one of these, the variant is + enabled. Each variant controls zero or more fields; and may also + control other variant parts as well. This struct corresponds to + DW_TAG_variant in DWARF. */ + +struct variant : allocate_on_obstack { - /* * The index of the discriminant field. If -1, then this union - must have just a single field. */ + /* * The discriminant ranges for this variant. */ + gdb::array_view discriminants; + + /* * The fields controlled by this variant. This is inclusive on + the low end and exclusive on the high end. A variant may not + control any fields, in which case the two values will be equal. + These are indexes into the type's array of fields. */ + int first_field; + int last_field; + + /* * Variant parts controlled by this variant. */ + gdb::array_view parts; + + /* * Return true if this is the default variant. The default + variant can be recognized because it has no associated + discriminants. */ + bool is_default () const + { + return discriminants.empty (); + } - int discriminant_index; + /* * Return true if this variant matches VALUE. IS_UNSIGNED is true + if this should be an unsigned comparison; false for signed. */ + bool matches (ULONGEST value, bool is_unsigned) const; +}; - /* * The index of the default branch of the union. If -1, then - there is no default branch. */ +/* * A variant part. Each variant part has an optional discriminant + and holds an array of variants. This struct corresponds to + DW_TAG_variant_part in DWARF. */ - int default_index; +struct variant_part : allocate_on_obstack +{ + /* * The index of the discriminant field in the outer type. This is + an index into the type's array of fields. If this is -1, there + is no discriminant, and only the default variant can be + considered to be selected. */ + int discriminant_index; - /* * The discriminant values corresponding to each branch. This has - a number of entries equal to the number of fields in this union. - If discriminant_index is not -1, then that entry in this array is - not used. If default_index is not -1, then that entry in this - array is not used. */ + /* * True if this discriminant is unsigned; false if signed. This + comes from the type of the discriminant. */ + bool is_unsigned; - ULONGEST discriminants[1]; + /* * The variants that are controlled by this variant part. Note + that these will always be sorted by field number. */ + gdb::array_view variants; }; + enum dynamic_prop_kind { PROP_UNDEFINED, /* Not defined. */ PROP_CONST, /* Constant. */ PROP_ADDR_OFFSET, /* Address offset. */ PROP_LOCEXPR, /* Location expression. */ - PROP_LOCLIST /* Location list. */ + PROP_LOCLIST, /* Location list. */ + PROP_VARIANT_PARTS, /* Variant parts. */ + PROP_TYPE, /* Type. */ }; union dynamic_prop_data @@ -451,6 +490,21 @@ union dynamic_prop_data /* Storage for dynamic property. */ void *baton; + + /* Storage of variant parts for a type. A type with variant parts + has all its fields "linearized" -- stored in a single field + array, just as if they had all been declared that way. The + variant parts are attached via a dynamic property, and then are + used to control which fields end up in the final type during + dynamic type resolution. */ + + const gdb::array_view *variant_parts; + + /* Once a variant type is resolved, we may want to be able to go + from the resolved type to the original type. In this case we + rewrite the property's kind and set this field. */ + + struct type *original_type; }; /* * Used to store a dynamic property. */ @@ -485,15 +539,18 @@ enum dynamic_prop_node_kind indicates that the object of the type can be allocated/deallocated. */ DYN_PROP_ALLOCATED, - /* A property representing DW_AT_allocated. The presence of this attribute + /* A property representing DW_AT_associated. The presence of this attribute indicated that the object of the type can be associated. */ DYN_PROP_ASSOCIATED, /* A property providing an array's byte stride. */ DYN_PROP_BYTE_STRIDE, - /* A property holding information about a discriminated union. */ - DYN_PROP_DISCRIMINATED, + /* A property holding variant parts. */ + DYN_PROP_VARIANT_PARTS, + + /* A property holding the size of the type. */ + DYN_PROP_BYTE_SIZE, }; /* * List for dynamic type attributes. */ @@ -578,6 +635,16 @@ union field_location struct field { + struct type *type () const + { + return this->m_type; + } + + void set_type (struct type *type) + { + this->m_type = type; + } + union field_location loc; /* * For a function or member type, this is 1 if the argument is @@ -603,7 +670,7 @@ struct field - In a function or member type, type of this argument. - In an array type, the domain-type of the array. */ - struct type *type; + struct type *m_type; /* * Name of field, value or argument. NULL for range bounds, array domains, and member function @@ -708,9 +775,7 @@ struct main_type unsigned int flag_nosign : 1; unsigned int flag_stub : 1; unsigned int flag_target_stub : 1; - unsigned int flag_static : 1; unsigned int flag_prototyped : 1; - unsigned int flag_incomplete : 1; unsigned int flag_varargs : 1; unsigned int flag_vector : 1; unsigned int flag_stub_supported : 1; @@ -729,13 +794,6 @@ struct main_type unsigned int flag_flag_enum : 1; - /* * True if this type is a discriminated union type. Only valid - for TYPE_CODE_UNION. A discriminated union stores a reference to - the discriminant field along with the discriminator values in a - dynamic property. */ - - unsigned int flag_discriminated_union : 1; - /* * A discriminant telling us which field of the type_specific union is being used for this type, if any. */ @@ -804,6 +862,10 @@ struct main_type struct range_bounds *bounds; + /* If this is a scalar type, then this is its corresponding + complex type. */ + struct type *complex_type; + } flds_bnds; /* * Slot to point to additional language-specific fields of this @@ -824,6 +886,86 @@ struct main_type struct type { + /* Get the type code of this type. + + Note that the code can be TYPE_CODE_TYPEDEF, so if you want the real + type, you need to do `check_typedef (type)->code ()`. */ + type_code code () const + { + return this->main_type->code; + } + + /* Set the type code of this type. */ + void set_code (type_code code) + { + this->main_type->code = code; + } + + /* Get the name of this type. */ + const char *name () const + { + return this->main_type->name; + } + + /* Set the name of this type. */ + void set_name (const char *name) + { + this->main_type->name = name; + } + + /* Get the number of fields of this type. */ + int num_fields () const + { + return this->main_type->nfields; + } + + /* Set the number of fields of this type. */ + void set_num_fields (int num_fields) + { + this->main_type->nfields = num_fields; + } + + /* Get the fields array of this type. */ + struct field *fields () const + { + return this->main_type->flds_bnds.fields; + } + + /* Get the field at index IDX. */ + struct field &field (int idx) const + { + return this->fields ()[idx]; + } + + /* Set the fields array of this type. */ + void set_fields (struct field *fields) + { + this->main_type->flds_bnds.fields = fields; + } + + type *index_type () const + { + return this->field (0).type (); + } + + void set_index_type (type *index_type) + { + this->field (0).set_type (index_type); + } + + /* * Return the dynamic property of the requested KIND from this type's + list of dynamic properties. */ + dynamic_prop *dyn_prop (dynamic_prop_node_kind kind) const; + + /* * Given a dynamic property PROP of a given KIND, add this dynamic + property to this type. + + This function assumes that this type is objfile-owned. */ + void add_dyn_prop (dynamic_prop_node_kind kind, dynamic_prop prop); + + /* * Remove dynamic property of kind KIND from this type, if it exists. */ + void remove_dyn_prop (dynamic_prop_node_kind kind); + /* * Type that is a pointer to this type. NULL if no such pointer-to type is known yet. The debugger may add the address of such a type @@ -957,9 +1099,18 @@ struct fn_field unsigned int is_constructor : 1; + /* * True if this function is deleted, false otherwise. */ + + unsigned int is_deleted : 1; + + /* * DW_AT_defaulted attribute for this function. The value is one + of the DW_DEFAULTED constants. */ + + ENUM_BITFIELD (dwarf_defaulted_attribute) defaulted : 2; + /* * Unused. */ - unsigned int dummy:9; + unsigned int dummy:6; /* * Index into that baseclass's virtual function table, minus 2; else if static: VOFFSET_STATIC; else: 0. */ @@ -1033,6 +1184,12 @@ struct cplus_struct_type int is_dynamic : 2; + /* * The calling convention for this type, fetched from the + DW_AT_calling_convention attribute. The value is one of the + DW_CC constants. */ + + ENUM_BITFIELD (dwarf_calling_convention) calling_convention : 8; + /* * The base class which defined the virtual function table pointer. */ struct type *vptr_basetype; @@ -1141,9 +1298,9 @@ struct func_type /* * The calling convention for targets supporting multiple ABIs. Right now this is only fetched from the Dwarf-2 DW_AT_calling_convention attribute. The value is one of the - DW_CC enum dwarf_calling_convention constants. */ + DW_CC constants. */ - unsigned calling_convention : 8; + ENUM_BITFIELD (dwarf_calling_convention) calling_convention : 8; /* * Whether this function normally returns to its caller. It is set from the DW_AT_noreturn attribute if set on the @@ -1255,7 +1412,11 @@ struct call_site /* * CU of the function where the call is located. It gets used for DWARF blocks execution in the parameter array below. */ - struct dwarf2_per_cu_data *per_cu; + dwarf2_per_cu_data *per_cu; + + /* objfile of the function where the call is located. */ + + dwarf2_per_objfile *per_objfile; /* * Describe DW_TAG_call_site's DW_TAG_formal_parameter. */ @@ -1311,7 +1472,6 @@ extern void allocate_gnat_aux_type (struct type *); #define TYPE_INSTANCE_FLAGS(thistype) (thistype)->instance_flags #define TYPE_MAIN_TYPE(thistype) (thistype)->main_type -#define TYPE_NAME(thistype) TYPE_MAIN_TYPE(thistype)->name #define TYPE_TARGET_TYPE(thistype) TYPE_MAIN_TYPE(thistype)->target_type #define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type #define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type @@ -1342,13 +1502,6 @@ extern unsigned type_align (struct type *); space in struct type. */ extern bool set_type_align (struct type *, ULONGEST); -/* * Note that TYPE_CODE can be TYPE_CODE_TYPEDEF, so if you want the real - type, you need to do TYPE_CODE (check_type (this_type)). */ -#define TYPE_CODE(thistype) 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_INDEX_TYPE(type) TYPE_FIELD_TYPE (type, 0) #define TYPE_RANGE_DATA(thistype) TYPE_MAIN_TYPE(thistype)->flds_bnds.bounds #define TYPE_LOW_BOUND(range_type) \ TYPE_RANGE_DATA(range_type)->low.data.const_val @@ -1368,23 +1521,23 @@ extern bool set_type_align (struct type *, ULONGEST); /* Property accessors for the type data location. */ #define TYPE_DATA_LOCATION(thistype) \ - get_dyn_prop (DYN_PROP_DATA_LOCATION, thistype) + ((thistype)->dyn_prop (DYN_PROP_DATA_LOCATION)) #define TYPE_DATA_LOCATION_BATON(thistype) \ TYPE_DATA_LOCATION (thistype)->data.baton #define TYPE_DATA_LOCATION_ADDR(thistype) \ TYPE_DATA_LOCATION (thistype)->data.const_val #define TYPE_DATA_LOCATION_KIND(thistype) \ TYPE_DATA_LOCATION (thistype)->kind +#define TYPE_DYNAMIC_LENGTH(thistype) \ + ((thistype)->dyn_prop (DYN_PROP_BYTE_SIZE)) /* Property accessors for the type allocated/associated. */ #define TYPE_ALLOCATED_PROP(thistype) \ - get_dyn_prop (DYN_PROP_ALLOCATED, thistype) + ((thistype)->dyn_prop (DYN_PROP_ALLOCATED)) #define TYPE_ASSOCIATED_PROP(thistype) \ - get_dyn_prop (DYN_PROP_ASSOCIATED, thistype) + ((thistype)->dyn_prop (DYN_PROP_ASSOCIATED)) /* Attribute accessors for dynamic properties. */ -#define TYPE_DYN_PROP_LIST(thistype) \ - TYPE_MAIN_TYPE(thistype)->dyn_prop_list #define TYPE_DYN_PROP_BATON(dynprop) \ dynprop->data.baton #define TYPE_DYN_PROP_ADDR(dynprop) \ @@ -1397,18 +1550,18 @@ extern bool set_type_align (struct type *, ULONGEST); index type. */ #define TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED(arraytype) \ - TYPE_HIGH_BOUND_UNDEFINED(TYPE_INDEX_TYPE(arraytype)) + TYPE_HIGH_BOUND_UNDEFINED((arraytype)->index_type ()) #define TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED(arraytype) \ - TYPE_LOW_BOUND_UNDEFINED(TYPE_INDEX_TYPE(arraytype)) + TYPE_LOW_BOUND_UNDEFINED((arraytype)->index_type ()) #define TYPE_ARRAY_UPPER_BOUND_VALUE(arraytype) \ - (TYPE_HIGH_BOUND(TYPE_INDEX_TYPE((arraytype)))) + (TYPE_HIGH_BOUND((arraytype)->index_type ())) #define TYPE_ARRAY_LOWER_BOUND_VALUE(arraytype) \ - (TYPE_LOW_BOUND(TYPE_INDEX_TYPE((arraytype)))) + (TYPE_LOW_BOUND((arraytype)->index_type ())) #define TYPE_ARRAY_BIT_STRIDE(arraytype) \ - (TYPE_BIT_STRIDE(TYPE_INDEX_TYPE((arraytype)))) + (TYPE_BIT_STRIDE(((arraytype)->index_type ()))) /* C++ */ @@ -1437,13 +1590,15 @@ extern void set_type_vptr_basetype (struct type *, struct type *); ? (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_CPLUS_CALLING_CONVENTION(thistype) \ + TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff->calling_convention #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.func_stuff->calling_convention #define TYPE_NO_RETURN(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.func_stuff->is_noreturn #define TYPE_TAIL_CALL_LIST(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.func_stuff->tail_call_list -#define TYPE_BASECLASS(thistype,index) TYPE_FIELD_TYPE(thistype, index) +#define TYPE_BASECLASS(thistype,index) ((thistype)->field (index).type ()) #define TYPE_N_BASECLASSES(thistype) TYPE_CPLUS_SPECIFIC(thistype)->n_baseclasses #define TYPE_BASECLASS_NAME(thistype,index) TYPE_FIELD_NAME(thistype, index) #define TYPE_BASECLASS_BITPOS(thistype,index) TYPE_FIELD_BITPOS(thistype,index) @@ -1455,7 +1610,6 @@ extern void set_type_vptr_basetype (struct type *, struct type *); (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \ : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (index))) -#define FIELD_TYPE(thisfld) ((thisfld).type) #define FIELD_NAME(thisfld) ((thisfld).name) #define FIELD_LOC_KIND(thisfld) ((thisfld).loc_kind) #define FIELD_BITPOS_LVAL(thisfld) ((thisfld).loc.bitpos) @@ -1483,18 +1637,16 @@ extern void set_type_vptr_basetype (struct type *, struct type *); #define FIELD_ARTIFICIAL(thisfld) ((thisfld).artificial) #define FIELD_BITSIZE(thisfld) ((thisfld).bitsize) -#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_ENUMVAL(thistype, n) FIELD_ENUMVAL (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_FIELD_NAME(thistype, n) FIELD_NAME((thistype)->field (n)) +#define TYPE_FIELD_LOC_KIND(thistype, n) FIELD_LOC_KIND ((thistype)->field (n)) +#define TYPE_FIELD_BITPOS(thistype, n) FIELD_BITPOS ((thistype)->field (n)) +#define TYPE_FIELD_ENUMVAL(thistype, n) FIELD_ENUMVAL ((thistype)->field (n)) +#define TYPE_FIELD_STATIC_PHYSNAME(thistype, n) FIELD_STATIC_PHYSNAME ((thistype)->field (n)) +#define TYPE_FIELD_STATIC_PHYSADDR(thistype, n) FIELD_STATIC_PHYSADDR ((thistype)->field (n)) +#define TYPE_FIELD_DWARF_BLOCK(thistype, n) FIELD_DWARF_BLOCK ((thistype)->field (n)) +#define TYPE_FIELD_ARTIFICIAL(thistype, n) FIELD_ARTIFICIAL((thistype)->field (n)) +#define TYPE_FIELD_BITSIZE(thistype, n) FIELD_BITSIZE((thistype)->field (n)) +#define TYPE_FIELD_PACKED(thistype, n) (FIELD_BITSIZE((thistype)->field (n))!=0) #define TYPE_FIELD_PRIVATE_BITS(thistype) \ TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits @@ -1541,7 +1693,7 @@ extern void set_type_vptr_basetype (struct type *, struct type *); #define TYPE_FN_FIELD(thisfn, n) (thisfn)[n] #define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname #define TYPE_FN_FIELD_TYPE(thisfn, n) (thisfn)[n].type -#define TYPE_FN_FIELD_ARGS(thisfn, n) TYPE_FIELDS ((thisfn)[n].type) +#define TYPE_FN_FIELD_ARGS(thisfn, n) (((thisfn)[n].type)->fields ()) #define TYPE_FN_FIELD_CONST(thisfn, n) ((thisfn)[n].is_const) #define TYPE_FN_FIELD_VOLATILE(thisfn, n) ((thisfn)[n].is_volatile) #define TYPE_FN_FIELD_PRIVATE(thisfn, n) ((thisfn)[n].is_private) @@ -1553,6 +1705,8 @@ extern void set_type_vptr_basetype (struct type *, struct type *); #define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2) #define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1) #define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC) +#define TYPE_FN_FIELD_DEFAULTED(thisfn, n) ((thisfn)[n].defaulted) +#define TYPE_FN_FIELD_DELETED(thisfn, n) ((thisfn)[n].is_deleted) /* Accessors for typedefs defined by a class. */ #define TYPE_TYPEDEF_FIELD_ARRAY(thistype) \ @@ -1586,9 +1740,9 @@ extern void set_type_vptr_basetype (struct type *, struct type *); TYPE_NESTED_TYPES_FIELD (thistype, n).is_private #define TYPE_IS_OPAQUE(thistype) \ - (((TYPE_CODE (thistype) == TYPE_CODE_STRUCT) \ - || (TYPE_CODE (thistype) == TYPE_CODE_UNION)) \ - && (TYPE_NFIELDS (thistype) == 0) \ + ((((thistype)->code () == TYPE_CODE_STRUCT) \ + || ((thistype)->code () == TYPE_CODE_UNION)) \ + && ((thistype)->num_fields () == 0) \ && (!HAVE_CPLUS_STRUCT (thistype) \ || TYPE_NFN_FIELDS (thistype) == 0) \ && (TYPE_STUB (thistype) || !TYPE_STUB_SUPPORTED (thistype))) @@ -1597,13 +1751,13 @@ extern void set_type_vptr_basetype (struct type *, struct type *); if the type has no name. */ #define TYPE_SAFE_NAME(type) \ - (TYPE_NAME (type) ? TYPE_NAME (type) : _("")) + (type->name () != nullptr ? type->name () : _("")) /* * 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) : _("")) + (type->name () ? type->name () : _("")) /* Given TYPE, return its floatformat. */ const struct floatformat *floatformat_from_type (const struct type *type); @@ -1823,8 +1977,7 @@ extern struct type *init_float_type (struct objfile *, int, const char *, const struct floatformat **, enum bfd_endian = BFD_ENDIAN_UNKNOWN); extern struct type *init_decfloat_type (struct objfile *, int, const char *); -extern struct type *init_complex_type (struct objfile *, const char *, - struct type *); +extern struct type *init_complex_type (const char *, struct type *); extern struct type *init_pointer_type (struct objfile *, int, const char *, struct type *); @@ -1840,8 +1993,6 @@ extern struct type *arch_boolean_type (struct gdbarch *, int, int, extern struct type *arch_float_type (struct gdbarch *, int, const char *, const struct floatformat **); extern struct type *arch_decfloat_type (struct gdbarch *, int, const char *); -extern struct type *arch_complex_type (struct gdbarch *, const char *, - struct type *); extern struct type *arch_pointer_type (struct gdbarch *, int, const char *, struct type *); @@ -2018,29 +2169,13 @@ extern void get_signed_type_minmax (struct type *, LONGEST *, LONGEST *); ADDR specifies the location of the variable the type is bound to. If TYPE has no dynamic properties return TYPE; otherwise a new type with static properties is returned. */ -extern struct type *resolve_dynamic_type (struct type *type, - const gdb_byte *valaddr, - CORE_ADDR addr); +extern struct type *resolve_dynamic_type + (struct type *type, gdb::array_view valaddr, + CORE_ADDR addr); /* * Predicate if the type has dynamic values, which are not resolved yet. */ extern int is_dynamic_type (struct type *type); -/* * Return the dynamic property of the requested KIND from TYPE's - list of dynamic properties. */ -extern struct dynamic_prop *get_dyn_prop - (enum dynamic_prop_node_kind kind, const struct type *type); - -/* * Given a dynamic property PROP of a given KIND, add this dynamic - property to the given TYPE. - - This function assumes that TYPE is objfile-owned. */ -extern void add_dyn_prop - (enum dynamic_prop_node_kind kind, struct dynamic_prop prop, - struct type *type); - -extern void remove_dyn_prop (enum dynamic_prop_node_kind prop_kind, - struct type *type); - extern struct type *check_typedef (struct type *); extern void check_stub_method_group (struct type *, int); @@ -2105,6 +2240,7 @@ extern const struct rank BASE_CONVERSION_BADNESS; /* * Badness of converting from non-reference to reference. Subrank is the type of reference conversion being done. */ extern const struct rank REFERENCE_CONVERSION_BADNESS; +extern const struct rank REFERENCE_SEE_THROUGH_BADNESS; /* * Conversion to rvalue reference. */ #define REFERENCE_CONVERSION_RVALUE 1 /* * Conversion to const lvalue reference. */