X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbtypes.h;h=bb4d26eef1a1a842ec77c6a386e63d298b28eddb;hb=e2ea3a381a4a7c739419a8b76a2fd132f7c1f9b1;hp=5d9ed3972ff1c56fc6ec70fc931a430aa12b13fb;hpb=8c2e4e0689ea244d0ed979171a3d09c9176b8175;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index 5d9ed3972f..bb4d26eef1 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -1,7 +1,7 @@ /* Internal type definitions for GDB. - Copyright (C) 1992-2020 Free Software Foundation, Inc. + Copyright (C) 1992-2021 Free Software Foundation, Inc. Contributed by Cygnus Support, using pieces from other GDB modules. @@ -46,12 +46,14 @@ #include "hashtab.h" #include "gdbsupport/array-view.h" +#include "gdbsupport/gdb_optional.h" #include "gdbsupport/offset-type.h" #include "gdbsupport/enum-flags.h" #include "gdbsupport/underlying.h" #include "gdbsupport/print-utils.h" #include "dwarf2.h" #include "gdb_obstack.h" +#include "gmp-utils.h" /* Forward declarations for prototypes. */ struct field; @@ -189,7 +191,10 @@ enum type_code TYPE_CODE_INTERNAL_FUNCTION, /* * Methods implemented in extension languages. */ - TYPE_CODE_XMETHOD + TYPE_CODE_XMETHOD, + + /* * Fixed Point type. */ + TYPE_CODE_FIXED_POINT, }; /* * Some bits for the type's instance_flags word. See the macros @@ -210,129 +215,33 @@ enum type_instance_flag_value : unsigned 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) - -/* * 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) - -/* * Type owner. If TYPE_OBJFILE_OWNED is true, the type is owned by - the objfile retrieved as TYPE_OBJFILE. Otherwise, the type is - owned by an architecture; TYPE_OBJFILE is NULL in this case. */ - -#define TYPE_OBJFILE_OWNED(t) (TYPE_MAIN_TYPE (t)->flag_objfile_owned) -#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 and enum types. If false, a structure - was declared as a "struct"; if true it was declared "class". For - enum types, this is true when "enum class" or "enum struct" was - used to declare the type.. */ - -#define TYPE_DECLARED_CLASS(t) (TYPE_MAIN_TYPE (t)->flag_declared_class) - -/* * True if this type is a "flag" enum. A flag enum is one where all - the values are pairwise disjoint when "and"ed together. This - affects how enum values are printed. */ - -#define TYPE_FLAG_ENUM(t) (TYPE_MAIN_TYPE (t)->flag_flag_enum) +#define TYPE_NOTTEXT(t) (((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_NOTTEXT) /* * 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. */ @@ -371,10 +280,10 @@ DEF_ENUM_FLAGS_TYPE (enum type_instance_flag_value, type_instance_flags); 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 @@ -383,13 +292,13 @@ DEF_ENUM_FLAGS_TYPE (enum type_instance_flag_value, type_instance_flags); target specific ways to represent these different types of address classes. */ -#define TYPE_ADDRESS_CLASS_1(t) (TYPE_INSTANCE_FLAGS(t) \ - & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1) -#define TYPE_ADDRESS_CLASS_2(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) (((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. */ @@ -673,7 +582,9 @@ enum type_specific_kind 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, + TYPE_SPECIFIC_FIXED_POINT, }; union type_owner @@ -757,6 +668,14 @@ struct field 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; @@ -830,6 +749,25 @@ union type_specific is a member of. */ struct type *self_type; + + /* * For TYPE_CODE_FIXED_POINT types, the info necessary to decode + values of that type. */ + struct fixed_point_type_info *fixed_point_info; + + /* * 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. @@ -847,28 +785,28 @@ struct main_type 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_prototyped : 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 flag_objfile_owned : 1; - unsigned int flag_endianity_not_default : 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 m_flag_objfile_owned : 1; + unsigned int m_flag_endianity_not_default : 1; /* * True if this type was declared with "class" rather than "struct". */ - unsigned int flag_declared_class : 1; + unsigned int m_flag_declared_class : 1; /* * True if this is an enum type with disjoint values. This affects how the enum is printed. */ - unsigned int flag_flag_enum : 1; + unsigned int m_flag_flag_enum : 1; /* * A discriminant telling us which field of the type_specific union is being used for this type, if any. */ @@ -900,7 +838,7 @@ struct main_type this is somewhat ugly, but without major overhaul of the internal type system, it can't be avoided for now. */ - union type_owner owner; + union type_owner m_owner; /* * For a pointer type, describes the type of object pointed to. - For an array type, describes the type of the elements. @@ -1029,12 +967,34 @@ struct 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 { - gdb_assert (this->code () == TYPE_CODE_RANGE); - - return this->main_type->flds_bnds.bounds; + 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. */ @@ -1045,6 +1005,240 @@ struct type 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; + } + + + /* True if this type was declared using the "class" keyword. This is + only valid for C++ structure and enum types. If false, a structure + was declared as a "struct"; if true it was declared "class". For + enum types, this is true when "enum class" or "enum struct" was + used to declare the type. */ + + bool is_declared_class () const + { + return this->main_type->m_flag_declared_class; + } + + void set_is_declared_class (bool is_declared_class) const + { + this->main_type->m_flag_declared_class = is_declared_class; + } + + /* True if this type is a "flag" enum. A flag enum is one where all + the values are pairwise disjoint when "and"ed together. This + affects how enum values are printed. */ + + bool is_flag_enum () const + { + return this->main_type->m_flag_flag_enum; + } + + void set_is_flag_enum (bool is_flag_enum) + { + this->main_type->m_flag_flag_enum = is_flag_enum; + } + + /* * Assuming that THIS is a TYPE_CODE_FIXED_POINT, return a reference + to this type's fixed_point_info. */ + + struct fixed_point_type_info &fixed_point_info () const + { + gdb_assert (this->code () == TYPE_CODE_FIXED_POINT); + gdb_assert (this->main_type->type_specific.fixed_point_info != nullptr); + + return *this->main_type->type_specific.fixed_point_info; + } + + /* * Assuming that THIS is a TYPE_CODE_FIXED_POINT, set this type's + fixed_point_info to INFO. */ + + void set_fixed_point_info (struct fixed_point_type_info *info) const + { + gdb_assert (this->code () == TYPE_CODE_FIXED_POINT); + + this->main_type->type_specific.fixed_point_info = info; + } + + /* * Assuming that THIS is a TYPE_CODE_FIXED_POINT, return its base type. + + In other words, this returns the type after having peeled all + intermediate type layers (such as TYPE_CODE_RANGE, for instance). + The TYPE_CODE of the type returned is guaranteed to be + a TYPE_CODE_FIXED_POINT. */ + + struct type *fixed_point_type_base_type (); + + /* * Assuming that THIS is a TYPE_CODE_FIXED_POINT, return its scaling + factor. */ + + const gdb_mpq &fixed_point_scaling_factor (); + /* * 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; @@ -1058,6 +1252,85 @@ struct type /* * 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 type is owned by an objfile. Return false if it is + owned by an architecture. */ + bool is_objfile_owned () const + { + return this->main_type->m_flag_objfile_owned; + } + + /* Set the owner of the type to be OBJFILE. */ + void set_owner (objfile *objfile) + { + gdb_assert (objfile != nullptr); + + this->main_type->m_owner.objfile = objfile; + this->main_type->m_flag_objfile_owned = true; + } + + /* Set the owner of the type to be ARCH. */ + void set_owner (gdbarch *arch) + { + gdb_assert (arch != nullptr); + + this->main_type->m_owner.gdbarch = arch; + this->main_type->m_flag_objfile_owned = false; + } + + /* Return the objfile owner of this type. + + Return nullptr if this type is not objfile-owned. */ + struct objfile *objfile_owner () const + { + if (!this->is_objfile_owned ()) + return nullptr; + + return this->main_type->m_owner.objfile; + } + + /* Return the gdbarch owner of this type. + + Return nullptr if this type is not gdbarch-owned. */ + gdbarch *arch_owner () const + { + if (this->is_objfile_owned ()) + return nullptr; + + return this->main_type->m_owner.gdbarch; + } + + /* Return the type's architecture. For types owned by an + architecture, that architecture is returned. For types owned by an + objfile, that objfile's architecture is returned. + + The return value is always non-nullptr. */ + gdbarch *arch () const; + + /* * 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 @@ -1100,7 +1373,7 @@ struct 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 @@ -1125,8 +1398,6 @@ struct type struct main_type *main_type; }; -#define NULL_TYPE ((struct type *) 0) - struct fn_fieldlist { @@ -1515,6 +1786,14 @@ struct call_site struct call_site_parameter parameter[1]; }; +/* The type-specific info for TYPE_CODE_FIXED_POINT types. */ + +struct fixed_point_type_info +{ + /* The fixed point type's scaling factor. */ + gdb_mpq scaling_factor; +}; + /* * The default value of TYPE_CPLUS_SPECIFIC(T) points to this shared static structure. */ @@ -1554,7 +1833,7 @@ extern void allocate_gnat_aux_type (struct type *); #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, \ @@ -1562,7 +1841,13 @@ extern void allocate_gnat_aux_type (struct type *); TYPE_ZALLOC (type, \ sizeof (*TYPE_MAIN_TYPE (type)->type_specific.func_stuff))) -#define TYPE_INSTANCE_FLAGS(thistype) (thistype)->instance_flags +/* "struct fixed_point_type_info" has a field that has a destructor. + See allocate_fixed_point_type_info to understand how this is + handled. */ +#define INIT_FIXED_POINT_SPECIFIC(type) \ + (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FIXED_POINT, \ + allocate_fixed_point_type_info (type)) + #define TYPE_MAIN_TYPE(thistype) (thistype)->main_type #define TYPE_TARGET_TYPE(thistype) TYPE_MAIN_TYPE(thistype)->target_type #define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type @@ -1594,22 +1879,6 @@ extern unsigned type_align (struct type *); space in struct type. */ extern bool set_type_align (struct type *, ULONGEST); -#define TYPE_LOW_BOUND(range_type) \ - ((range_type)->bounds ()->low.const_val ()) -#define TYPE_HIGH_BOUND(range_type) \ - ((range_type)->bounds ()->high.const_val ()) -#define TYPE_LOW_BOUND_UNDEFINED(range_type) \ - (TYPE_LOW_BOUND_KIND(range_type) == PROP_UNDEFINED) -#define TYPE_HIGH_BOUND_UNDEFINED(range_type) \ - (TYPE_HIGH_BOUND_KIND(range_type) == PROP_UNDEFINED) -#define TYPE_HIGH_BOUND_KIND(range_type) \ - ((range_type)->bounds ()->high.kind ()) -#define TYPE_LOW_BOUND_KIND(range_type) \ - ((range_type)->bounds ()->low.kind ()) -#define TYPE_BIT_STRIDE(range_type) \ - ((range_type)->bounds ()->stride.const_val () \ - * ((range_type)->bounds ()->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)) @@ -1628,32 +1897,6 @@ extern bool set_type_align (struct type *, ULONGEST); #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->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((arraytype)->index_type ()) -#define TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED(arraytype) \ - TYPE_LOW_BOUND_UNDEFINED((arraytype)->index_type ()) - -#define TYPE_ARRAY_UPPER_BOUND_VALUE(arraytype) \ - (TYPE_HIGH_BOUND((arraytype)->index_type ())) - -#define TYPE_ARRAY_LOWER_BOUND_VALUE(arraytype) \ - (TYPE_LOW_BOUND((arraytype)->index_type ())) - -#define TYPE_ARRAY_BIT_STRIDE(arraytype) \ - (TYPE_BIT_STRIDE(((arraytype)->index_type ()))) - /* C++ */ #define TYPE_SELF_TYPE(thistype) internal_type_self_type (thistype) @@ -1836,7 +2079,7 @@ extern void set_type_vptr_basetype (struct type *, struct type *); && ((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. */ @@ -1868,6 +2111,7 @@ struct builtin_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; @@ -2002,7 +2246,7 @@ extern const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN]; 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 @@ -2019,10 +2263,10 @@ extern const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN when it is no longer needed. */ #define TYPE_ALLOC(t,size) \ - (obstack_alloc ((TYPE_OBJFILE_OWNED (t) \ - ? &TYPE_OBJFILE (t)->objfile_obstack \ - : gdbarch_obstack (TYPE_OWNER (t).gdbarch)), \ - size)) + (obstack_alloc (((t)->is_objfile_owned () \ + ? &((t)->objfile_owner ()->objfile_obstack) \ + : gdbarch_obstack ((t)->arch_owner ())), \ + size)) /* See comment on TYPE_ALLOC. */ @@ -2038,12 +2282,6 @@ extern struct type *alloc_type (struct objfile *); extern struct type *alloc_type_arch (struct gdbarch *); extern struct type *alloc_type_copy (const struct type *); -/* * Return the type's architecture. For types owned by an - architecture, that architecture is returned. For types owned by an - objfile, that objfile's architecture is returned. */ - -extern struct gdbarch *get_type_arch (const struct type *); - /* * This returns the target type (or NULL) of TYPE, also skipping past typedefs. */ @@ -2068,9 +2306,12 @@ 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 bool can_create_complex_type (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 *); +extern struct type *init_fixed_point_type (struct objfile *, int, int, + const char *); /* Helper functions to construct architecture-owned types. */ extern struct type *arch_type (struct gdbarch *, enum type_code, int, @@ -2124,7 +2365,7 @@ extern struct type *lookup_rvalue_reference_type (struct type *); extern struct type *make_reference_type (struct type *, struct type **, - enum type_code); + enum type_code); extern struct type *make_cv_type (int, int, struct type *, struct type **); @@ -2136,12 +2377,14 @@ extern struct type *make_atomic_type (struct type *); 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 *); @@ -2281,12 +2524,34 @@ extern struct type *lookup_template_type (const char *, struct type *, extern int get_vptr_fieldno (struct type *, struct type **); -extern int get_discrete_bounds (struct type *, LONGEST *, LONGEST *); +/* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type + TYPE. + + Return true if the two bounds are available, false otherwise. */ + +extern bool get_discrete_bounds (struct type *type, LONGEST *lowp, + LONGEST *highp); + +/* If TYPE's low bound is a known constant, return it, else return nullopt. */ + +extern gdb::optional get_discrete_low_bound (struct type *type); + +/* If TYPE's high bound is a known constant, return it, else return nullopt. */ -extern int get_array_bounds (struct type *type, LONGEST *low_bound, - LONGEST *high_bound); +extern gdb::optional get_discrete_high_bound (struct type *type); -extern int discrete_position (struct type *type, LONGEST val, LONGEST *pos); +/* Assuming TYPE is a simple, non-empty array type, compute its upper + and lower bound. Save the low bound into LOW_BOUND if not NULL. + Save the high bound into HIGH_BOUND if not NULL. + + Return true if the operation was successful. Return false otherwise, + in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified. */ + +extern bool get_array_bounds (struct type *type, LONGEST *low_bound, + LONGEST *high_bound); + +extern gdb::optional discrete_position (struct type *type, + LONGEST val); extern int class_types_same_p (const struct type *, const struct type *); @@ -2390,7 +2655,7 @@ extern int class_or_union_p (const struct type *); 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, @@ -2406,10 +2671,18 @@ extern int type_not_allocated (const struct type *type); extern int type_not_associated (const struct type *type); +/* Return True if TYPE is a TYPE_CODE_FIXED_POINT or if TYPE is + a range type whose base type is a TYPE_CODE_FIXED_POINT. */ +extern bool is_fixed_point_type (struct type *type); + +/* Allocate a fixed-point type info for TYPE. This should only be + called by INIT_FIXED_POINT_SPECIFIC. */ +extern void allocate_fixed_point_type_info (struct type *type); + /* * When the type includes explicit byte ordering, return that. - Otherwise, the byte ordering from gdbarch_byte_order for - get_type_arch is returned. */ - + Otherwise, the byte ordering from gdbarch_byte_order for + the type's arch is returned. */ + extern enum bfd_endian type_byte_order (const struct type *type); /* A flag to enable printing of debugging information of C++