From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 2621 invoked by alias); 4 Jun 2016 14:49:58 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Received: (qmail 2505 invoked by uid 89); 4 Jun 2016 14:49:58 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=0.0 required=5.0 tests=AWL,BAYES_00,FSL_HELO_HOME,KAM_STOCKGEN,RCVD_IN_DNSWL_NONE,SPF_PASS,T_FILL_THIS_FORM_SHORT autolearn=no version=3.3.2 spammy=symbol's, shame, routing, Assembly X-HELO: gproxy5-pub.mail.unifiedlayer.com Received: from gproxy5-pub.mail.unifiedlayer.com (HELO gproxy5-pub.mail.unifiedlayer.com) (67.222.38.55) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with SMTP; Sat, 04 Jun 2016 14:49:38 +0000 Received: (qmail 27796 invoked by uid 0); 4 Jun 2016 14:49:36 -0000 Received: from unknown (HELO cmgw2) (10.0.90.83) by gproxy5.mail.unifiedlayer.com with SMTP; 4 Jun 2016 14:49:36 -0000 Received: from box522.bluehost.com ([74.220.219.122]) by cmgw2 with id 2epX1t00X2f2jeq01epal7; Sat, 04 Jun 2016 08:49:34 -0600 X-Authority-Analysis: v=2.1 cv=ff4+lSgF c=1 sm=1 tr=0 a=GsOEXm/OWkKvwdLVJsfwcA==:117 a=GsOEXm/OWkKvwdLVJsfwcA==:17 a=L9H7d07YOLsA:10 a=9cW_t1CCXrUA:10 a=s5jvgZ67dGcA:10 a=PnD2wP_eR3oA:10 a=-N9Dh3nx2ZYA:10 a=pD_ry4oyNxEA:10 a=zstS-IiYAAAA:8 a=TrhYz7kbIYecxKsE8_YA:9 a=4G6NA9xxw8l3yy4pmD5M:22 Received: from [65.128.48.199] (port=36208 helo=bapiya.Home) by box522.bluehost.com with esmtpsa (TLSv1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.86_2) (envelope-from ) id 1b9CtI-0005Fy-Uy; Sat, 04 Jun 2016 08:49:33 -0600 From: Tom Tromey To: gdb-patches@sourceware.org Cc: Tom Tromey Subject: [RFA 3/3] Move logic out of symbol_find_demangled_name Date: Sat, 04 Jun 2016 14:49:00 -0000 Message-Id: <1465051760-25840-4-git-send-email-tom@tromey.com> In-Reply-To: <1465051760-25840-1-git-send-email-tom@tromey.com> References: <1465051760-25840-1-git-send-email-tom@tromey.com> X-Identified-User: {36111:box522.bluehost.com:elynrobi:tromey.com} {sentby:smtp auth 65.128.48.199 authed with tom+tromey.com} X-Exim-ID: 1b9CtI-0005Fy-Uy X-Source-Sender: (bapiya.Home) [65.128.48.199]:36208 X-Source-Auth: tom+tromey.com X-Email-Count: 0 X-Source-Cap: ZWx5bnJvYmk7ZWx5bnJvYmk7Ym94NTIyLmJsdWVob3N0LmNvbQ== X-SW-Source: 2016-06/txt/msg00076.txt.bz2 This patch moves most of the demangling logic out of symbol_find_demangled_name into the various language_defn objects. The simplest way to do this seemed to be to add a new method to language_defn. This is shame given the existing la_demangle, but given Ada's unusual needs, and the differing demangling options between languages, la_demangle didn't seem to fit. In order to make this work, I made enum language order-sensitive. This helps preserve the current ordering of demangling operations. I'm not especially fond of the new name, "la_demangle_for_symbol". 2016-06-04 Tom Tromey * symtab.c (symbol_find_demangled_name): Loop over languages and use language_demangle_for_symbol. * rust-lang.c (exp_descriptor_rust): New function. (rust_language_defn): Update. * p-lang.c (pascal_language_defn): Update. * opencl-lang.c (opencl_language_defn): Update. * objc-lang.c (objc_demangle_for_symbol): New function. (objc_language_defn): Update. * m2-lang.c (m2_language_defn): Update. * language.h (struct language_defn) : New field. (language_demangle_for_symbol): Declare. * language.c (language_demangle_for_symbol): New function. (unknown_language_defn, auto_language_defn, local_language_defn): Update. * jv-lang.c (java_demangle_for_symbol): New function. (java_language_defn): Use it. * go-lang.c (go_demangle_for_symbol): New function. (go_language_defn): Use it. * f-lang.c (f_language_defn): Update. * defs.h (enum language): Reorder. * d-lang.c (d_demangle_for_symbol): New function. (d_language_defn): Use it. * cp-support.h (gdb_demangle_for_symbol): Declare. * cp-support.c (gdb_demangle_for_symbol): New function. * c-lang.c (c_language_defn, cplus_language_defn) (asm_language_defn, minimal_language_defn): Update. * ada-lang.c (ada_demangle_for_symbol): New function. (ada_language_defn): Use it. --- gdb/ChangeLog | 32 ++++++++++++++++ gdb/ada-lang.c | 38 +++++++++++++++++++ gdb/c-lang.c | 4 ++ gdb/cp-support.c | 8 ++++ gdb/cp-support.h | 4 ++ gdb/d-lang.c | 9 +++++ gdb/defs.h | 11 ++++-- gdb/f-lang.c | 7 ++++ gdb/go-lang.c | 9 +++++ gdb/jv-lang.c | 9 +++++ gdb/language.c | 18 +++++++++ gdb/language.h | 20 ++++++++++ gdb/m2-lang.c | 1 + gdb/objc-lang.c | 9 +++++ gdb/opencl-lang.c | 1 + gdb/p-lang.c | 1 + gdb/rust-lang.c | 12 ++++++ gdb/symtab.c | 107 +++++++----------------------------------------------- 18 files changed, 203 insertions(+), 97 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index b58ccde..264355a 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,5 +1,37 @@ 2016-06-04 Tom Tromey + * symtab.c (symbol_find_demangled_name): Loop over languages and + use language_demangle_for_symbol. + * rust-lang.c (exp_descriptor_rust): New function. + (rust_language_defn): Update. + * p-lang.c (pascal_language_defn): Update. + * opencl-lang.c (opencl_language_defn): Update. + * objc-lang.c (objc_demangle_for_symbol): New function. + (objc_language_defn): Update. + * m2-lang.c (m2_language_defn): Update. + * language.h (struct language_defn) : New + field. + (language_demangle_for_symbol): Declare. + * language.c (language_demangle_for_symbol): New function. + (unknown_language_defn, auto_language_defn, local_language_defn): + Update. + * jv-lang.c (java_demangle_for_symbol): New function. + (java_language_defn): Use it. + * go-lang.c (go_demangle_for_symbol): New function. + (go_language_defn): Use it. + * f-lang.c (f_language_defn): Update. + * defs.h (enum language): Reorder. + * d-lang.c (d_demangle_for_symbol): New function. + (d_language_defn): Use it. + * cp-support.h (gdb_demangle_for_symbol): Declare. + * cp-support.c (gdb_demangle_for_symbol): New function. + * c-lang.c (c_language_defn, cplus_language_defn) + (asm_language_defn, minimal_language_defn): Update. + * ada-lang.c (ada_demangle_for_symbol): New function. + (ada_language_defn): Use it. + +2016-06-04 Tom Tromey + * ada-lang.c (ada_extensions): New array. (ada_language_defn): Use it. * c-lang.c (c_extensions): New array. diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index e3f236f..62a7050 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -1452,6 +1452,43 @@ ada_la_decode (const char *encoded, int options) return xstrdup (ada_decode (encoded)); } +/* Implement la_demangle_for_symbol for Ada. */ + +static char * +ada_demangle_for_symbol (const char *mangled, int *recognized) +{ + const char *demangled = ada_decode (mangled); + + if (demangled != mangled && demangled != NULL && demangled[0] != '<') + { + /* Set the gsymbol language to Ada, but still return NULL. + Two reasons for that: + + 1. For Ada, we prefer computing the symbol's decoded name + on the fly rather than pre-compute it, in order to save + memory (Ada projects are typically very large). + + 2. There are some areas in the definition of the GNAT + encoding where, with a bit of bad luck, we might be able + to decode a non-Ada symbol, generating an incorrect + demangled name (Eg: names ending with "TB" for instance + are identified as task bodies and so stripped from + the decoded name returned). + + Returning NULL, here, helps us get a little bit of + the best of both worlds. Because we're last, we should + not affect any of the other languages that were able to + demangle the symbol before us; we get to correctly tag + Ada symbols as such; and even if we incorrectly tagged + a non-Ada symbol, which should be rare, any routing + through the Ada language should be transparent (Ada + tries to behave much like C/C++ with non-Ada symbols). */ + *recognized = 1; + } + + return NULL; +} + /* Returns non-zero iff SYM_NAME matches NAME, ignoring any trailing suffixes that encode debugging information or leading _ada_ on SYM_NAME (see is_name_suffix commentary for the debugging @@ -14077,6 +14114,7 @@ const struct language_defn ada_language_defn = { ada_lookup_symbol_nonlocal, /* Looking up non-local symbols. */ basic_lookup_transparent_type, /* lookup_transparent_type */ ada_la_decode, /* Language specific symbol demangler */ + ada_demangle_for_symbol, NULL, /* Language specific class_name_from_physname */ ada_op_print_tab, /* expression operators for printing */ diff --git a/gdb/c-lang.c b/gdb/c-lang.c index 9ccb87f..a733754 100644 --- a/gdb/c-lang.c +++ b/gdb/c-lang.c @@ -856,6 +856,7 @@ const struct language_defn c_language_defn = basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ basic_lookup_transparent_type,/* lookup_transparent_type */ NULL, /* Language specific symbol demangler */ + NULL, NULL, /* Language specific class_name_from_physname */ c_op_print_tab, /* expression operators for printing */ @@ -989,6 +990,7 @@ const struct language_defn cplus_language_defn = cp_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ cp_lookup_transparent_type, /* lookup_transparent_type */ gdb_demangle, /* Language specific symbol demangler */ + gdb_demangle_for_symbol, cp_class_name_from_physname, /* Language specific class_name_from_physname */ c_op_print_tab, /* expression operators for printing */ @@ -1040,6 +1042,7 @@ const struct language_defn asm_language_defn = basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ basic_lookup_transparent_type,/* lookup_transparent_type */ NULL, /* Language specific symbol demangler */ + NULL, NULL, /* Language specific class_name_from_physname */ c_op_print_tab, /* expression operators for printing */ @@ -1091,6 +1094,7 @@ const struct language_defn minimal_language_defn = basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ basic_lookup_transparent_type,/* lookup_transparent_type */ NULL, /* Language specific symbol demangler */ + NULL, NULL, /* Language specific class_name_from_physname */ c_op_print_tab, /* expression operators for printing */ diff --git a/gdb/cp-support.c b/gdb/cp-support.c index 5662f86..c799216 100644 --- a/gdb/cp-support.c +++ b/gdb/cp-support.c @@ -1627,6 +1627,14 @@ gdb_demangle (const char *name, int options) return result; } +/* See cp-support.h. */ + +char * +gdb_demangle_for_symbol (const char *mangled, int *recognized) +{ + return gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI); +} + /* Don't allow just "maintenance cplus". */ static void diff --git a/gdb/cp-support.h b/gdb/cp-support.h index 78749c8..7c675d7 100644 --- a/gdb/cp-support.h +++ b/gdb/cp-support.h @@ -158,4 +158,8 @@ extern struct cmd_list_element *maint_cplus_cmd_list; char *gdb_demangle (const char *name, int options); +/* Like gdb_demangle, but suitable for use as la_demangle_for_symbol. */ + +char *gdb_demangle_for_symbol (const char *mangled, int *recognized); + #endif /* CP_SUPPORT_H */ diff --git a/gdb/d-lang.c b/gdb/d-lang.c index b25136d..21d379e 100644 --- a/gdb/d-lang.c +++ b/gdb/d-lang.c @@ -55,6 +55,14 @@ d_demangle (const char *symbol, int options) return gdb_demangle (symbol, options | DMGL_DLANG); } +/* la_demangle_for_symbol implementation for D. */ + +static char * +d_demangle_for_symbol (const char *mangled, int *recognized) +{ + return d_demangle (mangled, 0); +} + /* Table mapping opcodes into strings for printing operators and precedences of the operators. */ static const struct op_print d_op_print_tab[] = @@ -223,6 +231,7 @@ static const struct language_defn d_language_defn = d_lookup_symbol_nonlocal, basic_lookup_transparent_type, d_demangle, /* Language specific symbol demangler. */ + d_demangle_for_symbol, NULL, /* Language specific class_name_from_physname. */ d_op_print_tab, /* Expression operators for printing. */ diff --git a/gdb/defs.h b/gdb/defs.h index ed51396..15d3805 100644 --- a/gdb/defs.h +++ b/gdb/defs.h @@ -194,26 +194,29 @@ extern void quit_serial_event_clear (void); /* * Languages represented in the symbol table and elsewhere. This should probably be in language.h, but since enum's can't be forward declared to satisfy opaque references before their - actual definition, needs to be here. */ + actual definition, needs to be here. + + The constants here are in priority order. In particular, + demangling is attempted according to this order. */ enum language { language_unknown, /* Language not known */ language_auto, /* Placeholder for automatic setting */ language_c, /* C */ + language_objc, /* Objective-C */ language_cplus, /* C++ */ + language_java, /* Java */ language_d, /* D */ language_go, /* Go */ - language_objc, /* Objective-C */ - language_java, /* Java */ language_fortran, /* Fortran */ language_m2, /* Modula-2 */ language_asm, /* Assembly language */ language_pascal, /* Pascal */ - language_ada, /* Ada */ language_opencl, /* OpenCL */ language_rust, /* Rust */ language_minimal, /* All other languages, minimal support only */ + language_ada, /* Ada */ nr_languages }; diff --git a/gdb/f-lang.c b/gdb/f-lang.c index 719083b..58f58dd 100644 --- a/gdb/f-lang.c +++ b/gdb/f-lang.c @@ -268,7 +268,14 @@ const struct language_defn f_language_defn = NULL, /* name_of_this */ cp_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ basic_lookup_transparent_type,/* lookup_transparent_type */ + + /* We could support demangling here to provide module namespaces + also for inferiors with only minimal symbol table (ELF symbols). + Just the mangling standard is not standardized across compilers + and there is no DW_AT_producer available for inferiors with only + the ELF symbols to check the mangling kind. */ NULL, /* Language specific symbol demangler */ + NULL, NULL, /* Language specific class_name_from_physname */ f_op_print_tab, /* expression operators for printing */ diff --git a/gdb/go-lang.c b/gdb/go-lang.c index 15ca78b..152cf87 100644 --- a/gdb/go-lang.c +++ b/gdb/go-lang.c @@ -385,6 +385,14 @@ go_demangle (const char *mangled_name, int options) return result; } +/* la_demangle_for_symbol for Go. */ + +static char * +go_demangle_for_symbol (const char *mangled, int *recognized) +{ + return go_demangle (mangled, 0); +} + /* Given a Go symbol, return its package or NULL if unknown. Space for the result is malloc'd, caller must free. */ @@ -584,6 +592,7 @@ static const struct language_defn go_language_defn = basic_lookup_symbol_nonlocal, basic_lookup_transparent_type, go_demangle, /* Language specific symbol demangler. */ + go_demangle_for_symbol, NULL, /* Language specific class_name_from_physname. */ go_op_print_tab, /* Expression operators for printing. */ diff --git a/gdb/jv-lang.c b/gdb/jv-lang.c index 797a7f0..b3f998d 100644 --- a/gdb/jv-lang.c +++ b/gdb/jv-lang.c @@ -1018,6 +1018,14 @@ static char *java_demangle (const char *mangled, int options) return gdb_demangle (mangled, options | DMGL_JAVA); } +/* la_demangle_for_symbol for Java. */ + +static char * +java_demangle_for_symbol (const char *mangled, int *recognized) +{ + return java_demangle (mangled, DMGL_PARAMS | DMGL_ANSI); +} + /* Find the member function name of the demangled name NAME. NAME must be a method name including arguments, in order to correctly locate the last component. @@ -1194,6 +1202,7 @@ const struct language_defn java_language_defn = basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ basic_lookup_transparent_type,/* lookup_transparent_type */ java_demangle, /* Language specific symbol demangler */ + java_demangle_for_symbol, java_class_name_from_physname,/* Language specific class name */ java_op_print_tab, /* expression operators for printing */ 0, /* not c-style arrays */ diff --git a/gdb/language.c b/gdb/language.c index 02e21ca..48faca7 100644 --- a/gdb/language.c +++ b/gdb/language.c @@ -663,6 +663,21 @@ language_demangle (const struct language_defn *current_language, return NULL; } +/* See langauge.h. */ + +char * +language_demangle_for_symbol (const struct language_defn *lang, + const char *mangled, int *recognized) +{ + gdb_assert (lang != NULL); + + *recognized = 0; + if (lang->la_demangle_for_symbol == NULL) + return NULL; + + return lang->la_demangle_for_symbol (mangled, recognized); +} + /* Return class name from physname or NULL. */ char * language_class_name_from_physname (const struct language_defn *lang, @@ -843,6 +858,7 @@ const struct language_defn unknown_language_defn = basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ basic_lookup_transparent_type,/* lookup_transparent_type */ unk_lang_demangle, /* Language specific symbol demangler */ + NULL, unk_lang_class_name, /* Language specific class_name_from_physname */ unk_op_print_tab, /* expression operators for printing */ @@ -891,6 +907,7 @@ const struct language_defn auto_language_defn = basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ basic_lookup_transparent_type,/* lookup_transparent_type */ unk_lang_demangle, /* Language specific symbol demangler */ + NULL, unk_lang_class_name, /* Language specific class_name_from_physname */ unk_op_print_tab, /* expression operators for printing */ @@ -937,6 +954,7 @@ const struct language_defn local_language_defn = basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ basic_lookup_transparent_type,/* lookup_transparent_type */ unk_lang_demangle, /* Language specific symbol demangler */ + NULL, unk_lang_class_name, /* Language specific class_name_from_physname */ unk_op_print_tab, /* expression operators for printing */ diff --git a/gdb/language.h b/gdb/language.h index d57c60e..f6ffe88 100644 --- a/gdb/language.h +++ b/gdb/language.h @@ -292,6 +292,19 @@ struct language_defn /* Return demangled language symbol, or NULL. */ char *(*la_demangle) (const char *mangled, int options); + /* Demangle a symbol according to this language's rules. Unlike + la_demangle, this does not take any options. The return value + should either be NULL if the name cannot be demangled, or an + xmalloc'd string, to be owned by the caller. + + If this function returns non-NULL, then it can be assumed that + MANGLED represents a mangled symbol for this language. If this + function returns NULL, then normally the converse is true, but + RECOGNIZED can be set to 1 to override this. + + RECOGNIZED must be initialized to 0 by the caller. */ + char *(*la_demangle_for_symbol) (const char *mangled, int *recognized); + /* Return class name of a mangled method name or NULL. */ char *(*la_class_name_from_physname) (const char *physname); @@ -565,6 +578,13 @@ extern CORE_ADDR skip_language_trampoline (struct frame_info *, CORE_ADDR pc); extern char *language_demangle (const struct language_defn *current_language, const char *mangled, int options); +/* A wrapper for la_demangle_for_symbol that initializes RECOGNIZED + first. The arguments and result are as for the method. */ + +extern char *language_demangle_for_symbol (const struct language_defn *lang, + const char *mangled, + int *recognized); + /* Return class name from physname, or NULL. */ extern char *language_class_name_from_physname (const struct language_defn *, const char *physname); diff --git a/gdb/m2-lang.c b/gdb/m2-lang.c index 4626bfc..67d0f6b 100644 --- a/gdb/m2-lang.c +++ b/gdb/m2-lang.c @@ -381,6 +381,7 @@ const struct language_defn m2_language_defn = basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ basic_lookup_transparent_type,/* lookup_transparent_type */ NULL, /* Language specific symbol demangler */ + NULL, NULL, /* Language specific class_name_from_physname */ m2_op_print_tab, /* expression operators for printing */ diff --git a/gdb/objc-lang.c b/gdb/objc-lang.c index fe3e082..5abfc13 100644 --- a/gdb/objc-lang.c +++ b/gdb/objc-lang.c @@ -281,6 +281,14 @@ objc_demangle (const char *mangled, int options) return NULL; /* Not an objc mangled name. */ } +/* la_demangle_for_symbol for ObjC. */ + +static char * +objc_demangle_for_symbol (const char *mangled, int *recognized) +{ + return objc_demangle (mangled, 0); +} + /* Determine if we are currently in the Objective-C dispatch function. If so, get the address of the method function that the dispatcher would call and use that as the function to step into instead. Also @@ -381,6 +389,7 @@ const struct language_defn objc_language_defn = { basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ basic_lookup_transparent_type,/* lookup_transparent_type */ objc_demangle, /* Language specific symbol demangler */ + objc_demangle_for_symbol, NULL, /* Language specific class_name_from_physname */ objc_op_print_tab, /* Expression operators for printing */ diff --git a/gdb/opencl-lang.c b/gdb/opencl-lang.c index 74651bc..2a46d86 100644 --- a/gdb/opencl-lang.c +++ b/gdb/opencl-lang.c @@ -1070,6 +1070,7 @@ const struct language_defn opencl_language_defn = basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ basic_lookup_transparent_type,/* lookup_transparent_type */ NULL, /* Language specific symbol demangler */ + NULL, NULL, /* Language specific class_name_from_physname */ c_op_print_tab, /* expression operators for printing */ diff --git a/gdb/p-lang.c b/gdb/p-lang.c index 0897be2..86e787b 100644 --- a/gdb/p-lang.c +++ b/gdb/p-lang.c @@ -444,6 +444,7 @@ const struct language_defn pascal_language_defn = basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ basic_lookup_transparent_type,/* lookup_transparent_type */ NULL, /* Language specific symbol demangler */ + NULL, NULL, /* Language specific class_name_from_physname */ pascal_op_print_tab, /* expression operators for printing */ 1, /* c-style arrays */ diff --git a/gdb/rust-lang.c b/gdb/rust-lang.c index 36dab67..b9215c8 100644 --- a/gdb/rust-lang.c +++ b/gdb/rust-lang.c @@ -25,6 +25,7 @@ #include "c-lang.h" #include "charset.h" #include "cp-support.h" +#include "demangle.h" #include "gdbarch.h" #include "infcall.h" #include "objfiles.h" @@ -1988,6 +1989,16 @@ rust_lookup_symbol_nonlocal (const struct language_defn *langdef, +/* la_demangle_for_symbol for Rust. */ + +static char * +rust_demangle_for_symbol (const char *mangled, int *recognized) +{ + return gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI); +} + + + static const struct exp_descriptor exp_descriptor_rust = { rust_print_subexp, @@ -2030,6 +2041,7 @@ static const struct language_defn rust_language_defn = rust_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ basic_lookup_transparent_type,/* lookup_transparent_type */ gdb_demangle, /* Language specific symbol demangler */ + rust_demangle_for_symbol, NULL, /* Language specific class_name_from_physname */ c_op_print_tab, /* expression operators for printing */ diff --git a/gdb/symtab.c b/gdb/symtab.c index f7a207a..1185723 100644 --- a/gdb/symtab.c +++ b/gdb/symtab.c @@ -747,111 +747,32 @@ symbol_find_demangled_name (struct general_symbol_info *gsymbol, const char *mangled) { char *demangled = NULL; + int i; + int recognized; if (gsymbol->language == language_unknown) gsymbol->language = language_auto; - if (gsymbol->language == language_objc - || gsymbol->language == language_auto) - { - demangled = - objc_demangle (mangled, 0); - if (demangled != NULL) - { - gsymbol->language = language_objc; - return demangled; - } - } - if (gsymbol->language == language_cplus - || gsymbol->language == language_rust - || gsymbol->language == language_auto) - { - demangled = - gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI); - if (demangled != NULL) - { - gsymbol->language = language_cplus; - return demangled; - } - } - if (gsymbol->language == language_java) + if (gsymbol->language != language_auto) { - demangled = - gdb_demangle (mangled, - DMGL_PARAMS | DMGL_ANSI | DMGL_JAVA); - if (demangled != NULL) - { - gsymbol->language = language_java; - return demangled; - } - } - if (gsymbol->language == language_d - || gsymbol->language == language_auto) - { - demangled = d_demangle(mangled, 0); - if (demangled != NULL) - { - gsymbol->language = language_d; - return demangled; - } + const struct language_defn *lang = language_def (gsymbol->language); + + return language_demangle_for_symbol (lang, mangled, &recognized); } - /* FIXME(dje): Continually adding languages here is clumsy. - Better to just call la_demangle if !auto, and if auto then call - a utility routine that tries successive languages in turn and reports - which one it finds. I realize the la_demangle options may be different - for different languages but there's already a FIXME for that. */ - if (gsymbol->language == language_go - || gsymbol->language == language_auto) + + for (i = language_unknown; i < nr_languages; ++i) { - demangled = go_demangle (mangled, 0); - if (demangled != NULL) + enum language l = (enum language) i; + const struct language_defn *lang = language_def (l); + + demangled = language_demangle_for_symbol (lang, mangled, &recognized); + if (demangled != NULL || recognized) { - gsymbol->language = language_go; + gsymbol->language = l; return demangled; } } - /* We could support `gsymbol->language == language_fortran' here to provide - module namespaces also for inferiors with only minimal symbol table (ELF - symbols). Just the mangling standard is not standardized across compilers - and there is no DW_AT_producer available for inferiors with only the ELF - symbols to check the mangling kind. */ - - /* Check for Ada symbols last. See comment below explaining why. */ - - if (gsymbol->language == language_auto) - { - const char *demangled = ada_decode (mangled); - - if (demangled != mangled && demangled != NULL && demangled[0] != '<') - { - /* Set the gsymbol language to Ada, but still return NULL. - Two reasons for that: - - 1. For Ada, we prefer computing the symbol's decoded name - on the fly rather than pre-compute it, in order to save - memory (Ada projects are typically very large). - - 2. There are some areas in the definition of the GNAT - encoding where, with a bit of bad luck, we might be able - to decode a non-Ada symbol, generating an incorrect - demangled name (Eg: names ending with "TB" for instance - are identified as task bodies and so stripped from - the decoded name returned). - - Returning NULL, here, helps us get a little bit of - the best of both worlds. Because we're last, we should - not affect any of the other languages that were able to - demangle the symbol before us; we get to correctly tag - Ada symbols as such; and even if we incorrectly tagged - a non-Ada symbol, which should be rare, any routing - through the Ada language should be transparent (Ada - tries to behave much like C/C++ with non-Ada symbols). */ - gsymbol->language = language_ada; - return NULL; - } - } - return NULL; } -- 2.5.5