mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-05 10:29:37 +00:00
![Nick Gasson](/assets/img/avatar_default.png)
For a Java method signature like: Ljava/lang/AbstractStringBuilder;appendChars(Ljava/lang/String;II)V The demangler produces: void class java.lang.AbstractStringBuilder.appendChars(class java.lang., shorttring., int, int) The arguments should be (java.lang.String, int, int) but the demangler interprets the "S" in String as the type code for "short". Correct this and two other minor things: - There is no "bool" type in Java, should be "boolean". - The demangler prepends "class" to every Java class name. This is not standard Java syntax and it wastes a lot of horizontal space if the signature is long. Remove this as there isn't any ambiguity between class names and primitives. Committer notes: This was split from a larger patch that also added a java demangler 'perf test' entry, that, before this patch shows the error being fixed by it: $ perf test java 65: Demangle Java : FAILED! $ perf test -v java Couldn't bump rlimit(MEMLOCK), failures may take place when creating BPF maps, etc 65: Demangle Java : --- start --- test child forked, pid 307264 FAILED: Ljava/lang/StringLatin1;equals([B[B)Z: bool class java.lang.StringLatin1.equals(byte[], byte[]) != boolean java.lang.StringLatin1.equals(byte[], byte[]) FAILED: Ljava/util/zip/ZipUtils;CENSIZ([BI)J: long class java.util.zip.ZipUtils.CENSIZ(byte[], int) != long java.util.zip.ZipUtils.CENSIZ(byte[], int) FAILED: Ljava/util/regex/Pattern$BmpCharProperty;match(Ljava/util/regex/Matcher;ILjava/lang/CharSequence;)Z: bool class java.util.regex.Pattern$BmpCharProperty.match(class java.util.regex.Matcher., int, class java.lang., charhar, shortequence) != boolean java.util.regex.Pattern$BmpCharProperty.match(java.util.regex.Matcher, int, java.lang.CharSequence) FAILED: Ljava/lang/AbstractStringBuilder;appendChars(Ljava/lang/String;II)V: void class java.lang.AbstractStringBuilder.appendChars(class java.lang., shorttring., int, int) != void java.lang.AbstractStringBuilder.appendChars(java.lang.String, int, int) FAILED: Ljava/lang/Object;<init>()V: void class java.lang.Object<init>() != void java.lang.Object<init>() test child finished with -1 ---- end ---- Demangle Java: FAILED! $ After applying this patch: $ perf test java 65: Demangle Java : Ok $ Signed-off-by: Nick Gasson <nick.gasson@arm.com> Reviewed-by: Ian Rogers <irogers@google.com> Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com> Tested-by: Ian Rogers <irogers@google.com> Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com> Cc: Jiri Olsa <jolsa@redhat.com> Cc: Mark Rutland <mark.rutland@arm.com> Cc: Namhyung Kim <namhyung@kernel.org> Cc: Peter Zijlstra <peterz@infradead.org> Link: http://lore.kernel.org/lkml/20200427061520.24905-4-nick.gasson@arm.com Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
203 lines
4.2 KiB
C
203 lines
4.2 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
#include <sys/types.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "symbol.h"
|
|
|
|
#include "demangle-java.h"
|
|
|
|
#include <linux/ctype.h>
|
|
#include <linux/kernel.h>
|
|
|
|
enum {
|
|
MODE_PREFIX = 0,
|
|
MODE_CLASS = 1,
|
|
MODE_FUNC = 2,
|
|
MODE_TYPE = 3,
|
|
MODE_CTYPE = 4, /* 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', "boolean" ),
|
|
};
|
|
|
|
/*
|
|
* 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_TYPE) {
|
|
if (mode == MODE_TYPE) {
|
|
if (narg)
|
|
rlen += scnprintf(buf + rlen, maxlen - rlen, ", ");
|
|
narg++;
|
|
}
|
|
if (mode == MODE_PREFIX)
|
|
mode = MODE_CLASS;
|
|
else
|
|
mode = MODE_CTYPE;
|
|
} 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)) && mode == MODE_CLASS)
|
|
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;
|
|
}
|