+2020-09-14 Pedro Alves <pedro@palves.net>
+ Andrew Burgess <andrew.burgess@embecosm.com>
+
+ * avr-tdep.c (avr_address_class_type_flags): Return
+ type_instance_flags.
+ (avr_address_class_type_flags_to_name): Take a
+ type_instance_flags.
+ (avr_address_class_name_to_type_flags): Return bool and take a
+ type_instance_flags.
+ * d-lang.c (build_d_types): Use type::set_instance_flags.
+ * ft32-tdep.c (ft32_address_class_type_flags): Return
+ type_instance_flags.
+ (ft32_address_class_type_flags_to_name): Take a
+ type_instance_flags.
+ (ft32_address_class_name_to_type_flags): Return bool and take a
+ type_instance_flags.
+ (ft32_gdbarch_init): Use type::set_instance_flags.
+ * eval.c (fake_method::fake_method): Use type::set_instance_flags.
+ * gdbarch.h, gdbarch.c: Regenerate.
+ * gdbarch.sh (address_class_type_flags): Use type_instance_flags.
+ (address_class_name_to_type_flags): Use type_instance_flags and
+ bool.
+ * gdbtypes.c (address_space_name_to_int)
+ (address_space_int_to_name, make_qualified_type): Use
+ type_instance_flags.
+ (make_qualified_type): Use type_instance_flags and
+ type::set_instance_flags.
+ (make_type_with_address_space, make_cv_type, make_vector_type)
+ (check_typedef): Use type_instance_flags.
+ (recursive_dump_type): Cast type_instance_flags to unsigned for
+ printing.
+ (copy_type_recursive): Use type::set_instance_flags.
+ (gdbtypes_post_init): Use type::set_instance_flags.
+ * gdbtypes.h (struct type) <instance_flags>: Rename to ...
+ <m_instance_flags>: ... this.
+ <instance_flags, set_instance_flags>: New methods.
+ (TYPE_INSTANCE_FLAGS): Use the instance_flags method.
+ (SET_TYPE_INSTANCE_FLAGS): New.
+ (address_space_name_to_int, address_space_int_to_name)
+ (make_type_with_address_space): Pass flags using
+ type_instance_flags instead of int.
+ * stabsread.c (cleanup_undefined_types_noname): Use
+ type::set_instance_flags.
+ * s390-tdep.c (s390_address_class_type_flags): Return
+ type_instance_flags.
+ (s390_address_class_type_flags_to_name): Take a
+ type_instance_flags.
+ (s390_address_class_name_to_type_flags): Return bool and take a
+ type_instance_flags.
+ * type-stack.c (type_stack::follow_types): Use
+ type_instance_flags.
+ * dwarf2/read.c (read_tag_pointer_type): Use type_instance_flags.
+
2020-09-14 Tom Tromey <tromey@adacore.com>
* x86-tdep.h (x86_in_indirect_branch_thunk): Update.
This method maps DW_AT_address_class attributes to a
type_instance_flag_value. */
-static int
+static type_instance_flags
avr_address_class_type_flags (int byte_size, int dwarf2_addr_class)
{
/* The value 1 of the DW_AT_address_class attribute corresponds to the
Convert a type_instance_flag_value to an address space qualifier. */
static const char*
-avr_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
+avr_address_class_type_flags_to_name (struct gdbarch *gdbarch,
+ type_instance_flags type_flags)
{
if (type_flags & AVR_TYPE_INSTANCE_FLAG_ADDRESS_CLASS_FLASH)
return "flash";
Convert an address space qualifier to a type_instance_flag_value. */
-static int
+static bool
avr_address_class_name_to_type_flags (struct gdbarch *gdbarch,
- const char* name,
- int *type_flags_ptr)
+ const char* name,
+ type_instance_flags *type_flags_ptr)
{
if (strcmp (name, "flash") == 0)
{
*type_flags_ptr = AVR_TYPE_INSTANCE_FLAG_ADDRESS_CLASS_FLASH;
- return 1;
+ return true;
}
else
- return 0;
+ return false;
}
/* Initialize the gdbarch structure for the AVR's. */
= arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
"real", gdbarch_long_double_format (gdbarch));
- TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_byte)
- |= TYPE_INSTANCE_FLAG_NOTTEXT;
- TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_ubyte)
- |= TYPE_INSTANCE_FLAG_NOTTEXT;
+ builtin_d_type->builtin_byte->set_instance_flags
+ (builtin_d_type->builtin_byte->instance_flags ()
+ | TYPE_INSTANCE_FLAG_NOTTEXT);
+
+ builtin_d_type->builtin_ubyte->set_instance_flags
+ (builtin_d_type->builtin_ubyte->instance_flags ()
+ | TYPE_INSTANCE_FLAG_NOTTEXT);
/* Imaginary and complex types. */
builtin_d_type->builtin_ifloat
{
if (gdbarch_address_class_type_flags_p (gdbarch))
{
- int type_flags;
-
- type_flags = gdbarch_address_class_type_flags
- (gdbarch, byte_size, addr_class);
+ type_instance_flags type_flags
+ = gdbarch_address_class_type_flags (gdbarch, byte_size,
+ addr_class);
gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
== 0);
type = make_type_with_address_space (type, type_flags);
TYPE_LENGTH (type) = 1;
type->set_code (TYPE_CODE_METHOD);
TYPE_CHAIN (type) = type;
- TYPE_INSTANCE_FLAGS (type) = flags;
+ type->set_instance_flags (flags);
if (num_types > 0)
{
if (param_types[num_types - 1] == NULL)
This method maps DW_AT_address_class attributes to a
type_instance_flag_value. */
-static int
+static type_instance_flags
ft32_address_class_type_flags (int byte_size, int dwarf2_addr_class)
{
/* The value 1 of the DW_AT_address_class attribute corresponds to the
Convert a type_instance_flag_value to an address space qualifier. */
static const char*
-ft32_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
+ft32_address_class_type_flags_to_name (struct gdbarch *gdbarch,
+ type_instance_flags type_flags)
{
if (type_flags & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
return "flash";
Convert an address space qualifier to a type_instance_flag_value. */
-static int
+static bool
ft32_address_class_name_to_type_flags (struct gdbarch *gdbarch,
const char* name,
- int *type_flags_ptr)
+ type_instance_flags *type_flags_ptr)
{
if (strcmp (name, "flash") == 0)
{
*type_flags_ptr = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
- return 1;
+ return true;
}
else
- return 0;
+ return false;
}
/* Given a return value in `regbuf' with a type `valtype',
func_void_type = make_function_type (void_type, NULL);
tdep->pc_type = arch_pointer_type (gdbarch, 4 * TARGET_CHAR_BIT, NULL,
func_void_type);
- TYPE_INSTANCE_FLAGS (tdep->pc_type) |= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
+ tdep->pc_type->set_instance_flags (tdep->pc_type->instance_flags ()
+ | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1);
set_gdbarch_num_regs (gdbarch, FT32_NUM_REGS);
set_gdbarch_sp_regnum (gdbarch, FT32_SP_REGNUM);
return gdbarch->address_class_type_flags != NULL;
}
-int
+type_instance_flags
gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
{
gdb_assert (gdbarch != NULL);
}
const char *
-gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
+gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, type_instance_flags type_flags)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->address_class_type_flags_to_name != NULL);
return gdbarch->address_class_name_to_type_flags != NULL;
}
-int
-gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
+bool
+gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, type_instance_flags *type_flags_ptr)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->address_class_name_to_type_flags != NULL);
extern int gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch);
-typedef int (gdbarch_address_class_type_flags_ftype) (int byte_size, int dwarf2_addr_class);
-extern int gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class);
+typedef type_instance_flags (gdbarch_address_class_type_flags_ftype) (int byte_size, int dwarf2_addr_class);
+extern type_instance_flags gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class);
extern void set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch, gdbarch_address_class_type_flags_ftype *address_class_type_flags);
extern int gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch);
-typedef const char * (gdbarch_address_class_type_flags_to_name_ftype) (struct gdbarch *gdbarch, int type_flags);
-extern const char * gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags);
+typedef const char * (gdbarch_address_class_type_flags_to_name_ftype) (struct gdbarch *gdbarch, type_instance_flags type_flags);
+extern const char * gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, type_instance_flags type_flags);
extern void set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name);
/* Execute vendor-specific DWARF Call Frame Instruction. OP is the instruction.
extern void set_gdbarch_execute_dwarf_cfa_vendor_op (struct gdbarch *gdbarch, gdbarch_execute_dwarf_cfa_vendor_op_ftype *execute_dwarf_cfa_vendor_op);
/* Return the appropriate type_flags for the supplied address class.
- This function should return 1 if the address class was recognized and
- type_flags was set, zero otherwise. */
+ This function should return true if the address class was recognized and
+ type_flags was set, false otherwise. */
extern int gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch);
-typedef int (gdbarch_address_class_name_to_type_flags_ftype) (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr);
-extern int gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr);
+typedef bool (gdbarch_address_class_name_to_type_flags_ftype) (struct gdbarch *gdbarch, const char *name, type_instance_flags *type_flags_ptr);
+extern bool gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, type_instance_flags *type_flags_ptr);
extern void set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags);
/* Is a register in a group */
# See comment in target.h about continuable, steppable and
# non-steppable watchpoints.
v;int;have_nonsteppable_watchpoint;;;0;0;;0
-F;int;address_class_type_flags;int byte_size, int dwarf2_addr_class;byte_size, dwarf2_addr_class
-M;const char *;address_class_type_flags_to_name;int type_flags;type_flags
+F;type_instance_flags;address_class_type_flags;int byte_size, int dwarf2_addr_class;byte_size, dwarf2_addr_class
+M;const char *;address_class_type_flags_to_name;type_instance_flags type_flags;type_flags
# Execute vendor-specific DWARF Call Frame Instruction. OP is the instruction.
# FS are passed from the generic execute_cfa_program function.
m;bool;execute_dwarf_cfa_vendor_op;gdb_byte op, struct dwarf2_frame_state *fs;op, fs;;default_execute_dwarf_cfa_vendor_op;;0
# Return the appropriate type_flags for the supplied address class.
-# This function should return 1 if the address class was recognized and
-# type_flags was set, zero otherwise.
-M;int;address_class_name_to_type_flags;const char *name, int *type_flags_ptr;name, type_flags_ptr
+# This function should return true if the address class was recognized and
+# type_flags was set, false otherwise.
+M;bool;address_class_name_to_type_flags;const char *name, type_instance_flags *type_flags_ptr;name, type_flags_ptr
# Is a register in a group
m;int;register_reggroup_p;int regnum, struct reggroup *reggroup;regnum, reggroup;;default_register_reggroup_p;;0
# Fetch the pointer to the ith function argument.
/* Identify address space identifier by name --
return the integer flag defined in gdbtypes.h. */
-int
+type_instance_flags
address_space_name_to_int (struct gdbarch *gdbarch,
const char *space_identifier)
{
- int type_flags;
+ type_instance_flags type_flags;
/* Check for known address space delimiters. */
if (!strcmp (space_identifier, "code"))
gdbtypes.h -- return the string version of the adress space name. */
const char *
-address_space_int_to_name (struct gdbarch *gdbarch, int space_flag)
+address_space_int_to_name (struct gdbarch *gdbarch,
+ type_instance_flags space_flag)
{
if (space_flag & TYPE_INSTANCE_FLAG_CODE_SPACE)
return "code";
STORAGE must be in the same obstack as TYPE. */
static struct type *
-make_qualified_type (struct type *type, int new_flags,
+make_qualified_type (struct type *type, type_instance_flags new_flags,
struct type *storage)
{
struct type *ntype;
TYPE_CHAIN (type) = ntype;
/* Now set the instance flags and return the new type. */
- TYPE_INSTANCE_FLAGS (ntype) = new_flags;
+ ntype->set_instance_flags (new_flags);
/* Set length of new type to that of the original type. */
TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
representations. */
struct type *
-make_type_with_address_space (struct type *type, int space_flag)
+make_type_with_address_space (struct type *type,
+ type_instance_flags space_flag)
{
- int new_flags = ((TYPE_INSTANCE_FLAGS (type)
- & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
- | TYPE_INSTANCE_FLAG_DATA_SPACE
- | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL))
- | space_flag);
+ type_instance_flags new_flags = ((type->instance_flags ()
+ & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
+ | TYPE_INSTANCE_FLAG_DATA_SPACE
+ | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL))
+ | space_flag);
return make_qualified_type (type, new_flags, NULL);
}
{
struct type *ntype; /* New type */
- int new_flags = (TYPE_INSTANCE_FLAGS (type)
- & ~(TYPE_INSTANCE_FLAG_CONST
- | TYPE_INSTANCE_FLAG_VOLATILE));
+ type_instance_flags new_flags = (type->instance_flags ()
+ & ~(TYPE_INSTANCE_FLAG_CONST
+ | TYPE_INSTANCE_FLAG_VOLATILE));
if (cnst)
new_flags |= TYPE_INSTANCE_FLAG_CONST;
make_vector_type (struct type *array_type)
{
struct type *inner_array, *elt_type;
- int flags;
/* Find the innermost array type, in case the array is
multi-dimensional. */
elt_type = TYPE_TARGET_TYPE (inner_array);
if (elt_type->code () == TYPE_CODE_INT)
{
- flags = TYPE_INSTANCE_FLAGS (elt_type) | TYPE_INSTANCE_FLAG_NOTTEXT;
+ type_instance_flags flags
+ = elt_type->instance_flags () | TYPE_INSTANCE_FLAG_NOTTEXT;
elt_type = make_qualified_type (elt_type, flags, NULL);
TYPE_TARGET_TYPE (inner_array) = elt_type;
}
check_typedef (struct type *type)
{
struct type *orig_type = type;
- /* While we're removing typedefs, we don't want to lose qualifiers.
- E.g., const/volatile. */
- int instance_flags = TYPE_INSTANCE_FLAGS (type);
gdb_assert (type);
+ /* While we're removing typedefs, we don't want to lose qualifiers.
+ E.g., const/volatile. */
+ type_instance_flags instance_flags = type->instance_flags ();
+
while (type->code () == TYPE_CODE_TYPEDEF)
{
if (!TYPE_TARGET_TYPE (type))
outer cast in a chain of casting win), instead of assuming
"it can't happen". */
{
- const int ALL_SPACES = (TYPE_INSTANCE_FLAG_CODE_SPACE
- | TYPE_INSTANCE_FLAG_DATA_SPACE);
- const int ALL_CLASSES = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL;
- int new_instance_flags = TYPE_INSTANCE_FLAGS (type);
+ const type_instance_flags ALL_SPACES
+ = (TYPE_INSTANCE_FLAG_CODE_SPACE
+ | TYPE_INSTANCE_FLAG_DATA_SPACE);
+ const type_instance_flags ALL_CLASSES
+ = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL;
+
+ type_instance_flags new_instance_flags = type->instance_flags ();
/* Treat code vs data spaces and address classes separately. */
if ((instance_flags & ALL_SPACES) != 0)
gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);
printf_filtered ("\n");
printfi_filtered (spaces, "instance_flags 0x%x",
- TYPE_INSTANCE_FLAGS (type));
+ (unsigned) type->instance_flags ());
if (TYPE_CONST (type))
{
puts_filtered (" TYPE_CONST");
if (type->name ())
new_type->set_name (xstrdup (type->name ()));
- TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
+ new_type->set_instance_flags (type->instance_flags ());
TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
/* Copy the fields. */
gdb_assert (TYPE_OBJFILE_OWNED (type));
new_type = alloc_type_copy (type);
- TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
+ new_type->set_instance_flags (type->instance_flags ());
TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type),
sizeof (struct main_type));
= arch_integer_type (gdbarch, 128, 0, "int128_t");
builtin_type->builtin_uint128
= arch_integer_type (gdbarch, 128, 1, "uint128_t");
- TYPE_INSTANCE_FLAGS (builtin_type->builtin_int8) |=
- TYPE_INSTANCE_FLAG_NOTTEXT;
- TYPE_INSTANCE_FLAGS (builtin_type->builtin_uint8) |=
- TYPE_INSTANCE_FLAG_NOTTEXT;
+
+ builtin_type->builtin_int8->set_instance_flags
+ (builtin_type->builtin_int8->instance_flags ()
+ | TYPE_INSTANCE_FLAG_NOTTEXT);
+
+ builtin_type->builtin_uint8->set_instance_flags
+ (builtin_type->builtin_uint8->instance_flags ()
+ | TYPE_INSTANCE_FLAG_NOTTEXT);
/* Wide character types. */
builtin_type->builtin_char16
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
{
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
TYPE_ZALLOC (type, \
sizeof (*TYPE_MAIN_TYPE (type)->type_specific.func_stuff)))
-#define TYPE_INSTANCE_FLAGS(thistype) (thistype)->instance_flags
+#define TYPE_INSTANCE_FLAGS(thistype) ((thistype)->instance_flags ())
#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
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_int (struct gdbarch *,
+ const char *);
-extern const char *address_space_int_to_name (struct gdbarch *, int);
+extern const char *address_space_int_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 *);
/* Implement addr_class_type_flags gdbarch method.
Only used for ABI_LINUX_ZSERIES. */
-static int
+static type_instance_flags
s390_address_class_type_flags (int byte_size, int dwarf2_addr_class)
{
if (byte_size == 4)
Only used for ABI_LINUX_ZSERIES. */
static const char *
-s390_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
+s390_address_class_type_flags_to_name (struct gdbarch *gdbarch,
+ type_instance_flags type_flags)
{
if (type_flags & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
return "mode32";
/* Implement addr_class_name_to_type_flags gdbarch method.
Only used for ABI_LINUX_ZSERIES. */
-static int
+static bool
s390_address_class_name_to_type_flags (struct gdbarch *gdbarch,
const char *name,
- int *type_flags_ptr)
+ type_instance_flags *type_flags_ptr)
{
if (strcmp (name, "mode32") == 0)
{
*type_flags_ptr = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
- return 1;
+ return true;
}
else
- return 0;
+ return false;
}
/* Inferior function calls. */
and needs to be copied over from the reference type.
Since replace_type expects them to be identical, we need
to set these flags manually before hand. */
- TYPE_INSTANCE_FLAGS (nat.type) = TYPE_INSTANCE_FLAGS (*type);
+ nat.type->set_instance_flags ((*type)->instance_flags ());
replace_type (nat.type, *type);
}
}
int done = 0;
int make_const = 0;
int make_volatile = 0;
- int make_addr_space = 0;
+ type_instance_flags make_addr_space = 0;
bool make_restrict = false;
bool make_atomic = false;
int array_size;
make_volatile = 1;
break;
case tp_space_identifier:
- make_addr_space = pop_int ();
+ make_addr_space = (enum type_instance_flag_value) pop_int ();
break;
case tp_atomic:
make_atomic = true;
projects / deliverable / binutils-gdb.git / commitdiff
