From patchwork Thu Jul 13 15:31:59 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Pedro Alves X-Patchwork-Id: 21592 Received: (qmail 111425 invoked by alias); 13 Jul 2017 15:32:19 -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 111299 invoked by uid 89); 13 Jul 2017 15:32:18 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-26.8 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_STOCKGEN, RP_MATCHES_RCVD, SPF_HELO_PASS autolearn=ham version=3.3.2 spammy= X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 13 Jul 2017 15:32:15 +0000 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id E517DC060208 for ; Thu, 13 Jul 2017 15:32:13 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mx1.redhat.com E517DC060208 Authentication-Results: ext-mx08.extmail.prod.ext.phx2.redhat.com; dmarc=none (p=none dis=none) header.from=redhat.com Authentication-Results: ext-mx08.extmail.prod.ext.phx2.redhat.com; spf=pass smtp.mailfrom=palves@redhat.com DKIM-Filter: OpenDKIM Filter v2.11.0 mx1.redhat.com E517DC060208 Received: from cascais.lan (ovpn04.gateway.prod.ext.ams2.redhat.com [10.39.146.4]) by smtp.corp.redhat.com (Postfix) with ESMTP id 48F384DA78 for ; Thu, 13 Jul 2017 15:32:13 +0000 (UTC) From: Pedro Alves To: gdb-patches@sourceware.org Subject: [PATCH v2 03/13] Introduce OP_VAR_MSYM_VALUE Date: Thu, 13 Jul 2017 16:31:59 +0100 Message-Id: <1499959929-29497-4-git-send-email-palves@redhat.com> In-Reply-To: <1499959929-29497-1-git-send-email-palves@redhat.com> References: <1499959929-29497-1-git-send-email-palves@redhat.com> The previous patch left GDB with an inconsistency. While with normal expression evaluation the "unknown return type" error shows the name of the function that misses debug info: (gdb) p getenv ("PATH") 'getenv' has unknown return type; cast the call to its declared return type ^^^^^^ which can by handy in more complicated expressions, "ptype" does not: (gdb) ptype getenv ("PATH") function has unknown return type; cast the call to its declared return type ^^^^^^^^ This commit is a step toward fixing it. The problem is that while evaluating the expression above, we have no reference to the minimal symbol where we could extract the name from. This is because the resulting expression tree has no reference to the minsym at all. During parsing, the type and address of the minsym are extracted and an UNOP_MEMVAL / UNOP_MEMVAL_TLS operator is generated (see write_exp_elt_msym). With "set debug expression", here's what you see: 0 OP_FUNCALL Number of args: 0 3 UNOP_MEMVAL Type @0x565334a51930 () 6 OP_LONG Type @0x565334a51c60 (__CORE_ADDR), value 140737345035648 (0x7ffff7751d80) The "print" case finds the function name, because call_function_by_hand looks up the function by address again. However, for "ptype", we don't reach that code, because obviously we don't really call the function. Unlike minsym references, references to variables with debug info have a pointer to the variable's symbol in the expression tree, with OP_VAR_VALUE: (gdb) ptype main() ... 0 OP_FUNCALL Number of args: 0 3 OP_VAR_VALUE Block @0x0, symbol @0x559bbbd9b358 (main(int, char**)) ... so I don't see why do minsyms need to be different. So to prepare for fixing the missing function name issue, this commit adds a new OP_VAR_MSYM_VALUE operator that mimics OP_VAR_VALUE, except that it's for minsyms instead of debug symbols. For infcalls, we now get expressions like these: 0 OP_FUNCALL Number of args: 0 3 OP_VAR_MSYM_VALUE Objfile @0x1e41bf0, msymbol @0x7fffe599b000 (getenv) In the following patch, we'll make OP_FUNCALL extract the function name from the symbol stored in OP_VAR_VALUE/OP_VAR_MSYM_VALUE. OP_VAR_MSYM_VALUE will be used more in a later patch in the series too. gdb/ChangeLog: yyyy-dd-yy Pedro Alves * ada-lang.c (resolve_subexp): Handle OP_VAR_MSYM_VALUE. * ax-gdb.c (gen_msym_var_ref): New function. (gen_expr): Handle OP_VAR_MSYM_VALUE. * eval.c (evaluate_var_msym_value): New function. * eval.c (evaluate_subexp_standard): Handle OP_VAR_MSYM_VALUE. : Extract function name from symbol/minsym and pass it to call_function_by_hand. * expprint.c (print_subexp_standard, dump_subexp_body_standard): Handle OP_VAR_MSYM_VALUE. (union exp_element) : New field. * minsyms.h (struct type): Forward declare. (find_minsym_type_and_address): Declare. * parse.c (write_exp_elt_msym): New function. (write_exp_msymbol): Delete, refactored as ... (find_minsym_type_and_address): ... this new function. (write_exp_msymbol): Reimplement using OP_VAR_MSYM_VALUE. (operator_length_standard, operator_check_standard): Handle OP_VAR_MSYM_VALUE. * std-operator.def (OP_VAR_MSYM_VALUE): New. --- gdb/ada-lang.c | 1 + gdb/ax-gdb.c | 22 ++++++++++++++ gdb/eval.c | 24 ++++++++++++++++ gdb/expprint.c | 16 +++++++++++ gdb/expression.h | 1 + gdb/minsyms.h | 9 ++++++ gdb/parse.c | 81 +++++++++++++++++++++++++++++++--------------------- gdb/std-operator.def | 6 ++++ 8 files changed, 128 insertions(+), 32 deletions(-) diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index 77c5866..d4dde83 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -3387,6 +3387,7 @@ resolve_subexp (struct expression **expp, int *pos, int deprocedure_p, case OP_LONG: case OP_DOUBLE: case OP_VAR_VALUE: + case OP_VAR_MSYM_VALUE: *pos += 4; break; diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c index fae2e2d..70e7980 100644 --- a/gdb/ax-gdb.c +++ b/gdb/ax-gdb.c @@ -742,6 +742,23 @@ gen_var_ref (struct gdbarch *gdbarch, struct agent_expr *ax, break; } } + +/* Generate code for a minimal symbol variable reference to AX. The + variable is the symbol MINSYM, of OBJFILE. Set VALUE to describe + the result. */ + +static void +gen_msym_var_ref (agent_expr *ax, axs_value *value, + minimal_symbol *msymbol, objfile *objf) +{ + CORE_ADDR address; + type *t = find_minsym_type_and_address (msymbol, objf, &address); + value->type = t; + value->optimized_out = false; + ax_const_l (ax, address); + value->kind = axs_lvalue_memory; +} + @@ -1987,6 +2004,11 @@ gen_expr (struct expression *exp, union exp_element **pc, (*pc) += 4; break; + case OP_VAR_MSYM_VALUE: + gen_msym_var_ref (ax, value, (*pc)[2].msymbol, (*pc)[1].objfile); + (*pc) += 4; + break; + case OP_REGISTER: { const char *name = &(*pc)[2].string; diff --git a/gdb/eval.c b/gdb/eval.c index 1ec6751..457e280 100644 --- a/gdb/eval.c +++ b/gdb/eval.c @@ -676,6 +676,25 @@ make_params (int num_types, struct type **param_types) return type; } +/* Helper for evaluating an OP_VAR_MSYM_VALUE. */ + +static value * +evaluate_var_msym_value (enum noside noside, + struct objfile *objfile, minimal_symbol *msymbol) +{ + if (noside == EVAL_AVOID_SIDE_EFFECTS) + { + type *the_type = find_minsym_type_and_address (msymbol, objfile, NULL); + return value_zero (the_type, not_lval); + } + else + { + CORE_ADDR address; + type *the_type = find_minsym_type_and_address (msymbol, objfile, &address); + return value_at_lazy (the_type, address); + } +} + struct value * evaluate_subexp_standard (struct type *expect_type, struct expression *exp, int *pos, @@ -766,6 +785,11 @@ evaluate_subexp_standard (struct type *expect_type, return ret; } + case OP_VAR_MSYM_VALUE: + (*pos) += 3; + return evaluate_var_msym_value (noside, + exp->elts[pc + 1].objfile, + exp->elts[pc + 2].msymbol); case OP_VAR_ENTRY_VALUE: (*pos) += 2; diff --git a/gdb/expprint.c b/gdb/expprint.c index 9b8ac4c..4939c01 100644 --- a/gdb/expprint.c +++ b/gdb/expprint.c @@ -134,6 +134,13 @@ print_subexp_standard (struct expression *exp, int *pos, } return; + case OP_VAR_MSYM_VALUE: + { + (*pos) += 3; + fputs_filtered (MSYMBOL_PRINT_NAME (exp->elts[pc + 2].msymbol), stream); + } + return; + case OP_VAR_ENTRY_VALUE: { (*pos) += 2; @@ -876,6 +883,15 @@ dump_subexp_body_standard (struct expression *exp, SYMBOL_PRINT_NAME (exp->elts[elt + 1].symbol)); elt += 3; break; + case OP_VAR_MSYM_VALUE: + fprintf_filtered (stream, "Objfile @"); + gdb_print_host_address (exp->elts[elt].objfile, stream); + fprintf_filtered (stream, ", msymbol @"); + gdb_print_host_address (exp->elts[elt + 1].msymbol, stream); + fprintf_filtered (stream, " (%s)", + MSYMBOL_PRINT_NAME (exp->elts[elt + 1].msymbol)); + elt += 3; + break; case OP_VAR_ENTRY_VALUE: fprintf_filtered (stream, "Entry value of symbol @"); gdb_print_host_address (exp->elts[elt].symbol, stream); diff --git a/gdb/expression.h b/gdb/expression.h index 8fe6b07..9e4ddf5 100644 --- a/gdb/expression.h +++ b/gdb/expression.h @@ -64,6 +64,7 @@ union exp_element { enum exp_opcode opcode; struct symbol *symbol; + struct minimal_symbol *msymbol; LONGEST longconst; DOUBLEST doubleconst; gdb_byte decfloatconst[16]; diff --git a/gdb/minsyms.h b/gdb/minsyms.h index e763f62..dc51725 100644 --- a/gdb/minsyms.h +++ b/gdb/minsyms.h @@ -20,6 +20,8 @@ #ifndef MINSYMS_H #define MINSYMS_H +struct type; + /* Several lookup functions return both a minimal symbol and the objfile in which it is found. This structure is used in these cases. */ @@ -275,4 +277,11 @@ void iterate_over_minimal_symbols (struct objfile *objf, CORE_ADDR minimal_symbol_upper_bound (struct bound_minimal_symbol minsym); +/* Return the type of MSYMBOL, a minimal symbol of OBJFILE. If + ADDRESS_P is not NULL, set it to the MSYMBOL's resolved + address. */ + +type *find_minsym_type_and_address (minimal_symbol *msymbol, objfile *objf, + CORE_ADDR *address_p); + #endif /* MINSYMS_H */ diff --git a/gdb/parse.c b/gdb/parse.c index 3dd7075..4889c1a 100644 --- a/gdb/parse.c +++ b/gdb/parse.c @@ -255,6 +255,16 @@ write_exp_elt_sym (struct parser_state *ps, struct symbol *expelt) } void +write_exp_elt_msym (struct parser_state *ps, minimal_symbol *expelt) +{ + union exp_element tmp; + + memset (&tmp, 0, sizeof (union exp_element)); + tmp.msymbol = expelt; + write_exp_elt (ps, &tmp); +} + +void write_exp_elt_block (struct parser_state *ps, const struct block *b) { union exp_element tmp; @@ -469,17 +479,17 @@ write_exp_bitstring (struct parser_state *ps, struct stoken str) write_exp_elt_longcst (ps, (LONGEST) bits); } -/* Add the appropriate elements for a minimal symbol to the end of - the expression. */ +/* Return the type of MSYMBOL, a minimal symbol of OBJFILE. If + ADDRESS_P is not NULL, set it to the MSYMBOL's resolved + address. */ -void -write_exp_msymbol (struct parser_state *ps, - struct bound_minimal_symbol bound_msym) +type * +find_minsym_type_and_address (minimal_symbol *msymbol, + struct objfile *objfile, + CORE_ADDR *address_p) { - struct minimal_symbol *msymbol = bound_msym.minsym; - struct objfile *objfile = bound_msym.objfile; + bound_minimal_symbol bound_msym = {msymbol, objfile}; struct gdbarch *gdbarch = get_objfile_arch (objfile); - CORE_ADDR addr = BMSYMBOL_VALUE_ADDRESS (bound_msym); struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol); enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol); @@ -514,51 +524,54 @@ write_exp_msymbol (struct parser_state *ps, if (overlay_debugging) addr = symbol_overlayed_address (addr, section); - write_exp_elt_opcode (ps, OP_LONG); - /* Let's make the type big enough to hold a 64-bit address. */ - write_exp_elt_type (ps, objfile_type (objfile)->builtin_core_addr); - write_exp_elt_longcst (ps, (LONGEST) addr); - write_exp_elt_opcode (ps, OP_LONG); - if (section && section->the_bfd_section->flags & SEC_THREAD_LOCAL) { - write_exp_elt_opcode (ps, UNOP_MEMVAL_TLS); - write_exp_elt_objfile (ps, objfile); - write_exp_elt_type (ps, objfile_type (objfile)->nodebug_tls_symbol); - write_exp_elt_opcode (ps, UNOP_MEMVAL_TLS); - return; + /* Skip translation if caller does not need the address. */ + if (address_p != NULL) + *address_p = target_translate_tls_address (objfile, addr); + return objfile_type (objfile)->nodebug_tls_symbol; } - write_exp_elt_opcode (ps, UNOP_MEMVAL); + if (address_p != NULL) + *address_p = addr; + + struct type *the_type; + switch (type) { case mst_text: case mst_file_text: case mst_solib_trampoline: - write_exp_elt_type (ps, objfile_type (objfile)->nodebug_text_symbol); - break; + return objfile_type (objfile)->nodebug_text_symbol; case mst_text_gnu_ifunc: - write_exp_elt_type (ps, objfile_type (objfile) - ->nodebug_text_gnu_ifunc_symbol); - break; + return objfile_type (objfile)->nodebug_text_gnu_ifunc_symbol; case mst_data: case mst_file_data: case mst_bss: case mst_file_bss: - write_exp_elt_type (ps, objfile_type (objfile)->nodebug_data_symbol); - break; + return objfile_type (objfile)->nodebug_data_symbol; case mst_slot_got_plt: - write_exp_elt_type (ps, objfile_type (objfile)->nodebug_got_plt_symbol); - break; + return objfile_type (objfile)->nodebug_got_plt_symbol; default: - write_exp_elt_type (ps, objfile_type (objfile)->nodebug_unknown_symbol); - break; + return objfile_type (objfile)->nodebug_unknown_symbol; } - write_exp_elt_opcode (ps, UNOP_MEMVAL); +} + +/* Add the appropriate elements for a minimal symbol to the end of + the expression. */ + +void +write_exp_msymbol (struct parser_state *ps, + struct bound_minimal_symbol bound_msym) +{ + write_exp_elt_opcode (ps, OP_VAR_MSYM_VALUE); + write_exp_elt_objfile (ps, bound_msym.objfile); + write_exp_elt_msym (ps, bound_msym.minsym); + write_exp_elt_opcode (ps, OP_VAR_MSYM_VALUE); } /* Mark the current index as the starting location of a structure @@ -883,6 +896,7 @@ operator_length_standard (const struct expression *expr, int endpos, case OP_DOUBLE: case OP_DECFLOAT: case OP_VAR_VALUE: + case OP_VAR_MSYM_VALUE: oplen = 4; break; @@ -1844,6 +1858,9 @@ operator_check_standard (struct expression *exp, int pos, type = SYMBOL_TYPE (symbol); } break; + case OP_VAR_MSYM_VALUE: + objfile = elts[pos + 1].objfile; + break; } /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL. */ diff --git a/gdb/std-operator.def b/gdb/std-operator.def index 4650726..9007dd4 100644 --- a/gdb/std-operator.def +++ b/gdb/std-operator.def @@ -132,6 +132,12 @@ OP (OP_VAR_VALUE) current function. Implemented via DW_OP_entry_value. */ OP (OP_VAR_ENTRY_VALUE) +/* OP_VAR_MSYM_VALUE takes one struct objfile * in the following + element, and one struct minimal_symbol * in the following + exp_element, followed by another OP_VAR_MSYM_VALUE, making four + exp_elements. */ +OP (OP_VAR_MSYM_VALUE) + /* OP_LAST is followed by an integer in the next exp_element. The integer is zero for the last value printed, or it is the absolute number of a history element.