From patchwork Sun Jun 3 22:27:35 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Tromey X-Patchwork-Id: 27609 Received: (qmail 104462 invoked by alias); 3 Jun 2018 22:27:44 -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 104032 invoked by uid 89); 3 Jun 2018 22:27:43 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-24.4 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_STOCKGEN, SPF_HELO_PASS autolearn=ham version=3.3.2 spammy=entities, FULL, Quick, sk:get_sel X-HELO: gateway32.websitewelcome.com Received: from gateway32.websitewelcome.com (HELO gateway32.websitewelcome.com) (192.185.145.189) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sun, 03 Jun 2018 22:27:40 +0000 Received: from cm14.websitewelcome.com (cm14.websitewelcome.com [100.42.49.7]) by gateway32.websitewelcome.com (Postfix) with ESMTP id AA002DA7F7 for ; Sun, 3 Jun 2018 17:27:38 -0500 (CDT) Received: from box5379.bluehost.com ([162.241.216.53]) by cmsmtp with SMTP id PbTOfbk9qkBj6PbTOf5m3V; Sun, 03 Jun 2018 17:27:38 -0500 X-Authority-Reason: nr=8 Received: from 75-166-42-107.hlrn.qwest.net ([75.166.42.107]:35658 helo=bapiya.Home) by box5379.bluehost.com with esmtpsa (TLSv1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.91) (envelope-from ) id 1fPbTO-000mL3-1W; Sun, 03 Jun 2018 17:27:38 -0500 From: Tom Tromey To: gdb-patches@sourceware.org Cc: Tom Tromey Subject: [RFA] Remove last Ada cleanups Date: Sun, 3 Jun 2018 16:27:35 -0600 Message-Id: <20180603222735.19139-1-tom@tromey.com> X-BWhitelist: no X-Source-L: No X-Exim-ID: 1fPbTO-000mL3-1W X-Source-Sender: 75-166-42-107.hlrn.qwest.net (bapiya.Home) [75.166.42.107]:35658 X-Source-Auth: tom+tromey.com X-Email-Count: 1 X-Source-Cap: ZWx5bnJvYmk7ZWx5bnJvYmk7Ym94NTM3OS5ibHVlaG9zdC5jb20= X-Local-Domain: yes This removes the last cleanups from the Ada code by changing ada_lookup_symbol_list's out parameter to be a std::vector, and then fixing up the fallout. This is a relatively shallow change. Deeper changes are possible, for example (1) changing various other functions to accept a vector rather than a pointer, or (2) changing ada_lookup_symbol_list to return the vector and omitting the length entirely. Tested by the buildbot, but I'll wait for Joel to test these as well. gdb/ChangeLog 2018-06-03 Tom Tromey * ada-lang.h (ada_lookup_symbol_list): Update. * ada-lang.c (resolve_subexp): Update. (symbols_are_identical_enums): Change type of syms. Remove nsyms parameter. (remove_extra_symbols, remove_irrelevant_renamings): Likewise. (ada_lookup_symbol_list_worker, ada_lookup_symbol_list): Change results parameter to std::vector. (ada_iterate_over_symbols, ada_lookup_symbol, get_var_value): Update. * ada-exp.y (block_lookup): Update. (select_possible_type_sym): Change type of syms. Remove nsyms parameter. (write_var_or_type, write_name_assoc): Update. --- gdb/ChangeLog | 16 +++++ gdb/ada-exp.y | 39 +++--------- gdb/ada-lang.c | 194 ++++++++++++++++++++++++--------------------------------- gdb/ada-lang.h | 3 +- 4 files changed, 108 insertions(+), 144 deletions(-) diff --git a/gdb/ada-exp.y b/gdb/ada-exp.y index ac4c341bfe9..864f9bc754b 100644 --- a/gdb/ada-exp.y +++ b/gdb/ada-exp.y @@ -950,10 +950,9 @@ static const struct block* block_lookup (const struct block *context, const char *raw_name) { const char *name; - struct block_symbol *syms; + std::vector syms; int nsyms; struct symtab *symtab; - struct cleanup *old_chain; const struct block *result = NULL; if (raw_name[0] == '\'') @@ -965,7 +964,6 @@ block_lookup (const struct block *context, const char *raw_name) name = ada_encode (raw_name); nsyms = ada_lookup_symbol_list (name, context, VAR_DOMAIN, &syms); - old_chain = make_cleanup (xfree, syms); if (context == NULL && (nsyms == 0 || SYMBOL_CLASS (syms[0].symbol) != LOC_BLOCK)) @@ -989,19 +987,18 @@ block_lookup (const struct block *context, const char *raw_name) result = SYMBOL_BLOCK_VALUE (syms[0].symbol); } - do_cleanups (old_chain); return result; } static struct symbol* -select_possible_type_sym (struct block_symbol *syms, int nsyms) +select_possible_type_sym (const std::vector &syms) { int i; int preferred_index; struct type *preferred_type; preferred_index = -1; preferred_type = NULL; - for (i = 0; i < nsyms; i += 1) + for (i = 0; i < syms.size (); i += 1) switch (SYMBOL_CLASS (syms[i].symbol)) { case LOC_TYPEDEF: @@ -1204,7 +1201,6 @@ write_var_or_type (struct parser_state *par_state, int depth; char *encoded_name; int name_len; - struct cleanup *old_chain = make_cleanup (null_cleanup, NULL); if (block == NULL) block = expression_context_block; @@ -1221,7 +1217,7 @@ write_var_or_type (struct parser_state *par_state, while (tail_index > 0) { int nsyms; - struct block_symbol *syms; + std::vector syms; struct symbol *type_sym; struct symbol *renaming_sym; const char* renaming; @@ -1232,7 +1228,6 @@ write_var_or_type (struct parser_state *par_state, encoded_name[tail_index] = '\0'; nsyms = ada_lookup_symbol_list (encoded_name, block, VAR_DOMAIN, &syms); - make_cleanup (xfree, syms); encoded_name[tail_index] = terminator; /* A single symbol may rename a package or object. */ @@ -1248,7 +1243,7 @@ write_var_or_type (struct parser_state *par_state, syms[0].symbol = ren_sym; } - type_sym = select_possible_type_sym (syms, nsyms); + type_sym = select_possible_type_sym (syms); if (type_sym != NULL) renaming_sym = type_sym; @@ -1279,7 +1274,6 @@ write_var_or_type (struct parser_state *par_state, write_object_renaming (par_state, block, renaming, renaming_len, renaming_expr, MAX_RENAMING_CHAIN_LENGTH); write_selectors (par_state, encoded_name + tail_index); - do_cleanups (old_chain); return NULL; default: internal_error (__FILE__, __LINE__, @@ -1291,10 +1285,7 @@ write_var_or_type (struct parser_state *par_state, struct type *field_type; if (tail_index == name_len) - { - do_cleanups (old_chain); - return SYMBOL_TYPE (type_sym); - } + return SYMBOL_TYPE (type_sym); /* We have some extraneous characters after the type name. If this is an expression "TYPE_NAME.FIELD0.[...].FIELDN", @@ -1302,10 +1293,7 @@ write_var_or_type (struct parser_state *par_state, field_type = get_symbol_field_type (type_sym, encoded_name + tail_index); if (field_type != NULL) - { - do_cleanups (old_chain); - return field_type; - } + return field_type; else error (_("Invalid attempt to select from type: \"%s\"."), name0.ptr); @@ -1316,17 +1304,13 @@ write_var_or_type (struct parser_state *par_state, encoded_name); if (type != NULL) - { - do_cleanups (old_chain); - return type; - } + return type; } if (nsyms == 1) { write_var_from_sym (par_state, syms[0].block, syms[0].symbol); write_selectors (par_state, encoded_name + tail_index); - do_cleanups (old_chain); return NULL; } else if (nsyms == 0) @@ -1338,7 +1322,6 @@ write_var_or_type (struct parser_state *par_state, write_exp_msymbol (par_state, msym); /* Maybe cause error here rather than later? FIXME? */ write_selectors (par_state, encoded_name + tail_index); - do_cleanups (old_chain); return NULL; } @@ -1354,7 +1337,6 @@ write_var_or_type (struct parser_state *par_state, write_ambiguous_var (par_state, block, encoded_name, tail_index); write_selectors (par_state, encoded_name + tail_index); - do_cleanups (old_chain); return NULL; } } @@ -1393,17 +1375,14 @@ write_name_assoc (struct parser_state *par_state, struct stoken name) { if (strchr (name.ptr, '.') == NULL) { - struct block_symbol *syms; + std::vector syms; int nsyms = ada_lookup_symbol_list (name.ptr, expression_context_block, VAR_DOMAIN, &syms); - struct cleanup *old_chain = make_cleanup (xfree, syms); if (nsyms != 1 || SYMBOL_CLASS (syms[0].symbol) == LOC_TYPEDEF) write_exp_op_with_string (par_state, OP_NAME, name); else write_var_from_sym (par_state, syms[0].block, syms[0].symbol); - - do_cleanups (old_chain); } else if (write_var_or_type (par_state, NULL, name) != NULL) diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index 7d66a9ac550..b34efa919ea 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -3266,7 +3266,6 @@ resolve_subexp (expression_up *expp, int *pos, int deprocedure_p, struct value **argvec; /* Vector of operand types (alloca'ed). */ int nargs; /* Number of operands. */ int oplen; - struct cleanup *old_chain = make_cleanup (null_cleanup, NULL); argvec = NULL; nargs = 0; @@ -3431,7 +3430,7 @@ resolve_subexp (expression_up *expp, int *pos, int deprocedure_p, case OP_VAR_VALUE: if (SYMBOL_DOMAIN (exp->elts[pc + 2].symbol) == UNDEF_DOMAIN) { - struct block_symbol *candidates; + std::vector candidates; int n_candidates; n_candidates = @@ -3439,7 +3438,6 @@ resolve_subexp (expression_up *expp, int *pos, int deprocedure_p, (exp->elts[pc + 2].symbol), exp->elts[pc + 1].block, VAR_DOMAIN, &candidates); - make_cleanup (xfree, candidates); if (n_candidates > 1) { @@ -3483,10 +3481,10 @@ resolve_subexp (expression_up *expp, int *pos, int deprocedure_p, else if (n_candidates == 1) i = 0; else if (deprocedure_p - && !is_nonfunction (candidates, n_candidates)) + && !is_nonfunction (candidates.data (), n_candidates)) { i = ada_resolve_function - (candidates, n_candidates, NULL, 0, + (candidates.data (), n_candidates, NULL, 0, SYMBOL_LINKAGE_NAME (exp->elts[pc + 2].symbol), context_type); if (i < 0) @@ -3497,7 +3495,7 @@ resolve_subexp (expression_up *expp, int *pos, int deprocedure_p, { printf_filtered (_("Multiple matches for %s\n"), SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol)); - user_select_syms (candidates, n_candidates, 1); + user_select_syms (candidates.data (), n_candidates, 1); i = 0; } @@ -3522,7 +3520,7 @@ resolve_subexp (expression_up *expp, int *pos, int deprocedure_p, if (exp->elts[pc + 3].opcode == OP_VAR_VALUE && SYMBOL_DOMAIN (exp->elts[pc + 5].symbol) == UNDEF_DOMAIN) { - struct block_symbol *candidates; + std::vector candidates; int n_candidates; n_candidates = @@ -3530,14 +3528,13 @@ resolve_subexp (expression_up *expp, int *pos, int deprocedure_p, (exp->elts[pc + 5].symbol), exp->elts[pc + 4].block, VAR_DOMAIN, &candidates); - make_cleanup (xfree, candidates); if (n_candidates == 1) i = 0; else { i = ada_resolve_function - (candidates, n_candidates, + (candidates.data (), n_candidates, argvec, nargs, SYMBOL_LINKAGE_NAME (exp->elts[pc + 5].symbol), context_type); @@ -3575,17 +3572,16 @@ resolve_subexp (expression_up *expp, int *pos, int deprocedure_p, case UNOP_ABS: if (possible_user_operator_p (op, argvec)) { - struct block_symbol *candidates; + std::vector candidates; int n_candidates; n_candidates = ada_lookup_symbol_list (ada_decoded_op_name (op), (struct block *) NULL, VAR_DOMAIN, &candidates); - make_cleanup (xfree, candidates); - i = ada_resolve_function (candidates, n_candidates, argvec, nargs, - ada_decoded_op_name (op), NULL); + i = ada_resolve_function (candidates.data (), n_candidates, argvec, + nargs, ada_decoded_op_name (op), NULL); if (i < 0) break; @@ -3598,12 +3594,10 @@ resolve_subexp (expression_up *expp, int *pos, int deprocedure_p, case OP_TYPE: case OP_REGISTER: - do_cleanups (old_chain); return NULL; } *pos = pc; - do_cleanups (old_chain); if (exp->elts[pc].opcode == OP_VAR_MSYM_VALUE) return evaluate_var_msym_value (EVAL_AVOID_SIDE_EFFECTS, exp->elts[pc + 1].objfile, @@ -5049,7 +5043,7 @@ ada_identical_enum_types_p (struct type *type1, struct type *type2) So, for practical purposes, we consider them as the same. */ static int -symbols_are_identical_enums (struct block_symbol *syms, int nsyms) +symbols_are_identical_enums (const std::vector &syms) { int i; @@ -5061,17 +5055,17 @@ symbols_are_identical_enums (struct block_symbol *syms, int nsyms) (see ada_identical_enum_types_p). */ /* Quick check: All symbols should have an enum type. */ - for (i = 0; i < nsyms; i++) + for (i = 0; i < syms.size (); i++) if (TYPE_CODE (SYMBOL_TYPE (syms[i].symbol)) != TYPE_CODE_ENUM) return 0; /* Quick check: They should all have the same value. */ - for (i = 1; i < nsyms; i++) + for (i = 1; i < syms.size (); i++) if (SYMBOL_VALUE (syms[i].symbol) != SYMBOL_VALUE (syms[0].symbol)) return 0; /* Quick check: They should all have the same number of enumerals. */ - for (i = 1; i < nsyms; i++) + for (i = 1; i < syms.size (); i++) if (TYPE_NFIELDS (SYMBOL_TYPE (syms[i].symbol)) != TYPE_NFIELDS (SYMBOL_TYPE (syms[0].symbol))) return 0; @@ -5079,7 +5073,7 @@ symbols_are_identical_enums (struct block_symbol *syms, int nsyms) /* All the sanity checks passed, so we might have a set of identical enumeration types. Perform a more complete comparison of the type of each symbol. */ - for (i = 1; i < nsyms; i++) + for (i = 1; i < syms.size (); i++) if (!ada_identical_enum_types_p (SYMBOL_TYPE (syms[i].symbol), SYMBOL_TYPE (syms[0].symbol))) return 0; @@ -5087,7 +5081,7 @@ symbols_are_identical_enums (struct block_symbol *syms, int nsyms) return 1; } -/* Remove any non-debugging symbols in SYMS[0 .. NSYMS-1] that definitely +/* Remove any non-debugging symbols in SYMS that definitely duplicate other symbols in the list (The only case I know of where this happens is when object files containing stabs-in-ecoff are linked with files containing ordinary ecoff debugging symbols (or no @@ -5095,34 +5089,34 @@ symbols_are_identical_enums (struct block_symbol *syms, int nsyms) Returns the number of items in the modified list. */ static int -remove_extra_symbols (struct block_symbol *syms, int nsyms) +remove_extra_symbols (std::vector *syms) { int i, j; /* We should never be called with less than 2 symbols, as there cannot be any extra symbol in that case. But it's easy to handle, since we have nothing to do in that case. */ - if (nsyms < 2) - return nsyms; + if (syms->size () < 2) + return syms->size (); i = 0; - while (i < nsyms) + while (i < syms->size ()) { int remove_p = 0; /* If two symbols have the same name and one of them is a stub type, the get rid of the stub. */ - if (TYPE_STUB (SYMBOL_TYPE (syms[i].symbol)) - && SYMBOL_LINKAGE_NAME (syms[i].symbol) != NULL) + if (TYPE_STUB (SYMBOL_TYPE ((*syms)[i].symbol)) + && SYMBOL_LINKAGE_NAME ((*syms)[i].symbol) != NULL) { - for (j = 0; j < nsyms; j++) + for (j = 0; j < syms->size (); j++) { if (j != i - && !TYPE_STUB (SYMBOL_TYPE (syms[j].symbol)) - && SYMBOL_LINKAGE_NAME (syms[j].symbol) != NULL - && strcmp (SYMBOL_LINKAGE_NAME (syms[i].symbol), - SYMBOL_LINKAGE_NAME (syms[j].symbol)) == 0) + && !TYPE_STUB (SYMBOL_TYPE ((*syms)[j].symbol)) + && SYMBOL_LINKAGE_NAME ((*syms)[j].symbol) != NULL + && strcmp (SYMBOL_LINKAGE_NAME ((*syms)[i].symbol), + SYMBOL_LINKAGE_NAME ((*syms)[j].symbol)) == 0) remove_p = 1; } } @@ -5130,30 +5124,26 @@ remove_extra_symbols (struct block_symbol *syms, int nsyms) /* Two symbols with the same name, same class and same address should be identical. */ - else if (SYMBOL_LINKAGE_NAME (syms[i].symbol) != NULL - && SYMBOL_CLASS (syms[i].symbol) == LOC_STATIC - && is_nondebugging_type (SYMBOL_TYPE (syms[i].symbol))) + else if (SYMBOL_LINKAGE_NAME ((*syms)[i].symbol) != NULL + && SYMBOL_CLASS ((*syms)[i].symbol) == LOC_STATIC + && is_nondebugging_type (SYMBOL_TYPE ((*syms)[i].symbol))) { - for (j = 0; j < nsyms; j += 1) + for (j = 0; j < syms->size (); j += 1) { if (i != j - && SYMBOL_LINKAGE_NAME (syms[j].symbol) != NULL - && strcmp (SYMBOL_LINKAGE_NAME (syms[i].symbol), - SYMBOL_LINKAGE_NAME (syms[j].symbol)) == 0 - && SYMBOL_CLASS (syms[i].symbol) - == SYMBOL_CLASS (syms[j].symbol) - && SYMBOL_VALUE_ADDRESS (syms[i].symbol) - == SYMBOL_VALUE_ADDRESS (syms[j].symbol)) + && SYMBOL_LINKAGE_NAME ((*syms)[j].symbol) != NULL + && strcmp (SYMBOL_LINKAGE_NAME ((*syms)[i].symbol), + SYMBOL_LINKAGE_NAME ((*syms)[j].symbol)) == 0 + && SYMBOL_CLASS ((*syms)[i].symbol) + == SYMBOL_CLASS ((*syms)[j].symbol) + && SYMBOL_VALUE_ADDRESS ((*syms)[i].symbol) + == SYMBOL_VALUE_ADDRESS ((*syms)[j].symbol)) remove_p = 1; } } if (remove_p) - { - for (j = i + 1; j < nsyms; j += 1) - syms[j - 1] = syms[j]; - nsyms -= 1; - } + syms->erase (syms->begin () + i); i += 1; } @@ -5170,10 +5160,10 @@ remove_extra_symbols (struct block_symbol *syms, int nsyms) to ask the user to disambiguate anyways. And if we have to present a multiple-choice menu, it's less confusing if the list isn't missing some choices that were identical and yet distinct. */ - if (symbols_are_identical_enums (syms, nsyms)) - nsyms = 1; + if (symbols_are_identical_enums (*syms)) + syms->resize (1); - return nsyms; + return syms->size (); } /* Given a type that corresponds to a renaming entity, use the type name @@ -5301,8 +5291,8 @@ old_renaming_is_invisible (const struct symbol *sym, const char *function_name) the user will be unable to print such rename entities. */ static int -remove_irrelevant_renamings (struct block_symbol *syms, - int nsyms, const struct block *current_block) +remove_irrelevant_renamings (std::vector *syms, + const struct block *current_block) { struct symbol *current_function; const char *current_function_name; @@ -5313,10 +5303,10 @@ remove_irrelevant_renamings (struct block_symbol *syms, a simple variable foo in the same block, discard the latter. First, zero out such symbols, then compress. */ is_new_style_renaming = 0; - for (i = 0; i < nsyms; i += 1) + for (i = 0; i < syms->size (); i += 1) { - struct symbol *sym = syms[i].symbol; - const struct block *block = syms[i].block; + struct symbol *sym = (*syms)[i].symbol; + const struct block *block = (*syms)[i].block; const char *name; const char *suffix; @@ -5331,22 +5321,22 @@ remove_irrelevant_renamings (struct block_symbol *syms, int j; is_new_style_renaming = 1; - for (j = 0; j < nsyms; j += 1) - if (i != j && syms[j].symbol != NULL - && strncmp (name, SYMBOL_LINKAGE_NAME (syms[j].symbol), + for (j = 0; j < syms->size (); j += 1) + if (i != j && (*syms)[j].symbol != NULL + && strncmp (name, SYMBOL_LINKAGE_NAME ((*syms)[j].symbol), name_len) == 0 - && block == syms[j].block) - syms[j].symbol = NULL; + && block == (*syms)[j].block) + (*syms)[j].symbol = NULL; } } if (is_new_style_renaming) { int j, k; - for (j = k = 0; j < nsyms; j += 1) - if (syms[j].symbol != NULL) + for (j = k = 0; j < syms->size (); j += 1) + if ((*syms)[j].symbol != NULL) { - syms[k] = syms[j]; + (*syms)[k] = (*syms)[j]; k += 1; } return k; @@ -5356,38 +5346,33 @@ remove_irrelevant_renamings (struct block_symbol *syms, Abort if unable to do so. */ if (current_block == NULL) - return nsyms; + return syms->size (); current_function = block_linkage_function (current_block); if (current_function == NULL) - return nsyms; + return syms->size (); current_function_name = SYMBOL_LINKAGE_NAME (current_function); if (current_function_name == NULL) - return nsyms; + return syms->size (); /* Check each of the symbols, and remove it from the list if it is a type corresponding to a renaming that is out of the scope of the current block. */ i = 0; - while (i < nsyms) + while (i < syms->size ()) { - if (ada_parse_renaming (syms[i].symbol, NULL, NULL, NULL) + if (ada_parse_renaming ((*syms)[i].symbol, NULL, NULL, NULL) == ADA_OBJECT_RENAMING - && old_renaming_is_invisible (syms[i].symbol, current_function_name)) - { - int j; - - for (j = i + 1; j < nsyms; j += 1) - syms[j - 1] = syms[j]; - nsyms -= 1; - } + && old_renaming_is_invisible ((*syms)[i].symbol, + current_function_name)) + syms->erase (syms->begin () + i); else i += 1; } - return nsyms; + return syms->size (); } /* Add to OBSTACKP all symbols from BLOCK (and its super-blocks) @@ -5779,10 +5764,9 @@ ada_add_all_symbols (struct obstack *obstackp, /* Find symbols in DOMAIN matching LOOKUP_NAME, in BLOCK and, if FULL_SEARCH is non-zero, enclosing scope and in global scopes, returning the number of matches. - Sets *RESULTS to point to a newly allocated vector of (SYM,BLOCK) tuples, - indicating the symbols found and the blocks and symbol tables (if - any) in which they were found. This vector should be freed when - no longer useful. + Fills *RESULTS with (SYM,BLOCK) tuples, indicating the symbols + found and the blocks and symbol tables (if any) in which they were + found. When full_search is non-zero, any non-function/non-enumeral symbol match within the nest of blocks whose innermost member is BLOCK, @@ -5797,7 +5781,7 @@ static int ada_lookup_symbol_list_worker (const lookup_name_info &lookup_name, const struct block *block, domain_enum domain, - struct block_symbol **results, + std::vector *results, int full_search) { int syms_from_global_search; @@ -5810,11 +5794,11 @@ ada_lookup_symbol_list_worker (const lookup_name_info &lookup_name, ndefns = num_defns_collected (&obstack); - results_size = obstack_object_size (&obstack); - *results = (struct block_symbol *) malloc (results_size); - memcpy (*results, defns_collected (&obstack, 1), results_size); + struct block_symbol *base = defns_collected (&obstack, 1); + for (int i = 0; i < ndefns; ++i) + results->push_back (base[i]); - ndefns = remove_extra_symbols (*results, ndefns); + ndefns = remove_extra_symbols (results); if (ndefns == 0 && full_search && syms_from_global_search) cache_symbol (ada_lookup_name (lookup_name), domain, NULL, NULL); @@ -5823,21 +5807,21 @@ ada_lookup_symbol_list_worker (const lookup_name_info &lookup_name, cache_symbol (ada_lookup_name (lookup_name), domain, (*results)[0].symbol, (*results)[0].block); - ndefns = remove_irrelevant_renamings (*results, ndefns, block); + ndefns = remove_irrelevant_renamings (results, block); return ndefns; } /* Find symbols in DOMAIN matching NAME, in BLOCK and enclosing scope and - in global scopes, returning the number of matches, and setting *RESULTS - to a newly-allocated vector of (SYM,BLOCK) tuples. This newly-allocated - vector should be freed when no longer useful. + in global scopes, returning the number of matches, and filling *RESULTS + with (SYM,BLOCK) tuples. See ada_lookup_symbol_list_worker for further details. */ int ada_lookup_symbol_list (const char *name, const struct block *block, - domain_enum domain, struct block_symbol **results) + domain_enum domain, + std::vector *results) { symbol_name_match_type name_match_type = name_match_type_from_name (name); lookup_name_info lookup_name (name, name_match_type); @@ -5854,19 +5838,15 @@ ada_iterate_over_symbols gdb::function_view callback) { int ndefs, i; - struct block_symbol *results; - struct cleanup *old_chain; + std::vector results; ndefs = ada_lookup_symbol_list_worker (name, block, domain, &results, 0); - old_chain = make_cleanup (xfree, results); for (i = 0; i < ndefs; ++i) { if (!callback (results[i].symbol)) break; } - - do_cleanups (old_chain); } /* The result is as for ada_lookup_symbol_list with FULL_SEARCH set @@ -5906,24 +5886,16 @@ ada_lookup_symbol (const char *name, const struct block *block0, if (is_a_field_of_this != NULL) *is_a_field_of_this = 0; - struct block_symbol *candidates; + std::vector candidates; int n_candidates; - struct cleanup *old_chain; n_candidates = ada_lookup_symbol_list (name, block0, domain, &candidates); - old_chain = make_cleanup (xfree, candidates); if (n_candidates == 0) - { - do_cleanups (old_chain); - return {}; - } + return {}; block_symbol info = candidates[0]; info.symbol = fixup_symbol_section (info.symbol, NULL); - - do_cleanups (old_chain); - return info; } @@ -11766,24 +11738,20 @@ get_var_value (const char *name, const char *err_msg) { lookup_name_info lookup_name (name, symbol_name_match_type::FULL); - struct block_symbol *syms; + std::vector syms; int nsyms = ada_lookup_symbol_list_worker (lookup_name, get_selected_block (0), VAR_DOMAIN, &syms, 1); - struct cleanup *old_chain = make_cleanup (xfree, syms); if (nsyms != 1) { - do_cleanups (old_chain); if (err_msg == NULL) return 0; else error (("%s"), err_msg); } - struct value *result = value_of_variable (syms[0].symbol, syms[0].block); - do_cleanups (old_chain); - return result; + return value_of_variable (syms[0].symbol, syms[0].block); } /* Value of integer variable named NAME in the current environment. diff --git a/gdb/ada-lang.h b/gdb/ada-lang.h index a4192fc8a5a..8e7bd50cd2b 100644 --- a/gdb/ada-lang.h +++ b/gdb/ada-lang.h @@ -232,7 +232,8 @@ extern const char *ada_decode (const char*); extern enum language ada_update_initial_language (enum language); extern int ada_lookup_symbol_list (const char *, const struct block *, - domain_enum, struct block_symbol**); + domain_enum, + std::vector *); extern char *ada_fold_name (const char *);