Use rustc-demangle for Rust demangling
Subsystems (2)
Ian Rogers
reviewerv2 cover Use rustc-demangle for Rust demangling
Discussion of improved Rust demangling started with:
https://lore.kernel.org/lkml/jgxfnphfo3nzlfipnuuzdlfc4ehbr2tnh2evz3mdhynd6wvrsu@fcz6vrvepybb/
that led to implementing a Rust v0 demangler:
https://lore.kernel.org/lkml/[email protected]/
Discussion on that patch series led to the rust-lang issue:
https://github.com/rust-lang/rust/issues/60705
where the pre-existing Rust C demangler, authored by Ariel Ben-Yehuda
<[email protected]>, was mentioned. There wasn't progress on that
issue and so I've pulled that work into perf as discussed on the issue.
v2: Changes to references from arielb1 to "Ariel Ben Yehuda
<[email protected]>", license tidying as suggested by Miguel Ojeda" <[email protected]>. Don't change from alternate demangling flag from false to true in the test change, make it true from the beginning (patch 2).
Ian Rogers (6):
perf demangle-rust: Add rustc-demangle C demangler perf symbol-elf: Integrate rust-v0 demangling perf demangle-rust: Remove previous legacy rust decoder perf test demangle-rust: Add Rust demangling test perf test demangle-java: Switch to using dso__demangle_sym perf test demangle-ocaml: Switch to using dso__demangle_sym
tools/perf/tests/Build | 1 + tools/perf/tests/builtin-test.c | 1 + tools/perf/tests/demangle-java-test.c | 17 +- tools/perf/tests/demangle-ocaml-test.c | 7 +- tools/perf/tests/demangle-rust-v0-test.c | 74 + tools/perf/tests/tests.h | 1 + tools/perf/util/Build | 5 +- tools/perf/util/demangle-rust-v0.c | 2042 ++++++++++++++++++++++ tools/perf/util/demangle-rust-v0.h | 88 + tools/perf/util/demangle-rust.c | 269 --- tools/perf/util/demangle-rust.h | 8 - tools/perf/util/symbol-elf.c | 49 +- 12 files changed, 2257 insertions(+), 305 deletions(-) create mode 100644 tools/perf/tests/demangle-rust-v0-test.c create mode 100644 tools/perf/util/demangle-rust-v0.c create mode 100644 tools/perf/util/demangle-rust-v0.h delete mode 100644 tools/perf/util/demangle-rust.c delete mode 100644 tools/perf/util/demangle-rust.h
Signature · 1 line
2.49.0.901.g37484f566f-goog
Ian Rogers
reviewerPATCH v2 1/6 perf demangle-rust: Add rustc-demangle C demangler
Imported at commit 80e40f57d99f ("add comment about finding latest version of code") from:
https://github.com/rust-lang/rustc-demangle/blob/main/crates/native-c/src/demangle.c
https://github.com/rust-lang/rustc-demangle/blob/main/crates/native-c/include/demangle.h
There is discussion of this issue motivating the import in:
https://github.com/rust-lang/rust/issues/60705
https://lore.kernel.org/lkml/[email protected]/
The SPDX lines reflect the dual license Apache-2 or MIT in:
https://github.com/rust-lang/rustc-demangle/blob/main/README.md
Following Migual Ojeda's suggestion comments were added on copyright and keeping the code in sync with upstream.
The files are renamed as perf supports multiple demanglers and so demangle as a name would be overloaded.
The work here was done by Ariel Ben-Yehuda <[email protected]> and I am merely importing it as discussed in the rust-lang issue.
--- tools/perf/util/demangle-rust-v0.c | 2042 ++++++++++++++++++++++++++++ tools/perf/util/demangle-rust-v0.h | 88 ++ 2 files changed, 2130 insertions(+) create mode 100644 tools/perf/util/demangle-rust-v0.c create mode 100644 tools/perf/util/demangle-rust-v0.h
tools/perf/util/demangle-rust-v0.c new file +2042 -0
@@ -0,0 +1,2042 @@ +// SPDX-License-Identifier: Apache-2.0 OR MIT + +// The contents of this file come from the Rust rustc-demangle library, hosted +// in the <https://github.com/rust-lang/rustc-demangle> repository, licensed +// under "Apache-2.0 OR MIT". For copyright details, see +// <https://github.com/rust-lang/rustc-demangle/blob/main/README.md>. +// Please note that the file should be kept as close as possible to upstream. + +// Code for demangling Rust symbols. This code is mostly +// a line-by-line translation of the Rust code in `rustc-demangle`. + +// you can find the latest version of this code in https://github.com/rust-lang/rustc-demangle + +#include <stdint.h> +#include <stddef.h> +#include <string.h> +#include <stdbool.h> +#include <sys/param.h> +#include <stdio.h> + +#include "demangle-rust-v0.h" + +#if defined(__GNUC__) || defined(__clang__) +#define NODISCARD __attribute__((warn_unused_result)) +#else +#define NODISCARD +#endif + +#define MAX_DEPTH 500 + +typedef enum { + DemangleOk, + DemangleInvalid, + DemangleRecursed, + DemangleBug, +}demangle_status ; + +struct demangle_v0 { +const char *mangled; +size_t mangled_len; +}; + +struct demangle_legacy { +const char *mangled; +size_t mangled_len; +size_t elements; +}; + +// private version of memrchr to avoid _GNU_SOURCE +static void *demangle_memrchr (const void *s,int c,size_t n) { +const uint8_t *s_ = s; +for (; n !=0 ; n--) { +if (s_[n-1 ] == c) { +return (void *)&s_[n-1 ]; + } + } +return NULL ; +} + + +static bool unicode_iscontrol (uint32_t ch) { +// this is *technically* a unicode table, but +// some unicode properties are simpler than you might think +return ch <0x20 || (ch >=0x7f && ch <0xa0 ); +} + +// "good enough" tables, the only consequence is that when printing +// *constant strings*, some characters are printed as `\u{abcd}` rather than themselves. +// +// I'm leaving these here to allow easily replacing them with actual +// tables if desired. +static bool unicode_isprint (uint32_t ch) { +if (ch <0x20 ) { +return false; + } +if (ch <0x7f ) { +return true; + } +return false; +} + +static bool unicode_isgraphemextend (uint32_t ch) { + (void )ch; +return false; +} + +static bool str_isascii (const char *s,size_t s_len) { +for (size_t i =0 ; i < s_len; i++) { +if (s[i] &0x80 ) { +return false; + } + } + +return true; +} + +typedef enum { + PunycodeOk, + PunycodeError +}punycode_status ; + +struct parser { +// the parser assumes that `sym` has a safe "terminating byte". It might be NUL, +// but it might also be something else if a symbol is "truncated". +const char *sym; +size_t sym_len; +size_t next; +uint32_t depth; +}; + +struct printer { +demangle_status status;// if status == 0 parser is valid +struct parser parser; +char *out;// NULL for no output [in which case out_len is not decremented] +size_t out_len; +uint32_t bound_lifetime_depth; +bool alternate; +}; + +static NODISCARD overflow_status printer_print_path(struct printer *printer, bool in_value); +static NODISCARD overflow_status printer_print_type(struct printer *printer); +static NODISCARD overflow_status printer_print_const(struct printer *printer, bool in_value); + +static NODISCARD demangle_status try_parse_path(struct parser *parser) { +struct printer printer = { + DemangleOk, + *parser, +NULL , +SIZE_MAX , +0 , + false + }; +overflow_status ignore =printer_print_path (&printer, false);// can't fail since no output + (void )ignore; + *parser = printer.parser; +return printer.status; +} + +NODISCARD static demangle_status rust_demangle_v0_demangle(const char *s, size_t s_len, struct demangle_v0 *res, const char **rest) { +if (s_len >strlen (s)) { +// s_len only exists to shorten the string, this is not a buffer API +return DemangleInvalid; + } + +const char *inner; +size_t inner_len; +if (s_len >=2 && !strncmp (s,"_R" ,strlen ("_R" ))) { + inner = s+2 ; + inner_len = s_len -2 ; + }else if (s_len >=1 && !strncmp (s,"R" ,strlen ("R" ))) { +// On Windows, dbghelp strips leading underscores, so we accept "R..." +// form too. + inner = s+1 ; + inner_len = s_len -1 ; + }else if (s_len >=3 && !strncmp (s,"__R" ,strlen ("__R" ))) { +// On OSX, symbols are prefixed with an extra _ + inner = s+3 ; + inner_len = s_len -3 ; + }else { +return DemangleInvalid; + } + +// Paths always start with uppercase characters. +if (*inner <'A' || *inner >'Z' ) { +return DemangleInvalid; + } + +if (!str_isascii (inner, inner_len)) { +return DemangleInvalid; + } + +struct parser parser = { inner, inner_len,0 ,0 }; + +demangle_status status =try_parse_path (&parser); +if (status != DemangleOk)return status; +char next = parser.sym[parser.next]; + +// Instantiating crate (paths always start with uppercase characters). +if (parser.next < parser.sym_len && next >='A' && next <='Z' ) { + status =try_parse_path (&parser); +if (status != DemangleOk)return status; + } + + res->mangled = inner; + res->mangled_len = inner_len; +if (rest) { + *rest = parser.sym + parser.next; + } + +return DemangleOk; +} + +// This might require `len` to be up to 3 characters bigger than the real output len in case of utf-8 +NODISCARD static overflow_status rust_demangle_v0_display_demangle(struct demangle_v0 res, char *out, size_t len, bool alternate) { +struct printer printer = { + DemangleOk, + { + res.mangled, + res.mangled_len, +0 , +0 + }, + out, + len, +0 , + alternate + }; +if (printer_print_path (&printer, true) == OverflowOverflow) { +return OverflowOverflow; + } +if (printer.out_len <OVERFLOW_MARGIN ) { +return OverflowOverflow; + } + *printer.out ='\0' ; +return OverflowOk; +} + +static size_t code_to_utf8 (unsigned char *buffer,uint32_t code) +{ +if (code <=0x7F ) { + buffer[0 ] = code; +return 1 ; + } +if (code <=0x7FF ) { + buffer[0 ] =0xC0 | (code >>6 );/* 110xxxxx */ + buffer[1 ] =0x80 | (code &0x3F );/* 10xxxxxx */ +return 2 ; + } +if (code <=0xFFFF ) { + buffer[0 ] =0xE0 | (code >>12 );/* 1110xxxx */ + buffer[1 ] =0x80 | ((code >>6 ) &0x3F );/* 10xxxxxx */ + buffer[2 ] =0x80 | (code &0x3F );/* 10xxxxxx */ +return 3 ; + } +if (code <=0x10FFFF ) { + buffer[0 ] =0xF0 | (code >>18 );/* 11110xxx */ + buffer[1 ] =0x80 | ((code >>12 ) &0x3F );/* 10xxxxxx */ + buffer[2 ] =0x80 | ((code >>6 ) &0x3F );/* 10xxxxxx */ + buffer[3 ] =0x80 | (code &0x3F );/* 10xxxxxx */ +return 4 ; + } +return 0 ; +} + + +// return length of char at byte, or SIZE_MAX if invalid. buf should have 4 valid characters +static NODISCARD size_t utf8_next_char(uint8_t *s, uint32_t *ch) { +uint8_t byte = *s; +// UTF8-1 = %x00-7F +// UTF8-2 = %xC2-DF UTF8-tail +// UTF8-3 = %xE0 %xA0-BF UTF8-tail / %xE1-EC 2( UTF8-tail ) / +// %xED %x80-9F UTF8-tail / %xEE-EF 2( UTF8-tail ) +// UTF8-4 = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) / +// %xF4 %x80-8F 2( UTF8-tail ) +if (byte <0x80 ) { + *ch = byte; +return 1 ; + }else if (byte <0xc2 ) { +return SIZE_MAX ; + }else if (byte <0xe0 ) { +if (s[1 ] >=0x80 && s[1 ] <0xc0 ) { + *ch = ((byte&0x1f )<<6 ) + (s[1 ] &0x3f ); +return 2 ; + } +return SIZE_MAX ; + }if (byte <0xf0 ) { +if (!(s[1 ] >=0x80 && s[1 ] <0xc0 ) || !(s[2 ] >=0x80 && s[2 ] <0xc0 )) { +return SIZE_MAX ;// basic validation + } +if (byte ==0xe0 && s[1 ] <0xa0 ) { +return SIZE_MAX ;// overshort + } +if (byte ==0xed && s[1 ] >=0xa0 ) { +return SIZE_MAX ;// surrogate + } + *ch = ((byte&0x0f )<<12 ) + ((s[1 ] &0x3f )<<6 ) + (s[2 ] &0x3f ); +return 3 ; + }else if (byte <0xf5 ) { +if (!(s[1 ] >=0x80 && s[1 ] <0xc0 ) || !(s[2 ] >=0x80 && s[2 ] <0xc0 ) || !(s[3 ] >=0x80 && s[3 ] <0xc0 )) { +return SIZE_MAX ;// basic validation + } +if (byte ==0xf0 && s[1 ] <0x90 ) { +return SIZE_MAX ;// overshort + } +if (byte ==0xf4 && s[1 ] >=0x90 ) { +return SIZE_MAX ;// over max + } + *ch = ((byte&0x07 )<<18 ) + ((s[1 ] &0x3f )<<12 ) + ((s[2 ] &0x3f )<<6 ) + (s[3 ]&0x3f ); +return 4 ; + }else { +return SIZE_MAX ; + } +} + +static NODISCARD bool validate_char(uint32_t n) { +return ((n ^0xd800 ) -0x800 ) <0x110000 -0x800 ; +} + +#define SMALL_PUNYCODE_LEN 128 + +static NODISCARD punycode_status punycode_decode(const char *start, size_t ascii_len, const char *punycode_start, size_t punycode_len, uint32_t (*out_)[SMALL_PUNYCODE_LEN], size_t *out_len) { +uint32_t *out = *out_; + +if (punycode_len ==0 ) { +return PunycodeError; + } + +if (ascii_len >SMALL_PUNYCODE_LEN ) { +return PunycodeError; + } +for (size_t i =0 ; i < ascii_len; i++) { + out[i] = start[i]; + } +size_t len = ascii_len; + +size_t base =36 , t_min =1 , t_max =26 , skew =38 , damp =700 , bias =72 , i =0 , n =0x80 ; +for (;;) { +size_t delta =0 , w =1 , k =0 ; +for (;;) { + k += base; +size_t biased = k < bias ?0 : k - bias; +size_t t =MIN (MAX (biased, t_min), t_max); +size_t d; +if (punycode_len ==0 ) { +return PunycodeError; + } +char nx = *punycode_start++; + punycode_len--; +if ('a' <= nx && nx <='z' ) { + d = nx -'a' ; + }else if ('0' <= nx && nx <='9' ) { + d =26 + (nx -'0' ); + }else { +return PunycodeError; + } +if (w ==0 || d >SIZE_MAX / w || d*w >SIZE_MAX - delta) { +return PunycodeError; + } + delta += d * w; +if (d < t) { +break ; + } +if (base < t || w ==0 || (base - t) >SIZE_MAX / w) { +return PunycodeError; + } + w *= (base - t); + } + + len +=1 ; +if (i >SIZE_MAX - delta) { +return PunycodeError; + } + i += delta; +if (n >SIZE_MAX - i / len) { +return PunycodeError; + } + n += i / len; + i %= len; + +// char validation +if (n >UINT32_MAX || !validate_char ((uint32_t )n)) { +return PunycodeError; + } + +// insert new character +if (len >SMALL_PUNYCODE_LEN ) { +return PunycodeError; + } +memmove (out + i +1 , out + i, (len - i -1 ) *sizeof (uint32_t )); + out[i] = (uint32_t )n; + +// start i index at incremented position + i++; + +// If there are no more deltas, decoding is complete. +if (punycode_len ==0 ) { + *out_len = len; +return PunycodeOk; + } + +// 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); + } +} + +struct ident { +const char *ascii_start; +size_t ascii_len; +const char *punycode_start; +size_t punycode_len; +}; + +static NODISCARD overflow_status display_ident(const char *ascii_start, size_t ascii_len, const char *punycode_start, size_t punycode_len, uint8_t *out, size_t *out_len) { +uint32_t outbuf[SMALL_PUNYCODE_LEN ]; + +size_t wide_len; +size_t out_buflen = *out_len; + +if (punycode_len ==0 ) { +if (ascii_len > out_buflen) { +return OverflowOverflow; + } +memcpy (out, ascii_start, ascii_len); + *out_len = ascii_len; + }else if (punycode_decode (ascii_start, ascii_len, punycode_start, punycode_len, &outbuf, &wide_len) == PunycodeOk) { +size_t narrow_len =0 ; +for (size_t i =0 ; i < wide_len; i++) { +if (out_buflen - narrow_len <4 ) { +return OverflowOverflow; + } +unsigned char *pos = &out[narrow_len]; + narrow_len +=code_to_utf8 (pos, outbuf[i]); + } + *out_len = narrow_len; + }else { +size_t narrow_len =0 ; +if (out_buflen <strlen ("punycode{" )) { +return OverflowOverflow; + } +memcpy (out,"punycode{" ,strlen ("punycode{" )); + narrow_len =strlen ("punycode{" ); +if (ascii_len >0 ) { +if (out_buflen - narrow_len < ascii_len || out_buflen - narrow_len - ascii_len <1 ) { +return OverflowOverflow; + } +memcpy (out + narrow_len, ascii_start, ascii_len); + narrow_len += ascii_len; + out[narrow_len] ='-' ; + narrow_len++; + } +if (out_buflen - narrow_len < punycode_len || out_buflen - narrow_len - punycode_len <1 ) { +return OverflowOverflow; + } +memcpy (out + narrow_len, punycode_start, punycode_len); + narrow_len += punycode_len; + out[narrow_len] ='}' ; + narrow_len++; + *out_len = narrow_len; + } + +return OverflowOk; +} + +static NODISCARD bool try_parse_uint(const char *buf, size_t len, uint64_t *result) { +size_t cur =0 ; +for (;cur < len && buf[cur] =='0' ;cur++); +uint64_t result_val =0 ; +if (len - cur >16 )return false; +for (;cur < len;cur++) { +char c = buf[cur]; + result_val <<=4 ; +if ('0' <= c && c <='9' ) { + result_val += c -'0' ; + }else if ('a' <= c && c <='f' ) { + result_val +=10 + (c -'a' ); + }else { +return false; + } + } + *result = result_val; +return true; +} + +static NODISCARD bool dinibble2int(const char *buf, uint8_t *result) { +uint8_t result_val =0 ; +for (int i =0 ; i <2 ; i++) { +char c = buf[i]; + result_val <<=4 ; +if ('0' <= c && c <='9' ) { + result_val += c -'0' ; + }else if ('a' <= c && c <='f' ) { + result_val +=10 + (c -'a' ); + }else { +return false; + } + } + *result = result_val; +return true; +} + + +typedef enum { + NtsOk =0 , + NtsOverflow =1 , + NtsInvalid =2 +}nibbles_to_string_status ; + +// '\u{10ffff}', +margin +#define ESCAPED_SIZE 12 + +static NODISCARD size_t char_to_string(uint32_t ch, uint8_t quote, bool first, char (*buf)[ESCAPED_SIZE]) { +// encode the character +char *escaped_buf = *buf; + escaped_buf[0 ] ='\\' ; +size_t escaped_len =2 ; +switch (ch) { +case '\0' : + escaped_buf[1 ] ='0' ; +break ; +case '\t' : + escaped_buf[1 ] ='t' ; +break ; +case '\r' : + escaped_buf[1 ] ='r' ; +break ; +case '\n' : + escaped_buf[1 ] ='n' ; +break ; +case '\\' : + escaped_buf[1 ] ='\\' ; +break ; +default : +if (ch == quote) { + escaped_buf[1 ] = ch; + }else if (!unicode_isprint (ch) || (first &&unicode_isgraphemextend (ch))) { +int hexlen =snprintf (escaped_buf,ESCAPED_SIZE ,"\\u{%x}" , (unsigned int )ch); +if (hexlen <0 ) { +return 0 ;// (snprintf shouldn't fail!) + } + escaped_len = hexlen; + }else { +// printable character + escaped_buf[0 ] = ch; + escaped_len =1 ; + } +break ; + } + +return escaped_len; +} + +// convert nibbles to a single/double-quoted string +static NODISCARD nibbles_to_string_status nibbles_to_string(const char *buf, size_t len, uint8_t *out, size_t *out_len) { +uint8_t quote ='"' ; +bool first = true; + +if ((len %2 ) !=0 ) { +return NtsInvalid;// odd number of nibbles + } + +size_t cur_out_len =0 ; + +// write starting quote +if (out !=NULL ) { + cur_out_len = *out_len; +if (cur_out_len ==0 ) { +return NtsOverflow; + } + *out++ = quote; + cur_out_len--; + } + +uint8_t conv_buf[4 ] = {0 }; +size_t conv_buf_len =0 ; +while (len >1 || conv_buf_len >0 ) { +while (len >1 && conv_buf_len <sizeof (conv_buf)) { +if (!dinibble2int (buf, &conv_buf[conv_buf_len])) { +return NtsInvalid; + } + conv_buf_len++; + buf +=2 ; + len -=2 ; + } + +// conv_buf is full here if possible, process 1 UTF-8 character +uint32_t ch =0 ; +size_t consumed =utf8_next_char (conv_buf, &ch); +if (consumed > conv_buf_len) { +// either SIZE_MAX (invalid UTF-8) or finished input buffer and +// there are still bytes remaining, in both cases invalid +return NtsInvalid; + } + +// "consume" the character +memmove (conv_buf, conv_buf+consumed, conv_buf_len-consumed); + conv_buf_len -= consumed; + +char escaped_buf[ESCAPED_SIZE ]; +size_t escaped_len =char_to_string (ch,'"' , first, &escaped_buf); +if (out !=NULL ) { +if (cur_out_len < escaped_len) { +return NtsOverflow; + } +memcpy (out, escaped_buf, escaped_len); + out += escaped_len; + cur_out_len -= escaped_len; + } + first = false; + } + +// write ending quote +if (out !=NULL ) { +if (cur_out_len ==0 ) { +return NtsOverflow; + } + *out++ = quote; + cur_out_len--; + *out_len -= cur_out_len;// subtract remaining space to get used space + } + +return NtsOk; +} + +static const char *basic_type (uint8_t 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 NODISCARD demangle_status parser_push_depth(struct parser *parser) { + parser->depth++; +if (parser->depth >MAX_DEPTH ) { +return DemangleRecursed; + }else { +return DemangleOk; + } +} + +static demangle_status parser_pop_depth (struct parser *parser) { + parser->depth--; +return DemangleOk; +} + +static uint8_t parser_peek (struct parser const *parser) { +if (parser->next == parser->sym_len) { +return 0 ;// add a "pseudo nul terminator" to avoid peeking past the end of a symbol + }else { +return parser->sym[parser->next]; + } +} + +static bool parser_eat (struct parser *parser,uint8_t ch) { +if (parser_peek (parser) == ch) { +if (ch !=0 ) {// safety: make sure we don't skip past the NUL terminator + parser->next++; + } +return true; + }else { +return false; + } +} + +static uint8_t parser_next (struct parser *parser) { +// don't advance after end of input, and return an imaginary NUL terminator +if (parser->next == parser->sym_len) { +return 0 ; + }else { +return parser->sym[parser->next++]; + } +} + +static NODISCARD demangle_status parser_ch(struct parser *parser, uint8_t *next) { +// don't advance after end of input +if (parser->next == parser->sym_len) { +return DemangleInvalid; + }else { + *next = parser->sym[parser->next++]; +return DemangleOk; + } +} + +struct buf { +const char *start; +size_t len; +}; + +static NODISCARD demangle_status parser_hex_nibbles(struct parser *parser, struct buf *buf) { +size_t start = parser->next; +for (;;) { +uint8_t ch =parser_next (parser); +if (ch =='_' ) { +break ; + } +if (!(('0' <= ch && ch <='9' ) || ('a' <= ch && ch <='f' ))) { +return DemangleInvalid; + } + } + buf->start = parser->sym + start; + buf->len = parser->next - start -1 ;// skip final _ +return DemangleOk; +} + +static NODISCARD demangle_status parser_digit_10(struct parser *parser, uint8_t *out) { +uint8_t ch =parser_peek (parser); +if ('0' <= ch && ch <='9' ) { + *out = ch -'0' ; + parser->next++; +return DemangleOk; + }else { +return DemangleInvalid; + } +} + +static NODISCARD demangle_status parser_digit_62(struct parser *parser, uint64_t *out) { +uint8_t ch =parser_peek (parser); +if ('0' <= ch && ch <='9' ) { + *out = ch -'0' ; + parser->next++; +return DemangleOk; + }else if ('a' <= ch && ch <='z' ) { + *out =10 + (ch -'a' ); + parser->next++; +return DemangleOk; + }else if ('A' <= ch && ch <='Z' ) { + *out =10 +26 + (ch -'A' ); + parser->next++; +return DemangleOk; + }else { +return DemangleInvalid; + } +} + +static NODISCARD demangle_status parser_integer_62(struct parser *parser, uint64_t *out) { +if (parser_eat (parser,'_' )) { + *out =0 ; +return DemangleOk; + } + +uint64_t x =0 ; +demangle_status status; +while (!parser_eat (parser,'_' )) { +uint64_t d; +if ((status =parser_digit_62 (parser, &d)) != DemangleOk) { +return status; + } +if (x >UINT64_MAX /62 ) { +return DemangleInvalid; + } + x *=62 ; +if (x >UINT64_MAX - d) { +return DemangleInvalid; + } + x += d; + } +if (x ==UINT64_MAX ) { +return DemangleInvalid; + } + *out = x +1 ; +return DemangleOk; +} + +static NODISCARD demangle_status parser_opt_integer_62(struct parser *parser, uint8_t tag, uint64_t *out) { +if (!parser_eat (parser, tag)) { + *out =0 ; +return DemangleOk; + } + +demangle_status status; +if ((status =parser_integer_62 (parser, out)) != DemangleOk) { +return status; + } +if (*out ==UINT64_MAX ) { +return DemangleInvalid; + } + *out = *out +1 ; +return DemangleOk; +} + +static NODISCARD demangle_status parser_disambiguator(struct parser *parser, uint64_t *out) { +return parser_opt_integer_62 (parser,'s' , out); +} + +typedef uint8_t parser_namespace_type ; + +static NODISCARD demangle_status parser_namespace(struct parser *parser, parser_namespace_type *out) { +uint8_t next =parser_next (parser); +if ('A' <= next && next <='Z' ) { + *out = next; +return DemangleOk; + }else if ('a' <= next && next <='z' ) { + *out =0 ; +return DemangleOk; + }else { +return DemangleInvalid; + } +} + +static NODISCARD demangle_status parser_backref(struct parser *parser, struct parser *out) { +size_t start = parser->next; +if (start ==0 ) { +return DemangleBug; + } +size_t s_start = start -1 ; +uint64_t i; +demangle_status status =parser_integer_62 (parser, &i); +if (status != DemangleOk) { +return status; + } +if (i >= s_start) { +return DemangleInvalid; + } +struct parser res = { + .sym = parser->sym, + .sym_len = parser->sym_len, + .next = (size_t )i, + .depth = parser->depth + }; + status =parser_push_depth (&res); +if (status != DemangleOk) { +return status; + } + *out = res; +return DemangleOk; +} + +static NODISCARD demangle_status parser_ident(struct parser *parser, struct ident *out) { +bool is_punycode =parser_eat (parser,'u' ); +size_t len; +uint8_t d; +demangle_status status =parser_digit_10 (parser, &d); + len = d; +if (status != DemangleOk) { +return status; + } +if (len) { +for (;;) { + status =parser_digit_10 (parser, &d); +if (status != DemangleOk) { +break ; + } +if (len >SIZE_MAX /10 ) { +return DemangleInvalid; + } + len *=10 ; +if (len >SIZE_MAX - d) { +return DemangleInvalid; + } + len += d; + } + } + +// Skip past the optional `_` separator. +parser_eat (parser,'_' ); + +size_t start = parser->next; +if (parser->sym_len - parser->next < len) { +return DemangleInvalid; + } + parser->next += len; + +const char *ident = &parser->sym[start]; + +if (is_punycode) { +const char *underscore =demangle_memrchr (ident,'_' , (size_t )len); +if (underscore ==NULL ) { + *out = (struct ident ){ + .ascii_start="" , + .ascii_len=0 , + .punycode_start=ident, + .punycode_len=len + }; + }else { +size_t ascii_len = underscore - ident; +// ascii_len <= len - 1 since `_` is in the first len bytes +size_t punycode_len = len -1 - ascii_len; + *out = (struct ident ){ + .ascii_start=ident, + .ascii_len=ascii_len, + .punycode_start=underscore +1 , + .punycode_len=punycode_len + }; + } +if (out->punycode_len ==0 ) { +return DemangleInvalid; + } +return DemangleOk; + }else { + *out = (struct ident ) { + .ascii_start=ident, + .ascii_len=(size_t )len, + .punycode_start="" , + .punycode_len=0 , + }; +return DemangleOk; + } +} + +#define INVALID_SYNTAX "{invalid syntax}" + +static const char *demangle_error_message (demangle_status status) { +switch (status) { +case DemangleInvalid: +return INVALID_SYNTAX ; +case DemangleBug: +return "{bug}" ; +case DemangleRecursed: +return "{recursion limit reached}" ; +default : +return "{unknown error}" ; + } +} + +#define #define PRINT_CH (printer, s) PRINT(printer_print_ch((printer), (s))) +#define PRINT_STR (printer, s) PRINT(printer_print_str((printer), (s))) +#define PRINT_U64 (printer, s) PRINT(printer_print_u64((printer), (s))) +#define PRINT_IDENT (printer, s) PRINT(printer_print_ident((printer), (s))) + +#define INVALID (printer) \ + do { \ + PRINT_STR((printer), INVALID_SYNTAX); \ + (printer)->status = DemangleInvalid; \ + return OverflowOk; \ + } while(0) + +#define PARSE (printer, method, ...) \ + do { \ + if ((printer)->status != DemangleOk) { \ + PRINT_STR((printer), "?"); \ + return OverflowOk; \ + } else { \ + demangle_status _parse_status = method(&(printer)->parser, ## __VA_ARGS__); \ + if (_parse_status != DemangleOk) { \ + PRINT_STR((printer), demangle_error_message(_parse_status)); \ + (printer)->status = _parse_status; \ + return OverflowOk; \ + } \ + } \ + } while(0) + +#define PRINT_SEP_LIST (printer, body, sep) \ + do { \ + size_t _sep_list_i; \ + PRINT_SEP_LIST_COUNT(printer, _sep_list_i, body, sep); \ + } while(0) + +#define PRINT_SEP_LIST_COUNT (printer, count, body, sep) \ + do { \ + count = 0; \ + while ((printer)->status == DemangleOk && !printer_eat((printer), 'E')) { \ + if (count > 0) { PRINT_STR(printer, sep); } \ + body; \ + count++; \ + } \ + } while(0) + +static bool printer_eat (struct printer *printer,uint8_t b) { +if (printer->status != DemangleOk) { +return false; + } + +return parser_eat (&printer->parser, b); +} + +static void printer_pop_depth (struct printer *printer) { +if (printer->status == DemangleOk) { +parser_pop_depth (&printer->parser); + } +} + +static NODISCARD overflow_status printer_print_buf(struct printer *printer, const char *start, size_t len) { +if (printer->out ==NULL ) { +return OverflowOk; + } +if (printer->out_len < len) { +return OverflowOverflow; + } + +memcpy (printer->out, start, len); + printer->out += len; + printer->out_len -= len; +return OverflowOk; +} + +static NODISCARD overflow_status printer_print_str(struct printer *printer, const char *buf) { +return printer_print_buf (printer, buf,strlen (buf)); +} + +static NODISCARD overflow_status printer_print_ch(struct printer *printer, char ch) { +return printer_print_buf (printer, &ch,1 ); +} + +static NODISCARD overflow_status printer_print_u64(struct printer *printer, uint64_t n) { +char buf[32 ] = {0 }; +sprintf (buf,"%llu" , (unsigned long long )n);// printing uint64 uses 21 < 32 chars +return printer_print_str (printer, buf); +} + +static NODISCARD overflow_status printer_print_ident(struct printer *printer, struct ident *ident) { +if (printer->out ==NULL ) { +return OverflowOk; + } + +size_t out_len = printer->out_len; +overflow_status status; +if ((status =display_ident (ident->ascii_start, ident->ascii_len, ident->punycode_start, ident->punycode_len, (uint8_t *)printer->out, &out_len)) != OverflowOk) { +return status; + } + printer->out += out_len; + printer->out_len -= out_len; +return OverflowOk; +} + +typedef overflow_status (*printer_fn )(struct printer *printer); +typedef overflow_status (*backref_fn )(struct printer *printer,bool *arg); + +static NODISCARD overflow_status printer_print_backref(struct printer *printer, backref_fn func, bool *arg) { +struct parser backref; +PARSE (printer, parser_backref, &backref); + +if (printer->out ==NULL ) { +return OverflowOk; + } + +struct parser orig_parser = printer->parser; +demangle_status orig_status = printer->status;// fixme not sure this is needed match for Ok on the Rust side + printer->parser = backref; + printer->status = DemangleOk; +overflow_status status =func (printer, arg); + printer->parser = orig_parser; + printer->status = orig_status; + +return status; +} + +static NODISCARD overflow_status printer_print_lifetime_from_index(struct printer *printer, uint64_t lt) { +// Bound lifetimes aren't tracked when skipping printing. +if (printer->out ==NULL ) { +return OverflowOk; + } + +PRINT_STR (printer,"'" ); +if (lt ==0 ) { +PRINT_STR (printer,"_" ); +return OverflowOk; + } + +if (printer->bound_lifetime_depth < lt) { +INVALID (printer); + }else { +uint64_t depth = printer->bound_lifetime_depth - lt; +if (depth <26 ) { +PRINT_CH (printer,'a' + depth); + }else { +PRINT_STR (printer,"_" ); +PRINT_U64 (printer, depth); + } + +return OverflowOk; + } +} + +static NODISCARD overflow_status printer_in_binder(struct printer *printer, printer_fn func) { +uint64_t bound_lifetimes; +PARSE (printer, parser_opt_integer_62,'G' , &bound_lifetimes); + +// Don't track bound lifetimes when skipping printing. +if (printer->out ==NULL ) { +return func (printer); + } + +if (bound_lifetimes >0 ) { +PRINT_STR (printer,"for<" ); +for (uint64_t i =0 ; i < bound_lifetimes; i++) { +if (i >0 ) { +PRINT_STR (printer,", " ); + } + printer->bound_lifetime_depth++; +printer_print_lifetime_from_index (printer,1 )); + } +PRINT_STR (printer,"> " ); + } + +overflow_status r =func (printer); + printer->bound_lifetime_depth -= bound_lifetimes; + +return r; +} + +static NODISCARD overflow_status printer_print_generic_arg(struct printer *printer) { +if (printer_eat (printer,'L' )) { +uint64_t lt; +PARSE (printer, parser_integer_62, <); +return printer_print_lifetime_from_index (printer, lt); + }else if (printer_eat (printer,'K' )) { +return printer_print_const (printer, false); + }else { +return printer_print_type (printer); + } +} + +static NODISCARD overflow_status printer_print_generic_args(struct printer *printer) { +PRINT_STR (printer,"<" ); +PRINT_SEP_LIST (printer,printer_print_generic_arg (printer)),", " ); +PRINT_STR (printer,">" ); +return OverflowOk; +} + +static NODISCARD overflow_status printer_print_path_out_of_value(struct printer *printer, bool *_arg) { + (void )_arg; +return printer_print_path (printer, false); +} + +static NODISCARD overflow_status printer_print_path_in_value(struct printer *printer, bool *_arg) { + (void )_arg; +return printer_print_path (printer, true); +} + +static NODISCARD overflow_status printer_print_path(struct printer *printer, bool in_value) { +PARSE (printer, parser_push_depth); +uint8_t tag; +PARSE (printer, parser_ch, &tag); + +overflow_status st; +uint64_t dis; +struct ident name; +parser_namespace_type ns; +char *orig_out; + +switch (tag) { +case 'C' : +PARSE (printer, parser_disambiguator, &dis); +PARSE (printer, parser_ident, &name); + +PRINT_IDENT (printer, &name); + +if (printer->out !=NULL && !printer->alternate && dis !=0 ) { +PRINT_STR (printer,"[" ); +char buf[24 ] = {0 }; +sprintf (buf,"%llx" , (unsigned long long )dis); +PRINT_STR (printer, buf); +PRINT_STR (printer,"]" ); + } +break ; +case 'N' : +PARSE (printer, parser_namespace, &ns); +if ((st =printer_print_path (printer, in_value)) != OverflowOk) { +return st; + } + +// HACK(eddyb) if the parser is already marked as having errored, +// `parse!` below will print a `?` without its preceding `::` +// (because printing the `::` is skipped in certain conditions, +// i.e. a lowercase namespace with an empty identifier), +// so in order to get `::?`, the `::` has to be printed here. +if (printer->status != DemangleOk) { +PRINT_STR (printer,"::" ); + } + +PARSE (printer, parser_disambiguator, &dis); +PARSE (printer, parser_ident, &name); +// Special namespace, like closures and shims +if (ns) { +PRINT_STR (printer,"::{" ); +if (ns =='C' ) { +PRINT_STR (printer,"closure" ); + }else if (ns =='S' ) { +PRINT_STR (printer,"shim" ); + }else { +PRINT_CH (printer, ns); + } +if (name.ascii_len !=0 || name.punycode_len !=0 ) { +PRINT_STR (printer,":" ); +PRINT_IDENT (printer, &name); + } +PRINT_STR (printer,"#" ); +PRINT_U64 (printer, dis); +PRINT_STR (printer,"}" ); + }else { +// Implementation-specific/unspecified namespaces +if (name.ascii_len !=0 || name.punycode_len !=0 ) { +PRINT_STR (printer,"::" ); +PRINT_IDENT (printer, &name); + } + } +break ; +case 'M' : +case 'X' : +// for impls, ignore the impls own path +PARSE (printer, parser_disambiguator, &dis); + orig_out = printer->out; + printer->out =NULL ; +printer_print_path (printer, false)); + printer->out = orig_out; + +// fallthru +case 'Y' : +PRINT_STR (printer,"<" ); +printer_print_type (printer)); +if (tag !='M' ) { +PRINT_STR (printer," as " ); +printer_print_path (printer, false)); + } +PRINT_STR (printer,">" ); +break ; +case 'I' : +printer_print_path (printer, in_value)); +if (in_value) { +PRINT_STR (printer,"::" ); + } +printer_print_generic_args (printer)); +break ; +case 'B' : +printer_print_backref (printer, in_value ? printer_print_path_in_value : printer_print_path_out_of_value,NULL )); +break ; +default : +INVALID (printer); +break ; + } + +printer_pop_depth (printer); +return OverflowOk; +} + +static NODISCARD overflow_status printer_print_const_uint(struct printer *printer, uint8_t tag) { +struct buf hex; +PARSE (printer, parser_hex_nibbles, &hex); + +uint64_t val; +if (try_parse_uint (hex.start, hex.len, &val)) { +PRINT_U64 (printer, val); + }else { +PRINT_STR (printer,"0x" ); +printer_print_buf (printer, hex.start, hex.len)); + } + +if (printer->out !=NULL && !printer->alternate) { +const char *ty =basic_type (tag); +if (/* safety */ ty !=NULL ) { +PRINT_STR (printer, ty); + } + } + +return OverflowOk; +} + +static NODISCARD overflow_status printer_print_const_str_literal(struct printer *printer) { +struct buf hex; +PARSE (printer, parser_hex_nibbles, &hex); + +size_t out_len =SIZE_MAX ; +nibbles_to_string_status nts_status =nibbles_to_string (hex.start, hex.len,NULL , &out_len); +switch (nts_status) { +case NtsOk: +if (printer->out !=NULL ) { + out_len = printer->out_len; + nts_status =nibbles_to_string (hex.start, hex.len, (uint8_t *)printer->out, &out_len); +if (nts_status != NtsOk) { +return OverflowOverflow; + } + printer->out += out_len; + printer->out_len -= out_len; + } +return OverflowOk; +case NtsOverflow: +// technically if there is a string of size `SIZE_MAX/6` whose escaped version overflows +// SIZE_MAX but has an invalid char, this will be a "fake" overflow. In practice, +// that is not going to happen and a fuzzer will not generate strings of this length. +return OverflowOverflow; +case NtsInvalid: +default : +INVALID (printer); + } +} + +static NODISCARD overflow_status printer_print_const_struct(struct printer *printer) { +uint64_t dis; +struct ident name; +PARSE (printer, parser_disambiguator, &dis); +PARSE (printer, parser_ident, &name); +PRINT_IDENT (printer, &name); +PRINT_STR (printer,": " ); +return printer_print_const (printer, true); +} + +static NODISCARD overflow_status printer_print_const_out_of_value(struct printer *printer, bool *_arg) { + (void )_arg; +return printer_print_const (printer, false); +} + +static NODISCARD overflow_status printer_print_const_in_value(struct printer *printer, bool *_arg) { + (void )_arg; +return printer_print_const (printer, true); +} + +static NODISCARD overflow_status printer_print_const(struct printer *printer, bool in_value) { +uint8_t tag; + +PARSE (printer, parser_ch, &tag); +PARSE (printer, parser_push_depth); + +struct buf hex; +uint64_t val; +size_t count; + +bool opened_brace = false; +#define OPEN_BRACE_IF_OUTSIDE_EXPR \ + do { if (!in_value) { \ + opened_brace = true; \ + PRINT_STR(printer, "{"); \ + } } while(0) + +switch (tag) { +case 'p' : +PRINT_STR (printer,"_" ); +break ; +// Primitive leaves with hex-encoded values (see `basic_type`). +case 'a' : +case 's' : +case 'l' : +case 'x' : +case 'n' : +case 'i' : +if (printer_eat (printer,'n' )) { +PRINT_STR (printer,"-" ); + } +/* fallthrough */ +case 'h' : +case 't' : +case 'm' : +case 'y' : +case 'o' : +case 'j' : +printer_print_const_uint (printer, tag)); +break ; +case 'b' : +PARSE (printer, parser_hex_nibbles, &hex); +if (try_parse_uint (hex.start, hex.len, &val)) { +if (val ==0 ) { +PRINT_STR (printer,"false" ); + }else if (val ==1 ) { +PRINT_STR (printer,"true" ); + }else { +INVALID (printer); + } + }else { +INVALID (printer); + } +break ; +case 'c' : +PARSE (printer, parser_hex_nibbles, &hex); +if (try_parse_uint (hex.start, hex.len, &val) + && val <UINT32_MAX + &&validate_char ((uint32_t )val)) + { +char escaped_buf[ESCAPED_SIZE ]; +size_t escaped_size =char_to_string ((uint32_t )val,'\'' , true, &escaped_buf); + +PRINT_STR (printer,"'" ); +printer_print_buf (printer, escaped_buf, escaped_size)); +PRINT_STR (printer,"'" ); + }else { +INVALID (printer); + } +break ; +case 'e' : +OPEN_BRACE_IF_OUTSIDE_EXPR ; +PRINT_STR (printer,"*" ); +printer_print_const_str_literal (printer)); +break ; +case 'R' : +case 'Q' : +if (tag =='R' &&printer_eat (printer,'e' )) { +printer_print_const_str_literal (printer)); + }else { +OPEN_BRACE_IF_OUTSIDE_EXPR ; +PRINT_STR (printer,"&" ); +if (tag !='R' ) { +PRINT_STR (printer,"mut " ); + } +printer_print_const (printer, true)); + } +break ; +case 'A' : +OPEN_BRACE_IF_OUTSIDE_EXPR ; +PRINT_STR (printer,"[" ); +PRINT_SEP_LIST (printer,printer_print_const (printer, true)),", " ); +PRINT_STR (printer,"]" ); +break ; +case 'T' : +OPEN_BRACE_IF_OUTSIDE_EXPR ; +PRINT_STR (printer,"(" ); +PRINT_SEP_LIST_COUNT (printer, count,printer_print_const (printer, true)),", " ); +if (count ==1 ) { +PRINT_STR (printer,"," ); + } +PRINT_STR (printer,")" ); +break ; +case 'V' : +OPEN_BRACE_IF_OUTSIDE_EXPR ; +printer_print_path (printer, true)); +PARSE (printer, parser_ch, &tag); +switch (tag) { +case 'U' : +break ; +case 'T' : +PRINT_STR (printer,"(" ); +PRINT_SEP_LIST (printer,printer_print_const (printer, true)),", " ); +PRINT_STR (printer,")" ); +break ; +case 'S' : +PRINT_STR (printer," { " ); +PRINT_SEP_LIST (printer,printer_print_const_struct (printer)),", " ); +PRINT_STR (printer," }" ); +break ; +default : +INVALID (printer); + } +break ; +case 'B' : +printer_print_backref (printer, in_value ? printer_print_const_in_value : printer_print_const_out_of_value,NULL )); +break ; +default : +INVALID (printer); + } +#undef OPEN_BRACE_IF_OUTSIDE_EXPR + +if (opened_brace) { +PRINT_STR (printer,"}" ); + } +printer_pop_depth (printer); + +return OverflowOk; +} + +/// 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 NODISCARD overflow_status printer_print_maybe_open_generics(struct printer *printer, bool *open) { +if (printer_eat (printer,'B' )) { +// NOTE(eddyb) the closure may not run if printing is being skipped, +// but in that case the returned boolean doesn't matter. + *open = false; +return printer_print_backref (printer, printer_print_maybe_open_generics, open); + }else if (printer_eat (printer,'I' )) { +printer_print_path (printer, false)); +PRINT_STR (printer,"<" ); +PRINT_SEP_LIST (printer,printer_print_generic_arg (printer)),", " ); + *open = true; +return OverflowOk; + }else { +printer_print_path (printer, false)); + *open = false; +return OverflowOk; + } +} + +static NODISCARD overflow_status printer_print_dyn_trait(struct printer *printer) { +bool open; +printer_print_maybe_open_generics (printer, &open)); + +while (printer_eat (printer,'p' )) { +if (!open) { +PRINT_STR (printer,"<" ); + open = true; + }else { +PRINT_STR (printer,", " ); + } + +struct ident name; +PARSE (printer, parser_ident, &name); + +PRINT_IDENT (printer, &name); +PRINT_STR (printer," = " ); +printer_print_type (printer)); + } + +if (open) { +PRINT_STR (printer,">" ); + } + +return OverflowOk; +} + +static NODISCARD overflow_status printer_print_object_bounds(struct printer *printer) { +PRINT_SEP_LIST (printer,printer_print_dyn_trait (printer))," + " ); +return OverflowOk; +} + +static NODISCARD overflow_status printer_print_function_type(struct printer *printer) { +bool is_unsafe =printer_eat (printer,'U' ); +const char *abi; +size_t abi_len; +if (printer_eat (printer,'K' )) { +if (printer_eat (printer,'C' )) { + abi ="C" ; + abi_len =1 ; + }else { +struct ident abi_ident; +PARSE (printer, parser_ident, &abi_ident); +if (abi_ident.ascii_len ==0 || abi_ident.punycode_len !=0 ) { +INVALID (printer); + } + abi = abi_ident.ascii_start; + abi_len = abi_ident.ascii_len; + } + }else { + abi =NULL ; + abi_len =0 ; + } + +if (is_unsafe) { +PRINT_STR (printer,"unsafe " ); + } + +if (abi !=NULL ) { +PRINT_STR (printer,"extern \"" ); + +// replace _ with - +while (abi_len >0 ) { +const char *minus =memchr (abi,'_' , abi_len); +if (minus ==NULL ) { +printer_print_buf (printer, (const char *)abi, abi_len)); +break ; + }else { +size_t space_to_minus = minus - abi; +printer_print_buf (printer, (const char *)abi, space_to_minus)); +PRINT_STR (printer,"-" ); + abi = minus +1 ; + abi_len -= (space_to_minus +1 ); + } + } + +PRINT_STR (printer,"\" " ); + } + +PRINT_STR (printer,"fn(" ); +PRINT_SEP_LIST (printer,printer_print_type (printer)),", " ); +PRINT_STR (printer,")" ); + +if (printer_eat (printer,'u' )) { +// Skip printing the return type if it's 'u', i.e. `()`. + }else { +PRINT_STR (printer," -> " ); +printer_print_type (printer)); + } + +return OverflowOk; +} + +static NODISCARD overflow_status printer_print_type_backref(struct printer *printer, bool *_arg) { + (void )_arg; +return printer_print_type (printer); +} + +static NODISCARD overflow_status printer_print_type(struct printer *printer) { +uint8_t tag; +PARSE (printer, parser_ch, &tag); + +const char *basic_ty =basic_type (tag); +if (basic_ty) { +return printer_print_str (printer, basic_ty); + } + +uint64_t count; +uint64_t lt; + +PARSE (printer, parser_push_depth); +switch (tag) { +case 'R' : +case 'Q' : +PRINT_STR (printer,"&" ); +if (printer_eat (printer,'L' )) { +PARSE (printer, parser_integer_62, <); +if (lt !=0 ) { +printer_print_lifetime_from_index (printer, lt)); +PRINT_STR (printer," " ); + } + } +if (tag !='R' ) { +PRINT_STR (printer,"mut " ); + } +printer_print_type (printer)); +break ; +case 'P' : +case 'O' : +PRINT_STR (printer,"*" ); +if (tag !='P' ) { +PRINT_STR (printer,"mut " ); + }else { +PRINT_STR (printer,"const " ); + } +printer_print_type (printer)); +break ; +case 'A' : +case 'S' : +PRINT_STR (printer,"[" ); +printer_print_type (printer)); +if (tag =='A' ) { +PRINT_STR (printer,"; " ); +printer_print_const (printer, true)); + } +PRINT_STR (printer,"]" ); +break ; +case 'T' : +PRINT_STR (printer,"(" ); +PRINT_SEP_LIST_COUNT (printer, count,printer_print_type (printer)),", " ); +if (count ==1 ) { +PRINT_STR (printer,"," ); + } +PRINT_STR (printer,")" ); +break ; +case 'F' : +printer_in_binder (printer, printer_print_function_type)); +break ; +case 'D' : +PRINT_STR (printer,"dyn " ); +printer_in_binder (printer, printer_print_object_bounds)); + +if (!printer_eat (printer,'L' )) { +INVALID (printer); + } +PARSE (printer, parser_integer_62, <); + +if (lt !=0 ) { +PRINT_STR (printer," + " ); +printer_print_lifetime_from_index (printer, lt)); + } +break ; +case 'B' : +printer_print_backref (printer, printer_print_type_backref,NULL )); +break ; +default : +// Go back to the tag, so `print_path` also sees it. +if (printer->status == DemangleOk &&/* safety */ printer->parser.next >0 ) { + printer->parser.next--; + } +printer_print_path (printer, false)); + } + +printer_pop_depth (printer); +return OverflowOk; +} + +NODISCARD static demangle_status rust_demangle_legacy_demangle(const char *s, size_t s_len, struct demangle_legacy *res, const char **rest) +{ +if (s_len >strlen (s)) { +// s_len only exists to shorten the string, this is not a buffer API +return DemangleInvalid; + } + +const char *inner; +size_t inner_len; +if (s_len >=3 && !strncmp (s,"_ZN" ,3 )) { + inner = s +3 ; + inner_len = s_len -3 ; + }else if (s_len >=2 && !strncmp (s,"ZN" ,2 )) { +// On Windows, dbghelp strips leading underscores, so we accept "ZN...E" +// form too. + inner = s +2 ; + inner_len = s_len -2 ; + }else if (s_len >=4 && !strncmp (s,"__ZN" ,4 )) { +// On OSX, symbols are prefixed with an extra _ + inner = s +4 ; + inner_len = s_len -4 ; + }else { +return DemangleInvalid; + } + +if (!str_isascii (inner, inner_len)) { +return DemangleInvalid; + } + +size_t elements =0 ; +const char *chars = inner; +size_t chars_len = inner_len; +if (chars_len ==0 ) { +return DemangleInvalid; + } +char c; +while ((c = *chars) !='E' ) { +// Decode an identifier element's length +if (c <'0' || c >'9' ) { +return DemangleInvalid; + } +size_t len =0 ; +while (c >='0' && c <='9' ) { +size_t d = c -'0' ; +if (len >SIZE_MAX /10 ) { +return DemangleInvalid; + } + len *=10 ; +if (len >SIZE_MAX - d) { +return DemangleInvalid; + } + len += d; + + chars++; + chars_len--; +if (chars_len ==0 ) { +return DemangleInvalid; + } + c = *chars; + } + +// Advance by the length +if (chars_len <= len) { +return DemangleInvalid; + } + chars += len; + chars_len -= len; + elements++; + } + *res = (struct demangle_legacy ) { inner, inner_len, elements }; + *rest = chars +1 ; +return DemangleOk; +} + +static bool is_rust_hash (const char *s,size_t len) { +if (len ==0 || s[0 ] !='h' ) { +return false; + } + +for (size_t i =1 ; i < len; i++) { +if (!((s[i] >='0' && s[i] <='9' ) || (s[i] >='a' && s[i] <='f' ) || (s[i] >='A' && s[i] <='F' ))) { +return false; + } + } + +return true; +} + +NODISCARD static overflow_status rust_demangle_legacy_display_demangle(struct demangle_legacy res, char *out, size_t len, bool alternate) +{ +struct printer printer = { +// not actually using the parser part of the printer, just keeping it to share the format functions + DemangleOk, + {NULL }, + out, + len, +0 , + alternate + }; +const char *inner = res.mangled; +for (size_t element =0 ; element < res.elements; element++) { +size_t i =0 ; +const char *rest; +for (rest = inner; rest < res.mangled + res.mangled_len && *rest >='0' && *rest <='9' ; rest++) { + i *=10 ; + i += *rest -'0' ; + } +if ((size_t )(res.mangled + res.mangled_len - rest) < i) { +// safety: shouldn't reach this place if the input string is validated. bail out. +// safety: we knwo rest <= res.mangled + res.mangled_len from the for-loop above +break ; + } + +size_t len = i; + inner = rest + len; + +// From here on, inner contains a pointer to the next element, rest[:len] to the current one +if (alternate && element +1 == res.elements &&is_rust_hash (rest, i)) { +break ; + } +if (element !=0 ) { +PRINT_STR (&printer,"::" ); + } + +if (len >=2 && !strncmp (rest,"_$" ,2 )) { + rest++; + len--; + } + +while (len >0 ) { +if (rest[0 ] =='.' ) { +if (len >=2 && rest[1 ] =='.' ) { +PRINT_STR (&printer,"::" ); + rest +=2 ; + len -=2 ; + }else { +PRINT_STR (&printer,"." ); + rest +=1 ; + len -=1 ; + } + }else if (rest[0 ] =='$' ) { +const char *escape =memchr (rest +1 ,'$' , len -1 ); +if (escape ==NULL ) { +break ; + } +const char *escape_start = rest +1 ; +size_t escape_len = escape - (rest +1 ); + +size_t next_len = len - (escape +1 - rest); +const char *next_rest = escape +1 ; + +char ch; +if ((escape_len ==2 && escape_start[0 ] =='S' && escape_start[1 ] =='P' )) { + ch ='@' ; + }else if ((escape_len ==2 && escape_start[0 ] =='B' && escape_start[1 ] =='P' )) { + ch ='*' ; + }else if ((escape_len ==2 && escape_start[0 ] =='R' && escape_start[1 ] =='F' )) { + ch ='&' ; + }else if ((escape_len ==2 && escape_start[0 ] =='L' && escape_start[1 ] =='T' )) { + ch ='<' ; + }else if ((escape_len ==2 && escape_start[0 ] =='G' && escape_start[1 ] =='T' )) { + ch ='>' ; + }else if ((escape_len ==2 && escape_start[0 ] =='L' && escape_start[1 ] =='P' )) { + ch ='(' ; + }else if ((escape_len ==2 && escape_start[0 ] =='R' && escape_start[1 ] =='P' )) { + ch =')' ; + }else if ((escape_len ==1 && escape_start[0 ] =='C' )) { + ch =',' ; + }else { +if (escape_len >1 && escape_start[0 ] =='u' ) { + escape_start++; + escape_len--; +uint64_t val; +if (try_parse_uint (escape_start, escape_len, &val) + && val <UINT32_MAX + &&validate_char ((uint32_t )val)) + { +if (!unicode_iscontrol (val)) { +uint8_t wchr[4 ]; +size_t wchr_len =code_to_utf8 (wchr, (uint32_t )val); +printer_print_buf (&printer, (const char *)wchr, wchr_len)); + len = next_len; + rest = next_rest; +continue ; + } + } + } +break ;// print the rest of this element raw + } +PRINT_CH (&printer, ch); + len = next_len; + rest = next_rest; + }else { +size_t j =0 ; +for (;j < len && rest[j] !='$' && rest[j] !='.' ;j++); +if (j == len) { +break ; + } +printer_print_buf (&printer, rest, j)); + rest += j; + len -= j; + } + } +printer_print_buf (&printer, rest, len)); + } + +if (printer.out_len <OVERFLOW_MARGIN ) { +return OverflowOverflow; + } + *printer.out ='\0' ; +return OverflowOk; +} + +static bool is_symbol_like (const char *s,size_t len) { +// rust-demangle definition of symbol like: control characters and space are not symbol-like, all else is +for (size_t i =0 ; i < len; i++) { +char ch = s[i]; +if (!(ch >=0x21 && ch <=0x7e )) { +return false; + } + } +return true; +} + +void rust_demangle_demangle (const char *s,struct demangle *res) +{ +// During ThinLTO LLVM may import and rename internal symbols, so strip out +// those endings first as they're one of the last manglings applied to symbol +// names. +const char *llvm =".llvm." ; +const char *found_llvm =strstr (s, llvm); +size_t s_len =strlen (s); +if (found_llvm) { +const char *all_hex_ptr = found_llvm +strlen (".llvm." ); +bool all_hex = true; +for (;*all_hex_ptr;all_hex_ptr++) { +if (!(('0' <= *all_hex_ptr && *all_hex_ptr <='9' ) || + ('A' <= *all_hex_ptr && *all_hex_ptr <='F' ) || + *all_hex_ptr =='@' )) { + all_hex = false; +break ; + } + } + +if (all_hex) { + s_len = found_llvm - s; + } + } + +const char *suffix; +struct demangle_legacy legacy; +demangle_status st =rust_demangle_legacy_demangle (s, s_len, &legacy, &suffix); +if (st == DemangleOk) { + *res = (struct demangle ) { + .style=DemangleStyleLegacy, + .mangled=legacy.mangled, + .mangled_len=legacy.mangled_len, + .elements=legacy.elements, + .original=s, + .original_len=s_len, + .suffix=suffix, + .suffix_len=s_len - (suffix - s), + }; + }else { +struct demangle_v0 v0; + st =rust_demangle_v0_demangle (s, s_len, &v0, &suffix); +if (st == DemangleOk) { + *res = (struct demangle ) { + .style=DemangleStyleV0, + .mangled=v0.mangled, + .mangled_len=v0.mangled_len, + .elements=0 , + .original=s, + .original_len=s_len, + .suffix=suffix, + .suffix_len=s_len - (suffix - s), + }; + }else { + *res = (struct demangle ) { + .style=DemangleStyleUnknown, + .mangled=NULL , + .mangled_len=0 , + .elements=0 , + .original=s, + .original_len=s_len, + .suffix=s, + .suffix_len=0 , + }; + } + } + +// Output like LLVM IR adds extra period-delimited words. See if +// we are in that case and save the trailing words if so. +if (res->suffix_len) { +if (res->suffix[0 ] =='.' &&is_symbol_like (res->suffix, res->suffix_len)) { +// Keep the suffix + }else { +// Reset the suffix and invalidate the demangling + res->style = DemangleStyleUnknown; + res->suffix_len =0 ; + } + } +} + +bool rust_demangle_is_known (struct demangle *res) { +return res->style != DemangleStyleUnknown; +} + +overflow_status rust_demangle_display_demangle (struct demangle const *res,char *out,size_t len,bool alternate) { +size_t original_len = res->original_len; +size_t out_len; +switch (res->style) { +case DemangleStyleUnknown: +if (len < original_len) { +return OverflowOverflow; + }else { +memcpy (out, res->original, original_len); + out += original_len; + len -= original_len; +break ; + } +break ; +case DemangleStyleLegacy: { +struct demangle_legacy legacy = { + res->mangled, + res->mangled_len, + res->elements + }; +if (rust_demangle_legacy_display_demangle (legacy, out, len, alternate) == OverflowOverflow) { +return OverflowOverflow; + } + out_len =strlen (out); + out += out_len; + len -= out_len; +break ; + } +case DemangleStyleV0: { +struct demangle_v0 v0 = { + res->mangled, + res->mangled_len + }; +if (rust_demangle_v0_display_demangle (v0, out, len, alternate) == OverflowOverflow) { +return OverflowOverflow; + } + out_len =strlen (out); + out += out_len; + len -= out_len; +break ; + } + } +size_t suffix_len = res->suffix_len; +if (len < suffix_len || len - suffix_len <OVERFLOW_MARGIN ) { +return OverflowOverflow; + } +memcpy (out, res->suffix, suffix_len); + out[suffix_len] =0 ; +return OverflowOk; +}
tools/perf/util/demangle-rust-v0.h new file +88 -0
88 lines not on this page · raw message
Signature · 1 line
2.49.0.901.g37484f566f-goog
Re: [PATCH v2 1/6] perf demangle-rust: Add rustc-demangle C demangler
Quoted 6 lines · Ian Rogers
Imported at commit
80e40f57d99f("add comment about finding latest version of code") from:
https://github.com/rust-lang/rustc-demangle/blob/main/crates/native-c/src/demangle.c
https://github.com/rust-lang/rustc-demangle/blob/main/crates/native-c/include/demangle.h
Quoted 8 lines
There is discussion of this issue motivating the import in:
https://github.com/rust-lang/rust/issues/60705
https://lore.kernel.org/lkml/[email protected]/The SPDX lines reflect the dual license Apache-2 or MIT in:
https://github.com/rust-lang/rustc-demangle/blob/main/README.md
Following Migual Ojeda's suggestion comments were added on copyright and keeping the code in sync with upstream.
Thanks! I doubled-checked that the files added here are essentially equal to upstream, modulo trailing whitespace cleanups, the header addition and the change to the include name, so:
(Typo on "Migual", but I don't mind it -- it sounds like "M-equal" :)
Cheers,
Miguel
Ian Rogers
reviewerRe: [PATCH v2 1/6] perf demangle-rust: Add rustc-demangle C demangler
Quoted 17 lines · Miguel Ojeda
Quoted 6 lines · Ian Rogers
Imported at commit
80e40f57d99f("add comment about finding latest version of code") from:
https://github.com/rust-lang/rustc-demangle/blob/main/crates/native-c/src/demangle.c
https://github.com/rust-lang/rustc-demangle/blob/main/crates/native-c/include/demangle.hQuoted 8 lines
There is discussion of this issue motivating the import in:
https://github.com/rust-lang/rust/issues/60705
https://lore.kernel.org/lkml/[email protected]/The SPDX lines reflect the dual license Apache-2 or MIT in:
https://github.com/rust-lang/rustc-demangle/blob/main/README.md
Following Migual Ojeda's suggestion comments were added on copyright and keeping the code in sync with upstream.
Quoted 7 lines
Thanks! I doubled-checked that the files added here are essentially equal to upstream, modulo trailing whitespace cleanups, the header addition and the change to the include name, so:
Reviewed-by Miguel Ojeda <[email protected]>(Typo on "Migual", but I don't mind it -- it sounds like "M-equal" :)
Thanks! and sorry for the typo.
Ian
Quoted 2 lines
Cheers,
Miguel
Ian Rogers
reviewerPATCH v2 2/6 perf symbol-elf: Integrate rust-v0 demangling
In reply to Ian RogersUse the demangle-rust-v0 APIs to see if symbol is Rust mangled and demangle if so. The API requires a pre-allocated output buffer, some estimation and retrying are added for this.
--- tools/perf/util/Build | 5 +++- tools/perf/util/symbol-elf.c | 47 ++++++++++++++++++++++++++---------- 2 files changed, 38 insertions(+), 14 deletions(-)
tools/perf/util/Build +4 -1
@@ -241,9 +241,12 @@ perf-util-y += cap.o perf-util-$(CONFIG_CXX_DEMANGLE) += demangle-cxx.o perf-util-y += demangle-ocaml.o perf-util-y += demangle-java.o -perf-util-y += demangle-rust.o +perf-util-y += demangle-rust-v0.o perf-util-$(CONFIG_LIBLLVM) += llvm-c-helpers.o +CFLAGS_demangle-rust-v0.o += -Wno-shadow -Wno-declaration-after-statement \ + -Wno-switch-default -Wno-switch-enum -Wno-missing-field-initializers + ifdef CONFIG_JITDUMP perf-util-$(CONFIG_LIBELF) += jitdump.o perf-util-$(CONFIG_LIBELF) += genelf.o
tools/perf/util/symbol-elf.c +34 -13
74 lines not on this page · raw message
Signature · 1 line
2.49.0.901.g37484f566f-goog
Ian Rogers
reviewerPATCH v2 3/6 perf demangle-rust: Remove previous legacy rust decoder
In reply to Ian RogersCode is unused since the introduction of rustc-demangle demangler.
--- tools/perf/util/demangle-rust.c | 269 -------------------------------- tools/perf/util/demangle-rust.h | 8 - 2 files changed, 277 deletions(-) delete mode 100644 tools/perf/util/demangle-rust.c delete mode 100644 tools/perf/util/demangle-rust.h
tools/perf/util/demangle-rust.c deleted +0 -269
@@ -1,269 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0 -#include <string.h> -#include "debug.h" - -#include "demangle-rust.h" - -/* -* Mangled 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$ -* " " => $u20$ -* "'" => $u27$ -* "[" => $u5b$ -* "]" => $u5d$ -* "~" => $u7e$ -* -* 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 bool is_prefixed_hash (const char *start); -static bool looks_like_rust (const char *sym,size_t len); -static bool unescape (const char **in,char **out,const char *seq,char value); - -/* -* INPUT: -* sym: symbol that has been through BFD-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 _.:$ -* -* 4. There must be no unrecognized $-sign sequences. -* -* 5. There must be no sequence of three or more dots in a row ("..."). -*/ -bool -rust_is_mangled (const char *sym) -{ -size_t len, len_without_hash; - -if (!sym) -return false; - - len =strlen (sym); -if (len <= hash_prefix_len + hash_len) -/* Not long enough to contain "::h" + hash + something else */ -return false; - - len_without_hash = len - (hash_prefix_len + hash_len); -if (!is_prefixed_hash (sym + len_without_hash)) -return false; - -return looks_like_rust (sym, len_without_hash); -} - -/* -* A hash is the prefix "::h" followed by 16 lowercase hex digits. The hex -* digits must comprise between 5 and 15 (inclusive) distinct digits. -*/ -static bool is_prefixed_hash (const char *str) -{ -const char *end; -bool seen[16 ]; -size_t i; -int count; - -if (strncmp (str, hash_prefix, hash_prefix_len)) -return false; - str += hash_prefix_len; - -memset (seen, false,sizeof (seen)); -for (end = str + hash_len; str < end; str++) -if (*str >='0' && *str <='9' ) - seen[*str -'0' ] = true; -else if (*str >='a' && *str <='f' ) - seen[*str -'a' +10 ] = true; -else -return false; - -/* Count how many distinct digits seen */ - count =0 ; -for (i =0 ; i <16 ; i++) -if (seen[i]) - count++; - -return count >=5 && count <=15 ; -} - -static bool looks_like_rust (const char *str,size_t len) -{ -const char *end = str + len; - -while (str < end) -switch (*str) { -case '$' : -if (!strncmp (str,"$C$" ,3 )) - str +=3 ; -else if (!strncmp (str,"$SP$" ,4 ) - || !strncmp (str,"$BP$" ,4 ) - || !strncmp (str,"$RF$" ,4 ) - || !strncmp (str,"$LT$" ,4 ) - || !strncmp (str,"$GT$" ,4 ) - || !strncmp (str,"$LP$" ,4 ) - || !strncmp (str,"$RP$" ,4 )) - str +=4 ; -else if (!strncmp (str,"$u20$" ,5 ) - || !strncmp (str,"$u27$" ,5 ) - || !strncmp (str,"$u5b$" ,5 ) - || !strncmp (str,"$u5d$" ,5 ) - || !strncmp (str,"$u7e$" ,5 )) - str +=5 ; -else -return false; -break ; -case '.' : -/* Do not allow three or more consecutive dots */ -if (!strncmp (str,"..." ,3 )) -return false; -/* Fall through */ - case 'a' ... 'z': - case 'A' ... 'Z': - case '0' ... '9': -case '_' : -case ':' : - str++; -break ; -default : -return false; - } - -return true; -} - -/* -* INPUT: -* sym: symbol for which rust_is_mangled(sym) returns true -* -* The input is demangled in-place because the mangled name is always longer -* than the demangled one. -*/ -void -rust_demangle_sym (char *sym) -{ -const char *in; -char *out; -const char *end; - -if (!sym) -return ; - - in = sym; - out = sym; - end = sym +strlen (sym) - (hash_prefix_len + hash_len); - -while (in < end) -switch (*in) { -case '$' : -if (!(unescape (&in, &out,"$C$" ,',' ) - ||unescape (&in, &out,"$SP$" ,'@' ) - ||unescape (&in, &out,"$BP$" ,'*' ) - ||unescape (&in, &out,"$RF$" ,'&' ) - ||unescape (&in, &out,"$LT$" ,'<' ) - ||unescape (&in, &out,"$GT$" ,'>' ) - ||unescape (&in, &out,"$LP$" ,'(' ) - ||unescape (&in, &out,"$RP$" ,')' ) - ||unescape (&in, &out,"$u20$" ,' ' ) - ||unescape (&in, &out,"$u27$" ,'\'' ) - ||unescape (&in, &out,"$u5b$" ,'[' ) - ||unescape (&in, &out,"$u5d$" ,']' ) - ||unescape (&in, &out,"$u7e$" ,'~' ))) { -pr_err ("demangle-rust: unexpected escape sequence" ); - goto done; - } -break ; -case '_' : -/* -* 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++; -break ; -case '.' : -if (in[1 ] =='.' ) { -/* ".." becomes "::" */ - *out++ =':' ; - *out++ =':' ; - in +=2 ; - }else { -/* "." becomes "-" */ - *out++ ='-' ; - in++; - } -break ; - case 'a' ... 'z': - case 'A' ... 'Z': - case '0' ... '9': -case ':' : - *out++ = *in++; -break ; -default : -pr_err ("demangle-rust: unexpected character '%c' in symbol\n" , - *in); - goto done; - } - -done: - *out ='\0' ; -} - -static bool unescape (const char **in,char **out,const char *seq,char value) -{ -size_t len =strlen (seq); - -if (strncmp (*in, seq, len)) -return false; - - **out = value; - - *in += len; - *out +=1 ; - -return true; -}
tools/perf/util/demangle-rust.h deleted +0 -8
@@ -1,8 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0 */ -#ifndef __PERF_DEMANGLE_RUST -#define __PERF_DEMANGLE_RUST 1 - -bool rust_is_mangled (const char *str); -void rust_demangle_sym (char *str); - -#endif /* __PERF_DEMANGLE_RUST */
Signature · 1 line
2.49.0.901.g37484f566f-goog
Ian Rogers
reviewerPATCH v2 4/6 perf test demangle-rust: Add Rust demangling test
In reply to Ian RogersThe test cases are listed examples in:
https://doc.rust-lang.org/rustc/symbol-mangling/v0.html
This test was previously part of a different Rust v0 demangler:
https://lore.kernel.org/lkml/[email protected]/
--- tools/perf/tests/Build | 1 + tools/perf/tests/builtin-test.c | 1 + tools/perf/tests/demangle-rust-v0-test.c | 74 ++++++++++++++++++++++++ tools/perf/tests/tests.h | 1 + tools/perf/util/symbol-elf.c | 2 +- 5 files changed, 78 insertions(+), 1 deletion(-) create mode 100644 tools/perf/tests/demangle-rust-v0-test.c
tools/perf/tests/Build +1 -0
@@ -56,6 +56,7 @@ perf-test-y += genelf.o perf-test-y += api-io.o perf-test-y += demangle-java-test.o perf-test-y += demangle-ocaml-test.o +perf-test-y += demangle-rust-v0-test.o perf-test-y += pfm.o perf-test-y += parse-metric.o perf-test-y += pe-file-parsing.o
tools/perf/tests/builtin-test.c +1 -0
@@ -126,6 +126,7 @@ static struct test_suite *generic_tests[] = { &suite__maps__merge_in, &suite__demangle_java, &suite__demangle_ocaml, + &suite__demangle_rust, &suite__parse_metric, &suite__pe_file_parsing, &suite__expand_cgroup_events,
tools/perf/tests/demangle-rust-v0-test.c new file +74 -0
74 lines not on this page · raw message
tools/perf/tests/tests.h +1 -0
@@ -157,6 +157,7 @@ DECLARE_SUITE(jit_write_elf);DECLARE_SUITE (api_io);DECLARE_SUITE (demangle_java);DECLARE_SUITE (demangle_ocaml); +DECLARE_SUITE (demangle_rust);DECLARE_SUITE (pfm);DECLARE_SUITE (parse_metric);DECLARE_SUITE (pe_file_parsing);
tools/perf/util/symbol-elf.c +1 -1
@@ -319,7 +319,7 @@ static char *demangle_sym(struct dso *dso, int kmodule, const char *elf_name)* DWARF DW_compile_unit has this, but we don't always have access * to it... */ -if (!want_demangle (dso__kernel (dso) || kmodule)) +if (!want_demangle ((dso &&dso__kernel (dso)) || kmodule))return demangled;rust_demangle_demangle (elf_name, &rust_demangle);
Signature · 1 line
2.49.0.901.g37484f566f-goog
Ian Rogers
reviewerPATCH v2 5/6 perf test demangle-java: Switch to using dso__demangle_sym
In reply to Ian RogersThe use of the demangle-java APIs means we don't detect if a different demangler is used before the Java one for the case that matters to perf. Remove the return types from the demangled names as dso__demangle_sym removes those.
--- tools/perf/tests/demangle-java-test.c | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-)
tools/perf/tests/demangle-java-test.c +8 -9
@@ -3,10 +3,9 @@#include <stdlib.h> #include <stdio.h> #include <linux/kernel.h> -#include "tests.h" -#include "session.h" #include "debug.h" -#include "demangle-java.h" +#include "symbol.h" +#include "tests.h" static int test__demangle_java (struct test_suite *test__maybe_unused ,int subtest__maybe_unused ) {
@@ -18,19 +17,19 @@ static int test__demangle_java(struct test_suite *test __maybe_unused, int subteconst char *mangled, *demangled; } test_cases[] = { { "Ljava/lang/StringLatin1;equals([B[B)Z", - "boolean java.lang.StringLatin1.equals(byte[], byte[])" }, + "java.lang.StringLatin1.equals(byte[], byte[])" }, { "Ljava/util/zip/ZipUtils;CENSIZ([BI)J", - "long java.util.zip.ZipUtils.CENSIZ(byte[], int)" }, + "java.util.zip.ZipUtils.CENSIZ(byte[], int)" }, { "Ljava/util/regex/Pattern$BmpCharProperty;match(Ljava/util/regex/Matcher;ILjava/lang/CharSequence;)Z", - "boolean java.util.regex.Pattern$BmpCharProperty.match(java.util.regex.Matcher, int, java.lang.CharSequence)" }, + "java.util.regex.Pattern$BmpCharProperty.match(java.util.regex.Matcher, int, java.lang.CharSequence)" }, { "Ljava/lang/AbstractStringBuilder;appendChars(Ljava/lang/String;II)V", - "void java.lang.AbstractStringBuilder.appendChars(java.lang.String, int, int)" }, + "java.lang.AbstractStringBuilder.appendChars(java.lang.String, int, int)" }, { "Ljava/lang/Object;<init>()V", - "void java.lang.Object<init>()" }, + "java.lang.Object<init>()" }, }; for (i = 0; i < ARRAY_SIZE(test_cases); i++) { - buf = java_demangle_sym(test_cases[i].mangled, 0); + buf = dso__demangle_sym(/*dso=*/NULL, /*kmodule=*/0, test_cases[i].mangled); if (strcmp(buf, test_cases[i].demangled)) { pr_debug("FAILED: %s: %s != %s\n", test_cases[i].mangled, buf, test_cases[i].demangled);
Signature · 1 line
2.49.0.901.g37484f566f-goog
Ian Rogers
reviewerPATCH v2 6/6 perf test demangle-ocaml: Switch to using dso__demangle_sym
In reply to Ian RogersThe use of the demangle-ocaml APIs means we don't detect if a different demangler is used before the OCaml one for the case that matters to perf.
--- tools/perf/tests/demangle-ocaml-test.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-)
tools/perf/tests/demangle-ocaml-test.c +3 -4
@@ -2,10 +2,9 @@#include <string.h> #include <stdlib.h> #include <stdio.h> -#include "tests.h" -#include "session.h" #include "debug.h" -#include "demangle-ocaml.h" +#include "symbol.h" +#include "tests.h" static int test__demangle_ocaml (struct test_suite *test__maybe_unused ,int subtest__maybe_unused ) {
@@ -27,7 +26,7 @@ static int test__demangle_ocaml(struct test_suite *test __maybe_unused, int subt };for (i =0 ; i <ARRAY_SIZE (test_cases); i++) { - buf =ocaml_demangle_sym (test_cases[i].mangled); + buf =dso__demangle_sym (/*dso=*/ NULL ,/*kmodule=*/ 0 , test_cases[i].mangled);if ((buf ==NULL && test_cases[i].demangled !=NULL ) || (buf !=NULL && test_cases[i].demangled ==NULL ) || (buf !=NULL &&strcmp (buf, test_cases[i].demangled))) {
Signature · 1 line
2.49.0.901.g37484f566f-goog
Quoted 17 lines · Ian Rogers
Discussion of improved Rust demangling started with:
https://lore.kernel.org/lkml/jgxfnphfo3nzlfipnuuzdlfc4ehbr2tnh2evz3mdhynd6wvrsu@fcz6vrvepybb/
that led to implementing a Rust v0 demangler:
https://lore.kernel.org/lkml/[email protected]/
Discussion on that patch series led to the rust-lang issue:
https://github.com/rust-lang/rust/issues/60705
where the pre-existing Rust C demangler, authored by Ariel Ben-Yehuda
<[email protected]>, was mentioned. There wasn't progress on that
issue and so I've pulled that work into perf as discussed on the issue.v2: Changes to references from arielb1 to "Ariel Ben Yehuda
<[email protected]>", license tidying as suggested by Miguel Ojeda" <[email protected]>. Don't change from alternate demangling flag from false to true in the test change, make it true from the beginning (patch 2).
Quoted 7 lines
Ian Rogers (6):
perf demangle-rust: Add rustc-demangle C demangler perf symbol-elf: Integrate rust-v0 demangling perf demangle-rust: Remove previous legacy rust decoder perf test demangle-rust: Add Rust demangling test perf test demangle-java: Switch to usingdso__demangle_symperf test demangle-ocaml: Switch to usingdso__demangle_sym
I'm fixing these up, ok?
✗ BADSIG: DKIM/google.com
---
Total patches: 6
---
Cover: ./v2_20250429_irogers_use_rustc_demangle_for_rust_demangling.cover
Base: applies clean to current tree
git checkout -b v2_20250429_irogers_google_com HEAD
git am ./v2_20250429_irogers_use_rustc_demangle_for_rust_demangling.mbx⬢ [acme@toolbx perf-tools-next]$ git am ./v2_20250429_irogers_use_rustc_demangle_for_rust_demangling.mbx
Applying: perf demangle-rust: Add rustc-demangle C demangler .git/rebase-apply/patch:1098: trailing whitespace.
.git/rebase-apply/patch:1363: trailing whitespace.
.git/rebase-apply/patch:1474: trailing whitespace.
default:
.git/rebase-apply/patch:1791: trailing whitespace.
{ NULL },
.git/rebase-apply/patch:1814: trailing whitespace.
// From here on, inner contains a pointer to the next element, rest[:len] to the current one warning: squelched 4 whitespace errors
warning: 9 lines add whitespace errors.
Applying: perf symbol-elf: Integrate rust-v0 demangling
Applying: perf demangle-rust: Remove previous legacy rust decoder
Applying: perf test demangle-rust: Add Rust demangling test
Applying: perf test demangle-java: Switch to using dso__demangle_sym
Applying: perf test demangle-ocaml: Switch to using dso__demangle_sym ⬢ [acme@toolbx perf-tools-next]$
Applied.
- Arnaldo