From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtp-out2.suse.de (smtp-out2.suse.de [IPv6:2001:67c:2178:6::1d]) by sourceware.org (Postfix) with ESMTPS id AA01B3858C20 for ; Wed, 30 Aug 2023 19:13:08 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org AA01B3858C20 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=suse.de Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=suse.de Received: from imap2.suse-dmz.suse.de (imap2.suse-dmz.suse.de [192.168.254.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (P-521) server-digest SHA512) (No client certificate requested) by smtp-out2.suse.de (Postfix) with ESMTPS id 744C91F749 for ; Wed, 30 Aug 2023 19:13:06 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.de; s=susede2_rsa; t=1693422786; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=zO/3sPXaf5uaO3iHcA4E+EWWIVU9/zbC+9suyAEdlW8=; b=LRvwjB0+znaUSb7zFIV0NWjgb1qQXc4vSNqHq6rTdin2bmazYy2c8HZWwbpTcFeov+t9rT iOzDyLabUC0guU3CZ92XirWOr+aI0PNw275b+7kbyH1bZJY6timKcURa2O04JTc1KRPs33 rL5IQOHfUqQjFUwxC2MOG6ueyIOevOg= DKIM-Signature: v=1; a=ed25519-sha256; c=relaxed/relaxed; d=suse.de; s=susede2_ed25519; t=1693422786; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=zO/3sPXaf5uaO3iHcA4E+EWWIVU9/zbC+9suyAEdlW8=; b=MVIT9ozhbPxewiBPok+XFF4GXpzOzPWTjuUgZfOw1mkvpmLqbIhBEHdpVFKKesKa24EIh+ 4Ir0I96KdYf+TLCg== Received: from imap2.suse-dmz.suse.de (imap2.suse-dmz.suse.de [192.168.254.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (P-521) server-digest SHA512) (No client certificate requested) by imap2.suse-dmz.suse.de (Postfix) with ESMTPS id 5E6C4139F5 for ; Wed, 30 Aug 2023 19:13:06 +0000 (UTC) Received: from dovecot-director2.suse.de ([192.168.254.65]) by imap2.suse-dmz.suse.de with ESMTPSA id iPv8FcKU72Q2IQAAMHmgww (envelope-from ) for ; Wed, 30 Aug 2023 19:13:06 +0000 From: Tom de Vries To: gdb-patches@sourceware.org Subject: [PATCH 2/6] [gdb/symtab] Factor out type::{alloc_fields,copy_fields} Date: Wed, 30 Aug 2023 21:13:32 +0200 Message-Id: <20230830191336.15885-2-tdevries@suse.de> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20230830191336.15885-1-tdevries@suse.de> References: <20230830191336.15885-1-tdevries@suse.de> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Spam-Status: No, score=-10.7 required=5.0 tests=BAYES_00,DKIM_INVALID,DKIM_SIGNED,GIT_PATCH_0,KAM_DMARC_STATUS,SPF_HELO_NONE,SPF_PASS,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: After finding this code in buildsym_compunit::finish_block_internal: ... ftype->set_fields ((struct field *) TYPE_ALLOC (ftype, nparams * sizeof (struct field))); ... and fixing PR30810 by using TYPE_ZALLOC, I wondered if there were more locations that needed fixing. I decided to make things easier to spot by factoring out a new function alloc_fields: ... /* Allocate the fields array of this type, with NFIELDS elements. If INIT, zero-initialize the allocated memory. */ void alloc_fields (unsigned int nfields, bool init = true); ... where: - a regular use would be "alloc_fields (nfields)", and - an exceptional use that needed no initialization would be "alloc_fields (nfields, false)". Pretty soon I discovered that most of the latter cases are due to initialization by memcpy, so I added two variants of copy_fields as well. After this rewrite there are 8 uses of set_fields left: ... gdb/coffread.c: type->set_fields (nullptr); gdb/coffread.c: type->set_fields (nullptr); gdb/coffread.c: type->set_fields (nullptr); gdb/eval.c: type->set_fields gdb/gdbtypes.c: type->set_fields (args); gdb/gdbtypes.c: t->set_fields (XRESIZEVEC (struct field, t->fields (), gdb/dwarf2/read.c: type->set_fields (new_fields); gdb/dwarf2/read.c: sub_type->set_fields (sub_type->fields () + 1); ... These fall into the following categories: - set to nullptr (coffread.c), - type not owned by objfile or gdbarch (eval.c), and - modifying an existing fields array, like adding an element at the end or dropping an element at the start (the rest). Tested on x86_64-linux. --- gdb/ada-lang.c | 19 ++------ gdb/amdgpu-tdep.c | 5 +-- gdb/buildsym.c | 5 +-- gdb/coffread.c | 15 ++----- gdb/ctfread.c | 7 +-- gdb/dwarf2/read.c | 40 +++-------------- gdb/gdbtypes.c | 88 ++++++++++++++++++++++--------------- gdb/gdbtypes.h | 8 ++++ gdb/gnu-v3-abi.c | 106 ++++++++++++++++++++++++--------------------- gdb/mdebugread.c | 9 +--- gdb/rust-lang.c | 4 +- gdb/stabsread.c | 21 ++------- gdb/windows-tdep.c | 4 +- 13 files changed, 141 insertions(+), 190 deletions(-) diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index 575568cffb5..5b856da3189 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -7772,9 +7772,7 @@ ada_template_to_fixed_record_type_1 (struct type *type, rtype = type_allocator (type).new_type (); rtype->set_code (TYPE_CODE_STRUCT); INIT_NONE_SPECIFIC (rtype); - rtype->set_num_fields (nfields); - rtype->set_fields - ((struct field *) TYPE_ZALLOC (rtype, nfields * sizeof (struct field))); + rtype->alloc_fields (nfields); rtype->set_name (ada_type_name (type)); rtype->set_is_fixed_instance (true); @@ -8024,14 +8022,8 @@ template_to_static_fixed_type (struct type *type0) type0->set_target_type (type); type->set_code (type0->code ()); INIT_NONE_SPECIFIC (type); - type->set_num_fields (nfields); - field *fields = - ((struct field *) - TYPE_ALLOC (type, nfields * sizeof (struct field))); - memcpy (fields, type0->fields (), - sizeof (struct field) * nfields); - type->set_fields (fields); + type->copy_fields (type0); type->set_name (ada_type_name (type0)); type->set_is_fixed_instance (true); @@ -8077,12 +8069,7 @@ to_record_with_fixed_variant_part (struct type *type, const gdb_byte *valaddr, rtype = type_allocator (type).new_type (); rtype->set_code (TYPE_CODE_STRUCT); INIT_NONE_SPECIFIC (rtype); - rtype->set_num_fields (nfields); - - field *fields = - (struct field *) TYPE_ALLOC (rtype, nfields * sizeof (struct field)); - memcpy (fields, type->fields (), sizeof (struct field) * nfields); - rtype->set_fields (fields); + rtype->copy_fields (type); rtype->set_name (ada_type_name (type)); rtype->set_is_fixed_instance (true); diff --git a/gdb/amdgpu-tdep.c b/gdb/amdgpu-tdep.c index 21a7a3ae1b7..3a521a43977 100644 --- a/gdb/amdgpu-tdep.c +++ b/gdb/amdgpu-tdep.c @@ -757,10 +757,7 @@ amd_dbgapi_register_type_to_gdb_type (const amd_dbgapi_register_type &type, .new_type (TYPE_CODE_ENUM, enum_type.bit_size (), enum_type.name ().c_str ())); - gdb_type->set_num_fields (enum_type.size ()); - gdb_type->set_fields - ((struct field *) TYPE_ZALLOC (gdb_type, (sizeof (struct field) - * enum_type.size ()))); + gdb_type->alloc_fields (enum_type.size ()); gdb_type->set_is_unsigned (true); for (size_t i = 0; i < enum_type.size (); ++i) diff --git a/gdb/buildsym.c b/gdb/buildsym.c index 65ce3a0f5a8..3c1e9179411 100644 --- a/gdb/buildsym.c +++ b/gdb/buildsym.c @@ -264,10 +264,7 @@ buildsym_compunit::finish_block_internal } if (nparams > 0) { - ftype->set_num_fields (nparams); - ftype->set_fields - ((struct field *) - TYPE_ZALLOC (ftype, nparams * sizeof (struct field))); + ftype->alloc_fields (nparams); iparams = 0; /* Here we want to directly access the dictionary, because diff --git a/gdb/coffread.c b/gdb/coffread.c index c2fe9fa1761..e132dd1a1f7 100644 --- a/gdb/coffread.c +++ b/gdb/coffread.c @@ -1462,14 +1462,9 @@ patch_type (struct type *type, struct type *real_type) { struct type *target = type->target_type (); struct type *real_target = real_type->target_type (); - int field_size = real_target->num_fields () * sizeof (struct field); target->set_length (real_target->length ()); - target->set_num_fields (real_target->num_fields ()); - - field *fields = (struct field *) TYPE_ALLOC (target, field_size); - memcpy (fields, real_target->fields (), field_size); - target->set_fields (fields); + target->copy_fields (real_target); if (real_target->name ()) { @@ -2037,9 +2032,7 @@ coff_read_struct_type (int index, int length, int lastsym, } /* Now create the vector of fields, and record how big it is. */ - type->set_num_fields (nfields); - type->set_fields - ((struct field *) TYPE_ALLOC (type, sizeof (struct field) * nfields)); + type->alloc_fields (nfields, false); /* Copy the saved-up fields into the field vector. */ @@ -2117,9 +2110,7 @@ coff_read_enum_type (int index, int length, int lastsym, else /* Assume ints. */ type->set_length (gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT); type->set_code (TYPE_CODE_ENUM); - type->set_num_fields (nsyms); - type->set_fields - ((struct field *) TYPE_ALLOC (type, sizeof (struct field) * nsyms)); + type->alloc_fields (nsyms, false); /* Find the symbols for the values and put them into the type. The symbols can be found in the symlist that we put them on diff --git a/gdb/ctfread.c b/gdb/ctfread.c index 16292c74b1a..859908923a4 100644 --- a/gdb/ctfread.c +++ b/gdb/ctfread.c @@ -346,9 +346,7 @@ attach_fields_to_type (struct ctf_field_info *fip, struct type *type) return; /* Record the field count, allocate space for the array of fields. */ - type->set_num_fields (nfields); - type->set_fields - ((struct field *) TYPE_ZALLOC (type, sizeof (struct field) * nfields)); + type->alloc_fields (nfields); /* Copy the saved-up fields into the field vector. */ for (int i = 0; i < nfields; ++i) @@ -715,8 +713,7 @@ read_func_kind_type (struct ctf_context *ccp, ctf_id_t tid) if (ctf_func_type_args (fp, tid, argc, argv.data ()) == CTF_ERR) return nullptr; - type->set_fields - ((struct field *) TYPE_ZALLOC (type, argc * sizeof (struct field))); + type->alloc_fields (argc); struct type *void_type = builtin_type (of)->builtin_void; /* If failed to find the argument type, fill it with void_type. */ for (int iparam = 0; iparam < argc; iparam++) diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c index 5b32089094d..7fe0e84cdda 100644 --- a/gdb/dwarf2/read.c +++ b/gdb/dwarf2/read.c @@ -6054,11 +6054,9 @@ quirk_rust_enum (struct type *type, struct objfile *objfile) /* Smash this type to be a structure type. We have to do this because the type has already been recorded. */ type->set_code (TYPE_CODE_STRUCT); - type->set_num_fields (3); /* Save the field we care about. */ struct field saved_field = type->field (0); - type->set_fields - ((struct field *) TYPE_ZALLOC (type, 3 * sizeof (struct field))); + type->alloc_fields (3); /* Put the discriminant at index 0. */ type->field (0).set_type (field_type); @@ -12059,9 +12057,7 @@ dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type, /* Record the field count, allocate space for the array of fields, and create blank accessibility bitfields if necessary. */ - type->set_num_fields (nfields); - type->set_fields - ((struct field *) TYPE_ZALLOC (type, sizeof (struct field) * nfields)); + type->alloc_fields (nfields); if (fip->non_public_fields && cu->lang () != language_ada) { @@ -12490,12 +12486,7 @@ rewrite_array_type (struct type *type) updated. Either way we want to copy the type and update everything. */ struct type *copy = copy_type (type); - int nfields = copy->num_fields (); - field *new_fields - = ((struct field *) TYPE_ZALLOC (copy, - nfields * sizeof (struct field))); - memcpy (new_fields, copy->fields (), nfields * sizeof (struct field)); - copy->set_fields (new_fields); + copy->copy_fields (type); if (new_target != nullptr) copy->set_target_type (new_target); @@ -13260,14 +13251,7 @@ update_enumeration_type_from_children (struct die_info *die, } if (!fields.empty ()) - { - type->set_num_fields (fields.size ()); - type->set_fields - ((struct field *) - TYPE_ALLOC (type, sizeof (struct field) * fields.size ())); - memcpy (type->fields (), fields.data (), - sizeof (struct field) * fields.size ()); - } + type->copy_fields (fields); else flag_enum = 0; @@ -13636,12 +13620,7 @@ quirk_ada_thick_pointer (struct die_info *die, struct dwarf2_cu *cu, struct type *bounds = alloc.new_type (); bounds->set_code (TYPE_CODE_STRUCT); - bounds->set_num_fields (range_fields.size ()); - bounds->set_fields - ((struct field *) TYPE_ALLOC (bounds, (bounds->num_fields () - * sizeof (struct field)))); - memcpy (bounds->fields (), range_fields.data (), - bounds->num_fields () * sizeof (struct field)); + bounds->copy_fields (range_fields); int last_fieldno = range_fields.size () - 1; int bounds_size = (bounds->field (last_fieldno).loc_bitpos () / 8 @@ -13664,10 +13643,7 @@ quirk_ada_thick_pointer (struct die_info *die, struct dwarf2_cu *cu, struct type *result = type_allocator (objfile).new_type (); result->set_code (TYPE_CODE_STRUCT); - result->set_num_fields (2); - result->set_fields - ((struct field *) TYPE_ZALLOC (result, (result->num_fields () - * sizeof (struct field)))); + result->alloc_fields (2); /* The names are chosen to coincide with what the compiler does with -fgnat-encodings=all, which the Ada code in gdb already @@ -14709,9 +14685,7 @@ read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu) } /* Allocate storage for parameters and fill them in. */ - ftype->set_num_fields (nparams); - ftype->set_fields - ((struct field *) TYPE_ZALLOC (ftype, nparams * sizeof (struct field))); + ftype->alloc_fields (nparams); /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it even if we error out during the parameters reading below. */ diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index 939fcc23b82..766107a7013 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -597,9 +597,7 @@ lookup_function_type_with_arguments (struct type *type, fn->set_is_prototyped (true); } - fn->set_num_fields (nparams); - fn->set_fields - ((struct field *) TYPE_ZALLOC (fn, nparams * sizeof (struct field))); + fn->alloc_fields (nparams); for (i = 0; i < nparams; ++i) fn->field (i).set_type (param_types[i]); @@ -1356,9 +1354,7 @@ create_array_type_with_stride (type_allocator &alloc, result_type->set_code (TYPE_CODE_ARRAY); result_type->set_target_type (element_type); - result_type->set_num_fields (1); - result_type->set_fields - ((struct field *) TYPE_ZALLOC (result_type, sizeof (struct field))); + result_type->alloc_fields (1); result_type->set_index_type (range_type); if (byte_stride_prop != NULL) result_type->add_dyn_prop (DYN_PROP_BYTE_STRIDE, *byte_stride_prop); @@ -1442,9 +1438,7 @@ create_set_type (type_allocator &alloc, struct type *domain_type) struct type *result_type = alloc.new_type (); result_type->set_code (TYPE_CODE_SET); - result_type->set_num_fields (1); - result_type->set_fields - ((struct field *) TYPE_ZALLOC (result_type, sizeof (struct field))); + result_type->alloc_fields (1); if (!domain_type->is_stub ()) { @@ -2452,13 +2446,7 @@ resolve_dynamic_union (struct type *type, gdb_assert (type->code () == TYPE_CODE_UNION); resolved_type = copy_type (type); - resolved_type->set_fields - ((struct field *) - TYPE_ALLOC (resolved_type, - resolved_type->num_fields () * sizeof (struct field))); - memcpy (resolved_type->fields (), - type->fields (), - resolved_type->num_fields () * sizeof (struct field)); + resolved_type->copy_fields (type); for (i = 0; i < resolved_type->num_fields (); ++i) { struct type *t; @@ -2618,12 +2606,10 @@ compute_variant_fields (struct type *type, for (const auto &part : parts) compute_variant_fields_inner (type, addr_stack, part, flags); - resolved_type->set_num_fields - (std::count (flags.begin (), flags.end (), true)); - resolved_type->set_fields - ((struct field *) - TYPE_ALLOC (resolved_type, - resolved_type->num_fields () * sizeof (struct field))); + unsigned int nfields = std::count (flags.begin (), flags.end (), true); + /* No need to zero-initialize the newly allocated fields, they'll be + initialized by the copy in the loop below. */ + resolved_type->alloc_fields (nfields, false); int out = 0; for (int i = 0; i < type->num_fields (); ++i) @@ -2664,14 +2650,7 @@ resolve_dynamic_struct (struct type *type, } else { - resolved_type->set_fields - ((struct field *) - TYPE_ALLOC (resolved_type, - resolved_type->num_fields () * sizeof (struct field))); - if (type->num_fields () > 0) - memcpy (resolved_type->fields (), - type->fields (), - resolved_type->num_fields () * sizeof (struct field)); + resolved_type->copy_fields (type); } for (i = 0; i < resolved_type->num_fields (); ++i) @@ -5556,9 +5535,7 @@ copy_type_recursive (struct type *type, htab_t copied_types) int i, nfields; nfields = type->num_fields (); - new_type->set_fields - ((struct field *) - TYPE_ZALLOC (new_type, nfields * sizeof (struct field))); + new_type->alloc_fields (type->num_fields ()); for (i = 0; i < nfields; i++) { @@ -5703,10 +5680,9 @@ arch_flags_type (struct gdbarch *gdbarch, const char *name, int bit) type = type_allocator (gdbarch).new_type (TYPE_CODE_FLAGS, bit, name); type->set_is_unsigned (true); - type->set_num_fields (0); /* Pre-allocate enough space assuming every field is one bit. */ - type->set_fields - ((struct field *) TYPE_ZALLOC (type, bit * sizeof (struct field))); + type->alloc_fields (bit); + type->set_num_fields (0); return type; } @@ -5912,6 +5888,46 @@ type::fixed_point_scaling_factor () return type->fixed_point_info ().scaling_factor; } +void type::alloc_fields (unsigned int nfields, bool init) +{ + this->set_num_fields (nfields); + + if (nfields == 0) + { + this->main_type->flds_bnds.fields = nullptr; + return; + } + + size_t size = nfields * sizeof (*this->fields ()); + struct field *fields + = (struct field *) (init + ? TYPE_ZALLOC (this, size) + : TYPE_ALLOC (this, size)); + + this->main_type->flds_bnds.fields = fields; +} + +void type::copy_fields (struct type *src) +{ + unsigned int nfields = src->num_fields (); + alloc_fields (nfields, false); + if (nfields == 0) + return; + + size_t size = nfields * sizeof (*this->fields ()); + memcpy (this->fields (), src->fields (), size); +} + +void type::copy_fields (std::vector &src) +{ + unsigned int nfields = src.size (); + alloc_fields (nfields, false); + if (nfields == 0) + return; + + size_t size = nfields * sizeof (*this->fields ()); + memcpy (this->fields (), src.data (), size); +} static const registry::key gdbtypes_data; diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index aedaf53cd5d..8f592dbe1c0 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -992,6 +992,14 @@ struct type this->main_type->flds_bnds.fields = fields; } + /* Allocate the fields array of this type, with NFIELDS elements. If INIT, + zero-initialize the allocated memory. */ + void alloc_fields (unsigned int nfields, bool init = true); + + /* Allocate the fields array of this type, and copy the fields from SRC. */ + void copy_fields (struct type *src); + void copy_fields (std::vector &src); + type *index_type () const { return this->field (0).type (); diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c index 2c7c83e67b1..73b69da21e5 100644 --- a/gdb/gnu-v3-abi.c +++ b/gdb/gnu-v3-abi.c @@ -113,7 +113,6 @@ static struct type * get_gdb_vtable_type (struct gdbarch *arch) { struct type *t; - struct field *field_list, *field; int offset; struct type *result = vtable_type_gdbarch_data.get (arch); @@ -131,50 +130,56 @@ get_gdb_vtable_type (struct gdbarch *arch) struct type *ptrdiff_type = init_integer_type (alloc, gdbarch_ptr_bit (arch), 0, "ptrdiff_t"); + t = alloc.new_type (TYPE_CODE_STRUCT, 0, nullptr); + /* We assume no padding is necessary, since GDB doesn't know anything about alignment at the moment. If this assumption bites us, we should add a gdbarch method which, given a type, returns the alignment that type requires, and then use that here. */ /* Build the field list. */ - field_list = XCNEWVEC (struct field, 4); - field = &field_list[0]; + t->alloc_fields (4); + offset = 0; /* ptrdiff_t vcall_and_vbase_offsets[0]; */ - field->set_name ("vcall_and_vbase_offsets"); - field->set_type (lookup_array_range_type (ptrdiff_type, 0, -1)); - field->set_loc_bitpos (offset * TARGET_CHAR_BIT); - offset += field->type ()->length (); - field++; + { + struct field &field0 = t->field (0); + field0.set_name ("vcall_and_vbase_offsets"); + field0.set_type (lookup_array_range_type (ptrdiff_type, 0, -1)); + field0.set_loc_bitpos (offset * TARGET_CHAR_BIT); + offset += field0.type ()->length (); + } /* ptrdiff_t offset_to_top; */ - field->set_name ("offset_to_top"); - field->set_type (ptrdiff_type); - field->set_loc_bitpos (offset * TARGET_CHAR_BIT); - offset += field->type ()->length (); - field++; + { + struct field &field1 = t->field (1); + field1.set_name ("offset_to_top"); + field1.set_type (ptrdiff_type); + field1.set_loc_bitpos (offset * TARGET_CHAR_BIT); + offset += field1.type ()->length (); + } /* void *type_info; */ - field->set_name ("type_info"); - field->set_type (void_ptr_type); - field->set_loc_bitpos (offset * TARGET_CHAR_BIT); - offset += field->type ()->length (); - field++; + { + struct field &field2 = t->field (2); + field2.set_name ("type_info"); + field2.set_type (void_ptr_type); + field2.set_loc_bitpos (offset * TARGET_CHAR_BIT); + offset += field2.type ()->length (); + } /* void (*virtual_functions[0]) (); */ - field->set_name ("virtual_functions"); - field->set_type (lookup_array_range_type (ptr_to_void_fn_type, 0, -1)); - field->set_loc_bitpos (offset * TARGET_CHAR_BIT); - offset += field->type ()->length (); - field++; - - /* We assumed in the allocation above that there were four fields. */ - gdb_assert (field == (field_list + 4)); - - t = alloc.new_type (TYPE_CODE_STRUCT, offset * TARGET_CHAR_BIT, NULL); - t->set_num_fields (field - field_list); - t->set_fields (field_list); + { + struct field &field3 = t->field (3); + field3.set_name ("virtual_functions"); + field3.set_type (lookup_array_range_type (ptr_to_void_fn_type, 0, -1)); + field3.set_loc_bitpos (offset * TARGET_CHAR_BIT); + offset += field3.type ()->length (); + } + + t->set_length (offset); + t->set_name ("gdb_gnu_v3_abi_vtable"); INIT_CPLUS_SPECIFIC (t); @@ -1026,7 +1031,6 @@ static struct type * build_std_type_info_type (struct gdbarch *arch) { struct type *t; - struct field *field_list, *field; int offset; struct type *void_ptr_type = builtin_type (arch)->builtin_data_ptr; @@ -1035,30 +1039,32 @@ build_std_type_info_type (struct gdbarch *arch) struct type *char_ptr_type = make_pointer_type (make_cv_type (1, 0, char_type, NULL), NULL); - field_list = XCNEWVEC (struct field, 2); - field = &field_list[0]; + t = type_allocator (arch).new_type (TYPE_CODE_STRUCT, 0, nullptr); + + t->alloc_fields (2); + offset = 0; /* The vtable. */ - field->set_name ("_vptr.type_info"); - field->set_type (void_ptr_type); - field->set_loc_bitpos (offset * TARGET_CHAR_BIT); - offset += field->type ()->length (); - field++; + { + struct field &field0 = t->field (0); + field0.set_name ("_vptr.type_info"); + field0.set_type (void_ptr_type); + field0.set_loc_bitpos (offset * TARGET_CHAR_BIT); + offset += field0.type ()->length (); + } /* The name. */ - field->set_name ("__name"); - field->set_type (char_ptr_type); - field->set_loc_bitpos (offset * TARGET_CHAR_BIT); - offset += field->type ()->length (); - field++; - - gdb_assert (field == (field_list + 2)); - - t = type_allocator (arch).new_type (TYPE_CODE_STRUCT, - offset * TARGET_CHAR_BIT, nullptr); - t->set_num_fields (field - field_list); - t->set_fields (field_list); + { + struct field &field1 = t->field (1); + field1.set_name ("__name"); + field1.set_type (char_ptr_type); + field1.set_loc_bitpos (offset * TARGET_CHAR_BIT); + offset += field1.type ()->length (); + } + + t->set_length (offset); + t->set_name ("gdb_gnu_v3_type_info"); INIT_CPLUS_SPECIFIC (t); diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c index 40ebe6ae9c5..688501e157a 100644 --- a/gdb/mdebugread.c +++ b/gdb/mdebugread.c @@ -1034,9 +1034,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, t->set_code (type_code); t->set_length (sh->value); - t->set_num_fields (nfields); - f = ((struct field *) TYPE_ALLOC (t, nfields * sizeof (struct field))); - t->set_fields (f); + t->alloc_fields (nfields, false); if (type_code == TYPE_CODE_ENUM) { @@ -1197,10 +1195,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, if (nparams > 0) { - ftype->set_num_fields (nparams); - ftype->set_fields - ((struct field *) - TYPE_ALLOC (ftype, nparams * sizeof (struct field))); + ftype->alloc_fields (nparams, false); iparams = 0; for (struct symbol *sym : block_iterator_range (cblock)) diff --git a/gdb/rust-lang.c b/gdb/rust-lang.c index 0e2ca090ba8..cacfea86ab1 100644 --- a/gdb/rust-lang.c +++ b/gdb/rust-lang.c @@ -950,9 +950,7 @@ rust_composite_type (struct type *original, result->set_code (TYPE_CODE_STRUCT); result->set_name (name); - result->set_num_fields (nfields); - result->set_fields - ((struct field *) TYPE_ZALLOC (result, nfields * sizeof (struct field))); + result->alloc_fields (nfields); i = 0; bitpos = 0; diff --git a/gdb/stabsread.c b/gdb/stabsread.c index c3d87033f4f..c29d1c0d397 100644 --- a/gdb/stabsread.c +++ b/gdb/stabsread.c @@ -982,9 +982,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, } /* Allocate parameter information fields and fill them in. */ - ftype->set_fields - ((struct field *) - TYPE_ALLOC (ftype, nsemi * sizeof (struct field))); + ftype->alloc_fields (nsemi, false); while (*p++ == ';') { struct type *ptype; @@ -1826,10 +1824,7 @@ read_type (const char **pp, struct objfile *objfile) && arg_types->type->code () == TYPE_CODE_VOID) num_args = 0; - func_type->set_fields - ((struct field *) TYPE_ALLOC (func_type, - num_args * sizeof (struct field))); - memset (func_type->fields (), 0, num_args * sizeof (struct field)); + func_type->alloc_fields (num_args); { int i; struct type_list *t; @@ -3295,11 +3290,7 @@ attach_fields_to_type (struct stab_field_info *fip, struct type *type, non-public fields. Record the field count, allocate space for the array of fields, and create blank visibility bitfields if necessary. */ - type->set_num_fields (nfields); - type->set_fields - ((struct field *) - TYPE_ALLOC (type, sizeof (struct field) * nfields)); - memset (type->fields (), 0, sizeof (struct field) * nfields); + type->alloc_fields (nfields); if (non_public_fields) { @@ -3644,11 +3635,7 @@ read_enum_type (const char **pp, struct type *type, type->set_is_stub (false); if (unsigned_enum) type->set_is_unsigned (true); - type->set_num_fields (nsyms); - type->set_fields - ((struct field *) - TYPE_ALLOC (type, sizeof (struct field) * nsyms)); - memset (type->fields (), 0, sizeof (struct field) * nsyms); + type->alloc_fields (nsyms); /* Find the symbols for the values and put them into the type. The symbols can be found in the symlist that we put them on diff --git a/gdb/windows-tdep.c b/gdb/windows-tdep.c index bc1927049d8..0414aea6f1a 100644 --- a/gdb/windows-tdep.c +++ b/gdb/windows-tdep.c @@ -745,9 +745,7 @@ create_enum (struct gdbarch *gdbarch, int bit, const char *name, int i; type = type_allocator (gdbarch).new_type (TYPE_CODE_ENUM, bit, name); - type->set_num_fields (count); - type->set_fields - ((struct field *) TYPE_ZALLOC (type, sizeof (struct field) * count)); + type->alloc_fields (count); type->set_is_unsigned (true); for (i = 0; i < count; i++) -- 2.35.3