perf symbols: add Java demangling support

Add Java function descriptor demangling support.  Something bfd cannot
do.

Use the JAVA_DEMANGLE_NORET flag to avoid decoding the return type of
functions.

Signed-off-by: Stephane Eranian <eranian@google.com>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Carl Love <cel@us.ibm.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: John McCutchan <johnmccutchan@google.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Pawel Moll <pawel.moll@arm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Sonny Rao <sonnyrao@chromium.org>
Cc: Sukadev Bhattiprolu <sukadev@linux.vnet.ibm.com>
Link: http://lkml.kernel.org/r/1448874143-7269-2-git-send-email-eranian@google.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

1 files changed, 199 insertions, 0 deletions

diff --git a/tools/perf/util/demangle-java.c b/tools/perf/util/demangle-java.c
new file mode 100644
index 000000000000..3e6062ab2cdd
--- /dev/null
+++ b/tools/perf/util/demangle-java.c
@@ -0,0 +1,199 @@
+#include <sys/types.h>
+#include <stdio.h>
+#include <string.h>
+#include "util.h"
+#include "debug.h"
+#include "symbol.h"
+
+#include "demangle-java.h"
+
+enum {
+        MODE_PREFIX = 0,
+        MODE_CLASS  = 1,
+        MODE_FUNC   = 2,
+        MODE_TYPE   = 3,
+        MODE_CTYPE  = 3, /* class arg */
+};
+
+#define BASE_ENT(c, n)  [c - 'A']=n
+static const char *base_types['Z' - 'A' + 1] = {
+        BASE_ENT('B', "byte" ),
+        BASE_ENT('C', "char" ),
+        BASE_ENT('D', "double" ),
+        BASE_ENT('F', "float" ),
+        BASE_ENT('I', "int" ),
+        BASE_ENT('J', "long" ),
+        BASE_ENT('S', "short" ),
+        BASE_ENT('Z', "bool" ),
+};
+
+/*
+ * demangle Java symbol between str and end positions and stores
+ * up to maxlen characters into buf. The parser starts in mode.
+ *
+ * Use MODE_PREFIX to process entire prototype till end position
+ * Use MODE_TYPE to process return type if str starts on return type char
+ *
+ *  Return:
+ *      success: buf
+ *      error  : NULL
+ */
+static char *
+__demangle_java_sym(const char *str, const char *end, char *buf, int maxlen, int mode)
+{
+        int rlen = 0;
+        int array = 0;
+        int narg = 0;
+        const char *q;
+
+        if (!end)
+                end = str + strlen(str);
+
+        for (q = str; q != end; q++) {
+
+                if (rlen == (maxlen - 1))
+                        break;
+
+                switch (*q) {
+                case 'L':
+                        if (mode == MODE_PREFIX || mode == MODE_CTYPE) {
+                                if (mode == MODE_CTYPE) {
+                                        if (narg)
+                                                rlen += scnprintf(buf + rlen, maxlen - rlen, ", ");
+                                        narg++;
+                                }
+                                rlen += scnprintf(buf + rlen, maxlen - rlen, "class ");
+                                if (mode == MODE_PREFIX)
+                                        mode = MODE_CLASS;
+                        } else
+                                buf[rlen++] = *q;
+                        break;
+                case 'B':
+                case 'C':
+                case 'D':
+                case 'F':
+                case 'I':
+                case 'J':
+                case 'S':
+                case 'Z':
+                        if (mode == MODE_TYPE) {
+                                if (narg)
+                                        rlen += scnprintf(buf + rlen, maxlen - rlen, ", ");
+                                rlen += scnprintf(buf + rlen, maxlen - rlen, "%s", base_types[*q - 'A']);
+                                while (array--)
+                                        rlen += scnprintf(buf + rlen, maxlen - rlen, "[]");
+                                array = 0;
+                                narg++;
+                        } else
+                                buf[rlen++] = *q;
+                        break;
+                case 'V':
+                        if (mode == MODE_TYPE) {
+                                rlen += scnprintf(buf + rlen, maxlen - rlen, "void");
+                                while (array--)
+                                        rlen += scnprintf(buf + rlen, maxlen - rlen, "[]");
+                                array = 0;
+                        } else
+                                buf[rlen++] = *q;
+                        break;
+                case '[':
+                        if (mode != MODE_TYPE)
+                                goto error;
+                        array++;
+                        break;
+                case '(':
+                        if (mode != MODE_FUNC)
+                                goto error;
+                        buf[rlen++] = *q;
+                        mode = MODE_TYPE;
+                        break;
+                case ')':
+                        if (mode != MODE_TYPE)
+                                goto error;
+                        buf[rlen++] = *q;
+                        narg = 0;
+                        break;
+                case ';':
+                        if (mode != MODE_CLASS && mode != MODE_CTYPE)
+                                goto error;
+                        /* safe because at least one other char to process */
+                        if (isalpha(*(q + 1)))
+                                rlen += scnprintf(buf + rlen, maxlen - rlen, ".");
+                        if (mode == MODE_CLASS)
+                                mode = MODE_FUNC;
+                        else if (mode == MODE_CTYPE)
+                                mode = MODE_TYPE;
+                        break;
+                case '/':
+                        if (mode != MODE_CLASS && mode != MODE_CTYPE)
+                                goto error;
+                        rlen += scnprintf(buf + rlen, maxlen - rlen, ".");
+                        break;
+                default :
+                        buf[rlen++] = *q;
+                }
+        }
+        buf[rlen] = '\0';
+        return buf;
+error:
+        return NULL;
+}
+
+/*
+ * Demangle Java function signature (openJDK, not GCJ)
+ * input:
+ *      str: string to parse. String is not modified
+ *    flags: comobination of JAVA_DEMANGLE_* flags to modify demangling
+ * return:
+ *      if input can be demangled, then a newly allocated string is returned.
+ *      if input cannot be demangled, then NULL is returned
+ *
+ * Note: caller is responsible for freeing demangled string
+ */
+char *
+java_demangle_sym(const char *str, int flags)
+{
+        char *buf, *ptr;
+        char *p;
+        size_t len, l1 = 0;
+
+        if (!str)
+                return NULL;
+
+        /* find start of retunr type */
+        p = strrchr(str, ')');
+        if (!p)
+                return NULL;
+
+        /*
+         * expansion factor estimated to 3x
+         */
+        len = strlen(str) * 3 + 1;
+        buf = malloc(len);
+        if (!buf)
+                return NULL;
+
+        buf[0] = '\0';
+        if (!(flags & JAVA_DEMANGLE_NORET)) {
+                /*
+                 * get return type first
+                 */
+                ptr = __demangle_java_sym(p + 1, NULL, buf, len, MODE_TYPE);
+                if (!ptr)
+                        goto error;
+
+                /* add space between return type and function prototype */
+                l1 = strlen(buf);
+                buf[l1++] = ' ';
+        }
+
+        /* process function up to return type */
+        ptr = __demangle_java_sym(str, p + 1, buf + l1, len - l1, MODE_PREFIX);
+        if (!ptr)
+                goto error;
+
+        return buf;
+error:
+        free(buf);
+        return NULL;
+}