@@ -1,5 +1,37 @@
2016-06-04 Tom Tromey <tom@tromey.com>
+ * 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) <la_demangle_for_symbol>: 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 <tom@tromey.com>
+
* ada-lang.c (ada_extensions): New array.
(ada_language_defn): Use it.
* c-lang.c (c_extensions): New array.
@@ -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 */
@@ -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 */
@@ -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
@@ -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 */
@@ -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. */
@@ -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
};
@@ -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 */
@@ -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. */
@@ -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 */
@@ -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 */
@@ -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);
@@ -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 */
@@ -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 */
@@ -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 */
@@ -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 */
@@ -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 */
@@ -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;
}