procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

[PATCH] Refactor rust-demangle to be independent of C++ demangling.

Browse source 
* demangle.h (rust_demangle_callback): Add.

	* cplus-dem.c (cplus_demangle): Use rust_demangle directly.
	(rust_demangle): Remove.
	* rust-demangle.c (is_prefixed_hash): Rename to is_legacy_prefixed_hash.
	(parse_lower_hex_nibble): Rename to decode_lower_hex_nibble.
	(parse_legacy_escape): Rename to decode_legacy_escape.
	(rust_is_mangled): Remove.
	(struct rust_demangler): Add.
	(peek): Add.
	(next): Add.
	(struct rust_mangled_ident): Add.
	(parse_ident): Add.
	(rust_demangle_sym): Remove.
	(print_str): Add.
	(PRINT): Add.
	(print_ident): Add.
	(rust_demangle_callback): Add.
	(struct str_buf): Add.
	(str_buf_reserve): Add.
	(str_buf_append): Add.
	(str_buf_demangle_callback): Add.
	(rust_demangle): Add.
	* rust-demangle.h: Remove.

From-SVN: r278358
This commit is contained in:
Eduard-Mihai Burtescu 2019-11-16 16:32:50 +01:00 • committed by Jeff Law
parent f73cb38f65
commit 32fc3719e0
6 changed files with 442 additions and 272 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
include/ChangeLog
View file

@ -1,3 +1,7 @@
2019-10-22 Eduard-Mihai Burtescu <eddyb@lyken.rs>
* demangle.h (rust_demangle_callback): Add.
2019-11-13 Andrew Stubbs <ams@codesourcery.com>
Kwok Cheung Yeung <kcy@codesourcery.com>
Julian Brown <julian@codesourcery.com>

5
include/demangle.h
View file

@ -159,6 +159,11 @@ ada_demangle (const char *mangled, int options);
extern char *
dlang_demangle (const char *mangled, int options);
extern int
rust_demangle_callback (const char *mangled, int options,
demangle_callbackref callback, void *opaque);
extern char *
rust_demangle (const char *mangled, int options);

25
libiberty/ChangeLog
View file

@ -1,3 +1,28 @@
2019-10-22 Eduard-Mihai Burtescu <eddyb@lyken.rs>
* cplus-dem.c (cplus_demangle): Use rust_demangle directly.
(rust_demangle): Remove.
* rust-demangle.c (is_prefixed_hash): Rename to is_legacy_prefixed_hash.
(parse_lower_hex_nibble): Rename to decode_lower_hex_nibble.
(parse_legacy_escape): Rename to decode_legacy_escape.
(rust_is_mangled): Remove.
(struct rust_demangler): Add.
(peek): Add.
(next): Add.
(struct rust_mangled_ident): Add.
(parse_ident): Add.
(rust_demangle_sym): Remove.
(print_str): Add.
(PRINT): Add.
(print_ident): Add.
(rust_demangle_callback): Add.
(struct str_buf): Add.
(str_buf_reserve): Add.
(str_buf_append): Add.
(str_buf_demangle_callback): Add.
(rust_demangle): Add.
* rust-demangle.h: Remove.
2019-11-15 Miguel Saldivar <saldivarcher@gmail.com>
* testsuite/demangle-expected: Fix test.

51
libiberty/cplus-dem.c
View file

@ -52,7 +52,6 @@ void * realloc ();
#define CURRENT_DEMANGLING_STYLE options
#include "libiberty.h"
#include "rust-demangle.h"
enum demangling_styles current_demangling_style = auto_demangling;
@ -160,27 +159,20 @@ cplus_demangle (const char *mangled, int options)
if ((options & DMGL_STYLE_MASK) == 0)
options |= (int) current_demangling_style & DMGL_STYLE_MASK;
/* The Rust demangling is implemented elsewhere.
Legacy Rust symbols overlap with GNU_V3, so try Rust first. */
if (RUST_DEMANGLING || AUTO_DEMANGLING)
{
ret = rust_demangle (mangled, options);
if (ret || RUST_DEMANGLING)
return ret;
}
/* The V3 ABI demangling is implemented elsewhere. */
if (GNU_V3_DEMANGLING || RUST_DEMANGLING || AUTO_DEMANGLING)
if (GNU_V3_DEMANGLING || AUTO_DEMANGLING)
{
ret = cplus_demangle_v3 (mangled, options);
if (GNU_V3_DEMANGLING)
return ret;
if (ret)
{
/* Rust symbols are GNU_V3 mangled plus some extra subtitutions.
The subtitutions are always smaller, so do in place changes. */
if (rust_is_mangled (ret))
rust_demangle_sym (ret);
else if (RUST_DEMANGLING)
{
free (ret);
ret = NULL;
}
}
if (ret || RUST_DEMANGLING)
if (ret || GNU_V3_DEMANGLING)
return ret;
}
@ -204,27 +196,6 @@ cplus_demangle (const char *mangled, int options)
return (ret);
}
char *
rust_demangle (const char *mangled, int options)
{
/* Rust symbols are GNU_V3 mangled plus some extra subtitutions. */
char *ret = cplus_demangle_v3 (mangled, options);
/* The Rust subtitutions are always smaller, so do in place changes. */
if (ret != NULL)
{
if (rust_is_mangled (ret))
rust_demangle_sym (ret);
else
{
free (ret);
ret = NULL;
}
}
return ret;
}
/* Demangle ada names. The encoding is documented in gcc/ada/exp_dbug.ads. */
char *

584
libiberty/rust-demangle.c
View file

@ -33,9 +33,11 @@ If not, see <http://www.gnu.org/licenses/>. */
#include "safe-ctype.h"
#include <inttypes.h>
#include <sys/types.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#ifdef HAVE_STRING_H
#include <string.h>
@ -47,207 +49,110 @@ extern void *memset(void *s, int c, size_t n);
#include <demangle.h>
#include "libiberty.h"
#include "rust-demangle.h"
/* Mangled (legacy) Rust symbols look like this:
_$LT$std..sys..fd..FileDesc$u20$as$u20$core..ops..Drop$GT$::drop::hc68340e1baa4987a
The original symbol is:
<std::sys::fd::FileDesc as core::ops::Drop>::drop
The last component of the path is a 64-bit hash in lowercase hex,
prefixed with "h". Rust does not have a global namespace between
crates, an illusion which Rust maintains by using the hash to
distinguish things that would otherwise have the same symbol.
Any path component not starting with a XID_Start character is
prefixed with "_".
The following escape sequences are used:
"," => $C$
"@" => $SP$
"*" => $BP$
"&" => $RF$
"<" => $LT$
">" => $GT$
"(" => $LP$
")" => $RP$
"\u{XY}" => $uXY$
A double ".." means "::" and a single "." means "-".
The only characters allowed in the mangled symbol are a-zA-Z0-9 and _.:$ */
static const char *hash_prefix = "::h";
static const size_t hash_prefix_len = 3;
static const size_t hash_len = 16;
static int is_prefixed_hash (const char *start);
static int parse_lower_hex_nibble (char nibble);
static char parse_legacy_escape (const char **in);
/* INPUT: sym: symbol that has been through C++ (gnu v3) demangling
This function looks for the following indicators:
1. The hash must consist of "h" followed by 16 lowercase hex digits.
2. As a sanity check, the hash must use between 5 and 15 of the 16
possible hex digits. This is true of 99.9998% of hashes so once
in your life you may see a false negative. The point is to
notice path components that could be Rust hashes but are
probably not, like "haaaaaaaaaaaaaaaa". In this case a false
positive (non-Rust symbol has an important path component
removed because it looks like a Rust hash) is worse than a false
negative (the rare Rust symbol is not demangled) so this sets
the balance in favor of false negatives.
3. There must be no characters other than a-zA-Z0-9 and _.:$ */
int
rust_is_mangled (const char *sym)
struct rust_demangler
{
size_t len, len_without_hash;
const char *end;
const char *sym;
size_t sym_len;
if (!sym)
return 0;
void *callback_opaque;
demangle_callbackref callback;
len = strlen (sym);
if (len <= hash_prefix_len + hash_len)
/* Not long enough to contain "::h" + hash + something else */
return 0;
/* Position of the next character to read from the symbol. */
size_t next;
len_without_hash = len - (hash_prefix_len + hash_len);
if (!is_prefixed_hash (sym + len_without_hash))
return 0;
/* Non-zero if any error occurred. */
int errored;
end = sym + len_without_hash;
/* Non-zero if printing should be verbose (e.g. include hashes). */
int verbose;
while (sym < end)
{
if (*sym == '$' || *sym == '.' || *sym == '_' || *sym == ':'
|| ISALNUM (*sym))
sym++;
else
return 0;
}
/* Rust mangling version, with legacy mangling being -1. */
int version;
};
return 1;
/* Parsing functions. */
static char
peek (const struct rust_demangler *rdm)
{
if (rdm->next < rdm->sym_len)
return rdm->sym[rdm->next];
return 0;
}
/* A hash is the prefix "::h" followed by 16 lowercase hex digits. The
hex digits must contain at least 5 distinct digits. */
static int
is_prefixed_hash (const char *str)
static char
next (struct rust_demangler *rdm)
{
const char *end;
char seen[16];
size_t i;
int count, nibble;
if (strncmp (str, hash_prefix, hash_prefix_len))
return 0;
str += hash_prefix_len;
memset (seen, 0, sizeof(seen));
for (end = str + hash_len; str < end; str++)
{
nibble = parse_lower_hex_nibble (*str);
if (nibble < 0)
return 0;
seen[nibble] = 1;
}
/* Count how many distinct digits seen */
count = 0;
for (i = 0; i < 16; i++)
if (seen[i])
count++;
return count >= 5;
char c = peek (rdm);
if (!c)
rdm->errored = 1;
else
rdm->next++;
return c;
}
/*
INPUT: sym: symbol for which rust_is_mangled(sym) returned 1.
The input is demangled in-place because the mangled name is always
longer than the demangled one. */
void
rust_demangle_sym (char *sym)
struct rust_mangled_ident
{
const char *in;
char *out;
const char *end;
char unescaped;
/* ASCII part of the identifier. */
const char *ascii;
size_t ascii_len;
};
if (!sym)
return;
static struct rust_mangled_ident
parse_ident (struct rust_demangler *rdm)
{
char c;
size_t start, len;
struct rust_mangled_ident ident;
in = sym;
out = sym;
end = sym + strlen (sym) - (hash_prefix_len + hash_len);
ident.ascii = NULL;
ident.ascii_len = 0;
while (in < end)
c = next (rdm);
if (!ISDIGIT (c))
{
if (*in == '$')
{
unescaped = parse_legacy_escape (&in);
if (unescaped)
*out++ = unescaped;
else
/* unexpected escape sequence, skip the rest of this segment. */
while (in < end && *in != ':')
*out++ = *in++;
}
else if (*in == '_')
{
/* If this is the start of a path component and the next
character is an escape sequence, ignore the underscore. The
mangler inserts an underscore to make sure the path
component begins with a XID_Start character. */
if ((in == sym || in[-1] == ':') && in[1] == '$')
in++;
else
*out++ = *in++;
}
else if (*in == '.')
{
if (in[1] == '.')
{
/* ".." becomes "::" */
*out++ = ':';
*out++ = ':';
in += 2;
}
else
{
/* "." becomes "-" */
*out++ = '-';
in++;
}
}
else if (*in == ':' || ISALNUM (*in))
*out++ = *in++;
else
{
/* unexpected character in symbol, not rust_is_mangled. */
*out++ = '?'; /* This is pretty lame, but it's hard to do better. */
*out = '\0';
return;
}
rdm->errored = 1;
return ident;
}
len = c - '0';
if (c != '0')
while (ISDIGIT (peek (rdm)))
len = len * 10 + (next (rdm) - '0');
start = rdm->next;
rdm->next += len;
/* Check for overflows. */
if ((start > rdm->next) || (rdm->next > rdm->sym_len))
{
rdm->errored = 1;
return ident;
}
*out = '\0';
ident.ascii = rdm->sym + start;
ident.ascii_len = len;
if (ident.ascii_len == 0)
ident.ascii = NULL;
return ident;
}
/* Printing functions. */
static void
print_str (struct rust_demangler *rdm, const char *data, size_t len)
{
if (!rdm->errored)
rdm->callback (data, len, rdm->callback_opaque);
}
#define PRINT(s) print_str (rdm, s, strlen (s))
/* Return a 0x0-0xf value if the char is 0-9a-f, and -1 otherwise. */
static int
parse_lower_hex_nibble (char nibble)
decode_lower_hex_nibble (char nibble)
{
if ('0' <= nibble && nibble <= '9')
return nibble - '0';
@ -258,17 +163,17 @@ parse_lower_hex_nibble (char nibble)
/* Return the unescaped character for a "$...$" escape, or 0 if invalid. */
static char
parse_legacy_escape (const char **in)
decode_legacy_escape (const char *e, size_t len, size_t *out_len)
{
char c = 0;
const char *e;
size_t escape_len = 0;
int lo_nibble = -1, hi_nibble = -1;
if ((*in)[0] != '$')
if (len < 3 || e[0] != '$')
return 0;
e = *in + 1;
e++;
len--;
if (e[0] == 'C')
{
@ -276,7 +181,7 @@ parse_legacy_escape (const char **in)
c = ',';
}
else
else if (len > 2)
{
escape_len = 2;
@ -294,14 +199,14 @@ parse_legacy_escape (const char **in)
c = '(';
else if (e[0] == 'R' && e[1] == 'P')
c = ')';
else if (e[0] == 'u')
else if (e[0] == 'u' && len > 3)
{
escape_len = 3;
hi_nibble = parse_lower_hex_nibble (e[1]);
hi_nibble = decode_lower_hex_nibble (e[1]);
if (hi_nibble < 0)
return 0;
lo_nibble = parse_lower_hex_nibble (e[2]);
lo_nibble = decode_lower_hex_nibble (e[2]);
if (lo_nibble < 0)
return 0;
@ -314,9 +219,314 @@ parse_legacy_escape (const char **in)
}
}
if (!c || e[escape_len] != '$')
if (!c || len <= escape_len || e[escape_len] != '$')
return 0;
*in += 2 + escape_len;
*out_len = 2 + escape_len;
return c;
}
static void
print_ident (struct rust_demangler *rdm, struct rust_mangled_ident ident)
{
char unescaped;
size_t len;
if (rdm->errored)
return;
if (rdm->version == -1)
{
/* Ignore leading underscores preceding escape sequences.
The mangler inserts an underscore to make sure the
identifier begins with a XID_Start character. */
if (ident.ascii_len >= 2 && ident.ascii[0] == '_'
&& ident.ascii[1] == '$')
{
ident.ascii++;
ident.ascii_len--;
}
while (ident.ascii_len > 0)
{
/* Handle legacy escape sequences ("$...$", ".." or "."). */
if (ident.ascii[0] == '$')
{
unescaped
= decode_legacy_escape (ident.ascii, ident.ascii_len, &len);
if (unescaped)
print_str (rdm, &unescaped, 1);
else
{
/* Unexpected escape sequence, print the rest verbatim. */
print_str (rdm, ident.ascii, ident.ascii_len);
return;
}
}
else if (ident.ascii[0] == '.')
{
if (ident.ascii_len >= 2 && ident.ascii[1] == '.')
{
/* ".." becomes "::" */
PRINT ("::");
len = 2;
}
else
{
/* "." becomes "-" */
PRINT ("-");
len = 1;
}
}
else
{
/* Print everything before the next escape sequence, at once. */
for (len = 0; len < ident.ascii_len; len++)
if (ident.ascii[len] == '$' || ident.ascii[len] == '.')
break;
print_str (rdm, ident.ascii, len);
}
ident.ascii += len;
ident.ascii_len -= len;
}
return;
}
}
/* A legacy hash is the prefix "h" followed by 16 lowercase hex digits.
The hex digits must contain at least 5 distinct digits. */
static int
is_legacy_prefixed_hash (struct rust_mangled_ident ident)
{
uint16_t seen;
int nibble;
size_t i, count;
if (ident.ascii_len != 17 || ident.ascii[0] != 'h')
return 0;
seen = 0;
for (i = 0; i < 16; i++)
{
nibble = decode_lower_hex_nibble (ident.ascii[1 + i]);
if (nibble < 0)
return 0;
seen |= (uint16_t)1 << nibble;
}
/* Count how many distinct digits were seen. */
count = 0;
while (seen)
{
if (seen & 1)
count++;
seen >>= 1;
}
return count >= 5;
}
int
rust_demangle_callback (const char *mangled, int options,
demangle_callbackref callback, void *opaque)
{
const char *p;
struct rust_demangler rdm;
struct rust_mangled_ident ident;
rdm.sym = mangled;
rdm.sym_len = 0;
rdm.callback_opaque = opaque;
rdm.callback = callback;
rdm.next = 0;
rdm.errored = 0;
rdm.verbose = (options & DMGL_VERBOSE) != 0;
rdm.version = 0;
/* Rust symbols always start with _ZN (legacy). */
if (rdm.sym[0] == '_' && rdm.sym[1] == 'Z' && rdm.sym[2] == 'N')
{
rdm.sym += 3;
rdm.version = -1;
}
else
return 0;
/* Legacy Rust symbols use only [_0-9a-zA-Z.:$] characters. */
for (p = rdm.sym; *p; p++)
{
rdm.sym_len++;
if (*p == '_' || ISALNUM (*p))
continue;
if (rdm.version == -1 && (*p == '$' || *p == '.' || *p == ':'))
continue;
return 0;
}
/* Legacy Rust symbols need to be handled separately. */
if (rdm.version == -1)
{
/* Legacy Rust symbols always end with E. */
if (!(rdm.sym_len > 0 && rdm.sym[rdm.sym_len - 1] == 'E'))
return 0;
rdm.sym_len--;
/* Legacy Rust symbols also always end with a path segment
that encodes a 16 hex digit hash, i.e. '17h[a-f0-9]{16}'.
This early check, before any parse_ident calls, should
quickly filter out most C++ symbols unrelated to Rust. */
if (!(rdm.sym_len > 19
&& !memcmp (&rdm.sym[rdm.sym_len - 19], "17h", 3)))
return 0;
do
{
ident = parse_ident (&rdm);
if (rdm.errored || !ident.ascii)
return 0;
}
while (rdm.next < rdm.sym_len);
/* The last path segment should be the hash. */
if (!is_legacy_prefixed_hash (ident))
return 0;
/* Reset the state for a second pass, to print the symbol. */
rdm.next = 0;
if (!rdm.verbose && rdm.sym_len > 19)
{
/* Hide the last segment, containing the hash, if not verbose. */
rdm.sym_len -= 19;
}
do
{
if (rdm.next > 0)
print_str (&rdm, "::", 2);
ident = parse_ident (&rdm);
print_ident (&rdm, ident);
}
while (rdm.next < rdm.sym_len);
}
else
return 0;
return !rdm.errored;
}
/* Growable string buffers. */
struct str_buf
{
char *ptr;
size_t len;
size_t cap;
int errored;
};
static void
str_buf_reserve (struct str_buf *buf, size_t extra)
{
size_t available, min_new_cap, new_cap;
char *new_ptr;
/* Allocation failed before. */
if (buf->errored)
return;
available = buf->cap - buf->len;
if (extra <= available)
return;
min_new_cap = buf->cap + (extra - available);
/* Check for overflows. */
if (min_new_cap < buf->cap)
{
buf->errored = 1;
return;
}
new_cap = buf->cap;
if (new_cap == 0)
new_cap = 4;
/* Double capacity until sufficiently large. */
while (new_cap < min_new_cap)
{
new_cap *= 2;
/* Check for overflows. */
if (new_cap < buf->cap)
{
buf->errored = 1;
return;
}
}
new_ptr = (char *)realloc (buf->ptr, new_cap);
if (new_ptr == NULL)
{
free (buf->ptr);
buf->ptr = NULL;
buf->len = 0;
buf->cap = 0;
buf->errored = 1;
}
else
{
buf->ptr = new_ptr;
buf->cap = new_cap;
}
}
static void
str_buf_append (struct str_buf *buf, const char *data, size_t len)
{
str_buf_reserve (buf, len);
if (buf->errored)
return;
memcpy (buf->ptr + buf->len, data, len);
buf->len += len;
}
static void
str_buf_demangle_callback (const char *data, size_t len, void *opaque)
{
str_buf_append ((struct str_buf *)opaque, data, len);
}
char *
rust_demangle (const char *mangled, int options)
{
struct str_buf out;
int success;
out.ptr = NULL;
out.len = 0;
out.cap = 0;
out.errored = 0;
success = rust_demangle_callback (mangled, options,
str_buf_demangle_callback, &out);
if (!success)
{
free (out.ptr);
return NULL;
}
str_buf_append (&out, "\0", 1);
return out.ptr;
}

45
libiberty/rust-demangle.h
View file

@ -1,45 +0,0 @@
/* Internal demangler interface for the Rust programming language.
Copyright (C) 2016-2019 Free Software Foundation, Inc.
Written by David Tolnay (dtolnay@gmail.com).
This file is part of the libiberty library.
Libiberty is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
In addition to the permissions in the GNU Library General Public
License, the Free Software Foundation gives you unlimited permission
to link the compiled version of this file into combinations with other
programs, and to distribute those combinations without any restriction
coming from the use of this file. (The Library Public License
restrictions do apply in other respects; for example, they cover
modification of the file, and distribution when not linked into a
combined executable.)
Libiberty is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with libiberty; see the file COPYING.LIB.
If not, see <http://www.gnu.org/licenses/>. */
/* This file provides some definitions shared by cplus-dem.c and
rust-demangle.c. It should not be included by any other files. */
/* Returns non-zero iff MANGLED is a rust mangled symbol. MANGLED must
already have been demangled through cplus_demangle_v3. If this function
returns non-zero then MANGLED can be demangled (in-place) using
RUST_DEMANGLE_SYM. */
extern int
rust_is_mangled (const char *mangled);
/* Demangles SYM (in-place) if RUST_IS_MANGLED returned non-zero for SYM.
If RUST_IS_MANGLED returned zero for SYM then RUST_DEMANGLE_SYM might
replace characters that cannot be demangled with '?' and might truncate
SYM. After calling RUST_DEMANGLE_SYM SYM might be shorter, but never
larger. */
extern void
rust_demangle_sym (char *sym);