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. */
DEF_ENUM_FLAGS_TYPE (enum type_instance_flag_value, type_instance_flags);
-/* * 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)
-
-/* * 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! */
-
-#define TYPE_NOSIGN(t) (TYPE_MAIN_TYPE (t)->flag_nosign)
-
-/* * A compiler may supply dwarf instrumentation
- that indicates the desired endian interpretation of the variable
- differs from the native endian representation. */
-
-#define TYPE_ENDIANITY_NOT_DEFAULT(t) (TYPE_MAIN_TYPE (t)->flag_endianity_not_default)
-
-/* * This appears in a type's flags word if it is a stub type (e.g.,
- if someone referenced a type that wasn't defined in a source file
- via (struct sir_not_appearing_in_this_film *)). */
-
-#define TYPE_STUB(t) (TYPE_MAIN_TYPE (t)->flag_stub)
-
-/* * The target type of this type is a stub type, and this type needs
- to 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. */
-
-#define TYPE_TARGET_STUB(t) (TYPE_MAIN_TYPE (t)->flag_target_stub)
-
-/* * 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)
-
-/* * 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. */
-
-#define TYPE_VARARGS(t) (TYPE_MAIN_TYPE (t)->flag_varargs)
-
-/* * Identify a vector type. Gcc is handling this by adding an extra
- attribute to the array type. We slurp that in as a new flag of a
- type. This is used only in dwarf2read.c. */
-#define TYPE_VECTOR(t) (TYPE_MAIN_TYPE (t)->flag_vector)
-
-/* * The debugging formats (especially STABS) do not contain enough
- information to represent all Ada types---especially those whose
- size depends on dynamic quantities. Therefore, the GNAT Ada
- compiler includes extra information in the form of additional type
- definitions 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. */
-
-#define TYPE_FIXED_INSTANCE(t) (TYPE_MAIN_TYPE (t)->flag_fixed_instance)
-
-/* * This debug target supports TYPE_STUB(t). In the unsupported case
- we have to rely on NFIELDS to be zero etc., see TYPE_IS_OPAQUE().
- TYPE_STUB(t) with !TYPE_STUB_SUPPORTED(t) may exist if we only
- guessed the TYPE_STUB(t) value (see dwarfread.c). */
-
-#define TYPE_STUB_SUPPORTED(t) (TYPE_MAIN_TYPE (t)->flag_stub_supported)
-
/* * 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_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)
+#define TYPE_NOTTEXT(t) (((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_NOTTEXT)
/* * Type owner. If TYPE_OBJFILE_OWNED is true, the type is owned by
the objfile retrieved as TYPE_OBJFILE. Otherwise, the type is
#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. */
-#define TYPE_CONST(t) ((TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_CONST) != 0)
+#define TYPE_CONST(t) ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_CONST) != 0)
/* * Volatile type. If this is set, the corresponding type has a
volatile modifier. */
#define TYPE_VOLATILE(t) \
- ((TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_VOLATILE) != 0)
+ ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_VOLATILE) != 0)
/* * Restrict type. If this is set, the corresponding type has a
restrict modifier. */
#define TYPE_RESTRICT(t) \
- ((TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_RESTRICT) != 0)
+ ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_RESTRICT) != 0)
/* * Atomic type. If this is set, the corresponding type has an
_Atomic modifier. */
#define TYPE_ATOMIC(t) \
- ((TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_ATOMIC) != 0)
+ ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_ATOMIC) != 0)
/* * 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) \
- (get_dyn_prop (DYN_PROP_VARIANT_PARTS, t) != nullptr)
+ ((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
is instruction space, and for data objects is data memory. */
#define TYPE_CODE_SPACE(t) \
- ((TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_CODE_SPACE) != 0)
+ ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_CODE_SPACE) != 0)
#define TYPE_DATA_SPACE(t) \
- ((TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_DATA_SPACE) != 0)
+ ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_DATA_SPACE) != 0)
/* * Address class flags. Some environments provide for pointers
whose size is different from that of a normal pointer or address
target specific ways to represent these different types of address
classes. */
-#define TYPE_ADDRESS_CLASS_1(t) (TYPE_INSTANCE_FLAGS(t) \
+#define TYPE_ADDRESS_CLASS_1(t) (((t)->instance_flags ()) \
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
-#define TYPE_ADDRESS_CLASS_2(t) (TYPE_INSTANCE_FLAGS(t) \
+#define TYPE_ADDRESS_CLASS_2(t) (((t)->instance_flags ()) \
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2)
#define TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL \
(TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2)
-#define TYPE_ADDRESS_CLASS_ALL(t) (TYPE_INSTANCE_FLAGS(t) \
+#define TYPE_ADDRESS_CLASS_ALL(t) (((t)->instance_flags ()) \
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
/* * Information about a single discriminant. */
};
-/* * Information needed for a discriminated union. A discriminated
- union is handled somewhat differently from an ordinary union.
-
- 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.
-
- 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 discriminant_info
-{
- /* * The index of the discriminant field. If -1, then this union
- must have just a single field. */
-
- int discriminant_index;
-
- /* * The index of the default branch of the union. If -1, then
- there is no default branch. */
-
- int default_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. */
-
- ULONGEST discriminants[1];
-};
-
enum dynamic_prop_kind
{
PROP_UNDEFINED, /* Not defined. */
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
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. */
TYPE_SPECIFIC_FLOATFORMAT,
/* Note: This is used by TYPE_CODE_FUNC and TYPE_CODE_METHOD. */
TYPE_SPECIFIC_FUNC,
- TYPE_SPECIFIC_SELF_TYPE
+ TYPE_SPECIFIC_SELF_TYPE,
+ TYPE_SPECIFIC_INT
};
union type_owner
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;
is a member of. */
struct type *self_type;
+
+ /* * An integer-like scalar type may be stored in just part of its
+ enclosing storage bytes. This structure describes this
+ situation. */
+ struct
+ {
+ /* * The bit size of the integer. This can be 0. For integers
+ that fill their storage (the ordinary case), this field holds
+ the byte size times 8. */
+ unsigned short bit_size;
+ /* * The bit offset of the integer. This is ordinarily 0, and can
+ only be non-zero if the bit size is less than the storage
+ size. */
+ unsigned short bit_offset;
+ } int_stuff;
};
/* * Main structure representing a type in GDB.
because they packs nicely here. See the TYPE_* macros for
documentation about these fields. */
- unsigned int flag_unsigned : 1;
- 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;
- unsigned int flag_gnu_ifunc : 1;
- unsigned int flag_fixed_instance : 1;
+ unsigned int m_flag_unsigned : 1;
+ unsigned int m_flag_nosign : 1;
+ unsigned int m_flag_stub : 1;
+ unsigned int m_flag_target_stub : 1;
+ unsigned int m_flag_prototyped : 1;
+ unsigned int m_flag_varargs : 1;
+ unsigned int m_flag_vector : 1;
+ unsigned int m_flag_stub_supported : 1;
+ unsigned int m_flag_gnu_ifunc : 1;
+ unsigned int m_flag_fixed_instance : 1;
unsigned int flag_objfile_owned : 1;
- unsigned int flag_endianity_not_default : 1;
+ unsigned int m_flag_endianity_not_default : 1;
/* * True if this type was declared with "class" rather than
"struct". */
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. */
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 instance flags converted to the correct type. */
+ const type_instance_flags instance_flags () const
+ {
+ return (enum type_instance_flag_value) this->m_instance_flags;
+ }
+
+ /* Set the instance flags. */
+ void set_instance_flags (type_instance_flags flags)
+ {
+ this->m_instance_flags = flags;
+ }
+
+ /* 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 ();
+ }
+
+ /* Unsigned integer type. If this is not set for a TYPE_CODE_INT,
+ the type is signed (unless TYPE_NOSIGN is set). */
+
+ 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;
+ }
+
+ /* 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! */
+
+ bool has_no_signedness () const
+ {
+ return this->main_type->m_flag_nosign;
+ }
+
+ void set_has_no_signedness (bool has_no_signedness)
+ {
+ this->main_type->m_flag_nosign = has_no_signedness;
+ }
+
+ /* This appears in a type's flags word if it is a stub type (e.g.,
+ if someone referenced a type that wasn't defined in a source file
+ via (struct sir_not_appearing_in_this_film *)). */
+
+ bool is_stub () const
+ {
+ return this->main_type->m_flag_stub;
+ }
+
+ void set_is_stub (bool is_stub)
+ {
+ this->main_type->m_flag_stub = is_stub;
+ }
+
+ /* The target type of this type is a stub type, and this type needs
+ to 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. */
+
+ bool target_is_stub () const
+ {
+ return this->main_type->m_flag_target_stub;
+ }
+
+ void set_target_is_stub (bool target_is_stub)
+ {
+ this->main_type->m_flag_target_stub = target_is_stub;
+ }
+
+ /* 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. */
+
+ bool is_prototyped () const
+ {
+ return this->main_type->m_flag_prototyped;
+ }
+
+ void set_is_prototyped (bool is_prototyped)
+ {
+ this->main_type->m_flag_prototyped = is_prototyped;
+ }
+
+ /* FIXME drow/2002-06-03: Only used for methods, but applies as well
+ to functions. */
+
+ bool has_varargs () const
+ {
+ return this->main_type->m_flag_varargs;
+ }
+
+ void set_has_varargs (bool has_varargs)
+ {
+ this->main_type->m_flag_varargs = has_varargs;
+ }
+
+ /* Identify a vector type. Gcc is handling this by adding an extra
+ attribute to the array type. We slurp that in as a new flag of a
+ type. This is used only in dwarf2read.c. */
+
+ bool is_vector () const
+ {
+ return this->main_type->m_flag_vector;
+ }
+
+ void set_is_vector (bool is_vector)
+ {
+ this->main_type->m_flag_vector = is_vector;
+ }
+
+ /* This debug target supports TYPE_STUB(t). In the unsupported case
+ we have to rely on NFIELDS to be zero etc., see TYPE_IS_OPAQUE().
+ TYPE_STUB(t) with !TYPE_STUB_SUPPORTED(t) may exist if we only
+ guessed the TYPE_STUB(t) value (see dwarfread.c). */
+
+ bool stub_is_supported () const
+ {
+ return this->main_type->m_flag_stub_supported;
+ }
+
+ void set_stub_is_supported (bool stub_is_supported)
+ {
+ this->main_type->m_flag_stub_supported = stub_is_supported;
+ }
+
+ /* 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. */
+
+ bool is_gnu_ifunc () const
+ {
+ return this->main_type->m_flag_gnu_ifunc;
+ }
+
+ void set_is_gnu_ifunc (bool is_gnu_ifunc)
+ {
+ this->main_type->m_flag_gnu_ifunc = is_gnu_ifunc;
+ }
+
+ /* The debugging formats (especially STABS) do not contain enough
+ information to represent all Ada types---especially those whose
+ size depends on dynamic quantities. Therefore, the GNAT Ada
+ compiler includes extra information in the form of additional type
+ definitions 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. */
+
+ bool is_fixed_instance () const
+ {
+ return this->main_type->m_flag_fixed_instance;
+ }
+
+ void set_is_fixed_instance (bool is_fixed_instance)
+ {
+ this->main_type->m_flag_fixed_instance = is_fixed_instance;
+ }
+
+ /* A compiler may supply dwarf instrumentation that indicates the desired
+ endian interpretation of the variable differs from the native endian
+ representation. */
+
+ bool endianity_is_not_default () const
+ {
+ return this->main_type->m_flag_endianity_not_default;
+ }
+
+ void set_endianity_is_not_default (bool endianity_is_not_default)
+ {
+ this->main_type->m_flag_endianity_not_default = endianity_is_not_default;
+ }
+
+ /* * 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);
+
+ /* * Return true if this is an integer type whose logical (bit) size
+ differs from its storage size; false otherwise. Always return
+ false for non-integer (i.e., non-TYPE_SPECIFIC_INT) types. */
+ bool bit_size_differs_p () const
+ {
+ return (main_type->type_specific_field == TYPE_SPECIFIC_INT
+ && main_type->type_specific.int_stuff.bit_size != 8 * length);
+ }
+
+ /* * Return the logical (bit) size for this integer type. Only
+ valid for integer (TYPE_SPECIFIC_INT) types. */
+ unsigned short bit_size () const
+ {
+ gdb_assert (main_type->type_specific_field == TYPE_SPECIFIC_INT);
+ return main_type->type_specific.int_stuff.bit_size;
+ }
+
+ /* * Return the bit offset for this integer type. Only valid for
+ integer (TYPE_SPECIFIC_INT) types. */
+ unsigned short bit_offset () const
+ {
+ gdb_assert (main_type->type_specific_field == TYPE_SPECIFIC_INT);
+ return main_type->type_specific.int_stuff.bit_offset;
+ }
+
/* * 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
instance flags are completely inherited from the target type. No
qualifiers can be cleared by the typedef. See also
check_typedef. */
- unsigned instance_flags : 9;
+ unsigned m_instance_flags : 9;
/* * Length of storage for a value of this type. The value is the
expression in host bytes of what sizeof(type) would return. This
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. */
#define ADA_TYPE_P(type) \
(TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_GNAT_STUFF \
|| (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_NONE \
- && TYPE_FIXED_INSTANCE (type)))
+ && (type)->is_fixed_instance ()))
#define INIT_FUNC_SPECIFIC(type) \
(TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FUNC, \
TYPE_ZALLOC (type, \
sizeof (*TYPE_MAIN_TYPE (type)->type_specific.func_stuff)))
-#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
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
-#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) \
- 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
+ (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))
/* 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)
-
-/* 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) \
- 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))))
+ ((thistype)->dyn_prop (DYN_PROP_ASSOCIATED))
/* C++ */
#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)
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)))
+ && ((thistype)->is_stub () || !(thistype)->stub_is_supported ()))
/* * A helper macro that returns the name of a type or "unnamed type"
if the type has no name. */
#define TYPE_SAFE_NAME(type) \
- (TYPE_NAME (type) ? TYPE_NAME (type) : _("<unnamed type>"))
+ (type->name () != nullptr ? type->name () : _("<unnamed type>"))
/* * 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>"))
+ (type->name () ? type->name () : _("<error type>"))
/* Given TYPE, return its floatformat. */
const struct floatformat *floatformat_from_type (const struct type *type);
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
extern void replace_type (struct type *, struct type *);
-extern int address_space_name_to_int (struct gdbarch *, const char *);
+extern type_instance_flags address_space_name_to_type_instance_flags
+ (struct gdbarch *, const char *);
-extern const char *address_space_int_to_name (struct gdbarch *, int);
+extern const char *address_space_type_instance_flags_to_name
+ (struct gdbarch *, type_instance_flags);
-extern struct type *make_type_with_address_space (struct type *type,
- int space_identifier);
+extern struct type *make_type_with_address_space
+ (struct type *type, type_instance_flags space_identifier);
extern struct type *lookup_memberptr_type (struct type *, struct type *);
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<const gdb_byte> 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);
extern void maintenance_print_type (const char *, int);
-extern htab_t create_copied_types_hash (struct objfile *objfile);
+extern htab_up create_copied_types_hash (struct objfile *objfile);
extern struct type *copy_type_recursive (struct objfile *objfile,
struct type *type,
projects / deliverable / binutils-gdb.git / blobdiff