From patchwork Sun Mar 11 05:19:59 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Tromey X-Patchwork-Id: 26277 Received: (qmail 29430 invoked by alias); 11 Mar 2018 05:20:12 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 29284 invoked by uid 89); 11 Mar 2018 05:20:06 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-25.7 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, RCVD_IN_DNSWL_NONE, SPF_HELO_PASS autolearn=ham version=3.3.2 spammy= X-HELO: gateway34.websitewelcome.com Received: from gateway34.websitewelcome.com (HELO gateway34.websitewelcome.com) (192.185.149.77) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sun, 11 Mar 2018 05:20:04 +0000 Received: from cm13.websitewelcome.com (cm13.websitewelcome.com [100.42.49.6]) by gateway34.websitewelcome.com (Postfix) with ESMTP id B6D7E210C8A for ; Sat, 10 Mar 2018 23:20:02 -0600 (CST) Received: from box5379.bluehost.com ([162.241.216.53]) by cmsmtp with SMTP id utOseA2rmQUwqutOse2sqf; Sat, 10 Mar 2018 23:20:02 -0600 Received: from 174-29-60-18.hlrn.qwest.net ([174.29.60.18]:34876 helo=bapiya.Home) by box5379.bluehost.com with esmtpsa (TLSv1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.89) (envelope-from ) id 1eutOs-001lC8-Dq; Sat, 10 Mar 2018 23:20:02 -0600 From: Tom Tromey To: gdb-patches@sourceware.org Cc: Tom Tromey Subject: [RFA 2/2] Use std::vector for field lists in dwarf2read.c Date: Sat, 10 Mar 2018 22:19:59 -0700 Message-Id: <20180311051959.17114-3-tom@tromey.com> In-Reply-To: <20180311051959.17114-1-tom@tromey.com> References: <20180311051959.17114-1-tom@tromey.com> X-BWhitelist: no X-Source-L: No X-Exim-ID: 1eutOs-001lC8-Dq X-Source-Sender: 174-29-60-18.hlrn.qwest.net (bapiya.Home) [174.29.60.18]:34876 X-Source-Auth: tom+tromey.com X-Email-Count: 4 X-Source-Cap: ZWx5bnJvYmk7ZWx5bnJvYmk7Ym94NTM3OS5ibHVlaG9zdC5jb20= X-Local-Domain: yes This changes dwarf2read.c to use std::vector rather than a linked list when managing the fields and base classes to be added to a type. This removes some bookkeeping types and also allows the removal of some cleanups. gdb/ChangeLog 2018-03-10 Tom Tromey * dwarf2read.c (struct nextfield): Add initializers. (struct nextfnfield): Remove. (struct fnfieldlist): Add initializers. Remove "length" and "head", use std::vector. (struct decl_field_list): Remove. (struct field_info): Add initializers. : Now std::vector. : Remove. (dwarf2_add_field, dwarf2_add_type_defn) (dwarf2_attach_fields_to_type, dwarf2_add_member_fn) (dwarf2_attach_fn_fields_to_type, handle_struct_member_die) (process_structure_scope): Update. --- gdb/ChangeLog | 16 ++++ gdb/dwarf2read.c | 287 ++++++++++++++++++------------------------------------- 2 files changed, 111 insertions(+), 192 deletions(-) diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index bbeb76ca70..4323d09d14 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -1725,31 +1725,17 @@ struct variant_field struct nextfield { - struct nextfield *next; - int accessibility; - int virtuality; + int accessibility = 0; + int virtuality = 0; /* Extra information to describe a variant or variant part. */ - struct variant_field variant; - struct field field; -}; - -struct nextfnfield -{ - struct nextfnfield *next; - struct fn_field fnfield; + struct variant_field variant {}; + struct field field {}; }; struct fnfieldlist { - const char *name; - int length; - struct nextfnfield *head; -}; - -struct decl_field_list -{ - struct decl_field field; - struct decl_field_list *next; + const char *name = nullptr; + std::vector fnfields; }; /* The routines that read and process dies for a C struct or C++ class @@ -1758,34 +1744,27 @@ struct decl_field_list struct field_info { /* List of data member and baseclasses fields. */ - struct nextfield *fields, *baseclasses; + std::vector fields; + std::vector baseclasses; /* Number of fields (including baseclasses). */ - int nfields; - - /* Number of baseclasses. */ - int nbaseclasses; + int nfields = 0; /* Set if the accesibility of one of the fields is not public. */ - int non_public_fields; + int non_public_fields = 0; /* Member function fieldlist array, contains name of possibly overloaded member function, number of overloaded member functions and a pointer to the head of the member function field chain. */ - struct fnfieldlist *fnfieldlists; - - /* Number of entries in the fnfieldlists array. */ - int nfnfields; + std::vector fnfieldlists; /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */ - struct decl_field_list *typedef_field_list; - unsigned typedef_field_list_count; + std::vector typedef_field_list; /* Nested types defined by this class and the number of elements in this list. */ - struct decl_field_list *nested_types_list; - unsigned nested_types_list_count; + std::vector nested_types_list; }; /* One item on the queue of compilation units to read in full symbols @@ -15475,43 +15454,35 @@ dwarf2_add_field (struct field_info *fip, struct die_info *die, { struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile; struct gdbarch *gdbarch = get_objfile_arch (objfile); - struct nextfield *new_field; struct attribute *attr; struct field *fp; const char *fieldname = ""; - /* Allocate a new field list entry and link it in. */ - new_field = XNEW (struct nextfield); - make_cleanup (xfree, new_field); - memset (new_field, 0, sizeof (struct nextfield)); - if (die->tag == DW_TAG_inheritance) - { - new_field->next = fip->baseclasses; - fip->baseclasses = new_field; - } + fip->baseclasses.emplace_back (); else - { - new_field->next = fip->fields; - fip->fields = new_field; - } + fip->fields.emplace_back (); + struct nextfield &new_field + = ((die->tag == DW_TAG_inheritance) + ? fip->baseclasses : fip->fields).back (); + fip->nfields++; attr = dwarf2_attr (die, DW_AT_accessibility, cu); if (attr) - new_field->accessibility = DW_UNSND (attr); + new_field.accessibility = DW_UNSND (attr); else - new_field->accessibility = dwarf2_default_access_attribute (die, cu); - if (new_field->accessibility != DW_ACCESS_public) + new_field.accessibility = dwarf2_default_access_attribute (die, cu); + if (new_field.accessibility != DW_ACCESS_public) fip->non_public_fields = 1; attr = dwarf2_attr (die, DW_AT_virtuality, cu); if (attr) - new_field->virtuality = DW_UNSND (attr); + new_field.virtuality = DW_UNSND (attr); else - new_field->virtuality = DW_VIRTUALITY_none; + new_field.virtuality = DW_VIRTUALITY_none; - fp = &new_field->field; + fp = &new_field.field; if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu)) { @@ -15602,7 +15573,7 @@ dwarf2_add_field (struct field_info *fip, struct die_info *die, if (dwarf2_attr (die, DW_AT_artificial, cu)) { FIELD_ARTIFICIAL (*fp) = 1; - new_field->accessibility = DW_ACCESS_private; + new_field.accessibility = DW_ACCESS_private; fip->non_public_fields = 1; } } @@ -15654,7 +15625,6 @@ dwarf2_add_field (struct field_info *fip, struct die_info *die, FIELD_BITSIZE (*fp) = 0; FIELD_TYPE (*fp) = die_type (die, cu); FIELD_NAME (*fp) = type_name_no_tag (fp->type); - fip->nbaseclasses++; } else if (die->tag == DW_TAG_variant_part) { @@ -15697,20 +15667,14 @@ static void dwarf2_add_type_defn (struct field_info *fip, struct die_info *die, struct dwarf2_cu *cu) { - struct decl_field_list *new_field; - struct decl_field *fp; - - /* Allocate a new field list entry and link it in. */ - new_field = XCNEW (struct decl_field_list); - make_cleanup (xfree, new_field); + struct decl_field fp; + memset (&fp, 0, sizeof (fp)); gdb_assert (type_can_define_types (die)); - fp = &new_field->field; - /* Get name of field. NULL is okay here, meaning an anonymous type. */ - fp->name = dwarf2_name (die, cu); - fp->type = read_type_die (die, cu); + fp.name = dwarf2_name (die, cu); + fp.type = read_type_die (die, cu); /* Save accessibility. */ enum dwarf_access_attribute accessibility; @@ -15725,10 +15689,10 @@ dwarf2_add_type_defn (struct field_info *fip, struct die_info *die, /* The assumed value if neither private nor protected. */ break; case DW_ACCESS_private: - fp->is_private = 1; + fp.is_private = 1; break; case DW_ACCESS_protected: - fp->is_protected = 1; + fp.is_protected = 1; break; default: complaint (&symfile_complaints, @@ -15736,17 +15700,9 @@ dwarf2_add_type_defn (struct field_info *fip, struct die_info *die, } if (die->tag == DW_TAG_typedef) - { - new_field->next = fip->typedef_field_list; - fip->typedef_field_list = new_field; - fip->typedef_field_list_count++; - } + fip->typedef_field_list.push_back (fp); else - { - new_field->next = fip->nested_types_list; - fip->nested_types_list = new_field; - fip->nested_types_list_count++; - } + fip->nested_types_list.push_back (fp); } /* Create the vector of fields, and attach it to the type. */ @@ -15761,8 +15717,7 @@ dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type, and create blank accessibility bitfields if necessary. */ TYPE_NFIELDS (type) = nfields; TYPE_FIELDS (type) = (struct field *) - TYPE_ALLOC (type, sizeof (struct field) * nfields); - memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields); + TYPE_ZALLOC (type, sizeof (struct field) * nfields); if (fip->non_public_fields && cu->language != language_ada) { @@ -15783,68 +15738,53 @@ dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type, /* If the type has baseclasses, allocate and clear a bit vector for TYPE_FIELD_VIRTUAL_BITS. */ - if (fip->nbaseclasses && cu->language != language_ada) + if (!fip->baseclasses.empty () && cu->language != language_ada) { - int num_bytes = B_BYTES (fip->nbaseclasses); + int num_bytes = B_BYTES (fip->baseclasses.size ()); unsigned char *pointer; ALLOCATE_CPLUS_STRUCT_TYPE (type); pointer = (unsigned char *) TYPE_ALLOC (type, num_bytes); TYPE_FIELD_VIRTUAL_BITS (type) = pointer; - B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses); - TYPE_N_BASECLASSES (type) = fip->nbaseclasses; + B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->baseclasses.size ()); + TYPE_N_BASECLASSES (type) = fip->baseclasses.size (); } if (TYPE_FLAG_DISCRIMINATED_UNION (type)) { struct discriminant_info *di = alloc_discriminant_info (type, -1, -1); - int index = nfields - 1; - struct nextfield *field = fip->fields; - - while (index >= 0) + for (int index = 0; index < nfields; ++index) { - if (field->variant.is_discriminant) + struct nextfield &field = fip->fields[index]; + + if (field.variant.is_discriminant) di->discriminant_index = index; - else if (field->variant.default_branch) + else if (field.variant.default_branch) di->default_index = index; else - di->discriminants[index] = field->variant.discriminant_value; - - --index; - field = field->next; + di->discriminants[index] = field.variant.discriminant_value; } } - /* Copy the saved-up fields into the field vector. Start from the head of - the list, adding to the tail of the field array, so that they end up in - the same order in the array in which they were added to the list. */ - while (nfields-- > 0) + /* Copy the saved-up fields into the field vector. */ + for (int i = 0; i < nfields; ++i) { - struct nextfield *fieldp; + struct nextfield &field + = ((i < fip->baseclasses.size ()) ? fip->baseclasses[i] + : fip->fields[i - fip->baseclasses.size ()]); - if (fip->fields) - { - fieldp = fip->fields; - fip->fields = fieldp->next; - } - else - { - fieldp = fip->baseclasses; - fip->baseclasses = fieldp->next; - } - - TYPE_FIELD (type, nfields) = fieldp->field; - switch (fieldp->accessibility) + TYPE_FIELD (type, i) = field.field; + switch (field.accessibility) { case DW_ACCESS_private: if (cu->language != language_ada) - SET_TYPE_FIELD_PRIVATE (type, nfields); + SET_TYPE_FIELD_PRIVATE (type, i); break; case DW_ACCESS_protected: if (cu->language != language_ada) - SET_TYPE_FIELD_PROTECTED (type, nfields); + SET_TYPE_FIELD_PROTECTED (type, i); break; case DW_ACCESS_public: @@ -15854,19 +15794,19 @@ dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type, /* Unknown accessibility. Complain and treat it as public. */ { complaint (&symfile_complaints, _("unsupported accessibility %d"), - fieldp->accessibility); + field.accessibility); } break; } - if (nfields < fip->nbaseclasses) + if (i < fip->baseclasses.size ()) { - switch (fieldp->virtuality) + switch (field.virtuality) { case DW_VIRTUALITY_virtual: case DW_VIRTUALITY_pure_virtual: if (cu->language == language_ada) error (_("unexpected virtuality in component of Ada type")); - SET_TYPE_FIELD_VIRTUAL (type, nfields); + SET_TYPE_FIELD_VIRTUAL (type, i); break; } } @@ -15909,11 +15849,10 @@ dwarf2_add_member_fn (struct field_info *fip, struct die_info *die, { struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile; struct attribute *attr; - struct fnfieldlist *flp; int i; + struct fnfieldlist *flp = nullptr; struct fn_field *fnp; const char *fieldname; - struct nextfnfield *new_fnfield; struct type *this_type; enum dwarf_access_attribute accessibility; @@ -15926,49 +15865,33 @@ dwarf2_add_member_fn (struct field_info *fip, struct die_info *die, return; /* Look up member function name in fieldlist. */ - for (i = 0; i < fip->nfnfields; i++) + for (i = 0; i < fip->fnfieldlists.size (); i++) { if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0) - break; + { + flp = &fip->fnfieldlists[i]; + break; + } } /* Create new list element if necessary. */ - if (i < fip->nfnfields) - flp = &fip->fnfieldlists[i]; - else + if (flp == nullptr) { - if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0) - { - fip->fnfieldlists = (struct fnfieldlist *) - xrealloc (fip->fnfieldlists, - (fip->nfnfields + DW_FIELD_ALLOC_CHUNK) - * sizeof (struct fnfieldlist)); - if (fip->nfnfields == 0) - make_cleanup (free_current_contents, &fip->fnfieldlists); - } - flp = &fip->fnfieldlists[fip->nfnfields]; + fip->fnfieldlists.emplace_back (); + flp = &fip->fnfieldlists.back (); flp->name = fieldname; - flp->length = 0; - flp->head = NULL; - i = fip->nfnfields++; + i = fip->fnfieldlists.size () - 1; } /* Create a new member function field and chain it to the field list entry. */ - new_fnfield = XNEW (struct nextfnfield); - make_cleanup (xfree, new_fnfield); - memset (new_fnfield, 0, sizeof (struct nextfnfield)); - new_fnfield->next = flp->head; - flp->head = new_fnfield; - flp->length++; - - /* Fill in the member function field info. */ - fnp = &new_fnfield->fnfield; + flp->fnfields.emplace_back (); + fnp = &flp->fnfields.back (); /* Delay processing of the physname until later. */ if (cu->language == language_cplus) { - add_to_method_list (type, i, flp->length - 1, fieldname, + add_to_method_list (type, i, flp->fnfields.size () - 1, fieldname, die, cu); } else @@ -16117,7 +16040,6 @@ static void dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type, struct dwarf2_cu *cu) { - struct fnfieldlist *flp; int i; if (cu->language == language_ada) @@ -16125,23 +16047,25 @@ dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type, ALLOCATE_CPLUS_STRUCT_TYPE (type); TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *) - TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields); + TYPE_ALLOC (type, + sizeof (struct fn_fieldlist) * fip->fnfieldlists.size ()); - for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++) + for (i = 0; i < fip->fnfieldlists.size (); i++) { - struct nextfnfield *nfp = flp->head; + struct fnfieldlist &nf = fip->fnfieldlists[i]; struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i); int k; - TYPE_FN_FIELDLIST_NAME (type, i) = flp->name; - TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length; + TYPE_FN_FIELDLIST_NAME (type, i) = nf.name; + TYPE_FN_FIELDLIST_LENGTH (type, i) = nf.fnfields.size (); fn_flp->fn_fields = (struct fn_field *) - TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length); - for (k = flp->length; (k--, nfp); nfp = nfp->next) - fn_flp->fn_fields[k] = nfp->fnfield; + TYPE_ALLOC (type, sizeof (struct fn_field) * nf.fnfields.size ()); + + for (k = 0; k < nf.fnfields.size (); ++k) + fn_flp->fn_fields[k] = nf.fnfields[k]; } - TYPE_NFN_FIELDS (type) = fip->nfnfields; + TYPE_NFN_FIELDS (type) = fip->fnfieldlists.size (); } /* Returns non-zero if NAME is the name of a vtable member in CU's @@ -16419,11 +16343,11 @@ handle_struct_member_die (struct die_info *child_die, struct type *type, /* The first field was just added, so we can stash the discriminant there. */ - gdb_assert (fi->fields != NULL); + gdb_assert (!fi->fields.empty ()); if (discr == NULL) - fi->fields->variant.default_branch = true; + fi->fields.back ().variant.default_branch = true; else - fi->fields->variant.discriminant_value = DW_UNSND (discr); + fi->fields.back ().variant.discriminant_value = DW_UNSND (discr); } } @@ -16478,9 +16402,6 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) { struct field_info fi; std::vector template_args; - struct cleanup *back_to = make_cleanup (null_cleanup, 0); - - memset (&fi, 0, sizeof (struct field_info)); child_die = die->child; @@ -16489,7 +16410,7 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) handle_struct_member_die (child_die, type, &fi, &template_args, cu); if (is_variant_part && discr_offset == child_die->sect_off) - fi.fields->variant.is_discriminant = true; + fi.fields.back ().variant.is_discriminant = true; child_die = sibling_die (child_die); } @@ -16512,7 +16433,7 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) /* Attach fields and member functions to the type. */ if (fi.nfields) dwarf2_attach_fields_to_type (&fi, type, cu); - if (fi.nfnfields) + if (!fi.fnfieldlists.empty ()) { dwarf2_attach_fn_fields_to_type (&fi, type, cu); @@ -16582,9 +16503,9 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) /* Copy fi.typedef_field_list linked list elements content into the allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */ - if (fi.typedef_field_list) + if (!fi.typedef_field_list.empty ()) { - int i = fi.typedef_field_list_count; + int i = fi.typedef_field_list.size (); ALLOCATE_CPLUS_STRUCT_TYPE (type); TYPE_TYPEDEF_FIELD_ARRAY (type) @@ -16592,23 +16513,15 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) TYPE_ALLOC (type, sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * i)); TYPE_TYPEDEF_FIELD_COUNT (type) = i; - /* Reverse the list order to keep the debug info elements order. */ - while (--i >= 0) - { - struct decl_field *dest, *src; - - dest = &TYPE_TYPEDEF_FIELD (type, i); - src = &fi.typedef_field_list->field; - fi.typedef_field_list = fi.typedef_field_list->next; - *dest = *src; - } + for (i = 0; i < fi.typedef_field_list.size (); ++i) + TYPE_TYPEDEF_FIELD (type, i) = fi.typedef_field_list[i]; } /* Copy fi.nested_types_list linked list elements content into the allocated array TYPE_NESTED_TYPES_ARRAY (type). */ - if (fi.nested_types_list != NULL && cu->language != language_ada) + if (!fi.nested_types_list.empty () && cu->language != language_ada) { - int i = fi.nested_types_list_count; + int i = fi.nested_types_list.size (); ALLOCATE_CPLUS_STRUCT_TYPE (type); TYPE_NESTED_TYPES_ARRAY (type) @@ -16616,19 +16529,9 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) TYPE_ALLOC (type, sizeof (struct decl_field) * i)); TYPE_NESTED_TYPES_COUNT (type) = i; - /* Reverse the list order to keep the debug info elements order. */ - while (--i >= 0) - { - struct decl_field *dest, *src; - - dest = &TYPE_NESTED_TYPES_FIELD (type, i); - src = &fi.nested_types_list->field; - fi.nested_types_list = fi.nested_types_list->next; - *dest = *src; - } + for (i = 0; i < fi.nested_types_list.size (); ++i) + TYPE_NESTED_TYPES_FIELD (type, i) = fi.nested_types_list[i]; } - - do_cleanups (back_to); } quirk_gcc_member_function_pointer (type, objfile);