Re: [PATCH 2/3] Use type_instance_flags more throughout

[Andrew Burgess <andrew.burgess@embecosm.com>]

* Pedro Alves <pedro@palves.net> [2020-08-21 15:45:22 +0100]:

> The next patch in this series will rewrites enum_flags fixing some API
> holes.  That would cause build failures around code using
> type_instance_flags.  Or rather, that should be using it, but wasn't.
> 
> This patch fixes it by using type_instance_flags throughout instead of
> plain integers.
> 
> Note that we can't make the seemingly obvious change to struct
> type::instance_flags:
> 
>  -  unsigned instance_flags : 9;
>  +  ENUM_BITFIELD (type_instance_flag_value) instance_flags : 9;
> 
> Because G++ complains then that 9 bits isn't sufficient for holding
> all values of type_instance_flag_value.
> 
> So the patch adds a cast to TYPE_INSTANCE_FLAGS, and adds a separate
> SET_TYPE_INSTANCE_FLAGS macro.
> 
> gdb/ChangeLog:
> 
> 	* dwarf2/read.c (read_tag_pointer_type): Use type_instance_flags.
> 	* eval.c (fake_method::fake_method): Use SET_TYPE_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
> 	SET_TYPE_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 SET_TYPE_INSTANCE_FLAGS.
> 	* gdbtypes.h (TYPE_INSTANCE_FLAGS): Return a type_instance_flags.
> 	(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
> 	SET_TYPE_INSTANCE_FLAGS.
> 	* type-stack.c (type_stack::follow_types): Use type_instance_flags.
> ---
>  gdb/dwarf2/read.c |  7 +++----
>  gdb/eval.c        |  2 +-
>  gdb/gdbarch.c     |  6 +++---
>  gdb/gdbarch.h     | 12 ++++++------
>  gdb/gdbarch.sh    |  8 ++++----
>  gdb/gdbtypes.c    | 58 ++++++++++++++++++++++++++++++-------------------------
>  gdb/gdbtypes.h    | 15 +++++++++-----
>  gdb/stabsread.c   |  2 +-
>  gdb/type-stack.c  |  4 ++--
>  9 files changed, 62 insertions(+), 52 deletions(-)
> 
> diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c
> index 0ac8533263..4ced5ac02b 100644
> --- a/gdb/dwarf2/read.c
> +++ b/gdb/dwarf2/read.c
> @@ -17292,10 +17292,9 @@ read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
>      {
>        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);
> diff --git a/gdb/eval.c b/gdb/eval.c
> index c62c35f318..cd300ddfef 100644
> --- a/gdb/eval.c
> +++ b/gdb/eval.c
> @@ -659,7 +659,7 @@ fake_method::fake_method (type_instance_flags flags,
>    TYPE_LENGTH (type) = 1;
>    type->set_code (TYPE_CODE_METHOD);
>    TYPE_CHAIN (type) = type;
> -  TYPE_INSTANCE_FLAGS (type) = flags;
> +  SET_TYPE_INSTANCE_FLAGS (type, flags);
>    if (num_types > 0)
>      {
>        if (param_types[num_types - 1] == NULL)
> diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c
> index f8fe03ca68..2be959ecfc 100644
> --- a/gdb/gdbarch.c
> +++ b/gdb/gdbarch.c
> @@ -3501,7 +3501,7 @@ gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
>    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);
> @@ -3566,8 +3566,8 @@ gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
>    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);
> diff --git a/gdb/gdbarch.h b/gdb/gdbarch.h
> index 7a3060e628..8a4a384fda 100644
> --- a/gdb/gdbarch.h
> +++ b/gdb/gdbarch.h
> @@ -848,8 +848,8 @@ extern void set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch, i
>  
>  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);
> @@ -866,13 +866,13 @@ extern bool gdbarch_execute_dwarf_cfa_vendor_op (struct gdbarch *gdbarch, gdb_by
>  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 */
> diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh
> index 6d3c5c889d..7e9204119b 100755
> --- a/gdb/gdbarch.sh
> +++ b/gdb/gdbarch.sh
> @@ -689,16 +689,16 @@ v;int;cannot_step_breakpoint;;;0;0;;0
>  # 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
> +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;int 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.
> diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
> index c1eb03d898..64e44bfe23 100644
> --- a/gdb/gdbtypes.c
> +++ b/gdb/gdbtypes.c
> @@ -574,11 +574,11 @@ lookup_function_type_with_arguments (struct type *type,
>  /* 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"))
> @@ -598,7 +598,8 @@ address_space_name_to_int (struct gdbarch *gdbarch,
>     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";
> @@ -617,7 +618,7 @@ address_space_int_to_name (struct gdbarch *gdbarch, int space_flag)
>     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;
> @@ -657,7 +658,7 @@ make_qualified_type (struct type *type, int new_flags,
>    TYPE_CHAIN (type) = ntype;
>  
>    /* Now set the instance flags and return the new type.  */
> -  TYPE_INSTANCE_FLAGS (ntype) = new_flags;
> +  SET_TYPE_INSTANCE_FLAGS (ntype, new_flags);
>  
>    /* Set length of new type to that of the original type.  */
>    TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
> @@ -675,13 +676,14 @@ make_qualified_type (struct type *type, int new_flags,
>     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)
> +				    & ~(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);
>  }
> @@ -705,9 +707,9 @@ make_cv_type (int cnst, int voltl,
>  {
>    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)
> +				   & ~(TYPE_INSTANCE_FLAG_CONST
> +				       | TYPE_INSTANCE_FLAG_VOLATILE));
>  
>    if (cnst)
>      new_flags |= TYPE_INSTANCE_FLAG_CONST;
> @@ -1410,7 +1412,6 @@ void
>  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.  */
> @@ -1421,7 +1422,8 @@ make_vector_type (struct type *array_type)
>    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
> +	= TYPE_INSTANCE_FLAGS (elt_type) | TYPE_INSTANCE_FLAG_NOTTEXT;
>        elt_type = make_qualified_type (elt_type, flags, NULL);
>        TYPE_TARGET_TYPE (inner_array) = elt_type;
>      }
> @@ -2732,12 +2734,13 @@ struct 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 (type);
> +
>    while (type->code () == TYPE_CODE_TYPEDEF)
>      {
>        if (!TYPE_TARGET_TYPE (type))
> @@ -2778,10 +2781,13 @@ check_typedef (struct 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 (type);
>  
>  	/* Treat code vs data spaces and address classes separately.  */
>  	if ((instance_flags & ALL_SPACES) != 0)
> @@ -5026,7 +5032,7 @@ recursive_dump_type (struct type *type, int spaces)
>    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 (type));
>    if (TYPE_CONST (type))
>      {
>        puts_filtered (" TYPE_CONST");
> @@ -5300,7 +5306,7 @@ copy_type_recursive (struct objfile *objfile,
>    if (type->name ())
>      new_type->set_name (xstrdup (type->name ()));
>  
> -  TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
> +  SET_TYPE_INSTANCE_FLAGS (new_type, TYPE_INSTANCE_FLAGS (type));
>    TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
>  
>    /* Copy the fields.  */
> @@ -5427,7 +5433,7 @@ copy_type (const struct type *type)
>    gdb_assert (TYPE_OBJFILE_OWNED (type));
>  
>    new_type = alloc_type_copy (type);
> -  TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
> +  SET_TYPE_INSTANCE_FLAGS (new_type, TYPE_INSTANCE_FLAGS (type));
>    TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
>    memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type),
>  	  sizeof (struct main_type));
> diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
> index 55a6dafb7e..b42cef6137 100644
> --- a/gdb/gdbtypes.h
> +++ b/gdb/gdbtypes.h
> @@ -1585,7 +1585,10 @@ 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
> +#define TYPE_INSTANCE_FLAGS(thistype) \
> +  type_instance_flags ((enum type_instance_flag_value) (thistype)->instance_flags)
> +#define SET_TYPE_INSTANCE_FLAGS(thistype, flags) \
> +  (thistype)->instance_flags = flags

There are some places where you've not updated a use of
TYPE_INSTANCE_FLAGS.  The patch below fixes these.  In order to find
these I changed TYPE_INSTANCE_FLAGS to make use of a member function
returning a 'const type_instance_flags'.

Feel free to take any parts of this patch you think are useful.

Thanks,
Andrew

---

commit 77f72bf3ec4f67354bb42b99b5115001f08bd492
Author: Andrew Burgess <andrew.burgess@embecosm.com>
Date:   Wed Aug 26 16:19:22 2020 +0100

    gdb: use SET_TYPE_INSTANCE_FLAGS more
    
    A few places where SET_TYPE_INSTANCE_FLAGS should be used.
    
    gdb/ChangeLog:
    
            * d-lang.c (build_d_types): Use SET_TYPE_INSTANCE_FLAGS.
            * ft32-tdep.c (ft32_gdbarch_init): Likewise.
            * gdbtypes.c (gdbtypes_post_init): Likewise.
            * gdbtypes.h (struct type) <get_instance_flags>: New member
            function.
            <set_instance_flags>: Likewise.
            (TYPE_INSTANCE_FLAGS): Update.
            (SET_TYPE_INSTANCE_FLAGS): Update.

diff --git a/gdb/d-lang.c b/gdb/d-lang.c
index 4ebb011ee9b..6b1f68b827e 100644
--- a/gdb/d-lang.c
+++ b/gdb/d-lang.c
@@ -321,10 +321,12 @@ build_d_types (struct gdbarch *gdbarch)
     = 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;
+  SET_TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_byte,
+			   (TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_byte)
+			    | TYPE_INSTANCE_FLAG_NOTTEXT));
+  SET_TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_ubyte,
+			   (TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_ubyte)
+			    | TYPE_INSTANCE_FLAG_NOTTEXT));
 
   /* Imaginary and complex types.  */
   builtin_d_type->builtin_ifloat
diff --git a/gdb/ft32-tdep.c b/gdb/ft32-tdep.c
index 8ce16c06505..c3a83149bec 100644
--- a/gdb/ft32-tdep.c
+++ b/gdb/ft32-tdep.c
@@ -577,7 +577,9 @@ ft32_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   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;
+  SET_TYPE_INSTANCE_FLAGS (tdep->pc_type,
+			   (TYPE_INSTANCE_FLAGS (tdep->pc_type)
+			    | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1));
 
   set_gdbarch_num_regs (gdbarch, FT32_NUM_REGS);
   set_gdbarch_sp_regnum (gdbarch, FT32_SP_REGNUM);
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 64e44bfe23d..394abaae106 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -5823,10 +5823,12 @@ gdbtypes_post_init (struct gdbarch *gdbarch)
     = 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;
+  SET_TYPE_INSTANCE_FLAGS (builtin_type->builtin_int8,
+			   (TYPE_INSTANCE_FLAGS (builtin_type->builtin_int8)
+			    | TYPE_INSTANCE_FLAG_NOTTEXT));
+  SET_TYPE_INSTANCE_FLAGS (builtin_type->builtin_uint8,
+			   (TYPE_INSTANCE_FLAGS (builtin_type->builtin_uint8)
+			    | TYPE_INSTANCE_FLAG_NOTTEXT));
 
   /* Wide character types.  */
   builtin_type->builtin_char16
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index b42cef61371..9c0289b18b2 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -1037,6 +1037,18 @@ struct type
     this->field (0).set_type (index_type);
   }
 
+  /* Return the instance flags converted to the correct type.  */
+  const type_instance_flags get_instance_flags () const
+  {
+    return type_instance_flags ((enum type_instance_flag_value) this->instance_flags);
+  }
+
+  /* Set the instance flags.  */
+  void set_instance_flags (type_instance_flags flags)
+  {
+    this->instance_flags = flags;
+  }
+
   /* Get the bounds bounds of this type.  The type must be a range type.  */
   range_bounds *bounds () const
   {
@@ -1585,10 +1597,9 @@ 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) \
-  type_instance_flags ((enum type_instance_flag_value) (thistype)->instance_flags)
-#define SET_TYPE_INSTANCE_FLAGS(thistype, flags) \
-  (thistype)->instance_flags = flags
+#define TYPE_INSTANCE_FLAGS(thistype) ((thistype)->get_instance_flags ())
+#define SET_TYPE_INSTANCE_FLAGS(thistype, flags)	\
+  ((thistype)->set_instance_flags (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