X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbtypes.h;h=bb4d26eef1a1a842ec77c6a386e63d298b28eddb;hb=e2ea3a381a4a7c739419a8b76a2fd132f7c1f9b1;hp=bceb1b876058b3a4302b0a8bdcfd14eb988aa972;hpb=e46d3488de137cd5a01377513ff49e32595456af;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index bceb1b8760..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,112 +215,33 @@ enum type_instance_flag_value : unsigned DEF_ENUM_FLAGS_TYPE (enum type_instance_flag_value, type_instance_flags); -/* * 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) - -/* * 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. */ @@ -354,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 @@ -366,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. */ @@ -656,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 @@ -821,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. @@ -841,25 +788,25 @@ struct main_type unsigned int m_flag_unsigned : 1; unsigned int m_flag_nosign : 1; unsigned int m_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_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. */ @@ -891,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. @@ -1020,6 +967,18 @@ 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 { @@ -1092,6 +1051,194 @@ struct type 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; @@ -1105,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 @@ -1147,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 @@ -1560,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. */ @@ -1599,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, \ @@ -1607,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 @@ -1839,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) \ - && ((thistype)->is_stub () || !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. */ @@ -2023,10 +2263,10 @@ extern const struct floatformat *floatformats_bfloat16[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. */ @@ -2042,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. */ @@ -2072,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, @@ -2128,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 **); @@ -2140,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 *); @@ -2285,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 int get_array_bounds (struct type *type, LONGEST *low_bound, - LONGEST *high_bound); +extern bool get_discrete_bounds (struct type *type, LONGEST *lowp, + LONGEST *highp); -extern int discrete_position (struct type *type, LONGEST val, LONGEST *pos); +/* 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 gdb::optional get_discrete_high_bound (struct type *type); + +/* 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 *); @@ -2394,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, @@ -2410,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++