1 /*- 2 * Copyright (c) 2008 Hyogeol Lee <hyogeollee@gmail.com> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer 10 * in this position and unchanged. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27 #include <sys/types.h> 28 #include <assert.h> 29 #include <ctype.h> 30 #include <errno.h> 31 #include <libelftc.h> 32 #include <limits.h> 33 #include <stdbool.h> 34 #include <stdio.h> 35 #include <stdlib.h> 36 #include <string.h> 37 38 #include "_libelftc.h" 39 40 ELFTC_VCSID("$Id: libelftc_dem_gnu2.c 3447 2016-05-03 13:32:23Z emaste $"); 41 42 /** 43 * @file cpp_demangle_gnu2.c 44 * @brief Decode function name encoding in GNU 2. 45 * 46 * Function name encoding in GNU 2 based on ARM style. 47 */ 48 49 enum encode_type { 50 ENCODE_FUNC, ENCODE_OP, ENCODE_OP_CT, ENCODE_OP_DT, ENCODE_OP_USER, 51 ENCODE_OP_TF, ENCODE_OP_TI, ENCODE_OP_VT 52 }; 53 54 struct cstring { 55 char *buf; 56 size_t size; 57 }; 58 59 struct demangle_data { 60 bool ptr, ref, cnst, array, cnst_fn, class_name; 61 struct cstring array_str; 62 const char *p; 63 enum encode_type type; 64 struct vector_str vec; 65 struct vector_str arg; 66 }; 67 68 #define SIMPLE_HASH(x,y) (64 * x + y) 69 #define CPP_DEMANGLE_GNU2_TRY 128 70 71 static void dest_cstring(struct cstring *); 72 static void dest_demangle_data(struct demangle_data *); 73 static bool init_cstring(struct cstring *, size_t); 74 static bool init_demangle_data(struct demangle_data *); 75 static bool push_CTDT(const char *, size_t, struct vector_str *); 76 static bool read_array(struct demangle_data *); 77 static bool read_class(struct demangle_data *); 78 static bool read_func(struct demangle_data *); 79 static bool read_func_name(struct demangle_data *); 80 static bool read_func_ptr(struct demangle_data *); 81 static bool read_memptr(struct demangle_data *); 82 static bool read_op(struct demangle_data *); 83 static bool read_op_user(struct demangle_data *); 84 static bool read_qual_name(struct demangle_data *); 85 static int read_subst(struct demangle_data *); 86 static int read_subst_iter(struct demangle_data *); 87 static bool read_type(struct demangle_data *); 88 89 /** 90 * @brief Decode the input string by the GNU 2 style. 91 * 92 * @return New allocated demangled string or NULL if failed. 93 */ 94 char * 95 cpp_demangle_gnu2(const char *org) 96 { 97 struct demangle_data d; 98 size_t arg_begin, arg_len; 99 unsigned int try; 100 char *rtn, *arg; 101 102 if (org == NULL) 103 return (NULL); 104 105 if (init_demangle_data(&d) == false) 106 return (NULL); 107 108 try = 0; 109 rtn = NULL; 110 111 d.p = org; 112 if (read_func_name(&d) == false) 113 goto clean; 114 115 switch (d.type) { 116 case ENCODE_FUNC : 117 case ENCODE_OP : 118 break; 119 120 case ENCODE_OP_CT : 121 if (push_CTDT("::", 2, &d.vec) == false) 122 goto clean; 123 124 break; 125 case ENCODE_OP_DT : 126 if (push_CTDT("::~", 3, &d.vec) == false) 127 goto clean; 128 129 if (vector_str_push(&d.vec, "(void)", 6) == false) 130 goto clean; 131 132 goto flat; 133 case ENCODE_OP_USER : 134 case ENCODE_OP_TF : 135 case ENCODE_OP_TI : 136 case ENCODE_OP_VT : 137 goto flat; 138 } 139 140 if (*d.p == 'F') 141 ++d.p; 142 else if (*d.p == '\0') { 143 if (d.class_name == true) { 144 if (vector_str_push(&d.vec, "(void)", 6) == false) 145 goto clean; 146 147 goto flat; 148 } else 149 goto clean; 150 } 151 152 /* start argument types */ 153 if (vector_str_push(&d.vec, "(", 1) == false) 154 goto clean; 155 156 for (;;) { 157 if (*d.p == 'T') { 158 const int rtn_subst = read_subst(&d); 159 160 if (rtn_subst == -1) 161 goto clean; 162 else if (rtn_subst == 1) 163 break; 164 165 continue; 166 } 167 168 if (*d.p == 'N') { 169 const int rtn_subst_iter = read_subst_iter(&d); 170 171 if (rtn_subst_iter == -1) 172 goto clean; 173 else if(rtn_subst_iter == 1) 174 break; 175 176 continue; 177 } 178 179 arg_begin = d.vec.size; 180 181 if (read_type(&d) == false) 182 goto clean; 183 184 if (d.ptr == true) { 185 if (vector_str_push(&d.vec, "*", 1) == false) 186 goto clean; 187 188 d.ptr = false; 189 } 190 191 if (d.ref == true) { 192 if (vector_str_push(&d.vec, "&", 1) == false) 193 goto clean; 194 195 d.ref = false; 196 } 197 198 if (d.cnst == true) { 199 if (vector_str_push(&d.vec, " const", 6) == false) 200 goto clean; 201 202 d.cnst = false; 203 } 204 205 if (d.array == true) { 206 if (vector_str_push(&d.vec, d.array_str.buf, 207 d.array_str.size) == false) 208 goto clean; 209 210 dest_cstring(&d.array_str); 211 d.array = false; 212 } 213 214 if (*d.p == '\0') 215 break; 216 217 if ((arg = vector_str_substr(&d.vec, arg_begin, d.vec.size - 1, 218 &arg_len)) == NULL) 219 goto clean; 220 221 if (vector_str_push(&d.arg, arg, arg_len) == false) 222 goto clean; 223 224 free(arg); 225 226 if (vector_str_push(&d.vec, ", ", 2) == false) 227 goto clean; 228 229 if (++try > CPP_DEMANGLE_GNU2_TRY) 230 goto clean; 231 } 232 233 /* end argument types */ 234 if (vector_str_push(&d.vec, ")", 1) == false) 235 goto clean; 236 flat: 237 if (d.cnst_fn == true && vector_str_push(&d.vec, " const", 6) == false) 238 goto clean; 239 240 rtn = vector_str_get_flat(&d.vec, NULL); 241 clean: 242 dest_demangle_data(&d); 243 244 return (rtn); 245 } 246 247 /** 248 * @brief Test input string is encoded by the GNU 2 style. 249 * 250 * @return True if input string is encoded by the GNU 2 style. 251 */ 252 bool 253 is_cpp_mangled_gnu2(const char *org) 254 { 255 char *str; 256 bool rtn = false; 257 258 if (org == NULL) 259 return (false); 260 261 /* search valid text to end */ 262 str = strstr(org, "__"); 263 while (str != NULL) { 264 if (*(str + 2) != '\0') { 265 if (*(str + 2) == 'C' || 266 *(str + 2) == 'F' || 267 *(str + 2) == 'Q' || 268 ELFTC_ISDIGIT(*(str + 2))) { 269 rtn |= true; 270 271 break; 272 } 273 274 if (*(str + 3) != '\0') { 275 switch (SIMPLE_HASH(*(str + 2), *(str + 3))) { 276 case SIMPLE_HASH('m', 'l') : 277 case SIMPLE_HASH('d', 'v') : 278 case SIMPLE_HASH('m', 'd') : 279 case SIMPLE_HASH('p', 'l') : 280 case SIMPLE_HASH('m', 'i') : 281 case SIMPLE_HASH('l', 's') : 282 case SIMPLE_HASH('r', 's') : 283 case SIMPLE_HASH('e', 'q') : 284 case SIMPLE_HASH('n', 'e') : 285 case SIMPLE_HASH('l', 't') : 286 case SIMPLE_HASH('g', 't') : 287 case SIMPLE_HASH('l', 'e') : 288 case SIMPLE_HASH('g', 'e') : 289 case SIMPLE_HASH('a', 'd') : 290 case SIMPLE_HASH('o', 'r') : 291 case SIMPLE_HASH('e', 'r') : 292 case SIMPLE_HASH('a', 'a') : 293 case SIMPLE_HASH('o', 'o') : 294 case SIMPLE_HASH('n', 't') : 295 case SIMPLE_HASH('c', 'o') : 296 case SIMPLE_HASH('p', 'p') : 297 case SIMPLE_HASH('m', 'm') : 298 case SIMPLE_HASH('a', 's') : 299 case SIMPLE_HASH('r', 'f') : 300 case SIMPLE_HASH('a', 'p') : 301 case SIMPLE_HASH('a', 'm') : 302 case SIMPLE_HASH('a', 'l') : 303 case SIMPLE_HASH('a', 'r') : 304 case SIMPLE_HASH('a', 'o') : 305 case SIMPLE_HASH('a', 'e') : 306 case SIMPLE_HASH('c', 'm') : 307 case SIMPLE_HASH('r', 'm') : 308 case SIMPLE_HASH('c', 'l') : 309 case SIMPLE_HASH('v', 'c') : 310 case SIMPLE_HASH('n', 'w') : 311 case SIMPLE_HASH('d', 'l') : 312 case SIMPLE_HASH('o', 'p') : 313 case SIMPLE_HASH('t', 'f') : 314 case SIMPLE_HASH('t', 'i') : 315 rtn |= true; 316 317 break; 318 } 319 } 320 } 321 322 str = strstr(str + 2, "__"); 323 } 324 325 rtn |= strstr(org, "_$_") != NULL; 326 rtn |= strstr(org, "_vt$") != NULL; 327 328 return (rtn); 329 } 330 331 static void 332 dest_cstring(struct cstring *s) 333 { 334 335 if (s == NULL) 336 return; 337 338 free(s->buf); 339 s->buf = NULL; 340 s->size = 0; 341 } 342 343 static void 344 dest_demangle_data(struct demangle_data *d) 345 { 346 347 if (d != NULL) { 348 vector_str_dest(&d->arg); 349 vector_str_dest(&d->vec); 350 351 dest_cstring(&d->array_str); 352 } 353 } 354 355 static bool 356 init_cstring(struct cstring *s, size_t len) 357 { 358 359 if (s == NULL || len <= 1) 360 return (false); 361 362 if ((s->buf = malloc(sizeof(char) * len)) == NULL) 363 return (false); 364 365 s->size = len - 1; 366 367 return (true); 368 } 369 370 static bool 371 init_demangle_data(struct demangle_data *d) 372 { 373 374 if (d == NULL) 375 return (false); 376 377 d->ptr = false; 378 d->ref = false; 379 d->cnst = false; 380 d->array = false; 381 d->cnst_fn = false; 382 d->class_name = false; 383 384 d->array_str.buf = NULL; 385 d->array_str.size = 0; 386 387 d->type = ENCODE_FUNC; 388 389 if (vector_str_init(&d->vec) == false) 390 return (false); 391 392 if (vector_str_init(&d->arg) == false) { 393 vector_str_dest(&d->vec); 394 395 return (false); 396 } 397 398 return (true); 399 } 400 401 static bool 402 push_CTDT(const char *s, size_t l, struct vector_str *v) 403 { 404 405 if (s == NULL || l == 0 || v == NULL) 406 return (false); 407 408 if (vector_str_push(v, s, l) == false) 409 return (false); 410 411 assert(v->size > 1); 412 413 return (vector_str_push(v, v->container[v->size - 2], 414 strlen(v->container[v->size - 2]))); 415 } 416 417 static bool 418 read_array(struct demangle_data *d) 419 { 420 size_t len; 421 const char *end; 422 423 if (d == NULL || d->p == NULL) 424 return (false); 425 426 end = d->p; 427 assert(end != NULL); 428 429 for (;;) { 430 if (*end == '\0') 431 return (false); 432 433 if (ELFTC_ISDIGIT(*end) == 0) 434 break; 435 436 ++end; 437 } 438 439 if (*end != '_') 440 return (false); 441 442 len = end - d->p; 443 assert(len > 0); 444 445 dest_cstring(&d->array_str); 446 if (init_cstring(&d->array_str, len + 3) == false) 447 return (false); 448 449 strncpy(d->array_str.buf + 1, d->p, len); 450 *d->array_str.buf = '['; 451 *(d->array_str.buf + len + 1) = ']'; 452 453 d->array = true; 454 d->p = end + 1; 455 456 return (true); 457 } 458 459 static bool 460 read_class(struct demangle_data *d) 461 { 462 size_t len; 463 char *str; 464 465 if (d == NULL) 466 return (false); 467 468 len = strtol(d->p, &str, 10); 469 if (len == 0 && (errno == EINVAL || errno == ERANGE)) 470 return (false); 471 472 assert(len > 0); 473 assert(str != NULL); 474 475 if (vector_str_push(&d->vec, str, len) == false) 476 return (false); 477 478 d->p = str + len; 479 480 d->class_name = true; 481 482 return (true); 483 } 484 485 static bool 486 read_func(struct demangle_data *d) 487 { 488 size_t len; 489 const char *name; 490 char *delim; 491 492 if (d == NULL) 493 return (false); 494 495 assert(d->p != NULL && "d->p (org str) is NULL"); 496 if ((delim = strstr(d->p, "__")) == NULL) 497 return (false); 498 499 len = delim - d->p; 500 assert(len != 0); 501 502 name = d->p; 503 504 d->p = delim + 2; 505 506 if (*d->p == 'C') { 507 ++d->p; 508 509 d->cnst_fn = true; 510 } 511 512 if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) { 513 ++d->p; 514 515 if (read_qual_name(d) == false) 516 return (false); 517 } else if (ELFTC_ISDIGIT(*d->p)) { 518 if (read_class(d) == false) 519 return (false); 520 521 if (vector_str_push(&d->vec, "::", 2) == false) 522 return (false); 523 } 524 525 return (vector_str_push(&d->vec, name, len)); 526 } 527 528 static bool 529 read_func_name(struct demangle_data *d) 530 { 531 size_t len; 532 bool rtn; 533 char *op_name; 534 535 if (d == NULL) 536 return (false); 537 538 rtn = false; 539 op_name = NULL; 540 541 assert(d->p != NULL && "d->p (org str) is NULL"); 542 543 if (*d->p == '_' && *(d->p + 1) == '_') { 544 d->p += 2; 545 546 /* CTOR */ 547 if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) { 548 ++d->p; 549 d->type = ENCODE_OP_CT; 550 551 if (read_qual_name(d) == false) 552 return (false); 553 554 return (vector_str_pop(&d->vec)); 555 } else if (ELFTC_ISDIGIT(*d->p)) { 556 d->type = ENCODE_OP_CT; 557 558 return (read_class(d)); 559 } 560 561 d->type = ENCODE_OP; 562 if (read_op(d) == false) { 563 /* not good condition, start function name with '__' */ 564 d->type = ENCODE_FUNC; 565 566 if (vector_str_push(&d->vec, "__", 2) == false) 567 return (false); 568 569 return (read_func(d)); 570 } 571 572 if (d->type == ENCODE_OP_USER || 573 d->type == ENCODE_OP_TF || 574 d->type == ENCODE_OP_TI) 575 return (true); 576 577 /* skip "__" */ 578 d->p += 2; 579 580 if (*d->p == 'C') { 581 ++d->p; 582 583 d->cnst_fn = true; 584 } 585 586 /* assume delimiter is removed */ 587 if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) { 588 ++d->p; 589 590 assert(d->vec.size > 0); 591 592 len = strlen(d->vec.container[d->vec.size - 1]); 593 if ((op_name = malloc(sizeof(char) * (len + 1))) 594 == NULL) 595 return (false); 596 597 snprintf(op_name, len + 1, "%s", 598 d->vec.container[d->vec.size - 1]); 599 vector_str_pop(&d->vec); 600 601 if (read_qual_name(d) == false) 602 goto clean; 603 604 if (vector_str_push(&d->vec, "::", 2) == false) 605 goto clean; 606 607 if (vector_str_push(&d->vec, op_name, len) == false) 608 goto clean; 609 610 rtn = true; 611 } else if (ELFTC_ISDIGIT(*d->p)) { 612 assert(d->vec.size > 0); 613 614 len = strlen(d->vec.container[d->vec.size - 1]); 615 if ((op_name = malloc(sizeof(char) * (len + 1))) 616 == NULL) 617 return (false); 618 619 snprintf(op_name, len + 1, "%s", 620 d->vec.container[d->vec.size - 1]); 621 vector_str_pop(&d->vec); 622 623 if (read_class(d) == false) 624 goto clean; 625 626 if (vector_str_push(&d->vec, "::", 2) == false) 627 goto clean; 628 629 if (vector_str_push(&d->vec, op_name, len) == false) 630 goto clean; 631 632 rtn = true; 633 } 634 } else if (memcmp(d->p, "_$_", 3) == 0) { 635 /* DTOR */ 636 d->p += 3; 637 d->type = ENCODE_OP_DT; 638 639 if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) { 640 ++d->p; 641 642 if (read_qual_name(d) == false) 643 return (false); 644 645 return (vector_str_pop(&d->vec)); 646 } else if (ELFTC_ISDIGIT(*d->p)) 647 return (read_class(d)); 648 649 return (false); 650 } else if (memcmp(d->p, "_vt$", 4) == 0) { 651 /* vtable */ 652 d->p += 4; 653 d->type = ENCODE_OP_VT; 654 655 if (*d->p == 'Q' && ELFTC_ISDIGIT(*(d->p + 1))) { 656 ++d->p; 657 658 if (read_qual_name(d) == false) 659 return (false); 660 661 if (vector_str_pop(&d->vec) == false) 662 return (false); 663 } else if (ELFTC_ISDIGIT(*d->p)) { 664 if (read_class(d) == false) 665 return (false); 666 } 667 668 return (vector_str_push(&d->vec, " virtual table", 14)); 669 } else 670 return (read_func(d)); 671 clean: 672 free(op_name); 673 674 return (rtn); 675 } 676 677 /* Read function ptr type */ 678 static bool 679 read_func_ptr(struct demangle_data *d) 680 { 681 struct demangle_data fptr; 682 size_t arg_len, rtn_len; 683 char *arg_type, *rtn_type; 684 int lim; 685 686 if (d == NULL) 687 return (false); 688 689 if (init_demangle_data(&fptr) == false) 690 return (false); 691 692 fptr.p = d->p + 1; 693 lim = 0; 694 arg_type = NULL; 695 rtn_type = NULL; 696 697 for (;;) { 698 if (read_type(&fptr) == false) { 699 dest_demangle_data(&fptr); 700 701 return (false); 702 } 703 704 if (fptr.ptr == true) { 705 if (vector_str_push(&fptr.vec, "*", 1) == false) { 706 dest_demangle_data(&fptr); 707 708 return (false); 709 } 710 711 fptr.ptr = false; 712 } 713 714 if (fptr.ref == true) { 715 if (vector_str_push(&fptr.vec, "&", 1) == false) { 716 dest_demangle_data(&fptr); 717 718 return (false); 719 } 720 721 fptr.ref = false; 722 } 723 724 if (fptr.cnst == true) { 725 if (vector_str_push(&fptr.vec, " const", 6) == false) { 726 dest_demangle_data(&fptr); 727 728 return (false); 729 } 730 731 fptr.cnst = false; 732 } 733 734 if (*fptr.p == '_') 735 break; 736 737 if (vector_str_push(&fptr.vec, ", ", 2) == false) { 738 dest_demangle_data(&fptr); 739 740 return (false); 741 } 742 743 if (++lim > CPP_DEMANGLE_GNU2_TRY) { 744 745 dest_demangle_data(&fptr); 746 747 return (false); 748 } 749 } 750 751 arg_type = vector_str_get_flat(&fptr.vec, &arg_len); 752 /* skip '_' */ 753 d->p = fptr.p + 1; 754 755 dest_demangle_data(&fptr); 756 757 if (init_demangle_data(&fptr) == false) { 758 free(arg_type); 759 760 return (false); 761 } 762 763 fptr.p = d->p; 764 lim = 0; 765 766 if (read_type(&fptr) == false) { 767 free(arg_type); 768 dest_demangle_data(&fptr); 769 770 return (false); 771 } 772 773 rtn_type = vector_str_get_flat(&fptr.vec, &rtn_len); 774 d->p = fptr.p; 775 776 777 dest_demangle_data(&fptr); 778 779 if (vector_str_push(&d->vec, rtn_type, rtn_len) == false) { 780 free(rtn_type); 781 free(arg_type); 782 783 return (false); 784 } 785 786 free(rtn_type); 787 788 if (vector_str_push(&d->vec, " (*)(", 5) == false) { 789 free(arg_type); 790 791 return (false); 792 } 793 794 if (vector_str_push(&d->vec, arg_type, arg_len) == false) { 795 free(arg_type); 796 797 return (false); 798 } 799 800 free(arg_type); 801 802 return (vector_str_push(&d->vec, ")", 1)); 803 } 804 805 static bool 806 read_memptr(struct demangle_data *d) 807 { 808 struct demangle_data mptr; 809 size_t len; 810 bool rtn; 811 char *mptr_str; 812 813 if (d == NULL || d->p == NULL) 814 return (false); 815 816 if (init_demangle_data(&mptr) == false) 817 return (false); 818 819 rtn = false; 820 mptr_str = NULL; 821 822 mptr.p = d->p; 823 if (*mptr.p == 'Q') { 824 ++mptr.p; 825 826 if (read_qual_name(&mptr) == false) 827 goto clean; 828 } else if (read_class(&mptr) == false) 829 goto clean; 830 831 d->p = mptr.p; 832 833 if ((mptr_str = vector_str_get_flat(&mptr.vec, &len)) == NULL) 834 goto clean; 835 836 if (vector_str_push(&d->vec, mptr_str, len) == false) 837 goto clean; 838 839 if (vector_str_push(&d->vec, "::*", 3) == false) 840 goto clean; 841 842 rtn = true; 843 clean: 844 free(mptr_str); 845 dest_demangle_data(&mptr); 846 847 return (rtn); 848 } 849 850 static bool 851 read_op(struct demangle_data *d) 852 { 853 854 if (d == NULL) 855 return (false); 856 857 assert(d->p != NULL && "d->p (org str) is NULL"); 858 859 switch (SIMPLE_HASH(*(d->p), *(d->p+1))) { 860 case SIMPLE_HASH('m', 'l') : 861 d->p += 2; 862 return (vector_str_push(&d->vec, "operator*", 9)); 863 case SIMPLE_HASH('d', 'v') : 864 d->p += 2; 865 return (vector_str_push(&d->vec, "operator/", 9)); 866 case SIMPLE_HASH('m', 'd') : 867 d->p += 2; 868 return (vector_str_push(&d->vec, "operator%", 9)); 869 case SIMPLE_HASH('p', 'l') : 870 d->p += 2; 871 return (vector_str_push(&d->vec, "operator+", 9)); 872 case SIMPLE_HASH('m', 'i') : 873 d->p += 2; 874 return (vector_str_push(&d->vec, "operator-", 9)); 875 case SIMPLE_HASH('l', 's') : 876 d->p += 2; 877 return (vector_str_push(&d->vec, "operator<<", 10)); 878 case SIMPLE_HASH('r', 's') : 879 d->p += 2; 880 return (vector_str_push(&d->vec, "operator>>", 10)); 881 case SIMPLE_HASH('e', 'q') : 882 d->p += 2; 883 return (vector_str_push(&d->vec, "operator==", 10)); 884 case SIMPLE_HASH('n', 'e') : 885 d->p += 2; 886 return (vector_str_push(&d->vec, "operator!=", 10)); 887 case SIMPLE_HASH('l', 't') : 888 d->p += 2; 889 return (vector_str_push(&d->vec, "operator<", 9)); 890 case SIMPLE_HASH('g', 't') : 891 d->p += 2; 892 return (vector_str_push(&d->vec, "operator>", 9)); 893 case SIMPLE_HASH('l', 'e') : 894 d->p += 2; 895 return (vector_str_push(&d->vec, "operator<=", 10)); 896 case SIMPLE_HASH('g', 'e') : 897 d->p += 2; 898 return (vector_str_push(&d->vec, "operator>=", 10)); 899 case SIMPLE_HASH('a', 'd') : 900 d->p += 2; 901 if (*d->p == 'v') { 902 ++d->p; 903 return (vector_str_push(&d->vec, "operator/=", 904 10)); 905 } else 906 return (vector_str_push(&d->vec, "operator&", 9)); 907 case SIMPLE_HASH('o', 'r') : 908 d->p += 2; 909 return (vector_str_push(&d->vec, "operator|", 9)); 910 case SIMPLE_HASH('e', 'r') : 911 d->p += 2; 912 return (vector_str_push(&d->vec, "operator^", 9)); 913 case SIMPLE_HASH('a', 'a') : 914 d->p += 2; 915 if (*d->p == 'd') { 916 ++d->p; 917 return (vector_str_push(&d->vec, "operator&=", 918 10)); 919 } else 920 return (vector_str_push(&d->vec, "operator&&", 921 10)); 922 case SIMPLE_HASH('o', 'o') : 923 d->p += 2; 924 return (vector_str_push(&d->vec, "operator||", 10)); 925 case SIMPLE_HASH('n', 't') : 926 d->p += 2; 927 return (vector_str_push(&d->vec, "operator!", 9)); 928 case SIMPLE_HASH('c', 'o') : 929 d->p += 2; 930 return (vector_str_push(&d->vec, "operator~", 9)); 931 case SIMPLE_HASH('p', 'p') : 932 d->p += 2; 933 return (vector_str_push(&d->vec, "operator++", 10)); 934 case SIMPLE_HASH('m', 'm') : 935 d->p += 2; 936 return (vector_str_push(&d->vec, "operator--", 10)); 937 case SIMPLE_HASH('a', 's') : 938 d->p += 2; 939 return (vector_str_push(&d->vec, "operator=", 9)); 940 case SIMPLE_HASH('r', 'f') : 941 d->p += 2; 942 return (vector_str_push(&d->vec, "operator->", 10)); 943 case SIMPLE_HASH('a', 'p') : 944 /* apl */ 945 if (*(d->p + 2) != 'l') 946 return (false); 947 948 d->p += 3; 949 return (vector_str_push(&d->vec, "operator+=", 10)); 950 case SIMPLE_HASH('a', 'm') : 951 d->p += 2; 952 if (*d->p == 'i') { 953 ++d->p; 954 return (vector_str_push(&d->vec, "operator-=", 955 10)); 956 } else if (*d->p == 'u') { 957 ++d->p; 958 return (vector_str_push(&d->vec, "operator*=", 959 10)); 960 } else if (*d->p == 'd') { 961 ++d->p; 962 return (vector_str_push(&d->vec, "operator%=", 963 10)); 964 } 965 966 return (false); 967 case SIMPLE_HASH('a', 'l') : 968 /* als */ 969 if (*(d->p + 2) != 's') 970 return (false); 971 972 d->p += 3; 973 return (vector_str_push(&d->vec, "operator<<=", 11)); 974 case SIMPLE_HASH('a', 'r') : 975 /* ars */ 976 if (*(d->p + 2) != 's') 977 return (false); 978 979 d->p += 3; 980 return (vector_str_push(&d->vec, "operator>>=", 11)); 981 case SIMPLE_HASH('a', 'o') : 982 /* aor */ 983 if (*(d->p + 2) != 'r') 984 return (false); 985 986 d->p += 3; 987 return (vector_str_push(&d->vec, "operator|=", 10)); 988 case SIMPLE_HASH('a', 'e') : 989 /* aer */ 990 if (*(d->p + 2) != 'r') 991 return (false); 992 993 d->p += 3; 994 return (vector_str_push(&d->vec, "operator^=", 10)); 995 case SIMPLE_HASH('c', 'm') : 996 d->p += 2; 997 return (vector_str_push(&d->vec, "operator,", 9)); 998 case SIMPLE_HASH('r', 'm') : 999 d->p += 2; 1000 return (vector_str_push(&d->vec, "operator->*", 11)); 1001 case SIMPLE_HASH('c', 'l') : 1002 d->p += 2; 1003 return (vector_str_push(&d->vec, "()", 2)); 1004 case SIMPLE_HASH('v', 'c') : 1005 d->p += 2; 1006 return (vector_str_push(&d->vec, "[]", 2)); 1007 case SIMPLE_HASH('n', 'w') : 1008 d->p += 2; 1009 return (vector_str_push(&d->vec, "operator new()", 14)); 1010 case SIMPLE_HASH('d', 'l') : 1011 d->p += 2; 1012 return (vector_str_push(&d->vec, "operator delete()", 1013 17)); 1014 case SIMPLE_HASH('o', 'p') : 1015 /* __op<TO_TYPE>__<FROM_TYPE> */ 1016 d->p += 2; 1017 1018 d->type = ENCODE_OP_USER; 1019 1020 return (read_op_user(d)); 1021 case SIMPLE_HASH('t', 'f') : 1022 d->p += 2; 1023 d->type = ENCODE_OP_TF; 1024 1025 if (read_type(d) == false) 1026 return (false); 1027 1028 return (vector_str_push(&d->vec, " type_info function", 19)); 1029 case SIMPLE_HASH('t', 'i') : 1030 d->p += 2; 1031 d->type = ENCODE_OP_TI; 1032 1033 if (read_type(d) == false) 1034 return (false); 1035 1036 return (vector_str_push(&d->vec, " type_info node", 15)); 1037 default : 1038 return (false); 1039 }; 1040 } 1041 1042 static bool 1043 read_op_user(struct demangle_data *d) 1044 { 1045 struct demangle_data from, to; 1046 size_t from_len, to_len; 1047 bool rtn; 1048 char *from_str, *to_str; 1049 1050 if (d == NULL) 1051 return (false); 1052 1053 if (init_demangle_data(&from) == false) 1054 return (false); 1055 1056 rtn = false; 1057 from_str = NULL; 1058 to_str = NULL; 1059 if (init_demangle_data(&to) == false) 1060 goto clean; 1061 1062 to.p = d->p; 1063 if (*to.p == 'Q') { 1064 ++to.p; 1065 1066 if (read_qual_name(&to) == false) 1067 goto clean; 1068 1069 /* pop last '::' */ 1070 if (vector_str_pop(&to.vec) == false) 1071 goto clean; 1072 } else { 1073 if (read_class(&to) == false) 1074 goto clean; 1075 1076 /* skip '__' */ 1077 to.p += 2; 1078 } 1079 1080 if ((to_str = vector_str_get_flat(&to.vec, &to_len)) == NULL) 1081 goto clean; 1082 1083 from.p = to.p; 1084 if (*from.p == 'Q') { 1085 ++from.p; 1086 1087 if (read_qual_name(&from) == false) 1088 goto clean; 1089 1090 /* pop last '::' */ 1091 if (vector_str_pop(&from.vec) == false) 1092 goto clean; 1093 } else if (read_class(&from) == false) 1094 goto clean; 1095 1096 if ((from_str = vector_str_get_flat(&from.vec, &from_len)) == NULL) 1097 goto clean; 1098 1099 if (vector_str_push(&d->vec, from_str, from_len) == false) 1100 goto clean; 1101 1102 if (vector_str_push(&d->vec, "::operator ", 11) == false) 1103 goto clean; 1104 1105 if (vector_str_push(&d->vec, to_str, to_len) == false) 1106 goto clean; 1107 1108 rtn = vector_str_push(&d->vec, "()", 2); 1109 clean: 1110 free(to_str); 1111 free(from_str); 1112 dest_demangle_data(&to); 1113 dest_demangle_data(&from); 1114 1115 return (rtn); 1116 } 1117 1118 /* single digit + class names */ 1119 static bool 1120 read_qual_name(struct demangle_data *d) 1121 { 1122 int i; 1123 char num; 1124 1125 if (d == NULL) 1126 return (false); 1127 1128 assert(d->p != NULL && "d->p (org str) is NULL"); 1129 assert(*d->p > 48 && *d->p < 58 && "*d->p not in ASCII numeric range"); 1130 1131 num = *d->p - 48; 1132 1133 assert(num > 0); 1134 1135 ++d->p; 1136 for (i = 0; i < num ; ++i) { 1137 if (read_class(d) == false) 1138 return (false); 1139 1140 if (vector_str_push(&d->vec, "::", 2) == false) 1141 return (false); 1142 } 1143 1144 if (*d->p != '\0') 1145 d->p = d->p + 2; 1146 1147 return (true); 1148 } 1149 1150 /* Return -1 at fail, 0 at success, and 1 at end */ 1151 static int 1152 read_subst(struct demangle_data *d) 1153 { 1154 size_t idx; 1155 char *str; 1156 1157 if (d == NULL) 1158 return (-1); 1159 1160 idx = strtol(d->p + 1, &str, 10); 1161 if (idx == 0 && (errno == EINVAL || errno == ERANGE)) 1162 return (-1); 1163 1164 assert(idx > 0); 1165 assert(str != NULL); 1166 1167 d->p = str; 1168 1169 if (vector_str_push(&d->vec, d->arg.container[idx - 1], 1170 strlen(d->arg.container[idx - 1])) == false) 1171 return (-1); 1172 1173 if (vector_str_push(&d->arg, d->arg.container[idx - 1], 1174 strlen(d->arg.container[idx - 1])) == false) 1175 return (-1); 1176 1177 if (*d->p == '\0') 1178 return (1); 1179 1180 return (0); 1181 } 1182 1183 static int 1184 read_subst_iter(struct demangle_data *d) 1185 { 1186 int i; 1187 size_t idx; 1188 char repeat; 1189 char *str; 1190 1191 if (d == NULL) 1192 return (-1); 1193 1194 ++d->p; 1195 assert(*d->p > 48 && *d->p < 58 && "*d->p not in ASCII numeric range"); 1196 1197 repeat = *d->p - 48; 1198 1199 assert(repeat > 1); 1200 1201 ++d->p; 1202 1203 idx = strtol(d->p, &str, 10); 1204 if (idx == 0 && (errno == EINVAL || errno == ERANGE)) 1205 return (-1); 1206 1207 assert(idx > 0); 1208 assert(str != NULL); 1209 1210 d->p = str; 1211 1212 for (i = 0; i < repeat ; ++i) { 1213 if (vector_str_push(&d->vec, d->arg.container[idx - 1], 1214 strlen(d->arg.container[idx - 1])) == false) 1215 return (-1); 1216 1217 if (vector_str_push(&d->arg, d->arg.container[idx - 1], 1218 strlen(d->arg.container[idx - 1])) == false) 1219 return (-1); 1220 1221 if (i != repeat - 1 && 1222 vector_str_push(&d->vec, ", ", 2) == false) 1223 return (-1); 1224 } 1225 1226 if (*d->p == '\0') 1227 return (1); 1228 1229 return (0); 1230 } 1231 1232 static bool 1233 read_type(struct demangle_data *d) 1234 { 1235 1236 if (d == NULL) 1237 return (false); 1238 1239 assert(d->p != NULL && "d->p (org str) is NULL"); 1240 1241 while (*d->p == 'U' || *d->p == 'C' || *d->p == 'V' || *d->p == 'S' || 1242 *d->p == 'P' || *d->p == 'R' || *d->p == 'A' || *d->p == 'F' || 1243 *d->p == 'M') { 1244 switch (*d->p) { 1245 case 'U' : 1246 ++d->p; 1247 1248 if (vector_str_push(&d->vec, "unsigned ", 9) == false) 1249 return (false); 1250 1251 break; 1252 case 'C' : 1253 ++d->p; 1254 1255 if (*d->p == 'P') 1256 d->cnst = true; 1257 else { 1258 if (vector_str_push(&d->vec, "const ", 6) == 1259 false) 1260 return (false); 1261 } 1262 1263 break; 1264 case 'V' : 1265 ++d->p; 1266 1267 if (vector_str_push(&d->vec, "volatile ", 9) == false) 1268 return (false); 1269 1270 break; 1271 case 'S' : 1272 ++d->p; 1273 1274 if (vector_str_push(&d->vec, "signed ", 7) == false) 1275 return (false); 1276 1277 break; 1278 case 'P' : 1279 ++d->p; 1280 1281 if (*d->p == 'F') 1282 return (read_func_ptr(d)); 1283 else 1284 d->ptr = true; 1285 1286 break; 1287 case 'R' : 1288 ++d->p; 1289 1290 d->ref = true; 1291 1292 break; 1293 case 'F' : 1294 break; 1295 case 'A' : 1296 ++d->p; 1297 1298 if (read_array(d) == false) 1299 return (false); 1300 1301 break; 1302 case 'M' : 1303 ++d->p; 1304 1305 if (read_memptr(d) == false) 1306 return (false); 1307 1308 break; 1309 default : 1310 break; 1311 } 1312 } 1313 1314 if (ELFTC_ISDIGIT(*d->p)) 1315 return (read_class(d)); 1316 1317 switch (*d->p) { 1318 case 'Q' : 1319 ++d->p; 1320 1321 return (read_qual_name(d)); 1322 case 'v' : 1323 ++d->p; 1324 1325 return (vector_str_push(&d->vec, "void", 4)); 1326 case 'b': 1327 ++d->p; 1328 1329 return(vector_str_push(&d->vec, "bool", 4)); 1330 case 'c' : 1331 ++d->p; 1332 1333 return (vector_str_push(&d->vec, "char", 4)); 1334 case 's' : 1335 ++d->p; 1336 1337 return (vector_str_push(&d->vec, "short", 5)); 1338 case 'i' : 1339 ++d->p; 1340 1341 return (vector_str_push(&d->vec, "int", 3)); 1342 case 'l' : 1343 ++d->p; 1344 1345 return (vector_str_push(&d->vec, "long", 4)); 1346 case 'f' : 1347 ++d->p; 1348 1349 return (vector_str_push(&d->vec, "float", 5)); 1350 case 'd': 1351 ++d->p; 1352 1353 return (vector_str_push(&d->vec, "double", 6)); 1354 case 'r': 1355 ++d->p; 1356 1357 return (vector_str_push(&d->vec, "long double", 11)); 1358 case 'e': 1359 ++d->p; 1360 1361 return (vector_str_push(&d->vec, "...", 3)); 1362 case 'w': 1363 ++d->p; 1364 1365 return (vector_str_push(&d->vec, "wchar_t", 7)); 1366 case 'x': 1367 ++d->p; 1368 1369 return (vector_str_push(&d->vec, "long long", 9)); 1370 default: 1371 return (false); 1372 }; 1373 1374 /* NOTREACHED */ 1375 return (false); 1376 } 1377