From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wm1-x344.google.com (mail-wm1-x344.google.com [IPv6:2a00:1450:4864:20::344]) by sourceware.org (Postfix) with ESMTPS id CF8E5384B00F for ; Wed, 26 Aug 2020 15:21:12 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org CF8E5384B00F Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=embecosm.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=andrew.burgess@embecosm.com Received: by mail-wm1-x344.google.com with SMTP id x5so2148979wmi.2 for ; Wed, 26 Aug 2020 08:21:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=embecosm.com; s=google; h=date:from:to:cc:subject:message-id:references:mime-version :content-disposition:in-reply-to; bh=nXB+D7faKhZZAUqXTgwpLYK8xxTVeCMx885X2MPGypo=; b=LkCobuojTQktt6etAIAyf12nfeIUqU+DEDml4aGDKnixJ3xxAvGn6gh/GehzSwVB+X A98qo1a35WcUgnJgyE7ldZB+fRuPwhUFBjAZXa3QJgtmkemTfJq1vdggbR5bL1Ee6Dqd ZWxAUZf6Hm5Kzej9lD6/YdlueXyBmwof1Rs45qPEscHehnLApKtOOMxBG05f1l0d581E a/vAgoYbRBlN6hktrear4gk/U7UJPNFVMBnRlUFUoLA1xakSxSQPajuExwuD5GHNF1Xk DAh6CcTpr5yNhYlcpCW3rnZyD+w1DT/MTCqz3g7IVYs9ZFQMLEAVDCHXoc/mgszfj8WU GP/w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:in-reply-to; bh=nXB+D7faKhZZAUqXTgwpLYK8xxTVeCMx885X2MPGypo=; b=r04E9sjHd4zrfy6u19YOI10YmcaYYTq0BNvRnECXxNUIuePTrEUseqfVL+QnAf26Rk ilpgtAci0eZeD4x9PBbMe7MrLBXxvlFf2W33wVmWUDwHvN6QhAjZouQN3HG5X5WiCZsu Czu0l2z5nheewrzb/p73Q3KxPHPVkPRgW2beYnuYJfRxoNVHuQ6BiofiPD8XgxZNdj5n g8LR0d80ojTta8fdF0q/SZo2+YmUFKM+svs+2cNgK11QnBo1mhhVPTh/DXqjmJ1ayq2T CtcXxnXqruHo6+MsVamLH8rBGCexDb8kZ4PfOplcE8+0mKHg8QP3K/qAYOusPIbwG4Dz h0Cg== X-Gm-Message-State: AOAM5322ouTn3Tl9v80i/XF9jzp/+8eUG9ZpAMUpkI6N9LHilgCeq5+I TwUdrs8FXj5tXdnnlRHF9SFgF5bFoRLBxQ== X-Google-Smtp-Source: ABdhPJycb861O5FF4F9X6VNKgB/FG/tlGOYoGeJxSa8ujPRXU5c6u2rA1ysSG+srYyiW3bR0N6YsNA== X-Received: by 2002:a1c:f20e:: with SMTP id s14mr5642716wmc.23.1598455271629; Wed, 26 Aug 2020 08:21:11 -0700 (PDT) Received: from localhost (host109-148-134-218.range109-148.btcentralplus.com. [109.148.134.218]) by smtp.gmail.com with ESMTPSA id n5sm7121536wme.9.2020.08.26.08.21.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 26 Aug 2020 08:21:10 -0700 (PDT) Date: Wed, 26 Aug 2020 16:21:09 +0100 From: Andrew Burgess To: Pedro Alves Cc: gdb-patches@sourceware.org Subject: Re: [PATCH 2/3] Use type_instance_flags more throughout Message-ID: <20200826152109.GV853475@embecosm.com> References: <20200821144523.19451-1-pedro@palves.net> <20200821144523.19451-3-pedro@palves.net> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20200821144523.19451-3-pedro@palves.net> X-Operating-System: Linux/5.6.15-200.fc31.x86_64 (x86_64) X-Uptime: 15:55:54 up 39 days, 10 min, X-Editor: GNU Emacs [ http://www.gnu.org/software/emacs ] X-Spam-Status: No, score=-8.5 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_ABUSEAT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 26 Aug 2020 15:21:15 -0000 * Pedro Alves [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 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) : New member function. : 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