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. */
/* * Unsigned integer type. If this is not set for a TYPE_CODE_INT,
the type is signed (unless TYPE_NOSIGN (below) is set). */
-#define TYPE_UNSIGNED(t) (TYPE_MAIN_TYPE (t)->flag_unsigned)
+#define TYPE_UNSIGNED(t) ((t)->is_unsigned ())
/* * No sign for this type. In C++, "char", "signed char", and
"unsigned char" are distinct types; so we need an extra flag to
struct dynamic_prop
{
+ dynamic_prop_kind kind () const
+ {
+ return m_kind;
+ }
+
+ void set_undefined ()
+ {
+ m_kind = PROP_UNDEFINED;
+ }
+
+ LONGEST const_val () const
+ {
+ gdb_assert (m_kind == PROP_CONST);
+
+ return m_data.const_val;
+ }
+
+ void set_const_val (LONGEST const_val)
+ {
+ m_kind = PROP_CONST;
+ m_data.const_val = const_val;
+ }
+
+ void *baton () const
+ {
+ gdb_assert (m_kind == PROP_LOCEXPR
+ || m_kind == PROP_LOCLIST
+ || m_kind == PROP_ADDR_OFFSET);
+
+ return m_data.baton;
+ }
+
+ void set_locexpr (void *baton)
+ {
+ m_kind = PROP_LOCEXPR;
+ m_data.baton = baton;
+ }
+
+ void set_loclist (void *baton)
+ {
+ m_kind = PROP_LOCLIST;
+ m_data.baton = baton;
+ }
+
+ void set_addr_offset (void *baton)
+ {
+ m_kind = PROP_ADDR_OFFSET;
+ m_data.baton = baton;
+ }
+
+ const gdb::array_view<variant_part> *variant_parts () const
+ {
+ gdb_assert (m_kind == PROP_VARIANT_PARTS);
+
+ return m_data.variant_parts;
+ }
+
+ void set_variant_parts (gdb::array_view<variant_part> *variant_parts)
+ {
+ m_kind = PROP_VARIANT_PARTS;
+ m_data.variant_parts = variant_parts;
+ }
+
+ struct type *original_type () const
+ {
+ gdb_assert (m_kind == PROP_TYPE);
+
+ return m_data.original_type;
+ }
+
+ void set_original_type (struct type *original_type)
+ {
+ m_kind = PROP_TYPE;
+ m_data.original_type = original_type;
+ }
+
/* Determine which field of the union dynamic_prop.data is used. */
- enum dynamic_prop_kind kind;
+ enum dynamic_prop_kind m_kind;
/* Storage for dynamic or static value. */
- union dynamic_prop_data data;
+ union dynamic_prop_data m_data;
};
/* Compare two dynamic_prop objects for equality. dynamic_prop
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
- 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
struct range_bounds
{
+ ULONGEST bit_stride () const
+ {
+ if (this->flag_is_byte_stride)
+ return this->stride.const_val () * 8;
+ else
+ return this->stride.const_val ();
+ }
+
/* * Low bound of range. */
struct dynamic_prop low;
because they packs nicely here. See the TYPE_* macros for
documentation about these fields. */
- unsigned int flag_unsigned : 1;
+ unsigned int m_flag_unsigned : 1;
unsigned int flag_nosign : 1;
unsigned int flag_stub : 1;
unsigned int flag_target_stub : 1;
}
/* Get the fields array of this type. */
- field *fields () const
+ 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 (field *fields)
+ 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);
+ }
+
+ /* Get the bounds bounds of this type. The type must be a range type. */
+ range_bounds *bounds () const
+ {
+ switch (this->code ())
+ {
+ case TYPE_CODE_RANGE:
+ return this->main_type->flds_bnds.bounds;
+
+ case TYPE_CODE_ARRAY:
+ case TYPE_CODE_STRING:
+ return this->index_type ()->bounds ();
+
+ default:
+ gdb_assert_not_reached
+ ("type::bounds called on type with invalid code");
+ }
+ }
+
+ /* Set the bounds of this type. The type must be a range type. */
+ void set_bounds (range_bounds *bounds)
+ {
+ gdb_assert (this->code () == TYPE_CODE_RANGE);
+
+ this->main_type->flds_bnds.bounds = bounds;
+ }
+
+ ULONGEST bit_stride () const
+ {
+ return this->bounds ()->bit_stride ();
+ }
+
+ bool is_unsigned () const
+ {
+ return this->main_type->m_flag_unsigned;
+ }
+
+ void set_is_unsigned (bool is_unsigned)
+ {
+ this->main_type->m_flag_unsigned = is_unsigned;
+ }
+
/* * 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;
struct main_type *main_type;
};
-#define NULL_TYPE ((struct type *) 0)
-
struct fn_fieldlist
{
/* * 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. */
space in struct type. */
extern bool set_type_align (struct type *, ULONGEST);
-#define TYPE_FIELDS(thistype) (thistype)->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
-#define TYPE_HIGH_BOUND(range_type) \
- TYPE_RANGE_DATA(range_type)->high.data.const_val
-#define TYPE_LOW_BOUND_UNDEFINED(range_type) \
- (TYPE_RANGE_DATA(range_type)->low.kind == PROP_UNDEFINED)
-#define TYPE_HIGH_BOUND_UNDEFINED(range_type) \
- (TYPE_RANGE_DATA(range_type)->high.kind == PROP_UNDEFINED)
-#define TYPE_HIGH_BOUND_KIND(range_type) \
- TYPE_RANGE_DATA(range_type)->high.kind
-#define TYPE_LOW_BOUND_KIND(range_type) \
- TYPE_RANGE_DATA(range_type)->low.kind
-#define TYPE_BIT_STRIDE(range_type) \
- (TYPE_RANGE_DATA(range_type)->stride.data.const_val \
- * (TYPE_RANGE_DATA(range_type)->flag_is_byte_stride ? 8 : 1))
-
/* Property accessors for the type data location. */
#define TYPE_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
+ (TYPE_DATA_LOCATION (thistype)->const_val ())
#define TYPE_DATA_LOCATION_KIND(thistype) \
- TYPE_DATA_LOCATION (thistype)->kind
+ (TYPE_DATA_LOCATION (thistype)->kind ())
#define TYPE_DYNAMIC_LENGTH(thistype) \
((thistype)->dyn_prop (DYN_PROP_BYTE_SIZE))
#define TYPE_ASSOCIATED_PROP(thistype) \
((thistype)->dyn_prop (DYN_PROP_ASSOCIATED))
-/* Attribute accessors for dynamic properties. */
-#define TYPE_DYN_PROP_BATON(dynprop) \
- dynprop->data.baton
-#define TYPE_DYN_PROP_ADDR(dynprop) \
- dynprop->data.const_val
-#define TYPE_DYN_PROP_KIND(dynprop) \
- dynprop->kind
-
-
-/* Accessors for struct range_bounds data attached to an array type's
- index 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_HIGH_BOUND(TYPE_INDEX_TYPE((arraytype))))
-
-#define TYPE_ARRAY_LOWER_BOUND_VALUE(arraytype) \
- (TYPE_LOW_BOUND(TYPE_INDEX_TYPE((arraytype))))
-
-#define TYPE_ARRAY_BIT_STRIDE(arraytype) \
- (TYPE_BIT_STRIDE(TYPE_INDEX_TYPE((arraytype))))
-
/* C++ */
#define TYPE_SELF_TYPE(thistype) internal_type_self_type (thistype)
#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)
(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)
#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
#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)
struct type *builtin_unsigned_short;
struct type *builtin_unsigned_int;
struct type *builtin_unsigned_long;
+ struct type *builtin_bfloat16;
struct type *builtin_half;
struct type *builtin_float;
struct type *builtin_double;
extern const struct floatformat *floatformats_vax_f[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 const struct floatformat *floatformats_bfloat16[BFD_ENDIAN_UNKNOWN];
/* Allocate space for storing data associated with a particular
type. We ensure that the space is allocated using the same