| /* Demangler for the Rust programming language |
| Copyright (C) 2016-2022 Free Software Foundation, Inc. |
| Written by David Tolnay (dtolnay@gmail.com). |
| Rewritten by Eduard-Mihai Burtescu (eddyb@lyken.rs) for v0 support. |
| |
| 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/>. */ |
| |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #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> |
| #else |
| extern size_t strlen(const char *s); |
| extern int strncmp(const char *s1, const char *s2, size_t n); |
| extern void *memset(void *s, int c, size_t n); |
| #endif |
| |
| #include <demangle.h> |
| #include "libiberty.h" |
| |
| struct rust_demangler |
| { |
| const char *sym; |
| size_t sym_len; |
| |
| void *callback_opaque; |
| demangle_callbackref callback; |
| |
| /* Position of the next character to read from the symbol. */ |
| size_t next; |
| |
| /* Non-zero if any error occurred. */ |
| int errored; |
| |
| /* Non-zero if nothing should be printed. */ |
| int skipping_printing; |
| |
| /* Non-zero if printing should be verbose (e.g. include hashes). */ |
| int verbose; |
| |
| /* Rust mangling version, with legacy mangling being -1. */ |
| int version; |
| |
| /* Recursion depth. */ |
| unsigned int recursion; |
| /* Maximum number of times demangle_path may be called recursively. */ |
| #define RUST_MAX_RECURSION_COUNT 1024 |
| #define RUST_NO_RECURSION_LIMIT ((unsigned int) -1) |
| |
| uint64_t bound_lifetime_depth; |
| }; |
| |
| /* Parsing functions. */ |
| |
| static char |
| peek (const struct rust_demangler *rdm) |
| { |
| if (rdm->next < rdm->sym_len) |
| return rdm->sym[rdm->next]; |
| return 0; |
| } |
| |
| static int |
| eat (struct rust_demangler *rdm, char c) |
| { |
| if (peek (rdm) == c) |
| { |
| rdm->next++; |
| return 1; |
| } |
| else |
| return 0; |
| } |
| |
| static char |
| next (struct rust_demangler *rdm) |
| { |
| char c = peek (rdm); |
| if (!c) |
| rdm->errored = 1; |
| else |
| rdm->next++; |
| return c; |
| } |
| |
| static uint64_t |
| parse_integer_62 (struct rust_demangler *rdm) |
| { |
| char c; |
| uint64_t x; |
| |
| if (eat (rdm, '_')) |
| return 0; |
| |
| x = 0; |
| while (!eat (rdm, '_') && !rdm->errored) |
| { |
| c = next (rdm); |
| x *= 62; |
| if (ISDIGIT (c)) |
| x += c - '0'; |
| else if (ISLOWER (c)) |
| x += 10 + (c - 'a'); |
| else if (ISUPPER (c)) |
| x += 10 + 26 + (c - 'A'); |
| else |
| { |
| rdm->errored = 1; |
| return 0; |
| } |
| } |
| return x + 1; |
| } |
| |
| static uint64_t |
| parse_opt_integer_62 (struct rust_demangler *rdm, char tag) |
| { |
| if (!eat (rdm, tag)) |
| return 0; |
| return 1 + parse_integer_62 (rdm); |
| } |
| |
| static uint64_t |
| parse_disambiguator (struct rust_demangler *rdm) |
| { |
| return parse_opt_integer_62 (rdm, 's'); |
| } |
| |
| static size_t |
| parse_hex_nibbles (struct rust_demangler *rdm, uint64_t *value) |
| { |
| char c; |
| size_t hex_len; |
| |
| hex_len = 0; |
| *value = 0; |
| |
| while (!eat (rdm, '_')) |
| { |
| *value <<= 4; |
| |
| c = next (rdm); |
| if (ISDIGIT (c)) |
| *value |= c - '0'; |
| else if (c >= 'a' && c <= 'f') |
| *value |= 10 + (c - 'a'); |
| else |
| { |
| rdm->errored = 1; |
| return 0; |
| } |
| hex_len++; |
| } |
| |
| return hex_len; |
| } |
| |
| struct rust_mangled_ident |
| { |
| /* ASCII part of the identifier. */ |
| const char *ascii; |
| size_t ascii_len; |
| |
| /* Punycode insertion codes for Unicode codepoints, if any. */ |
| const char *punycode; |
| size_t punycode_len; |
| }; |
| |
| static struct rust_mangled_ident |
| parse_ident (struct rust_demangler *rdm) |
| { |
| char c; |
| size_t start, len; |
| int is_punycode = 0; |
| struct rust_mangled_ident ident; |
| |
| ident.ascii = NULL; |
| ident.ascii_len = 0; |
| ident.punycode = NULL; |
| ident.punycode_len = 0; |
| |
| if (rdm->version != -1) |
| is_punycode = eat (rdm, 'u'); |
| |
| c = next (rdm); |
| if (!ISDIGIT (c)) |
| { |
| rdm->errored = 1; |
| return ident; |
| } |
| len = c - '0'; |
| |
| if (c != '0') |
| while (ISDIGIT (peek (rdm))) |
| len = len * 10 + (next (rdm) - '0'); |
| |
| /* Skip past the optional `_` separator (v0). */ |
| if (rdm->version != -1) |
| eat (rdm, '_'); |
| |
| start = rdm->next; |
| rdm->next += len; |
| /* Check for overflows. */ |
| if ((start > rdm->next) || (rdm->next > rdm->sym_len)) |
| { |
| rdm->errored = 1; |
| return ident; |
| } |
| |
| ident.ascii = rdm->sym + start; |
| ident.ascii_len = len; |
| |
| if (is_punycode) |
| { |
| ident.punycode_len = 0; |
| while (ident.ascii_len > 0) |
| { |
| ident.ascii_len--; |
| |
| /* The last '_' is a separator between ascii & punycode. */ |
| if (ident.ascii[ident.ascii_len] == '_') |
| break; |
| |
| ident.punycode_len++; |
| } |
| if (!ident.punycode_len) |
| { |
| rdm->errored = 1; |
| return ident; |
| } |
| ident.punycode = ident.ascii + (len - ident.punycode_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->skipping_printing) |
| rdm->callback (data, len, rdm->callback_opaque); |
| } |
| |
| #define PRINT(s) print_str (rdm, s, strlen (s)) |
| |
| static void |
| print_uint64 (struct rust_demangler *rdm, uint64_t x) |
| { |
| char s[21]; |
| snprintf (s, 21, "%" PRIu64, x); |
| PRINT (s); |
| } |
| |
| static void |
| print_uint64_hex (struct rust_demangler *rdm, uint64_t x) |
| { |
| char s[17]; |
| snprintf (s, 17, "%" PRIx64, x); |
| PRINT (s); |
| } |
| |
| /* Return a 0x0-0xf value if the char is 0-9a-f, and -1 otherwise. */ |
| static int |
| decode_lower_hex_nibble (char nibble) |
| { |
| if ('0' <= nibble && nibble <= '9') |
| return nibble - '0'; |
| if ('a' <= nibble && nibble <= 'f') |
| return 0xa + (nibble - 'a'); |
| return -1; |
| } |
| |
| /* Return the unescaped character for a "$...$" escape, or 0 if invalid. */ |
| static char |
| decode_legacy_escape (const char *e, size_t len, size_t *out_len) |
| { |
| char c = 0; |
| size_t escape_len = 0; |
| int lo_nibble = -1, hi_nibble = -1; |
| |
| if (len < 3 || e[0] != '$') |
| return 0; |
| |
| e++; |
| len--; |
| |
| if (e[0] == 'C') |
| { |
| escape_len = 1; |
| |
| c = ','; |
| } |
| else if (len > 2) |
| { |
| escape_len = 2; |
| |
| if (e[0] == 'S' && e[1] == 'P') |
| c = '@'; |
| else if (e[0] == 'B' && e[1] == 'P') |
| c = '*'; |
| else if (e[0] == 'R' && e[1] == 'F') |
| c = '&'; |
| else if (e[0] == 'L' && e[1] == 'T') |
| c = '<'; |
| else if (e[0] == 'G' && e[1] == 'T') |
| c = '>'; |
| else if (e[0] == 'L' && e[1] == 'P') |
| c = '('; |
| else if (e[0] == 'R' && e[1] == 'P') |
| c = ')'; |
| else if (e[0] == 'u' && len > 3) |
| { |
| escape_len = 3; |
| |
| hi_nibble = decode_lower_hex_nibble (e[1]); |
| if (hi_nibble < 0) |
| return 0; |
| lo_nibble = decode_lower_hex_nibble (e[2]); |
| if (lo_nibble < 0) |
| return 0; |
| |
| /* Only allow non-control ASCII characters. */ |
| if (hi_nibble > 7) |
| return 0; |
| c = (hi_nibble << 4) | lo_nibble; |
| if (c < 0x20) |
| return 0; |
| } |
| } |
| |
| if (!c || len <= escape_len || e[escape_len] != '$') |
| return 0; |
| |
| *out_len = 2 + escape_len; |
| return c; |
| } |
| |
| static void |
| print_ident (struct rust_demangler *rdm, struct rust_mangled_ident ident) |
| { |
| char unescaped; |
| uint8_t *out, *p, d; |
| size_t len, cap, punycode_pos, j; |
| /* Punycode parameters and state. */ |
| uint32_t c; |
| size_t base, t_min, t_max, skew, damp, bias, i; |
| size_t delta, w, k, t; |
| |
| if (rdm->errored || rdm->skipping_printing) |
| 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 |
| { |
| 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; |
| } |
| |
| if (!ident.punycode) |
| { |
| print_str (rdm, ident.ascii, ident.ascii_len); |
| return; |
| } |
| |
| len = 0; |
| cap = 4; |
| while (cap < ident.ascii_len) |
| { |
| cap *= 2; |
| /* Check for overflows. */ |
| if ((cap * 4) / 4 != cap) |
| { |
| rdm->errored = 1; |
| return; |
| } |
| } |
| |
| /* Store the output codepoints as groups of 4 UTF-8 bytes. */ |
| out = (uint8_t *)malloc (cap * 4); |
| if (!out) |
| { |
| rdm->errored = 1; |
| return; |
| } |
| |
| /* Populate initial output from ASCII fragment. */ |
| for (len = 0; len < ident.ascii_len; len++) |
| { |
| p = out + 4 * len; |
| p[0] = 0; |
| p[1] = 0; |
| p[2] = 0; |
| p[3] = ident.ascii[len]; |
| } |
| |
| /* Punycode parameters and initial state. */ |
| base = 36; |
| t_min = 1; |
| t_max = 26; |
| skew = 38; |
| damp = 700; |
| bias = 72; |
| i = 0; |
| c = 0x80; |
| |
| punycode_pos = 0; |
| while (punycode_pos < ident.punycode_len) |
| { |
| /* Read one delta value. */ |
| delta = 0; |
| w = 1; |
| k = 0; |
| do |
| { |
| k += base; |
| t = k < bias ? 0 : (k - bias); |
| if (t < t_min) |
| t = t_min; |
| if (t > t_max) |
| t = t_max; |
| |
| if (punycode_pos >= ident.punycode_len) |
| goto cleanup; |
| d = ident.punycode[punycode_pos++]; |
| |
| if (ISLOWER (d)) |
| d = d - 'a'; |
| else if (ISDIGIT (d)) |
| d = 26 + (d - '0'); |
| else |
| { |
| rdm->errored = 1; |
| goto cleanup; |
| } |
| |
| delta += d * w; |
| w *= base - t; |
| } |
| while (d >= t); |
| |
| /* Compute the new insert position and character. */ |
| len++; |
| i += delta; |
| c += i / len; |
| i %= len; |
| |
| /* Ensure enough space is available. */ |
| if (cap < len) |
| { |
| cap *= 2; |
| /* Check for overflows. */ |
| if ((cap * 4) / 4 != cap || cap < len) |
| { |
| rdm->errored = 1; |
| goto cleanup; |
| } |
| } |
| p = (uint8_t *)realloc (out, cap * 4); |
| if (!p) |
| { |
| rdm->errored = 1; |
| goto cleanup; |
| } |
| out = p; |
| |
| /* Move the characters after the insert position. */ |
| p = out + i * 4; |
| memmove (p + 4, p, (len - i - 1) * 4); |
| |
| /* Insert the new character, as UTF-8 bytes. */ |
| p[0] = c >= 0x10000 ? 0xf0 | (c >> 18) : 0; |
| p[1] = c >= 0x800 ? (c < 0x10000 ? 0xe0 : 0x80) | ((c >> 12) & 0x3f) : 0; |
| p[2] = (c < 0x800 ? 0xc0 : 0x80) | ((c >> 6) & 0x3f); |
| p[3] = 0x80 | (c & 0x3f); |
| |
| /* If there are no more deltas, decoding is complete. */ |
| if (punycode_pos == ident.punycode_len) |
| break; |
| |
| i++; |
| |
| /* Perform bias adaptation. */ |
| delta /= damp; |
| damp = 2; |
| |
| delta += delta / len; |
| k = 0; |
| while (delta > ((base - t_min) * t_max) / 2) |
| { |
| delta /= base - t_min; |
| k += base; |
| } |
| bias = k + ((base - t_min + 1) * delta) / (delta + skew); |
| } |
| |
| /* Remove all the 0 bytes to leave behind an UTF-8 string. */ |
| for (i = 0, j = 0; i < len * 4; i++) |
| if (out[i] != 0) |
| out[j++] = out[i]; |
| |
| print_str (rdm, (const char *)out, j); |
| |
| cleanup: |
| free (out); |
| } |
| |
| /* Print the lifetime according to the previously decoded index. |
| An index of `0` always refers to `'_`, but starting with `1`, |
| indices refer to late-bound lifetimes introduced by a binder. */ |
| static void |
| print_lifetime_from_index (struct rust_demangler *rdm, uint64_t lt) |
| { |
| char c; |
| uint64_t depth; |
| |
| PRINT ("'"); |
| if (lt == 0) |
| { |
| PRINT ("_"); |
| return; |
| } |
| |
| depth = rdm->bound_lifetime_depth - lt; |
| /* Try to print lifetimes alphabetically first. */ |
| if (depth < 26) |
| { |
| c = 'a' + depth; |
| print_str (rdm, &c, 1); |
| } |
| else |
| { |
| /* Use `'_123` after running out of letters. */ |
| PRINT ("_"); |
| print_uint64 (rdm, depth); |
| } |
| } |
| |
| /* Demangling functions. */ |
| |
| static void demangle_binder (struct rust_demangler *rdm); |
| static void demangle_path (struct rust_demangler *rdm, int in_value); |
| static void demangle_generic_arg (struct rust_demangler *rdm); |
| static void demangle_type (struct rust_demangler *rdm); |
| static int demangle_path_maybe_open_generics (struct rust_demangler *rdm); |
| static void demangle_dyn_trait (struct rust_demangler *rdm); |
| static void demangle_const (struct rust_demangler *rdm); |
| static void demangle_const_uint (struct rust_demangler *rdm); |
| static void demangle_const_int (struct rust_demangler *rdm); |
| static void demangle_const_bool (struct rust_demangler *rdm); |
| static void demangle_const_char (struct rust_demangler *rdm); |
| |
| /* Optionally enter a binder ('G') for late-bound lifetimes, |
| printing e.g. `for<'a, 'b> `, and make those lifetimes visible |
| to the caller (via depth level, which the caller should reset). */ |
| static void |
| demangle_binder (struct rust_demangler *rdm) |
| { |
| uint64_t i, bound_lifetimes; |
| |
| if (rdm->errored) |
| return; |
| |
| bound_lifetimes = parse_opt_integer_62 (rdm, 'G'); |
| if (bound_lifetimes > 0) |
| { |
| PRINT ("for<"); |
| for (i = 0; i < bound_lifetimes; i++) |
| { |
| if (i > 0) |
| PRINT (", "); |
| rdm->bound_lifetime_depth++; |
| print_lifetime_from_index (rdm, 1); |
| } |
| PRINT ("> "); |
| } |
| } |
| |
| static void |
| demangle_path (struct rust_demangler *rdm, int in_value) |
| { |
| char tag, ns; |
| int was_skipping_printing; |
| size_t i, backref, old_next; |
| uint64_t dis; |
| struct rust_mangled_ident name; |
| |
| if (rdm->errored) |
| return; |
| |
| if (rdm->recursion != RUST_NO_RECURSION_LIMIT) |
| { |
| ++ rdm->recursion; |
| if (rdm->recursion > RUST_MAX_RECURSION_COUNT) |
| /* FIXME: There ought to be a way to report |
| that the recursion limit has been reached. */ |
| goto fail_return; |
| } |
| |
| switch (tag = next (rdm)) |
| { |
| case 'C': |
| dis = parse_disambiguator (rdm); |
| name = parse_ident (rdm); |
| |
| print_ident (rdm, name); |
| if (rdm->verbose) |
| { |
| PRINT ("["); |
| print_uint64_hex (rdm, dis); |
| PRINT ("]"); |
| } |
| break; |
| case 'N': |
| ns = next (rdm); |
| if (!ISLOWER (ns) && !ISUPPER (ns)) |
| goto fail_return; |
| |
| demangle_path (rdm, in_value); |
| |
| dis = parse_disambiguator (rdm); |
| name = parse_ident (rdm); |
| |
| if (ISUPPER (ns)) |
| { |
| /* Special namespaces, like closures and shims. */ |
| PRINT ("::{"); |
| switch (ns) |
| { |
| case 'C': |
| PRINT ("closure"); |
| break; |
| case 'S': |
| PRINT ("shim"); |
| break; |
| default: |
| print_str (rdm, &ns, 1); |
| } |
| if (name.ascii || name.punycode) |
| { |
| PRINT (":"); |
| print_ident (rdm, name); |
| } |
| PRINT ("#"); |
| print_uint64 (rdm, dis); |
| PRINT ("}"); |
| } |
| else |
| { |
| /* Implementation-specific/unspecified namespaces. */ |
| |
| if (name.ascii || name.punycode) |
| { |
| PRINT ("::"); |
| print_ident (rdm, name); |
| } |
| } |
| break; |
| case 'M': |
| case 'X': |
| /* Ignore the `impl`'s own path.*/ |
| parse_disambiguator (rdm); |
| was_skipping_printing = rdm->skipping_printing; |
| rdm->skipping_printing = 1; |
| demangle_path (rdm, in_value); |
| rdm->skipping_printing = was_skipping_printing; |
| /* fallthrough */ |
| case 'Y': |
| PRINT ("<"); |
| demangle_type (rdm); |
| if (tag != 'M') |
| { |
| PRINT (" as "); |
| demangle_path (rdm, 0); |
| } |
| PRINT (">"); |
| break; |
| case 'I': |
| demangle_path (rdm, in_value); |
| if (in_value) |
| PRINT ("::"); |
| PRINT ("<"); |
| for (i = 0; !rdm->errored && !eat (rdm, 'E'); i++) |
| { |
| if (i > 0) |
| PRINT (", "); |
| demangle_generic_arg (rdm); |
| } |
| PRINT (">"); |
| break; |
| case 'B': |
| backref = parse_integer_62 (rdm); |
| if (!rdm->skipping_printing) |
| { |
| old_next = rdm->next; |
| rdm->next = backref; |
| demangle_path (rdm, in_value); |
| rdm->next = old_next; |
| } |
| break; |
| default: |
| goto fail_return; |
| } |
| goto pass_return; |
| |
| fail_return: |
| rdm->errored = 1; |
| pass_return: |
| if (rdm->recursion != RUST_NO_RECURSION_LIMIT) |
| -- rdm->recursion; |
| } |
| |
| static void |
| demangle_generic_arg (struct rust_demangler *rdm) |
| { |
| uint64_t lt; |
| if (eat (rdm, 'L')) |
| { |
| lt = parse_integer_62 (rdm); |
| print_lifetime_from_index (rdm, lt); |
| } |
| else if (eat (rdm, 'K')) |
| demangle_const (rdm); |
| else |
| demangle_type (rdm); |
| } |
| |
| static const char * |
| basic_type (char tag) |
| { |
| switch (tag) |
| { |
| case 'b': |
| return "bool"; |
| case 'c': |
| return "char"; |
| case 'e': |
| return "str"; |
| case 'u': |
| return "()"; |
| case 'a': |
| return "i8"; |
| case 's': |
| return "i16"; |
| case 'l': |
| return "i32"; |
| case 'x': |
| return "i64"; |
| case 'n': |
| return "i128"; |
| case 'i': |
| return "isize"; |
| case 'h': |
| return "u8"; |
| case 't': |
| return "u16"; |
| case 'm': |
| return "u32"; |
| case 'y': |
| return "u64"; |
| case 'o': |
| return "u128"; |
| case 'j': |
| return "usize"; |
| case 'f': |
| return "f32"; |
| case 'd': |
| return "f64"; |
| case 'z': |
| return "!"; |
| case 'p': |
| return "_"; |
| case 'v': |
| return "..."; |
| |
| default: |
| return NULL; |
| } |
| } |
| |
| static void |
| demangle_type (struct rust_demangler *rdm) |
| { |
| char tag; |
| size_t i, old_next, backref; |
| uint64_t lt, old_bound_lifetime_depth; |
| const char *basic; |
| struct rust_mangled_ident abi; |
| |
| if (rdm->errored) |
| return; |
| |
| tag = next (rdm); |
| |
| basic = basic_type (tag); |
| if (basic) |
| { |
| PRINT (basic); |
| return; |
| } |
| |
| if (rdm->recursion != RUST_NO_RECURSION_LIMIT) |
| { |
| ++ rdm->recursion; |
| if (rdm->recursion > RUST_MAX_RECURSION_COUNT) |
| /* FIXME: There ought to be a way to report |
| that the recursion limit has been reached. */ |
| { |
| rdm->errored = 1; |
| -- rdm->recursion; |
| return; |
| } |
| } |
| |
| switch (tag) |
| { |
| case 'R': |
| case 'Q': |
| PRINT ("&"); |
| if (eat (rdm, 'L')) |
| { |
| lt = parse_integer_62 (rdm); |
| if (lt) |
| { |
| print_lifetime_from_index (rdm, lt); |
| PRINT (" "); |
| } |
| } |
| if (tag != 'R') |
| PRINT ("mut "); |
| demangle_type (rdm); |
| break; |
| case 'P': |
| case 'O': |
| PRINT ("*"); |
| if (tag != 'P') |
| PRINT ("mut "); |
| else |
| PRINT ("const "); |
| demangle_type (rdm); |
| break; |
| case 'A': |
| case 'S': |
| PRINT ("["); |
| demangle_type (rdm); |
| if (tag == 'A') |
| { |
| PRINT ("; "); |
| demangle_const (rdm); |
| } |
| PRINT ("]"); |
| break; |
| case 'T': |
| PRINT ("("); |
| for (i = 0; !rdm->errored && !eat (rdm, 'E'); i++) |
| { |
| if (i > 0) |
| PRINT (", "); |
| demangle_type (rdm); |
| } |
| if (i == 1) |
| PRINT (","); |
| PRINT (")"); |
| break; |
| case 'F': |
| old_bound_lifetime_depth = rdm->bound_lifetime_depth; |
| demangle_binder (rdm); |
| |
| if (eat (rdm, 'U')) |
| PRINT ("unsafe "); |
| |
| if (eat (rdm, 'K')) |
| { |
| if (eat (rdm, 'C')) |
| { |
| abi.ascii = "C"; |
| abi.ascii_len = 1; |
| } |
| else |
| { |
| abi = parse_ident (rdm); |
| if (!abi.ascii || abi.punycode) |
| { |
| rdm->errored = 1; |
| goto restore; |
| } |
| } |
| |
| PRINT ("extern \""); |
| |
| /* If the ABI had any `-`, they were replaced with `_`, |
| so the parts between `_` have to be re-joined with `-`. */ |
| for (i = 0; i < abi.ascii_len; i++) |
| { |
| if (abi.ascii[i] == '_') |
| { |
| print_str (rdm, abi.ascii, i); |
| PRINT ("-"); |
| abi.ascii += i + 1; |
| abi.ascii_len -= i + 1; |
| i = 0; |
| } |
| } |
| print_str (rdm, abi.ascii, abi.ascii_len); |
| |
| PRINT ("\" "); |
| } |
| |
| PRINT ("fn("); |
| for (i = 0; !rdm->errored && !eat (rdm, 'E'); i++) |
| { |
| if (i > 0) |
| PRINT (", "); |
| demangle_type (rdm); |
| } |
| PRINT (")"); |
| |
| if (eat (rdm, 'u')) |
| { |
| /* Skip printing the return type if it's 'u', i.e. `()`. */ |
| } |
| else |
| { |
| PRINT (" -> "); |
| demangle_type (rdm); |
| } |
| |
| /* Restore `bound_lifetime_depth` to outside the binder. */ |
| restore: |
| rdm->bound_lifetime_depth = old_bound_lifetime_depth; |
| break; |
| case 'D': |
| PRINT ("dyn "); |
| |
| old_bound_lifetime_depth = rdm->bound_lifetime_depth; |
| demangle_binder (rdm); |
| |
| for (i = 0; !rdm->errored && !eat (rdm, 'E'); i++) |
| { |
| if (i > 0) |
| PRINT (" + "); |
| demangle_dyn_trait (rdm); |
| } |
| |
| /* Restore `bound_lifetime_depth` to outside the binder. */ |
| rdm->bound_lifetime_depth = old_bound_lifetime_depth; |
| |
| if (!eat (rdm, 'L')) |
| { |
| rdm->errored = 1; |
| return; |
| } |
| lt = parse_integer_62 (rdm); |
| if (lt) |
| { |
| PRINT (" + "); |
| print_lifetime_from_index (rdm, lt); |
| } |
| break; |
| case 'B': |
| backref = parse_integer_62 (rdm); |
| if (!rdm->skipping_printing) |
| { |
| old_next = rdm->next; |
| rdm->next = backref; |
| demangle_type (rdm); |
| rdm->next = old_next; |
| } |
| break; |
| default: |
| /* Go back to the tag, so `demangle_path` also sees it. */ |
| rdm->next--; |
| demangle_path (rdm, 0); |
| } |
| |
| if (rdm->recursion != RUST_NO_RECURSION_LIMIT) |
| -- rdm->recursion; |
| } |
| |
| /* A trait in a trait object may have some "existential projections" |
| (i.e. associated type bindings) after it, which should be printed |
| in the `<...>` of the trait, e.g. `dyn Trait<T, U, Assoc=X>`. |
| To this end, this method will keep the `<...>` of an 'I' path |
| open, by omitting the `>`, and return `Ok(true)` in that case. */ |
| static int |
| demangle_path_maybe_open_generics (struct rust_demangler *rdm) |
| { |
| int open; |
| size_t i, old_next, backref; |
| |
| open = 0; |
| |
| if (rdm->errored) |
| return open; |
| |
| if (rdm->recursion != RUST_NO_RECURSION_LIMIT) |
| { |
| ++ rdm->recursion; |
| if (rdm->recursion > RUST_MAX_RECURSION_COUNT) |
| { |
| /* FIXME: There ought to be a way to report |
| that the recursion limit has been reached. */ |
| rdm->errored = 1; |
| goto end_of_func; |
| } |
| } |
| |
| if (eat (rdm, 'B')) |
| { |
| backref = parse_integer_62 (rdm); |
| if (!rdm->skipping_printing) |
| { |
| old_next = rdm->next; |
| rdm->next = backref; |
| open = demangle_path_maybe_open_generics (rdm); |
| rdm->next = old_next; |
| } |
| } |
| else if (eat (rdm, 'I')) |
| { |
| demangle_path (rdm, 0); |
| PRINT ("<"); |
| open = 1; |
| for (i = 0; !rdm->errored && !eat (rdm, 'E'); i++) |
| { |
| if (i > 0) |
| PRINT (", "); |
| demangle_generic_arg (rdm); |
| } |
| } |
| else |
| demangle_path (rdm, 0); |
| |
| end_of_func: |
| if (rdm->recursion != RUST_NO_RECURSION_LIMIT) |
| -- rdm->recursion; |
| |
| return open; |
| } |
| |
| static void |
| demangle_dyn_trait (struct rust_demangler *rdm) |
| { |
| int open; |
| struct rust_mangled_ident name; |
| |
| if (rdm->errored) |
| return; |
| |
| open = demangle_path_maybe_open_generics (rdm); |
| |
| while (eat (rdm, 'p')) |
| { |
| if (!open) |
| PRINT ("<"); |
| else |
| PRINT (", "); |
| open = 1; |
| |
| name = parse_ident (rdm); |
| print_ident (rdm, name); |
| PRINT (" = "); |
| demangle_type (rdm); |
| } |
| |
| if (open) |
| PRINT (">"); |
| } |
| |
| static void |
| demangle_const (struct rust_demangler *rdm) |
| { |
| char ty_tag; |
| size_t old_next, backref; |
| |
| if (rdm->errored) |
| return; |
| |
| if (rdm->recursion != RUST_NO_RECURSION_LIMIT) |
| { |
| ++ rdm->recursion; |
| if (rdm->recursion > RUST_MAX_RECURSION_COUNT) |
| /* FIXME: There ought to be a way to report |
| that the recursion limit has been reached. */ |
| goto fail_return; |
| } |
| |
| if (eat (rdm, 'B')) |
| { |
| backref = parse_integer_62 (rdm); |
| if (!rdm->skipping_printing) |
| { |
| old_next = rdm->next; |
| rdm->next = backref; |
| demangle_const (rdm); |
| rdm->next = old_next; |
| } |
| goto pass_return; |
| } |
| |
| ty_tag = next (rdm); |
| switch (ty_tag) |
| { |
| /* Placeholder. */ |
| case 'p': |
| PRINT ("_"); |
| goto pass_return; |
| |
| /* Unsigned integer types. */ |
| case 'h': |
| case 't': |
| case 'm': |
| case 'y': |
| case 'o': |
| case 'j': |
| demangle_const_uint (rdm); |
| break; |
| |
| /* Signed integer types. */ |
| case 'a': |
| case 's': |
| case 'l': |
| case 'x': |
| case 'n': |
| case 'i': |
| demangle_const_int (rdm); |
| break; |
| |
| /* Boolean. */ |
| case 'b': |
| demangle_const_bool (rdm); |
| break; |
| |
| /* Character. */ |
| case 'c': |
| demangle_const_char (rdm); |
| break; |
| |
| default: |
| goto fail_return; |
| } |
| |
| if (!rdm->errored && rdm->verbose) |
| { |
| PRINT (": "); |
| PRINT (basic_type (ty_tag)); |
| } |
| goto pass_return; |
| |
| fail_return: |
| rdm->errored = 1; |
| pass_return: |
| if (rdm->recursion != RUST_NO_RECURSION_LIMIT) |
| -- rdm->recursion; |
| } |
| |
| static void |
| demangle_const_uint (struct rust_demangler *rdm) |
| { |
| size_t hex_len; |
| uint64_t value; |
| |
| if (rdm->errored) |
| return; |
| |
| hex_len = parse_hex_nibbles (rdm, &value); |
| |
| if (hex_len > 16) |
| { |
| /* Print anything that doesn't fit in `uint64_t` verbatim. */ |
| PRINT ("0x"); |
| print_str (rdm, rdm->sym + (rdm->next - hex_len), hex_len); |
| } |
| else if (hex_len > 0) |
| print_uint64 (rdm, value); |
| else |
| rdm->errored = 1; |
| } |
| |
| static void |
| demangle_const_int (struct rust_demangler *rdm) |
| { |
| if (eat (rdm, 'n')) |
| PRINT ("-"); |
| demangle_const_uint (rdm); |
| } |
| |
| static void |
| demangle_const_bool (struct rust_demangler *rdm) |
| { |
| uint64_t value; |
| |
| if (parse_hex_nibbles (rdm, &value) != 1) |
| { |
| rdm->errored = 1; |
| return; |
| } |
| |
| if (value == 0) |
| PRINT ("false"); |
| else if (value == 1) |
| PRINT ("true"); |
| else |
| rdm->errored = 1; |
| } |
| |
| static void |
| demangle_const_char (struct rust_demangler *rdm) |
| { |
| size_t hex_len; |
| uint64_t value; |
| |
| hex_len = parse_hex_nibbles (rdm, &value); |
| |
| if (hex_len == 0 || hex_len > 8) |
| { |
| rdm->errored = 1; |
| return; |
| } |
| |
| /* Match Rust's character "debug" output as best as we can. */ |
| PRINT ("'"); |
| if (value == '\t') |
| PRINT ("\\t"); |
| else if (value == '\r') |
| PRINT ("\\r"); |
| else if (value == '\n') |
| PRINT ("\\n"); |
| else if (value > ' ' && value < '~') |
| { |
| /* Rust also considers many non-ASCII codepoints to be printable, but |
| that logic is not easily ported to C. */ |
| char c = value; |
| print_str (rdm, &c, 1); |
| } |
| else |
| { |
| PRINT ("\\u{"); |
| print_uint64_hex (rdm, value); |
| PRINT ("}"); |
| } |
| PRINT ("'"); |
| } |
| |
| /* 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.skipping_printing = 0; |
| rdm.verbose = (options & DMGL_VERBOSE) != 0; |
| rdm.version = 0; |
| rdm.recursion = (options & DMGL_NO_RECURSE_LIMIT) ? RUST_NO_RECURSION_LIMIT : 0; |
| rdm.bound_lifetime_depth = 0; |
| |
| /* Rust symbols always start with _R (v0) or _ZN (legacy). */ |
| if (rdm.sym[0] == '_' && rdm.sym[1] == 'R') |
| rdm.sym += 2; |
| else if (rdm.sym[0] == '_' && rdm.sym[1] == 'Z' && rdm.sym[2] == 'N') |
| { |
| rdm.sym += 3; |
| rdm.version = -1; |
| } |
| else |
| return 0; |
| |
| /* Paths (v0) always start with uppercase characters. */ |
| if (rdm.version != -1 && !ISUPPER (rdm.sym[0])) |
| return 0; |
| |
| /* Rust symbols (v0) use only [_0-9a-zA-Z] characters. */ |
| for (p = rdm.sym; *p; p++) |
| { |
| /* Rust v0 symbols can have '.' suffixes, ignore those. */ |
| if (rdm.version == 0 && *p == '.') |
| break; |
| |
| rdm.sym_len++; |
| |
| if (*p == '_' || ISALNUM (*p)) |
| continue; |
| |
| /* Legacy Rust symbols can also contain [.:$] characters. |
| Or @ in the .suffix (which will be skipped, see below). */ |
| if (rdm.version == -1 && (*p == '$' || *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. But can be followed by a |
| .suffix (which we want to ignore). */ |
| int dot_suffix = 1; |
| while (rdm.sym_len > 0 && |
| !(dot_suffix && rdm.sym[rdm.sym_len - 1] == 'E')) |
| { |
| dot_suffix = rdm.sym[rdm.sym_len - 1] == '.'; |
| rdm.sym_len--; |
| } |
| |
| 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 |
| { |
| demangle_path (&rdm, 1); |
| |
| /* Skip instantiating crate. */ |
| if (!rdm.errored && rdm.next < rdm.sym_len) |
| { |
| rdm.skipping_printing = 1; |
| demangle_path (&rdm, 0); |
| } |
| |
| /* It's an error to not reach the end. */ |
| rdm.errored |= rdm.next != rdm.sym_len; |
| } |
| |
| 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; |
| } |
