contrib/elftoolchain/libelftc/libelftc_dem_arm.c

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