1 /* Demangler for the Rust programming language 2 Copyright (C) 2016-2022 Free Software Foundation, Inc. 3 Written by David Tolnay (dtolnay@gmail.com). 4 Rewritten by Eduard-Mihai Burtescu (eddyb@lyken.rs) for v0 support. 5 6 This file is part of the libiberty library. 7 Libiberty is free software; you can redistribute it and/or 8 modify it under the terms of the GNU Library General Public 9 License as published by the Free Software Foundation; either 10 version 2 of the License, or (at your option) any later version. 11 12 In addition to the permissions in the GNU Library General Public 13 License, the Free Software Foundation gives you unlimited permission 14 to link the compiled version of this file into combinations with other 15 programs, and to distribute those combinations without any restriction 16 coming from the use of this file. (The Library Public License 17 restrictions do apply in other respects; for example, they cover 18 modification of the file, and distribution when not linked into a 19 combined executable.) 20 21 Libiberty is distributed in the hope that it will be useful, 22 but WITHOUT ANY WARRANTY; without even the implied warranty of 23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 24 Library General Public License for more details. 25 26 You should have received a copy of the GNU Library General Public 27 License along with libiberty; see the file COPYING.LIB. 28 If not, see <http://www.gnu.org/licenses/>. */ 29 30 31 #ifdef HAVE_CONFIG_H 32 #include "config.h" 33 #endif 34 35 #include "safe-ctype.h" 36 37 #include <inttypes.h> 38 #include <sys/types.h> 39 #include <string.h> 40 #include <stdio.h> 41 #include <stdlib.h> 42 43 #ifdef HAVE_STRING_H 44 #include <string.h> 45 #else 46 extern size_t strlen(const char *s); 47 extern int strncmp(const char *s1, const char *s2, size_t n); 48 extern void *memset(void *s, int c, size_t n); 49 #endif 50 51 #include <demangle.h> 52 #include "libiberty.h" 53 54 struct rust_demangler 55 { 56 const char *sym; 57 size_t sym_len; 58 59 void *callback_opaque; 60 demangle_callbackref callback; 61 62 /* Position of the next character to read from the symbol. */ 63 size_t next; 64 65 /* Non-zero if any error occurred. */ 66 int errored; 67 68 /* Non-zero if nothing should be printed. */ 69 int skipping_printing; 70 71 /* Non-zero if printing should be verbose (e.g. include hashes). */ 72 int verbose; 73 74 /* Rust mangling version, with legacy mangling being -1. */ 75 int version; 76 77 /* Recursion depth. */ 78 unsigned int recursion; 79 /* Maximum number of times demangle_path may be called recursively. */ 80 #define RUST_MAX_RECURSION_COUNT 1024 81 #define RUST_NO_RECURSION_LIMIT ((unsigned int) -1) 82 83 uint64_t bound_lifetime_depth; 84 }; 85 86 /* Parsing functions. */ 87 88 static char 89 peek (const struct rust_demangler *rdm) 90 { 91 if (rdm->next < rdm->sym_len) 92 return rdm->sym[rdm->next]; 93 return 0; 94 } 95 96 static int 97 eat (struct rust_demangler *rdm, char c) 98 { 99 if (peek (rdm) == c) 100 { 101 rdm->next++; 102 return 1; 103 } 104 else 105 return 0; 106 } 107 108 static char 109 next (struct rust_demangler *rdm) 110 { 111 char c = peek (rdm); 112 if (!c) 113 rdm->errored = 1; 114 else 115 rdm->next++; 116 return c; 117 } 118 119 static uint64_t 120 parse_integer_62 (struct rust_demangler *rdm) 121 { 122 char c; 123 uint64_t x; 124 125 if (eat (rdm, '_')) 126 return 0; 127 128 x = 0; 129 while (!eat (rdm, '_') && !rdm->errored) 130 { 131 c = next (rdm); 132 x *= 62; 133 if (ISDIGIT (c)) 134 x += c - '0'; 135 else if (ISLOWER (c)) 136 x += 10 + (c - 'a'); 137 else if (ISUPPER (c)) 138 x += 10 + 26 + (c - 'A'); 139 else 140 { 141 rdm->errored = 1; 142 return 0; 143 } 144 } 145 return x + 1; 146 } 147 148 static uint64_t 149 parse_opt_integer_62 (struct rust_demangler *rdm, char tag) 150 { 151 if (!eat (rdm, tag)) 152 return 0; 153 return 1 + parse_integer_62 (rdm); 154 } 155 156 static uint64_t 157 parse_disambiguator (struct rust_demangler *rdm) 158 { 159 return parse_opt_integer_62 (rdm, 's'); 160 } 161 162 static size_t 163 parse_hex_nibbles (struct rust_demangler *rdm, uint64_t *value) 164 { 165 char c; 166 size_t hex_len; 167 168 hex_len = 0; 169 *value = 0; 170 171 while (!eat (rdm, '_')) 172 { 173 *value <<= 4; 174 175 c = next (rdm); 176 if (ISDIGIT (c)) 177 *value |= c - '0'; 178 else if (c >= 'a' && c <= 'f') 179 *value |= 10 + (c - 'a'); 180 else 181 { 182 rdm->errored = 1; 183 return 0; 184 } 185 hex_len++; 186 } 187 188 return hex_len; 189 } 190 191 struct rust_mangled_ident 192 { 193 /* ASCII part of the identifier. */ 194 const char *ascii; 195 size_t ascii_len; 196 197 /* Punycode insertion codes for Unicode codepoints, if any. */ 198 const char *punycode; 199 size_t punycode_len; 200 }; 201 202 static struct rust_mangled_ident 203 parse_ident (struct rust_demangler *rdm) 204 { 205 char c; 206 size_t start, len; 207 int is_punycode = 0; 208 struct rust_mangled_ident ident; 209 210 ident.ascii = NULL; 211 ident.ascii_len = 0; 212 ident.punycode = NULL; 213 ident.punycode_len = 0; 214 215 if (rdm->version != -1) 216 is_punycode = eat (rdm, 'u'); 217 218 c = next (rdm); 219 if (!ISDIGIT (c)) 220 { 221 rdm->errored = 1; 222 return ident; 223 } 224 len = c - '0'; 225 226 if (c != '0') 227 while (ISDIGIT (peek (rdm))) 228 len = len * 10 + (next (rdm) - '0'); 229 230 /* Skip past the optional `_` separator (v0). */ 231 if (rdm->version != -1) 232 eat (rdm, '_'); 233 234 start = rdm->next; 235 rdm->next += len; 236 /* Check for overflows. */ 237 if ((start > rdm->next) || (rdm->next > rdm->sym_len)) 238 { 239 rdm->errored = 1; 240 return ident; 241 } 242 243 ident.ascii = rdm->sym + start; 244 ident.ascii_len = len; 245 246 if (is_punycode) 247 { 248 ident.punycode_len = 0; 249 while (ident.ascii_len > 0) 250 { 251 ident.ascii_len--; 252 253 /* The last '_' is a separator between ascii & punycode. */ 254 if (ident.ascii[ident.ascii_len] == '_') 255 break; 256 257 ident.punycode_len++; 258 } 259 if (!ident.punycode_len) 260 { 261 rdm->errored = 1; 262 return ident; 263 } 264 ident.punycode = ident.ascii + (len - ident.punycode_len); 265 } 266 267 if (ident.ascii_len == 0) 268 ident.ascii = NULL; 269 270 return ident; 271 } 272 273 /* Printing functions. */ 274 275 static void 276 print_str (struct rust_demangler *rdm, const char *data, size_t len) 277 { 278 if (!rdm->errored && !rdm->skipping_printing) 279 rdm->callback (data, len, rdm->callback_opaque); 280 } 281 282 #define PRINT(s) print_str (rdm, s, strlen (s)) 283 284 static void 285 print_uint64 (struct rust_demangler *rdm, uint64_t x) 286 { 287 char s[21]; 288 snprintf (s, 21, "%" PRIu64, x); 289 PRINT (s); 290 } 291 292 static void 293 print_uint64_hex (struct rust_demangler *rdm, uint64_t x) 294 { 295 char s[17]; 296 snprintf (s, 17, "%" PRIx64, x); 297 PRINT (s); 298 } 299 300 /* Return a 0x0-0xf value if the char is 0-9a-f, and -1 otherwise. */ 301 static int 302 decode_lower_hex_nibble (char nibble) 303 { 304 if ('0' <= nibble && nibble <= '9') 305 return nibble - '0'; 306 if ('a' <= nibble && nibble <= 'f') 307 return 0xa + (nibble - 'a'); 308 return -1; 309 } 310 311 /* Return the unescaped character for a "$...$" escape, or 0 if invalid. */ 312 static char 313 decode_legacy_escape (const char *e, size_t len, size_t *out_len) 314 { 315 char c = 0; 316 size_t escape_len = 0; 317 int lo_nibble = -1, hi_nibble = -1; 318 319 if (len < 3 || e[0] != '$') 320 return 0; 321 322 e++; 323 len--; 324 325 if (e[0] == 'C') 326 { 327 escape_len = 1; 328 329 c = ','; 330 } 331 else if (len > 2) 332 { 333 escape_len = 2; 334 335 if (e[0] == 'S' && e[1] == 'P') 336 c = '@'; 337 else if (e[0] == 'B' && e[1] == 'P') 338 c = '*'; 339 else if (e[0] == 'R' && e[1] == 'F') 340 c = '&'; 341 else if (e[0] == 'L' && e[1] == 'T') 342 c = '<'; 343 else if (e[0] == 'G' && e[1] == 'T') 344 c = '>'; 345 else if (e[0] == 'L' && e[1] == 'P') 346 c = '('; 347 else if (e[0] == 'R' && e[1] == 'P') 348 c = ')'; 349 else if (e[0] == 'u' && len > 3) 350 { 351 escape_len = 3; 352 353 hi_nibble = decode_lower_hex_nibble (e[1]); 354 if (hi_nibble < 0) 355 return 0; 356 lo_nibble = decode_lower_hex_nibble (e[2]); 357 if (lo_nibble < 0) 358 return 0; 359 360 /* Only allow non-control ASCII characters. */ 361 if (hi_nibble > 7) 362 return 0; 363 c = (hi_nibble << 4) | lo_nibble; 364 if (c < 0x20) 365 return 0; 366 } 367 } 368 369 if (!c || len <= escape_len || e[escape_len] != '$') 370 return 0; 371 372 *out_len = 2 + escape_len; 373 return c; 374 } 375 376 static void 377 print_ident (struct rust_demangler *rdm, struct rust_mangled_ident ident) 378 { 379 char unescaped; 380 uint8_t *out, *p, d; 381 size_t len, cap, punycode_pos, j; 382 /* Punycode parameters and state. */ 383 uint32_t c; 384 size_t base, t_min, t_max, skew, damp, bias, i; 385 size_t delta, w, k, t; 386 387 if (rdm->errored || rdm->skipping_printing) 388 return; 389 390 if (rdm->version == -1) 391 { 392 /* Ignore leading underscores preceding escape sequences. 393 The mangler inserts an underscore to make sure the 394 identifier begins with a XID_Start character. */ 395 if (ident.ascii_len >= 2 && ident.ascii[0] == '_' 396 && ident.ascii[1] == '$') 397 { 398 ident.ascii++; 399 ident.ascii_len--; 400 } 401 402 while (ident.ascii_len > 0) 403 { 404 /* Handle legacy escape sequences ("$...$", ".." or "."). */ 405 if (ident.ascii[0] == '$') 406 { 407 unescaped 408 = decode_legacy_escape (ident.ascii, ident.ascii_len, &len); 409 if (unescaped) 410 print_str (rdm, &unescaped, 1); 411 else 412 { 413 /* Unexpected escape sequence, print the rest verbatim. */ 414 print_str (rdm, ident.ascii, ident.ascii_len); 415 return; 416 } 417 } 418 else if (ident.ascii[0] == '.') 419 { 420 if (ident.ascii_len >= 2 && ident.ascii[1] == '.') 421 { 422 /* ".." becomes "::" */ 423 PRINT ("::"); 424 len = 2; 425 } 426 else 427 { 428 PRINT ("."); 429 len = 1; 430 } 431 } 432 else 433 { 434 /* Print everything before the next escape sequence, at once. */ 435 for (len = 0; len < ident.ascii_len; len++) 436 if (ident.ascii[len] == '$' || ident.ascii[len] == '.') 437 break; 438 439 print_str (rdm, ident.ascii, len); 440 } 441 442 ident.ascii += len; 443 ident.ascii_len -= len; 444 } 445 446 return; 447 } 448 449 if (!ident.punycode) 450 { 451 print_str (rdm, ident.ascii, ident.ascii_len); 452 return; 453 } 454 455 len = 0; 456 cap = 4; 457 while (cap < ident.ascii_len) 458 { 459 cap *= 2; 460 /* Check for overflows. */ 461 if ((cap * 4) / 4 != cap) 462 { 463 rdm->errored = 1; 464 return; 465 } 466 } 467 468 /* Store the output codepoints as groups of 4 UTF-8 bytes. */ 469 out = (uint8_t *)malloc (cap * 4); 470 if (!out) 471 { 472 rdm->errored = 1; 473 return; 474 } 475 476 /* Populate initial output from ASCII fragment. */ 477 for (len = 0; len < ident.ascii_len; len++) 478 { 479 p = out + 4 * len; 480 p[0] = 0; 481 p[1] = 0; 482 p[2] = 0; 483 p[3] = ident.ascii[len]; 484 } 485 486 /* Punycode parameters and initial state. */ 487 base = 36; 488 t_min = 1; 489 t_max = 26; 490 skew = 38; 491 damp = 700; 492 bias = 72; 493 i = 0; 494 c = 0x80; 495 496 punycode_pos = 0; 497 while (punycode_pos < ident.punycode_len) 498 { 499 /* Read one delta value. */ 500 delta = 0; 501 w = 1; 502 k = 0; 503 do 504 { 505 k += base; 506 t = k < bias ? 0 : (k - bias); 507 if (t < t_min) 508 t = t_min; 509 if (t > t_max) 510 t = t_max; 511 512 if (punycode_pos >= ident.punycode_len) 513 goto cleanup; 514 d = ident.punycode[punycode_pos++]; 515 516 if (ISLOWER (d)) 517 d = d - 'a'; 518 else if (ISDIGIT (d)) 519 d = 26 + (d - '0'); 520 else 521 { 522 rdm->errored = 1; 523 goto cleanup; 524 } 525 526 delta += d * w; 527 w *= base - t; 528 } 529 while (d >= t); 530 531 /* Compute the new insert position and character. */ 532 len++; 533 i += delta; 534 c += i / len; 535 i %= len; 536 537 /* Ensure enough space is available. */ 538 if (cap < len) 539 { 540 cap *= 2; 541 /* Check for overflows. */ 542 if ((cap * 4) / 4 != cap || cap < len) 543 { 544 rdm->errored = 1; 545 goto cleanup; 546 } 547 } 548 p = (uint8_t *)realloc (out, cap * 4); 549 if (!p) 550 { 551 rdm->errored = 1; 552 goto cleanup; 553 } 554 out = p; 555 556 /* Move the characters after the insert position. */ 557 p = out + i * 4; 558 memmove (p + 4, p, (len - i - 1) * 4); 559 560 /* Insert the new character, as UTF-8 bytes. */ 561 p[0] = c >= 0x10000 ? 0xf0 | (c >> 18) : 0; 562 p[1] = c >= 0x800 ? (c < 0x10000 ? 0xe0 : 0x80) | ((c >> 12) & 0x3f) : 0; 563 p[2] = (c < 0x800 ? 0xc0 : 0x80) | ((c >> 6) & 0x3f); 564 p[3] = 0x80 | (c & 0x3f); 565 566 /* If there are no more deltas, decoding is complete. */ 567 if (punycode_pos == ident.punycode_len) 568 break; 569 570 i++; 571 572 /* Perform bias adaptation. */ 573 delta /= damp; 574 damp = 2; 575 576 delta += delta / len; 577 k = 0; 578 while (delta > ((base - t_min) * t_max) / 2) 579 { 580 delta /= base - t_min; 581 k += base; 582 } 583 bias = k + ((base - t_min + 1) * delta) / (delta + skew); 584 } 585 586 /* Remove all the 0 bytes to leave behind an UTF-8 string. */ 587 for (i = 0, j = 0; i < len * 4; i++) 588 if (out[i] != 0) 589 out[j++] = out[i]; 590 591 print_str (rdm, (const char *)out, j); 592 593 cleanup: 594 free (out); 595 } 596 597 /* Print the lifetime according to the previously decoded index. 598 An index of `0` always refers to `'_`, but starting with `1`, 599 indices refer to late-bound lifetimes introduced by a binder. */ 600 static void 601 print_lifetime_from_index (struct rust_demangler *rdm, uint64_t lt) 602 { 603 char c; 604 uint64_t depth; 605 606 PRINT ("'"); 607 if (lt == 0) 608 { 609 PRINT ("_"); 610 return; 611 } 612 613 depth = rdm->bound_lifetime_depth - lt; 614 /* Try to print lifetimes alphabetically first. */ 615 if (depth < 26) 616 { 617 c = 'a' + depth; 618 print_str (rdm, &c, 1); 619 } 620 else 621 { 622 /* Use `'_123` after running out of letters. */ 623 PRINT ("_"); 624 print_uint64 (rdm, depth); 625 } 626 } 627 628 /* Demangling functions. */ 629 630 static void demangle_binder (struct rust_demangler *rdm); 631 static void demangle_path (struct rust_demangler *rdm, int in_value); 632 static void demangle_generic_arg (struct rust_demangler *rdm); 633 static void demangle_type (struct rust_demangler *rdm); 634 static int demangle_path_maybe_open_generics (struct rust_demangler *rdm); 635 static void demangle_dyn_trait (struct rust_demangler *rdm); 636 static void demangle_const (struct rust_demangler *rdm); 637 static void demangle_const_uint (struct rust_demangler *rdm); 638 static void demangle_const_int (struct rust_demangler *rdm); 639 static void demangle_const_bool (struct rust_demangler *rdm); 640 static void demangle_const_char (struct rust_demangler *rdm); 641 642 /* Optionally enter a binder ('G') for late-bound lifetimes, 643 printing e.g. `for<'a, 'b> `, and make those lifetimes visible 644 to the caller (via depth level, which the caller should reset). */ 645 static void 646 demangle_binder (struct rust_demangler *rdm) 647 { 648 uint64_t i, bound_lifetimes; 649 650 if (rdm->errored) 651 return; 652 653 bound_lifetimes = parse_opt_integer_62 (rdm, 'G'); 654 if (bound_lifetimes > 0) 655 { 656 PRINT ("for<"); 657 for (i = 0; i < bound_lifetimes; i++) 658 { 659 if (i > 0) 660 PRINT (", "); 661 rdm->bound_lifetime_depth++; 662 print_lifetime_from_index (rdm, 1); 663 } 664 PRINT ("> "); 665 } 666 } 667 668 static void 669 demangle_path (struct rust_demangler *rdm, int in_value) 670 { 671 char tag, ns; 672 int was_skipping_printing; 673 size_t i, backref, old_next; 674 uint64_t dis; 675 struct rust_mangled_ident name; 676 677 if (rdm->errored) 678 return; 679 680 if (rdm->recursion != RUST_NO_RECURSION_LIMIT) 681 { 682 ++ rdm->recursion; 683 if (rdm->recursion > RUST_MAX_RECURSION_COUNT) 684 /* FIXME: There ought to be a way to report 685 that the recursion limit has been reached. */ 686 goto fail_return; 687 } 688 689 switch (tag = next (rdm)) 690 { 691 case 'C': 692 dis = parse_disambiguator (rdm); 693 name = parse_ident (rdm); 694 695 print_ident (rdm, name); 696 if (rdm->verbose) 697 { 698 PRINT ("["); 699 print_uint64_hex (rdm, dis); 700 PRINT ("]"); 701 } 702 break; 703 case 'N': 704 ns = next (rdm); 705 if (!ISLOWER (ns) && !ISUPPER (ns)) 706 goto fail_return; 707 708 demangle_path (rdm, in_value); 709 710 dis = parse_disambiguator (rdm); 711 name = parse_ident (rdm); 712 713 if (ISUPPER (ns)) 714 { 715 /* Special namespaces, like closures and shims. */ 716 PRINT ("::{"); 717 switch (ns) 718 { 719 case 'C': 720 PRINT ("closure"); 721 break; 722 case 'S': 723 PRINT ("shim"); 724 break; 725 default: 726 print_str (rdm, &ns, 1); 727 } 728 if (name.ascii || name.punycode) 729 { 730 PRINT (":"); 731 print_ident (rdm, name); 732 } 733 PRINT ("#"); 734 print_uint64 (rdm, dis); 735 PRINT ("}"); 736 } 737 else 738 { 739 /* Implementation-specific/unspecified namespaces. */ 740 741 if (name.ascii || name.punycode) 742 { 743 PRINT ("::"); 744 print_ident (rdm, name); 745 } 746 } 747 break; 748 case 'M': 749 case 'X': 750 /* Ignore the `impl`'s own path.*/ 751 parse_disambiguator (rdm); 752 was_skipping_printing = rdm->skipping_printing; 753 rdm->skipping_printing = 1; 754 demangle_path (rdm, in_value); 755 rdm->skipping_printing = was_skipping_printing; 756 /* fallthrough */ 757 case 'Y': 758 PRINT ("<"); 759 demangle_type (rdm); 760 if (tag != 'M') 761 { 762 PRINT (" as "); 763 demangle_path (rdm, 0); 764 } 765 PRINT (">"); 766 break; 767 case 'I': 768 demangle_path (rdm, in_value); 769 if (in_value) 770 PRINT ("::"); 771 PRINT ("<"); 772 for (i = 0; !rdm->errored && !eat (rdm, 'E'); i++) 773 { 774 if (i > 0) 775 PRINT (", "); 776 demangle_generic_arg (rdm); 777 } 778 PRINT (">"); 779 break; 780 case 'B': 781 backref = parse_integer_62 (rdm); 782 if (!rdm->skipping_printing) 783 { 784 old_next = rdm->next; 785 rdm->next = backref; 786 demangle_path (rdm, in_value); 787 rdm->next = old_next; 788 } 789 break; 790 default: 791 goto fail_return; 792 } 793 goto pass_return; 794 795 fail_return: 796 rdm->errored = 1; 797 pass_return: 798 if (rdm->recursion != RUST_NO_RECURSION_LIMIT) 799 -- rdm->recursion; 800 } 801 802 static void 803 demangle_generic_arg (struct rust_demangler *rdm) 804 { 805 uint64_t lt; 806 if (eat (rdm, 'L')) 807 { 808 lt = parse_integer_62 (rdm); 809 print_lifetime_from_index (rdm, lt); 810 } 811 else if (eat (rdm, 'K')) 812 demangle_const (rdm); 813 else 814 demangle_type (rdm); 815 } 816 817 static const char * 818 basic_type (char tag) 819 { 820 switch (tag) 821 { 822 case 'b': 823 return "bool"; 824 case 'c': 825 return "char"; 826 case 'e': 827 return "str"; 828 case 'u': 829 return "()"; 830 case 'a': 831 return "i8"; 832 case 's': 833 return "i16"; 834 case 'l': 835 return "i32"; 836 case 'x': 837 return "i64"; 838 case 'n': 839 return "i128"; 840 case 'i': 841 return "isize"; 842 case 'h': 843 return "u8"; 844 case 't': 845 return "u16"; 846 case 'm': 847 return "u32"; 848 case 'y': 849 return "u64"; 850 case 'o': 851 return "u128"; 852 case 'j': 853 return "usize"; 854 case 'f': 855 return "f32"; 856 case 'd': 857 return "f64"; 858 case 'z': 859 return "!"; 860 case 'p': 861 return "_"; 862 case 'v': 863 return "..."; 864 865 default: 866 return NULL; 867 } 868 } 869 870 static void 871 demangle_type (struct rust_demangler *rdm) 872 { 873 char tag; 874 size_t i, old_next, backref; 875 uint64_t lt, old_bound_lifetime_depth; 876 const char *basic; 877 struct rust_mangled_ident abi; 878 879 if (rdm->errored) 880 return; 881 882 tag = next (rdm); 883 884 basic = basic_type (tag); 885 if (basic) 886 { 887 PRINT (basic); 888 return; 889 } 890 891 if (rdm->recursion != RUST_NO_RECURSION_LIMIT) 892 { 893 ++ rdm->recursion; 894 if (rdm->recursion > RUST_MAX_RECURSION_COUNT) 895 /* FIXME: There ought to be a way to report 896 that the recursion limit has been reached. */ 897 { 898 rdm->errored = 1; 899 -- rdm->recursion; 900 return; 901 } 902 } 903 904 switch (tag) 905 { 906 case 'R': 907 case 'Q': 908 PRINT ("&"); 909 if (eat (rdm, 'L')) 910 { 911 lt = parse_integer_62 (rdm); 912 if (lt) 913 { 914 print_lifetime_from_index (rdm, lt); 915 PRINT (" "); 916 } 917 } 918 if (tag != 'R') 919 PRINT ("mut "); 920 demangle_type (rdm); 921 break; 922 case 'P': 923 case 'O': 924 PRINT ("*"); 925 if (tag != 'P') 926 PRINT ("mut "); 927 else 928 PRINT ("const "); 929 demangle_type (rdm); 930 break; 931 case 'A': 932 case 'S': 933 PRINT ("["); 934 demangle_type (rdm); 935 if (tag == 'A') 936 { 937 PRINT ("; "); 938 demangle_const (rdm); 939 } 940 PRINT ("]"); 941 break; 942 case 'T': 943 PRINT ("("); 944 for (i = 0; !rdm->errored && !eat (rdm, 'E'); i++) 945 { 946 if (i > 0) 947 PRINT (", "); 948 demangle_type (rdm); 949 } 950 if (i == 1) 951 PRINT (","); 952 PRINT (")"); 953 break; 954 case 'F': 955 old_bound_lifetime_depth = rdm->bound_lifetime_depth; 956 demangle_binder (rdm); 957 958 if (eat (rdm, 'U')) 959 PRINT ("unsafe "); 960 961 if (eat (rdm, 'K')) 962 { 963 if (eat (rdm, 'C')) 964 { 965 abi.ascii = "C"; 966 abi.ascii_len = 1; 967 } 968 else 969 { 970 abi = parse_ident (rdm); 971 if (!abi.ascii || abi.punycode) 972 { 973 rdm->errored = 1; 974 goto restore; 975 } 976 } 977 978 PRINT ("extern \""); 979 980 /* If the ABI had any `-`, they were replaced with `_`, 981 so the parts between `_` have to be re-joined with `-`. */ 982 for (i = 0; i < abi.ascii_len; i++) 983 { 984 if (abi.ascii[i] == '_') 985 { 986 print_str (rdm, abi.ascii, i); 987 PRINT ("-"); 988 abi.ascii += i + 1; 989 abi.ascii_len -= i + 1; 990 i = 0; 991 } 992 } 993 print_str (rdm, abi.ascii, abi.ascii_len); 994 995 PRINT ("\" "); 996 } 997 998 PRINT ("fn("); 999 for (i = 0; !rdm->errored && !eat (rdm, 'E'); i++) 1000 { 1001 if (i > 0) 1002 PRINT (", "); 1003 demangle_type (rdm); 1004 } 1005 PRINT (")"); 1006 1007 if (eat (rdm, 'u')) 1008 { 1009 /* Skip printing the return type if it's 'u', i.e. `()`. */ 1010 } 1011 else 1012 { 1013 PRINT (" -> "); 1014 demangle_type (rdm); 1015 } 1016 1017 /* Restore `bound_lifetime_depth` to outside the binder. */ 1018 restore: 1019 rdm->bound_lifetime_depth = old_bound_lifetime_depth; 1020 break; 1021 case 'D': 1022 PRINT ("dyn "); 1023 1024 old_bound_lifetime_depth = rdm->bound_lifetime_depth; 1025 demangle_binder (rdm); 1026 1027 for (i = 0; !rdm->errored && !eat (rdm, 'E'); i++) 1028 { 1029 if (i > 0) 1030 PRINT (" + "); 1031 demangle_dyn_trait (rdm); 1032 } 1033 1034 /* Restore `bound_lifetime_depth` to outside the binder. */ 1035 rdm->bound_lifetime_depth = old_bound_lifetime_depth; 1036 1037 if (!eat (rdm, 'L')) 1038 { 1039 rdm->errored = 1; 1040 return; 1041 } 1042 lt = parse_integer_62 (rdm); 1043 if (lt) 1044 { 1045 PRINT (" + "); 1046 print_lifetime_from_index (rdm, lt); 1047 } 1048 break; 1049 case 'B': 1050 backref = parse_integer_62 (rdm); 1051 if (!rdm->skipping_printing) 1052 { 1053 old_next = rdm->next; 1054 rdm->next = backref; 1055 demangle_type (rdm); 1056 rdm->next = old_next; 1057 } 1058 break; 1059 default: 1060 /* Go back to the tag, so `demangle_path` also sees it. */ 1061 rdm->next--; 1062 demangle_path (rdm, 0); 1063 } 1064 1065 if (rdm->recursion != RUST_NO_RECURSION_LIMIT) 1066 -- rdm->recursion; 1067 } 1068 1069 /* A trait in a trait object may have some "existential projections" 1070 (i.e. associated type bindings) after it, which should be printed 1071 in the `<...>` of the trait, e.g. `dyn Trait<T, U, Assoc=X>`. 1072 To this end, this method will keep the `<...>` of an 'I' path 1073 open, by omitting the `>`, and return `Ok(true)` in that case. */ 1074 static int 1075 demangle_path_maybe_open_generics (struct rust_demangler *rdm) 1076 { 1077 int open; 1078 size_t i, old_next, backref; 1079 1080 open = 0; 1081 1082 if (rdm->errored) 1083 return open; 1084 1085 if (rdm->recursion != RUST_NO_RECURSION_LIMIT) 1086 { 1087 ++ rdm->recursion; 1088 if (rdm->recursion > RUST_MAX_RECURSION_COUNT) 1089 { 1090 /* FIXME: There ought to be a way to report 1091 that the recursion limit has been reached. */ 1092 rdm->errored = 1; 1093 goto end_of_func; 1094 } 1095 } 1096 1097 if (eat (rdm, 'B')) 1098 { 1099 backref = parse_integer_62 (rdm); 1100 if (!rdm->skipping_printing) 1101 { 1102 old_next = rdm->next; 1103 rdm->next = backref; 1104 open = demangle_path_maybe_open_generics (rdm); 1105 rdm->next = old_next; 1106 } 1107 } 1108 else if (eat (rdm, 'I')) 1109 { 1110 demangle_path (rdm, 0); 1111 PRINT ("<"); 1112 open = 1; 1113 for (i = 0; !rdm->errored && !eat (rdm, 'E'); i++) 1114 { 1115 if (i > 0) 1116 PRINT (", "); 1117 demangle_generic_arg (rdm); 1118 } 1119 } 1120 else 1121 demangle_path (rdm, 0); 1122 1123 end_of_func: 1124 if (rdm->recursion != RUST_NO_RECURSION_LIMIT) 1125 -- rdm->recursion; 1126 1127 return open; 1128 } 1129 1130 static void 1131 demangle_dyn_trait (struct rust_demangler *rdm) 1132 { 1133 int open; 1134 struct rust_mangled_ident name; 1135 1136 if (rdm->errored) 1137 return; 1138 1139 open = demangle_path_maybe_open_generics (rdm); 1140 1141 while (eat (rdm, 'p')) 1142 { 1143 if (!open) 1144 PRINT ("<"); 1145 else 1146 PRINT (", "); 1147 open = 1; 1148 1149 name = parse_ident (rdm); 1150 print_ident (rdm, name); 1151 PRINT (" = "); 1152 demangle_type (rdm); 1153 } 1154 1155 if (open) 1156 PRINT (">"); 1157 } 1158 1159 static void 1160 demangle_const (struct rust_demangler *rdm) 1161 { 1162 char ty_tag; 1163 size_t old_next, backref; 1164 1165 if (rdm->errored) 1166 return; 1167 1168 if (rdm->recursion != RUST_NO_RECURSION_LIMIT) 1169 { 1170 ++ rdm->recursion; 1171 if (rdm->recursion > RUST_MAX_RECURSION_COUNT) 1172 /* FIXME: There ought to be a way to report 1173 that the recursion limit has been reached. */ 1174 goto fail_return; 1175 } 1176 1177 if (eat (rdm, 'B')) 1178 { 1179 backref = parse_integer_62 (rdm); 1180 if (!rdm->skipping_printing) 1181 { 1182 old_next = rdm->next; 1183 rdm->next = backref; 1184 demangle_const (rdm); 1185 rdm->next = old_next; 1186 } 1187 goto pass_return; 1188 } 1189 1190 ty_tag = next (rdm); 1191 switch (ty_tag) 1192 { 1193 /* Placeholder. */ 1194 case 'p': 1195 PRINT ("_"); 1196 goto pass_return; 1197 1198 /* Unsigned integer types. */ 1199 case 'h': 1200 case 't': 1201 case 'm': 1202 case 'y': 1203 case 'o': 1204 case 'j': 1205 demangle_const_uint (rdm); 1206 break; 1207 1208 /* Signed integer types. */ 1209 case 'a': 1210 case 's': 1211 case 'l': 1212 case 'x': 1213 case 'n': 1214 case 'i': 1215 demangle_const_int (rdm); 1216 break; 1217 1218 /* Boolean. */ 1219 case 'b': 1220 demangle_const_bool (rdm); 1221 break; 1222 1223 /* Character. */ 1224 case 'c': 1225 demangle_const_char (rdm); 1226 break; 1227 1228 default: 1229 goto fail_return; 1230 } 1231 1232 if (!rdm->errored && rdm->verbose) 1233 { 1234 PRINT (": "); 1235 PRINT (basic_type (ty_tag)); 1236 } 1237 goto pass_return; 1238 1239 fail_return: 1240 rdm->errored = 1; 1241 pass_return: 1242 if (rdm->recursion != RUST_NO_RECURSION_LIMIT) 1243 -- rdm->recursion; 1244 } 1245 1246 static void 1247 demangle_const_uint (struct rust_demangler *rdm) 1248 { 1249 size_t hex_len; 1250 uint64_t value; 1251 1252 if (rdm->errored) 1253 return; 1254 1255 hex_len = parse_hex_nibbles (rdm, &value); 1256 1257 if (hex_len > 16) 1258 { 1259 /* Print anything that doesn't fit in `uint64_t` verbatim. */ 1260 PRINT ("0x"); 1261 print_str (rdm, rdm->sym + (rdm->next - hex_len), hex_len); 1262 } 1263 else if (hex_len > 0) 1264 print_uint64 (rdm, value); 1265 else 1266 rdm->errored = 1; 1267 } 1268 1269 static void 1270 demangle_const_int (struct rust_demangler *rdm) 1271 { 1272 if (eat (rdm, 'n')) 1273 PRINT ("-"); 1274 demangle_const_uint (rdm); 1275 } 1276 1277 static void 1278 demangle_const_bool (struct rust_demangler *rdm) 1279 { 1280 uint64_t value; 1281 1282 if (parse_hex_nibbles (rdm, &value) != 1) 1283 { 1284 rdm->errored = 1; 1285 return; 1286 } 1287 1288 if (value == 0) 1289 PRINT ("false"); 1290 else if (value == 1) 1291 PRINT ("true"); 1292 else 1293 rdm->errored = 1; 1294 } 1295 1296 static void 1297 demangle_const_char (struct rust_demangler *rdm) 1298 { 1299 size_t hex_len; 1300 uint64_t value; 1301 1302 hex_len = parse_hex_nibbles (rdm, &value); 1303 1304 if (hex_len == 0 || hex_len > 8) 1305 { 1306 rdm->errored = 1; 1307 return; 1308 } 1309 1310 /* Match Rust's character "debug" output as best as we can. */ 1311 PRINT ("'"); 1312 if (value == '\t') 1313 PRINT ("\\t"); 1314 else if (value == '\r') 1315 PRINT ("\\r"); 1316 else if (value == '\n') 1317 PRINT ("\\n"); 1318 else if (value > ' ' && value < '~') 1319 { 1320 /* Rust also considers many non-ASCII codepoints to be printable, but 1321 that logic is not easily ported to C. */ 1322 char c = value; 1323 print_str (rdm, &c, 1); 1324 } 1325 else 1326 { 1327 PRINT ("\\u{"); 1328 print_uint64_hex (rdm, value); 1329 PRINT ("}"); 1330 } 1331 PRINT ("'"); 1332 } 1333 1334 /* A legacy hash is the prefix "h" followed by 16 lowercase hex digits. 1335 The hex digits must contain at least 5 distinct digits. */ 1336 static int 1337 is_legacy_prefixed_hash (struct rust_mangled_ident ident) 1338 { 1339 uint16_t seen; 1340 int nibble; 1341 size_t i, count; 1342 1343 if (ident.ascii_len != 17 || ident.ascii[0] != 'h') 1344 return 0; 1345 1346 seen = 0; 1347 for (i = 0; i < 16; i++) 1348 { 1349 nibble = decode_lower_hex_nibble (ident.ascii[1 + i]); 1350 if (nibble < 0) 1351 return 0; 1352 seen |= (uint16_t)1 << nibble; 1353 } 1354 1355 /* Count how many distinct digits were seen. */ 1356 count = 0; 1357 while (seen) 1358 { 1359 if (seen & 1) 1360 count++; 1361 seen >>= 1; 1362 } 1363 1364 return count >= 5; 1365 } 1366 1367 int 1368 rust_demangle_callback (const char *mangled, int options, 1369 demangle_callbackref callback, void *opaque) 1370 { 1371 const char *p; 1372 struct rust_demangler rdm; 1373 struct rust_mangled_ident ident; 1374 1375 rdm.sym = mangled; 1376 rdm.sym_len = 0; 1377 1378 rdm.callback_opaque = opaque; 1379 rdm.callback = callback; 1380 1381 rdm.next = 0; 1382 rdm.errored = 0; 1383 rdm.skipping_printing = 0; 1384 rdm.verbose = (options & DMGL_VERBOSE) != 0; 1385 rdm.version = 0; 1386 rdm.recursion = (options & DMGL_NO_RECURSE_LIMIT) ? RUST_NO_RECURSION_LIMIT : 0; 1387 rdm.bound_lifetime_depth = 0; 1388 1389 /* Rust symbols always start with _R (v0) or _ZN (legacy). */ 1390 if (rdm.sym[0] == '_' && rdm.sym[1] == 'R') 1391 rdm.sym += 2; 1392 else if (rdm.sym[0] == '_' && rdm.sym[1] == 'Z' && rdm.sym[2] == 'N') 1393 { 1394 rdm.sym += 3; 1395 rdm.version = -1; 1396 } 1397 else 1398 return 0; 1399 1400 /* Paths (v0) always start with uppercase characters. */ 1401 if (rdm.version != -1 && !ISUPPER (rdm.sym[0])) 1402 return 0; 1403 1404 /* Rust symbols (v0) use only [_0-9a-zA-Z] characters. */ 1405 for (p = rdm.sym; *p; p++) 1406 { 1407 /* Rust v0 symbols can have '.' suffixes, ignore those. */ 1408 if (rdm.version == 0 && *p == '.') 1409 break; 1410 1411 rdm.sym_len++; 1412 1413 if (*p == '_' || ISALNUM (*p)) 1414 continue; 1415 1416 /* Legacy Rust symbols can also contain [.:$] characters. 1417 Or @ in the .suffix (which will be skipped, see below). */ 1418 if (rdm.version == -1 && (*p == '$' || *p == '.' || *p == ':' 1419 || *p == '@')) 1420 continue; 1421 1422 return 0; 1423 } 1424 1425 /* Legacy Rust symbols need to be handled separately. */ 1426 if (rdm.version == -1) 1427 { 1428 /* Legacy Rust symbols always end with E. But can be followed by a 1429 .suffix (which we want to ignore). */ 1430 int dot_suffix = 1; 1431 while (rdm.sym_len > 0 && 1432 !(dot_suffix && rdm.sym[rdm.sym_len - 1] == 'E')) 1433 { 1434 dot_suffix = rdm.sym[rdm.sym_len - 1] == '.'; 1435 rdm.sym_len--; 1436 } 1437 1438 if (!(rdm.sym_len > 0 && rdm.sym[rdm.sym_len - 1] == 'E')) 1439 return 0; 1440 rdm.sym_len--; 1441 1442 /* Legacy Rust symbols also always end with a path segment 1443 that encodes a 16 hex digit hash, i.e. '17h[a-f0-9]{16}'. 1444 This early check, before any parse_ident calls, should 1445 quickly filter out most C++ symbols unrelated to Rust. */ 1446 if (!(rdm.sym_len > 19 1447 && !memcmp (&rdm.sym[rdm.sym_len - 19], "17h", 3))) 1448 return 0; 1449 1450 do 1451 { 1452 ident = parse_ident (&rdm); 1453 if (rdm.errored || !ident.ascii) 1454 return 0; 1455 } 1456 while (rdm.next < rdm.sym_len); 1457 1458 /* The last path segment should be the hash. */ 1459 if (!is_legacy_prefixed_hash (ident)) 1460 return 0; 1461 1462 /* Reset the state for a second pass, to print the symbol. */ 1463 rdm.next = 0; 1464 if (!rdm.verbose && rdm.sym_len > 19) 1465 { 1466 /* Hide the last segment, containing the hash, if not verbose. */ 1467 rdm.sym_len -= 19; 1468 } 1469 1470 do 1471 { 1472 if (rdm.next > 0) 1473 print_str (&rdm, "::", 2); 1474 1475 ident = parse_ident (&rdm); 1476 print_ident (&rdm, ident); 1477 } 1478 while (rdm.next < rdm.sym_len); 1479 } 1480 else 1481 { 1482 demangle_path (&rdm, 1); 1483 1484 /* Skip instantiating crate. */ 1485 if (!rdm.errored && rdm.next < rdm.sym_len) 1486 { 1487 rdm.skipping_printing = 1; 1488 demangle_path (&rdm, 0); 1489 } 1490 1491 /* It's an error to not reach the end. */ 1492 rdm.errored |= rdm.next != rdm.sym_len; 1493 } 1494 1495 return !rdm.errored; 1496 } 1497 1498 /* Growable string buffers. */ 1499 struct str_buf 1500 { 1501 char *ptr; 1502 size_t len; 1503 size_t cap; 1504 int errored; 1505 }; 1506 1507 static void 1508 str_buf_reserve (struct str_buf *buf, size_t extra) 1509 { 1510 size_t available, min_new_cap, new_cap; 1511 char *new_ptr; 1512 1513 /* Allocation failed before. */ 1514 if (buf->errored) 1515 return; 1516 1517 available = buf->cap - buf->len; 1518 1519 if (extra <= available) 1520 return; 1521 1522 min_new_cap = buf->cap + (extra - available); 1523 1524 /* Check for overflows. */ 1525 if (min_new_cap < buf->cap) 1526 { 1527 buf->errored = 1; 1528 return; 1529 } 1530 1531 new_cap = buf->cap; 1532 1533 if (new_cap == 0) 1534 new_cap = 4; 1535 1536 /* Double capacity until sufficiently large. */ 1537 while (new_cap < min_new_cap) 1538 { 1539 new_cap *= 2; 1540 1541 /* Check for overflows. */ 1542 if (new_cap < buf->cap) 1543 { 1544 buf->errored = 1; 1545 return; 1546 } 1547 } 1548 1549 new_ptr = (char *)realloc (buf->ptr, new_cap); 1550 if (new_ptr == NULL) 1551 { 1552 free (buf->ptr); 1553 buf->ptr = NULL; 1554 buf->len = 0; 1555 buf->cap = 0; 1556 buf->errored = 1; 1557 } 1558 else 1559 { 1560 buf->ptr = new_ptr; 1561 buf->cap = new_cap; 1562 } 1563 } 1564 1565 static void 1566 str_buf_append (struct str_buf *buf, const char *data, size_t len) 1567 { 1568 str_buf_reserve (buf, len); 1569 if (buf->errored) 1570 return; 1571 1572 memcpy (buf->ptr + buf->len, data, len); 1573 buf->len += len; 1574 } 1575 1576 static void 1577 str_buf_demangle_callback (const char *data, size_t len, void *opaque) 1578 { 1579 str_buf_append ((struct str_buf *)opaque, data, len); 1580 } 1581 1582 char * 1583 rust_demangle (const char *mangled, int options) 1584 { 1585 struct str_buf out; 1586 int success; 1587 1588 out.ptr = NULL; 1589 out.len = 0; 1590 out.cap = 0; 1591 out.errored = 0; 1592 1593 success = rust_demangle_callback (mangled, options, 1594 str_buf_demangle_callback, &out); 1595 1596 if (!success) 1597 { 1598 free (out.ptr); 1599 return NULL; 1600 } 1601 1602 str_buf_append (&out, "\0", 1); 1603 return out.ptr; 1604 } 1605