contrib/elftoolchain/libelftc/libelftc_dem_gnu3.c

   1 /*-
   2  * Copyright (c) 2007 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 #include <sys/types.h>
  27 #include <assert.h>
  28 #include <ctype.h>
  29 #include <errno.h>
  30 #include <libelftc.h>
  31 #include <limits.h>
  32 #include <stdbool.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36
  37 #include "_libelftc.h"
  38
  39 ELFTC_VCSID("$Id: libelftc_dem_gnu3.c 3480 2016-07-24 23:38:41Z emaste $");
  40
  41 /**
  42  * @file cpp_demangle.c
  43  * @brief Decode IA-64 C++ ABI style implementation.
  44  *
  45  * IA-64 standard ABI(Itanium C++ ABI) references.
  46  *
  47  * http://www.codesourcery.com/cxx-abi/abi.html#mangling \n
  48  * http://www.codesourcery.com/cxx-abi/abi-mangling.html
  49  */
  50
  51 enum type_qualifier {
  52         TYPE_PTR, TYPE_REF, TYPE_CMX, TYPE_IMG, TYPE_EXT, TYPE_RST, TYPE_VAT,
  53         TYPE_CST, TYPE_VEC
  54 };
  55
  56 struct vector_type_qualifier {
  57         size_t size, capacity;
  58         enum type_qualifier *q_container;
  59         struct vector_str ext_name;
  60 };
  61
  62 enum read_cmd {
  63         READ_FAIL, READ_NEST, READ_TMPL, READ_EXPR, READ_EXPL, READ_LOCAL,
  64         READ_TYPE, READ_FUNC, READ_PTRMEM
  65 };
  66
  67 struct vector_read_cmd {
  68         size_t size, capacity;
  69         enum read_cmd *r_container;
  70 };
  71
  72 struct cpp_demangle_data {
  73         struct vector_str        output;        /* output string vector */
  74         struct vector_str        output_tmp;
  75         struct vector_str        subst;         /* substitution string vector */
  76         struct vector_str        tmpl;
  77         struct vector_str        class_type;
  78         struct vector_read_cmd   cmd;
  79         bool                     paren;         /* parenthesis opened */
  80         bool                     pfirst;        /* first element of parameter */
  81         bool                     mem_rst;       /* restrict member function */
  82         bool                     mem_vat;       /* volatile member function */
  83         bool                     mem_cst;       /* const member function */
  84         int                      func_type;
  85         const char              *cur;           /* current mangled name ptr */
  86         const char              *last_sname;    /* last source name */
  87         int                      push_head;
  88 };
  89
  90 #define CPP_DEMANGLE_TRY_LIMIT  128
  91 #define FLOAT_SPRINTF_TRY_LIMIT 5
  92 #define FLOAT_QUADRUPLE_BYTES   16
  93 #define FLOAT_EXTENED_BYTES     10
  94
  95 #define SIMPLE_HASH(x,y)        (64 * x + y)
  96
  97 static void     cpp_demangle_data_dest(struct cpp_demangle_data *);
  98 static int      cpp_demangle_data_init(struct cpp_demangle_data *,
  99                     const char *);
 100 static int      cpp_demangle_get_subst(struct cpp_demangle_data *, size_t);
 101 static int      cpp_demangle_get_tmpl_param(struct cpp_demangle_data *, size_t);
 102 static int      cpp_demangle_push_fp(struct cpp_demangle_data *,
 103                     char *(*)(const char *, size_t));
 104 static int      cpp_demangle_push_str(struct cpp_demangle_data *, const char *,
 105                     size_t);
 106 static int      cpp_demangle_push_subst(struct cpp_demangle_data *,
 107                     const char *, size_t);
 108 static int      cpp_demangle_push_subst_v(struct cpp_demangle_data *,
 109                     struct vector_str *);
 110 static int      cpp_demangle_push_type_qualifier(struct cpp_demangle_data *,
 111                     struct vector_type_qualifier *, const char *);
 112 static int      cpp_demangle_read_array(struct cpp_demangle_data *);
 113 static int      cpp_demangle_read_encoding(struct cpp_demangle_data *);
 114 static int      cpp_demangle_read_expr_primary(struct cpp_demangle_data *);
 115 static int      cpp_demangle_read_expression(struct cpp_demangle_data *);
 116 static int      cpp_demangle_read_expression_flat(struct cpp_demangle_data *,
 117                     char **);
 118 static int      cpp_demangle_read_expression_binary(struct cpp_demangle_data *,
 119                     const char *, size_t);
 120 static int      cpp_demangle_read_expression_unary(struct cpp_demangle_data *,
 121                     const char *, size_t);
 122 static int      cpp_demangle_read_expression_trinary(struct cpp_demangle_data *,
 123                     const char *, size_t, const char *, size_t);
 124 static int      cpp_demangle_read_function(struct cpp_demangle_data *, int *,
 125                     struct vector_type_qualifier *);
 126 static int      cpp_demangle_local_source_name(struct cpp_demangle_data *ddata);
 127 static int      cpp_demangle_read_local_name(struct cpp_demangle_data *);
 128 static int      cpp_demangle_read_name(struct cpp_demangle_data *);
 129 static int      cpp_demangle_read_name_flat(struct cpp_demangle_data *,
 130                     char**);
 131 static int      cpp_demangle_read_nested_name(struct cpp_demangle_data *);
 132 static int      cpp_demangle_read_number(struct cpp_demangle_data *, long *);
 133 static int      cpp_demangle_read_number_as_string(struct cpp_demangle_data *,
 134                     char **);
 135 static int      cpp_demangle_read_nv_offset(struct cpp_demangle_data *);
 136 static int      cpp_demangle_read_offset(struct cpp_demangle_data *);
 137 static int      cpp_demangle_read_offset_number(struct cpp_demangle_data *);
 138 static int      cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *);
 139 static int      cpp_demangle_read_sname(struct cpp_demangle_data *);
 140 static int      cpp_demangle_read_subst(struct cpp_demangle_data *);
 141 static int      cpp_demangle_read_subst_std(struct cpp_demangle_data *);
 142 static int      cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *,
 143                     const char *, size_t);
 144 static int      cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *);
 145 static int      cpp_demangle_read_tmpl_args(struct cpp_demangle_data *);
 146 static int      cpp_demangle_read_tmpl_param(struct cpp_demangle_data *);
 147 static int      cpp_demangle_read_type(struct cpp_demangle_data *, int);
 148 static int      cpp_demangle_read_type_flat(struct cpp_demangle_data *,
 149                     char **);
 150 static int      cpp_demangle_read_uqname(struct cpp_demangle_data *);
 151 static int      cpp_demangle_read_v_offset(struct cpp_demangle_data *);
 152 static char     *decode_fp_to_double(const char *, size_t);
 153 static char     *decode_fp_to_float(const char *, size_t);
 154 static char     *decode_fp_to_float128(const char *, size_t);
 155 static char     *decode_fp_to_float80(const char *, size_t);
 156 static char     *decode_fp_to_long_double(const char *, size_t);
 157 static int      hex_to_dec(char);
 158 static void     vector_read_cmd_dest(struct vector_read_cmd *);
 159 static int      vector_read_cmd_find(struct vector_read_cmd *, enum read_cmd);
 160 static int      vector_read_cmd_init(struct vector_read_cmd *);
 161 static int      vector_read_cmd_pop(struct vector_read_cmd *);
 162 static int      vector_read_cmd_push(struct vector_read_cmd *, enum read_cmd);
 163 static void     vector_type_qualifier_dest(struct vector_type_qualifier *);
 164 static int      vector_type_qualifier_init(struct vector_type_qualifier *);
 165 static int      vector_type_qualifier_push(struct vector_type_qualifier *,
 166                     enum type_qualifier);
 167
 168 /**
 169  * @brief Decode the input string by IA-64 C++ ABI style.
 170  *
 171  * GNU GCC v3 use IA-64 standard ABI.
 172  * @return New allocated demangled string or NULL if failed.
 173  * @todo 1. Testing and more test case. 2. Code cleaning.
 174  */
 175 char *
 176 cpp_demangle_gnu3(const char *org)
 177 {
 178         struct cpp_demangle_data ddata;
 179         ssize_t org_len;
 180         unsigned int limit;
 181         char *rtn;
 182
 183         if (org == NULL || (org_len = strlen(org)) < 2)
 184                 return (NULL);
 185
 186         if (org_len > 11 && !strncmp(org, "_GLOBAL__I_", 11)) {
 187                 if ((rtn = malloc(org_len + 19)) == NULL)
 188                         return (NULL);
 189                 snprintf(rtn, org_len + 19,
 190                     "global constructors keyed to %s", org + 11);
 191                 return (rtn);
 192         }
 193
 194         if (org[0] != '_' || org[1] != 'Z')
 195                 return (NULL);
 196
 197         if (!cpp_demangle_data_init(&ddata, org + 2))
 198                 return (NULL);
 199
 200         rtn = NULL;
 201
 202         if (!cpp_demangle_read_encoding(&ddata))
 203                 goto clean;
 204
 205         limit = 0;
 206         while (*ddata.cur != '\0') {
 207                 /*
 208                  * Breaking at some gcc info at tail. e.g) @@GLIBCXX_3.4
 209                  */
 210                 if (*ddata.cur == '@' && *(ddata.cur + 1) == '@')
 211                         break;
 212                 if (!cpp_demangle_read_type(&ddata, 1))
 213                         goto clean;
 214                 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
 215                         goto clean;
 216         }
 217
 218         if (ddata.output.size == 0)
 219                 goto clean;
 220         if (ddata.paren && !vector_str_push(&ddata.output, ")", 1))
 221                 goto clean;
 222         if (ddata.mem_vat && !vector_str_push(&ddata.output, " volatile", 9))
 223                 goto clean;
 224         if (ddata.mem_cst && !vector_str_push(&ddata.output, " const", 6))
 225                 goto clean;
 226         if (ddata.mem_rst && !vector_str_push(&ddata.output, " restrict", 9))
 227                 goto clean;
 228
 229         rtn = vector_str_get_flat(&ddata.output, (size_t *) NULL);
 230
 231 clean:
 232         cpp_demangle_data_dest(&ddata);
 233
 234         return (rtn);
 235 }
 236
 237 static void
 238 cpp_demangle_data_dest(struct cpp_demangle_data *d)
 239 {
 240
 241         if (d == NULL)
 242                 return;
 243
 244         vector_read_cmd_dest(&d->cmd);
 245         vector_str_dest(&d->class_type);
 246         vector_str_dest(&d->tmpl);
 247         vector_str_dest(&d->subst);
 248         vector_str_dest(&d->output_tmp);
 249         vector_str_dest(&d->output);
 250 }
 251
 252 static int
 253 cpp_demangle_data_init(struct cpp_demangle_data *d, const char *cur)
 254 {
 255
 256         if (d == NULL || cur == NULL)
 257                 return (0);
 258
 259         if (!vector_str_init(&d->output))
 260                 return (0);
 261         if (!vector_str_init(&d->output_tmp))
 262                 goto clean1;
 263         if (!vector_str_init(&d->subst))
 264                 goto clean2;
 265         if (!vector_str_init(&d->tmpl))
 266                 goto clean3;
 267         if (!vector_str_init(&d->class_type))
 268                 goto clean4;
 269         if (!vector_read_cmd_init(&d->cmd))
 270                 goto clean5;
 271
 272         assert(d->output.container != NULL);
 273         assert(d->output_tmp.container != NULL);
 274         assert(d->subst.container != NULL);
 275         assert(d->tmpl.container != NULL);
 276         assert(d->class_type.container != NULL);
 277
 278         d->paren = false;
 279         d->pfirst = false;
 280         d->mem_rst = false;
 281         d->mem_vat = false;
 282         d->mem_cst = false;
 283         d->func_type = 0;
 284         d->cur = cur;
 285         d->last_sname = NULL;
 286         d->push_head = 0;
 287
 288         return (1);
 289
 290 clean5:
 291         vector_str_dest(&d->class_type);
 292 clean4:
 293         vector_str_dest(&d->tmpl);
 294 clean3:
 295         vector_str_dest(&d->subst);
 296 clean2:
 297         vector_str_dest(&d->output_tmp);
 298 clean1:
 299         vector_str_dest(&d->output);
 300
 301         return (0);
 302 }
 303
 304 static int
 305 cpp_demangle_push_fp(struct cpp_demangle_data *ddata,
 306     char *(*decoder)(const char *, size_t))
 307 {
 308         size_t len;
 309         int rtn;
 310         const char *fp;
 311         char *f;
 312
 313         if (ddata == NULL || decoder == NULL)
 314                 return (0);
 315
 316         fp = ddata->cur;
 317         while (*ddata->cur != 'E')
 318                 ++ddata->cur;
 319
 320         if ((f = decoder(fp, ddata->cur - fp)) == NULL)
 321                 return (0);
 322
 323         rtn = 0;
 324         if ((len = strlen(f)) > 0)
 325                 rtn = cpp_demangle_push_str(ddata, f, len);
 326
 327         free(f);
 328
 329         ++ddata->cur;
 330
 331         return (rtn);
 332 }
 333
 334 static int
 335 cpp_demangle_push_str(struct cpp_demangle_data *ddata, const char *str,
 336     size_t len)
 337 {
 338
 339         if (ddata == NULL || str == NULL || len == 0)
 340                 return (0);
 341
 342         if (ddata->push_head > 0)
 343                 return (vector_str_push(&ddata->output_tmp, str, len));
 344
 345         return (vector_str_push(&ddata->output, str, len));
 346 }
 347
 348 static int
 349 cpp_demangle_push_subst(struct cpp_demangle_data *ddata, const char *str,
 350     size_t len)
 351 {
 352
 353         if (ddata == NULL || str == NULL || len == 0)
 354                 return (0);
 355
 356         if (!vector_str_find(&ddata->subst, str, len))
 357                 return (vector_str_push(&ddata->subst, str, len));
 358
 359         return (1);
 360 }
 361
 362 static int
 363 cpp_demangle_push_subst_v(struct cpp_demangle_data *ddata, struct vector_str *v)
 364 {
 365         size_t str_len;
 366         int rtn;
 367         char *str;
 368
 369         if (ddata == NULL || v == NULL)
 370                 return (0);
 371
 372         if ((str = vector_str_get_flat(v, &str_len)) == NULL)
 373                 return (0);
 374
 375         rtn = cpp_demangle_push_subst(ddata, str, str_len);
 376
 377         free(str);
 378
 379         return (rtn);
 380 }
 381
 382 static int
 383 cpp_demangle_push_type_qualifier(struct cpp_demangle_data *ddata,
 384     struct vector_type_qualifier *v, const char *type_str)
 385 {
 386         struct vector_str subst_v;
 387         size_t idx, e_idx, e_len;
 388         int rtn;
 389         char *buf;
 390
 391         if (ddata == NULL || v == NULL)
 392                 return (0);
 393
 394         if ((idx = v->size) == 0)
 395                 return (1);
 396
 397         rtn = 0;
 398         if (type_str != NULL) {
 399                 if (!vector_str_init(&subst_v))
 400                         return (0);
 401                 if (!vector_str_push(&subst_v, type_str, strlen(type_str)))
 402                         goto clean;
 403         }
 404
 405         e_idx = 0;
 406         while (idx > 0) {
 407                 switch (v->q_container[idx - 1]) {
 408                 case TYPE_PTR:
 409                         if (!cpp_demangle_push_str(ddata, "*", 1))
 410                                 goto clean;
 411                         if (type_str != NULL) {
 412                                 if (!vector_str_push(&subst_v, "*", 1))
 413                                         goto clean;
 414                                 if (!cpp_demangle_push_subst_v(ddata,
 415                                     &subst_v))
 416                                         goto clean;
 417                         }
 418                         break;
 419
 420                 case TYPE_REF:
 421                         if (!cpp_demangle_push_str(ddata, "&", 1))
 422                                 goto clean;
 423                         if (type_str != NULL) {
 424                                 if (!vector_str_push(&subst_v, "&", 1))
 425                                         goto clean;
 426                                 if (!cpp_demangle_push_subst_v(ddata,
 427                                     &subst_v))
 428                                         goto clean;
 429                         }
 430                         break;
 431
 432                 case TYPE_CMX:
 433                         if (!cpp_demangle_push_str(ddata, " complex", 8))
 434                                 goto clean;
 435                         if (type_str != NULL) {
 436                                 if (!vector_str_push(&subst_v, " complex", 8))
 437                                         goto clean;
 438                                 if (!cpp_demangle_push_subst_v(ddata,
 439                                     &subst_v))
 440                                         goto clean;
 441                         }
 442                         break;
 443
 444                 case TYPE_IMG:
 445                         if (!cpp_demangle_push_str(ddata, " imaginary", 10))
 446                                 goto clean;
 447                         if (type_str != NULL) {
 448                                 if (!vector_str_push(&subst_v, " imaginary",
 449                                     10))
 450                                         goto clean;
 451                                 if (!cpp_demangle_push_subst_v(ddata,
 452                                     &subst_v))
 453                                         goto clean;
 454                         }
 455                         break;
 456
 457                 case TYPE_EXT:
 458                         if (v->ext_name.size == 0 ||
 459                             e_idx > v->ext_name.size - 1)
 460                                 goto clean;
 461                         if ((e_len = strlen(v->ext_name.container[e_idx])) ==
 462                             0)
 463                                 goto clean;
 464                         if ((buf = malloc(e_len + 2)) == NULL)
 465                                 goto clean;
 466                         snprintf(buf, e_len + 2, " %s",
 467                             v->ext_name.container[e_idx]);
 468
 469                         if (!cpp_demangle_push_str(ddata, buf, e_len + 1)) {
 470                                 free(buf);
 471                                 goto clean;
 472                         }
 473
 474                         if (type_str != NULL) {
 475                                 if (!vector_str_push(&subst_v, buf,
 476                                     e_len + 1)) {
 477                                         free(buf);
 478                                         goto clean;
 479                                 }
 480                                 if (!cpp_demangle_push_subst_v(ddata,
 481                                     &subst_v)) {
 482                                         free(buf);
 483                                         goto clean;
 484                                 }
 485                         }
 486                         free(buf);
 487                         ++e_idx;
 488                         break;
 489
 490                 case TYPE_RST:
 491                         if (!cpp_demangle_push_str(ddata, " restrict", 9))
 492                                 goto clean;
 493                         if (type_str != NULL) {
 494                                 if (!vector_str_push(&subst_v, " restrict", 9))
 495                                         goto clean;
 496                                 if (!cpp_demangle_push_subst_v(ddata,
 497                                     &subst_v))
 498                                         goto clean;
 499                         }
 500                         break;
 501
 502                 case TYPE_VAT:
 503                         if (!cpp_demangle_push_str(ddata, " volatile", 9))
 504                                 goto clean;
 505                         if (type_str != NULL) {
 506                                 if (!vector_str_push(&subst_v, " volatile", 9))
 507                                         goto clean;
 508                                 if (!cpp_demangle_push_subst_v(ddata,
 509                                     &subst_v))
 510                                         goto clean;
 511                         }
 512                         break;
 513
 514                 case TYPE_CST:
 515                         if (!cpp_demangle_push_str(ddata, " const", 6))
 516                                 goto clean;
 517                         if (type_str != NULL) {
 518                                 if (!vector_str_push(&subst_v, " const", 6))
 519                                         goto clean;
 520                                 if (!cpp_demangle_push_subst_v(ddata,
 521                                     &subst_v))
 522                                         goto clean;
 523                         }
 524                         break;
 525
 526                 case TYPE_VEC:
 527                         if (v->ext_name.size == 0 ||
 528                             e_idx > v->ext_name.size - 1)
 529                                 goto clean;
 530                         if ((e_len = strlen(v->ext_name.container[e_idx])) ==
 531                             0)
 532                                 goto clean;
 533                         if ((buf = malloc(e_len + 12)) == NULL)
 534                                 goto clean;
 535                         snprintf(buf, e_len + 12, " __vector(%s)",
 536                             v->ext_name.container[e_idx]);
 537                         if (!cpp_demangle_push_str(ddata, buf, e_len + 11)) {
 538                                 free(buf);
 539                                 goto clean;
 540                         }
 541                         if (type_str != NULL) {
 542                                 if (!vector_str_push(&subst_v, buf,
 543                                     e_len + 11)) {
 544                                         free(buf);
 545                                         goto clean;
 546                                 }
 547                                 if (!cpp_demangle_push_subst_v(ddata,
 548                                     &subst_v)) {
 549                                         free(buf);
 550                                         goto clean;
 551                                 }
 552                         }
 553                         free(buf);
 554                         ++e_idx;
 555                         break;
 556                 }
 557                 --idx;
 558         }
 559
 560         rtn = 1;
 561 clean:
 562         if (type_str != NULL)
 563                 vector_str_dest(&subst_v);
 564
 565         return (rtn);
 566 }
 567
 568 static int
 569 cpp_demangle_get_subst(struct cpp_demangle_data *ddata, size_t idx)
 570 {
 571         size_t len;
 572
 573         if (ddata == NULL || ddata->subst.size <= idx)
 574                 return (0);
 575         if ((len = strlen(ddata->subst.container[idx])) == 0)
 576                 return (0);
 577         if (!cpp_demangle_push_str(ddata, ddata->subst.container[idx], len))
 578                 return (0);
 579
 580         /* skip '_' */
 581         ++ddata->cur;
 582
 583         return (1);
 584 }
 585
 586 static int
 587 cpp_demangle_get_tmpl_param(struct cpp_demangle_data *ddata, size_t idx)
 588 {
 589         size_t len;
 590
 591         if (ddata == NULL || ddata->tmpl.size <= idx)
 592                 return (0);
 593         if ((len = strlen(ddata->tmpl.container[idx])) == 0)
 594                 return (0);
 595         if (!cpp_demangle_push_str(ddata, ddata->tmpl.container[idx], len))
 596                 return (0);
 597
 598         ++ddata->cur;
 599
 600         return (1);
 601 }
 602
 603 static int
 604 cpp_demangle_read_array(struct cpp_demangle_data *ddata)
 605 {
 606         size_t i, num_len, exp_len, p_idx, idx;
 607         const char *num;
 608         char *exp;
 609
 610         if (ddata == NULL || *(++ddata->cur) == '\0')
 611                 return (0);
 612
 613         if (*ddata->cur == '_') {
 614                 if (*(++ddata->cur) == '\0')
 615                         return (0);
 616
 617                 if (!cpp_demangle_read_type(ddata, 0))
 618                         return (0);
 619
 620                 if (!cpp_demangle_push_str(ddata, "[]", 2))
 621                         return (0);
 622         } else {
 623                 if (ELFTC_ISDIGIT(*ddata->cur) != 0) {
 624                         num = ddata->cur;
 625                         while (ELFTC_ISDIGIT(*ddata->cur) != 0)
 626                                 ++ddata->cur;
 627                         if (*ddata->cur != '_')
 628                                 return (0);
 629                         num_len = ddata->cur - num;
 630                         assert(num_len > 0);
 631                         if (*(++ddata->cur) == '\0')
 632                                 return (0);
 633                         if (!cpp_demangle_read_type(ddata, 0))
 634                                 return (0);
 635                         if (!cpp_demangle_push_str(ddata, "[", 1))
 636                                 return (0);
 637                         if (!cpp_demangle_push_str(ddata, num, num_len))
 638                                 return (0);
 639                         if (!cpp_demangle_push_str(ddata, "]", 1))
 640                                 return (0);
 641                 } else {
 642                         p_idx = ddata->output.size;
 643                         if (!cpp_demangle_read_expression(ddata))
 644                                 return (0);
 645                         if ((exp = vector_str_substr(&ddata->output, p_idx,
 646                                  ddata->output.size - 1, &exp_len)) == NULL)
 647                                 return (0);
 648                         idx = ddata->output.size;
 649                         for (i = p_idx; i < idx; ++i)
 650                                 if (!vector_str_pop(&ddata->output)) {
 651                                         free(exp);
 652                                         return (0);
 653                                 }
 654                         if (*ddata->cur != '_') {
 655                                 free(exp);
 656                                 return (0);
 657                         }
 658                         ++ddata->cur;
 659                         if (*ddata->cur == '\0') {
 660                                 free(exp);
 661                                 return (0);
 662                         }
 663                         if (!cpp_demangle_read_type(ddata, 0)) {
 664                                 free(exp);
 665                                 return (0);
 666                         }
 667                         if (!cpp_demangle_push_str(ddata, "[", 1)) {
 668                                 free(exp);
 669                                 return (0);
 670                         }
 671                         if (!cpp_demangle_push_str(ddata, exp, exp_len)) {
 672                                 free(exp);
 673                                 return (0);
 674                         }
 675                         if (!cpp_demangle_push_str(ddata, "]", 1)) {
 676                                 free(exp);
 677                                 return (0);
 678                         }
 679                         free(exp);
 680                 }
 681         }
 682
 683         return (1);
 684 }
 685
 686 static int
 687 cpp_demangle_read_expr_primary(struct cpp_demangle_data *ddata)
 688 {
 689         const char *num;
 690
 691         if (ddata == NULL || *(++ddata->cur) == '\0')
 692                 return (0);
 693
 694         if (*ddata->cur == '_' && *(ddata->cur + 1) == 'Z') {
 695                 ddata->cur += 2;
 696                 if (*ddata->cur == '\0')
 697                         return (0);
 698                 if (!cpp_demangle_read_encoding(ddata))
 699                         return (0);
 700                 ++ddata->cur;
 701                 return (1);
 702         }
 703
 704         switch (*ddata->cur) {
 705         case 'b':
 706                 if (*(ddata->cur + 2) != 'E')
 707                         return (0);
 708                 switch (*(++ddata->cur)) {
 709                 case '0':
 710                         ddata->cur += 2;
 711                         return (cpp_demangle_push_str(ddata, "false", 5));
 712                 case '1':
 713                         ddata->cur += 2;
 714                         return (cpp_demangle_push_str(ddata, "true", 4));
 715                 default:
 716                         return (0);
 717                 }
 718
 719         case 'd':
 720                 ++ddata->cur;
 721                 return (cpp_demangle_push_fp(ddata, decode_fp_to_double));
 722
 723         case 'e':
 724                 ++ddata->cur;
 725                 if (sizeof(long double) == 10)
 726                         return (cpp_demangle_push_fp(ddata,
 727                             decode_fp_to_double));
 728                 return (cpp_demangle_push_fp(ddata, decode_fp_to_float80));
 729
 730         case 'f':
 731                 ++ddata->cur;
 732                 return (cpp_demangle_push_fp(ddata, decode_fp_to_float));
 733
 734         case 'g':
 735                 ++ddata->cur;
 736                 if (sizeof(long double) == 16)
 737                         return (cpp_demangle_push_fp(ddata,
 738                             decode_fp_to_double));
 739                 return (cpp_demangle_push_fp(ddata, decode_fp_to_float128));
 740
 741         case 'i':
 742         case 'j':
 743         case 'l':
 744         case 'm':
 745         case 'n':
 746         case 's':
 747         case 't':
 748         case 'x':
 749         case 'y':
 750                 if (*(++ddata->cur) == 'n') {
 751                         if (!cpp_demangle_push_str(ddata, "-", 1))
 752                                 return (0);
 753                         ++ddata->cur;
 754                 }
 755                 num = ddata->cur;
 756                 while (*ddata->cur != 'E') {
 757                         if (!ELFTC_ISDIGIT(*ddata->cur))
 758                                 return (0);
 759                         ++ddata->cur;
 760                 }
 761                 ++ddata->cur;
 762                 return (cpp_demangle_push_str(ddata, num,
 763                     ddata->cur - num - 1));
 764
 765         default:
 766                 return (0);
 767         }
 768 }
 769
 770 static int
 771 cpp_demangle_read_expression(struct cpp_demangle_data *ddata)
 772 {
 773
 774         if (ddata == NULL || *ddata->cur == '\0')
 775                 return (0);
 776
 777         switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
 778         case SIMPLE_HASH('s', 't'):
 779                 ddata->cur += 2;
 780                 return (cpp_demangle_read_type(ddata, 0));
 781
 782         case SIMPLE_HASH('s', 'r'):
 783                 ddata->cur += 2;
 784                 if (!cpp_demangle_read_type(ddata, 0))
 785                         return (0);
 786                 if (!cpp_demangle_read_uqname(ddata))
 787                         return (0);
 788                 if (*ddata->cur == 'I')
 789                         return (cpp_demangle_read_tmpl_args(ddata));
 790                 return (1);
 791
 792         case SIMPLE_HASH('a', 'a'):
 793                 /* operator && */
 794                 ddata->cur += 2;
 795                 return (cpp_demangle_read_expression_binary(ddata, "&&", 2));
 796
 797         case SIMPLE_HASH('a', 'd'):
 798                 /* operator & (unary) */
 799                 ddata->cur += 2;
 800                 return (cpp_demangle_read_expression_unary(ddata, "&", 1));
 801
 802         case SIMPLE_HASH('a', 'n'):
 803                 /* operator & */
 804                 ddata->cur += 2;
 805                 return (cpp_demangle_read_expression_binary(ddata, "&", 1));
 806
 807         case SIMPLE_HASH('a', 'N'):
 808                 /* operator &= */
 809                 ddata->cur += 2;
 810                 return (cpp_demangle_read_expression_binary(ddata, "&=", 2));
 811
 812         case SIMPLE_HASH('a', 'S'):
 813                 /* operator = */
 814                 ddata->cur += 2;
 815                 return (cpp_demangle_read_expression_binary(ddata, "=", 1));
 816
 817         case SIMPLE_HASH('c', 'l'):
 818                 /* operator () */
 819                 ddata->cur += 2;
 820                 return (cpp_demangle_read_expression_binary(ddata, "()", 2));
 821
 822         case SIMPLE_HASH('c', 'm'):
 823                 /* operator , */
 824                 ddata->cur += 2;
 825                 return (cpp_demangle_read_expression_binary(ddata, ",", 1));
 826
 827         case SIMPLE_HASH('c', 'o'):
 828                 /* operator ~ */
 829                 ddata->cur += 2;
 830                 return (cpp_demangle_read_expression_binary(ddata, "~", 1));
 831
 832         case SIMPLE_HASH('c', 'v'):
 833                 /* operator (cast) */
 834                 ddata->cur += 2;
 835                 return (cpp_demangle_read_expression_binary(ddata, "(cast)", 6));
 836
 837         case SIMPLE_HASH('d', 'a'):
 838                 /* operator delete [] */
 839                 ddata->cur += 2;
 840                 return (cpp_demangle_read_expression_unary(ddata, "delete []", 9));
 841
 842         case SIMPLE_HASH('d', 'e'):
 843                 /* operator * (unary) */
 844                 ddata->cur += 2;
 845                 return (cpp_demangle_read_expression_unary(ddata, "*", 1));
 846
 847         case SIMPLE_HASH('d', 'l'):
 848                 /* operator delete */
 849                 ddata->cur += 2;
 850                 return (cpp_demangle_read_expression_unary(ddata, "delete", 6));
 851
 852         case SIMPLE_HASH('d', 'v'):
 853                 /* operator / */
 854                 ddata->cur += 2;
 855                 return (cpp_demangle_read_expression_binary(ddata, "/", 1));
 856
 857         case SIMPLE_HASH('d', 'V'):
 858                 /* operator /= */
 859                 ddata->cur += 2;
 860                 return (cpp_demangle_read_expression_binary(ddata, "/=", 2));
 861
 862         case SIMPLE_HASH('e', 'o'):
 863                 /* operator ^ */
 864                 ddata->cur += 2;
 865                 return (cpp_demangle_read_expression_binary(ddata, "^", 1));
 866
 867         case SIMPLE_HASH('e', 'O'):
 868                 /* operator ^= */
 869                 ddata->cur += 2;
 870                 return (cpp_demangle_read_expression_binary(ddata, "^=", 2));
 871
 872         case SIMPLE_HASH('e', 'q'):
 873                 /* operator == */
 874                 ddata->cur += 2;
 875                 return (cpp_demangle_read_expression_binary(ddata, "==", 2));
 876
 877         case SIMPLE_HASH('g', 'e'):
 878                 /* operator >= */
 879                 ddata->cur += 2;
 880                 return (cpp_demangle_read_expression_binary(ddata, ">=", 2));
 881
 882         case SIMPLE_HASH('g', 't'):
 883                 /* operator > */
 884                 ddata->cur += 2;
 885                 return (cpp_demangle_read_expression_binary(ddata, ">", 1));
 886
 887         case SIMPLE_HASH('i', 'x'):
 888                 /* operator [] */
 889                 ddata->cur += 2;
 890                 return (cpp_demangle_read_expression_binary(ddata, "[]", 2));
 891
 892         case SIMPLE_HASH('l', 'e'):
 893                 /* operator <= */
 894                 ddata->cur += 2;
 895                 return (cpp_demangle_read_expression_binary(ddata, "<=", 2));
 896
 897         case SIMPLE_HASH('l', 's'):
 898                 /* operator << */
 899                 ddata->cur += 2;
 900                 return (cpp_demangle_read_expression_binary(ddata, "<<", 2));
 901
 902         case SIMPLE_HASH('l', 'S'):
 903                 /* operator <<= */
 904                 ddata->cur += 2;
 905                 return (cpp_demangle_read_expression_binary(ddata, "<<=", 3));
 906
 907         case SIMPLE_HASH('l', 't'):
 908                 /* operator < */
 909                 ddata->cur += 2;
 910                 return (cpp_demangle_read_expression_binary(ddata, "<", 1));
 911
 912         case SIMPLE_HASH('m', 'i'):
 913                 /* operator - */
 914                 ddata->cur += 2;
 915                 return (cpp_demangle_read_expression_binary(ddata, "-", 1));
 916
 917         case SIMPLE_HASH('m', 'I'):
 918                 /* operator -= */
 919                 ddata->cur += 2;
 920                 return (cpp_demangle_read_expression_binary(ddata, "-=", 2));
 921
 922         case SIMPLE_HASH('m', 'l'):
 923                 /* operator * */
 924                 ddata->cur += 2;
 925                 return (cpp_demangle_read_expression_binary(ddata, "*", 1));
 926
 927         case SIMPLE_HASH('m', 'L'):
 928                 /* operator *= */
 929                 ddata->cur += 2;
 930                 return (cpp_demangle_read_expression_binary(ddata, "*=", 2));
 931
 932         case SIMPLE_HASH('m', 'm'):
 933                 /* operator -- */
 934                 ddata->cur += 2;
 935                 return (cpp_demangle_read_expression_binary(ddata, "--", 2));
 936
 937         case SIMPLE_HASH('n', 'a'):
 938                 /* operator new[] */
 939                 ddata->cur += 2;
 940                 return (cpp_demangle_read_expression_unary(ddata, "new []", 6));
 941
 942         case SIMPLE_HASH('n', 'e'):
 943                 /* operator != */
 944                 ddata->cur += 2;
 945                 return (cpp_demangle_read_expression_binary(ddata, "!=", 2));
 946
 947         case SIMPLE_HASH('n', 'g'):
 948                 /* operator - (unary) */
 949                 ddata->cur += 2;
 950                 return (cpp_demangle_read_expression_unary(ddata, "-", 1));
 951
 952         case SIMPLE_HASH('n', 't'):
 953                 /* operator ! */
 954                 ddata->cur += 2;
 955                 return (cpp_demangle_read_expression_binary(ddata, "!", 1));
 956
 957         case SIMPLE_HASH('n', 'w'):
 958                 /* operator new */
 959                 ddata->cur += 2;
 960                 return (cpp_demangle_read_expression_unary(ddata, "new", 3));
 961
 962         case SIMPLE_HASH('o', 'o'):
 963                 /* operator || */
 964                 ddata->cur += 2;
 965                 return (cpp_demangle_read_expression_binary(ddata, "||", 2));
 966
 967         case SIMPLE_HASH('o', 'r'):
 968                 /* operator | */
 969                 ddata->cur += 2;
 970                 return (cpp_demangle_read_expression_binary(ddata, "|", 1));
 971
 972         case SIMPLE_HASH('o', 'R'):
 973                 /* operator |= */
 974                 ddata->cur += 2;
 975                 return (cpp_demangle_read_expression_binary(ddata, "|=", 2));
 976
 977         case SIMPLE_HASH('p', 'l'):
 978                 /* operator + */
 979                 ddata->cur += 2;
 980                 return (cpp_demangle_read_expression_binary(ddata, "+", 1));
 981
 982         case SIMPLE_HASH('p', 'L'):
 983                 /* operator += */
 984                 ddata->cur += 2;
 985                 return (cpp_demangle_read_expression_binary(ddata, "+=", 2));
 986
 987         case SIMPLE_HASH('p', 'm'):
 988                 /* operator ->* */
 989                 ddata->cur += 2;
 990                 return (cpp_demangle_read_expression_binary(ddata, "->*", 3));
 991
 992         case SIMPLE_HASH('p', 'p'):
 993                 /* operator ++ */
 994                 ddata->cur += 2;
 995                 return (cpp_demangle_read_expression_binary(ddata, "++", 2));
 996
 997         case SIMPLE_HASH('p', 's'):
 998                 /* operator + (unary) */
 999                 ddata->cur += 2;
1000                 return (cpp_demangle_read_expression_unary(ddata, "+", 1));
1001
1002         case SIMPLE_HASH('p', 't'):
1003                 /* operator -> */
1004                 ddata->cur += 2;
1005                 return (cpp_demangle_read_expression_binary(ddata, "->", 2));
1006
1007         case SIMPLE_HASH('q', 'u'):
1008                 /* operator ? */
1009                 ddata->cur += 2;
1010                 return (cpp_demangle_read_expression_trinary(ddata, "?", 1,
1011                     ":", 1));
1012
1013         case SIMPLE_HASH('r', 'm'):
1014                 /* operator % */
1015                 ddata->cur += 2;
1016                 return (cpp_demangle_read_expression_binary(ddata, "%", 1));
1017
1018         case SIMPLE_HASH('r', 'M'):
1019                 /* operator %= */
1020                 ddata->cur += 2;
1021                 return (cpp_demangle_read_expression_binary(ddata, "%=", 2));
1022
1023         case SIMPLE_HASH('r', 's'):
1024                 /* operator >> */
1025                 ddata->cur += 2;
1026                 return (cpp_demangle_read_expression_binary(ddata, ">>", 2));
1027
1028         case SIMPLE_HASH('r', 'S'):
1029                 /* operator >>= */
1030                 ddata->cur += 2;
1031                 return (cpp_demangle_read_expression_binary(ddata, ">>=", 3));
1032
1033         case SIMPLE_HASH('r', 'z'):
1034                 /* operator sizeof */
1035                 ddata->cur += 2;
1036                 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
1037
1038         case SIMPLE_HASH('s', 'v'):
1039                 /* operator sizeof */
1040                 ddata->cur += 2;
1041                 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
1042         }
1043
1044         switch (*ddata->cur) {
1045         case 'L':
1046                 return (cpp_demangle_read_expr_primary(ddata));
1047         case 'T':
1048                 return (cpp_demangle_read_tmpl_param(ddata));
1049         }
1050
1051         return (0);
1052 }
1053
1054 static int
1055 cpp_demangle_read_expression_flat(struct cpp_demangle_data *ddata, char **str)
1056 {
1057         struct vector_str *output;
1058         size_t i, p_idx, idx, exp_len;
1059         char *exp;
1060
1061         output = ddata->push_head > 0 ? &ddata->output_tmp :
1062             &ddata->output;
1063
1064         p_idx = output->size;
1065
1066         if (!cpp_demangle_read_expression(ddata))
1067                 return (0);
1068
1069         if ((exp = vector_str_substr(output, p_idx, output->size - 1,
1070             &exp_len)) == NULL)
1071                 return (0);
1072
1073         idx = output->size;
1074         for (i = p_idx; i < idx; ++i) {
1075                 if (!vector_str_pop(output)) {
1076                         free(exp);
1077                         return (0);
1078                 }
1079         }
1080
1081         *str = exp;
1082
1083         return (1);
1084 }
1085
1086 static int
1087 cpp_demangle_read_expression_binary(struct cpp_demangle_data *ddata,
1088     const char *name, size_t len)
1089 {
1090
1091         if (ddata == NULL || name == NULL || len == 0)
1092                 return (0);
1093         if (!cpp_demangle_read_expression(ddata))
1094                 return (0);
1095         if (!cpp_demangle_push_str(ddata, name, len))
1096                 return (0);
1097
1098         return (cpp_demangle_read_expression(ddata));
1099 }
1100
1101 static int
1102 cpp_demangle_read_expression_unary(struct cpp_demangle_data *ddata,
1103     const char *name, size_t len)
1104 {
1105
1106         if (ddata == NULL || name == NULL || len == 0)
1107                 return (0);
1108         if (!cpp_demangle_read_expression(ddata))
1109                 return (0);
1110
1111         return (cpp_demangle_push_str(ddata, name, len));
1112 }
1113
1114 static int
1115 cpp_demangle_read_expression_trinary(struct cpp_demangle_data *ddata,
1116     const char *name1, size_t len1, const char *name2, size_t len2)
1117 {
1118
1119         if (ddata == NULL || name1 == NULL || len1 == 0 || name2 == NULL ||
1120             len2 == 0)
1121                 return (0);
1122
1123         if (!cpp_demangle_read_expression(ddata))
1124                 return (0);
1125         if (!cpp_demangle_push_str(ddata, name1, len1))
1126                 return (0);
1127         if (!cpp_demangle_read_expression(ddata))
1128                 return (0);
1129         if (!cpp_demangle_push_str(ddata, name2, len2))
1130                 return (0);
1131
1132         return (cpp_demangle_read_expression(ddata));
1133 }
1134
1135 static int
1136 cpp_demangle_read_function(struct cpp_demangle_data *ddata, int *ext_c,
1137     struct vector_type_qualifier *v)
1138 {
1139         size_t class_type_size, class_type_len, limit;
1140         const char *class_type;
1141
1142         if (ddata == NULL || *ddata->cur != 'F' || v == NULL)
1143                 return (0);
1144
1145         ++ddata->cur;
1146         if (*ddata->cur == 'Y') {
1147                 if (ext_c != NULL)
1148                         *ext_c = 1;
1149                 ++ddata->cur;
1150         }
1151         if (!cpp_demangle_read_type(ddata, 0))
1152                 return (0);
1153         if (*ddata->cur != 'E') {
1154                 if (!cpp_demangle_push_str(ddata, "(", 1))
1155                         return (0);
1156                 if (vector_read_cmd_find(&ddata->cmd, READ_PTRMEM)) {
1157                         if ((class_type_size = ddata->class_type.size) == 0)
1158                                 return (0);
1159                         class_type =
1160                             ddata->class_type.container[class_type_size - 1];
1161                         if (class_type == NULL)
1162                                 return (0);
1163                         if ((class_type_len = strlen(class_type)) == 0)
1164                                 return (0);
1165                         if (!cpp_demangle_push_str(ddata, class_type,
1166                             class_type_len))
1167                                 return (0);
1168                         if (!cpp_demangle_push_str(ddata, "::*", 3))
1169                                 return (0);
1170                         ++ddata->func_type;
1171                 } else {
1172                         if (!cpp_demangle_push_type_qualifier(ddata, v,
1173                             (const char *) NULL))
1174                                 return (0);
1175                         vector_type_qualifier_dest(v);
1176                         if (!vector_type_qualifier_init(v))
1177                                 return (0);
1178                 }
1179
1180                 if (!cpp_demangle_push_str(ddata, ")(", 2))
1181                         return (0);
1182
1183                 limit = 0;
1184                 for (;;) {
1185                         if (!cpp_demangle_read_type(ddata, 0))
1186                                 return (0);
1187                         if (*ddata->cur == 'E')
1188                                 break;
1189                         if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1190                                 return (0);
1191                 }
1192
1193                 if (vector_read_cmd_find(&ddata->cmd, READ_PTRMEM) == 1) {
1194                         if (!cpp_demangle_push_type_qualifier(ddata, v,
1195                             (const char *) NULL))
1196                                 return (0);
1197                         vector_type_qualifier_dest(v);
1198                         if (!vector_type_qualifier_init(v))
1199                                 return (0);
1200                 }
1201
1202                 if (!cpp_demangle_push_str(ddata, ")", 1))
1203                         return (0);
1204         }
1205
1206         ++ddata->cur;
1207
1208         return (1);
1209 }
1210
1211 /* read encoding, encoding are function name, data name, special-name */
1212 static int
1213 cpp_demangle_read_encoding(struct cpp_demangle_data *ddata)
1214 {
1215         char *name, *type, *num_str;
1216         long offset;
1217         int rtn;
1218
1219         if (ddata == NULL || *ddata->cur == '\0')
1220                 return (0);
1221
1222         /* special name */
1223         switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1224         case SIMPLE_HASH('G', 'A'):
1225                 if (!cpp_demangle_push_str(ddata, "hidden alias for ", 17))
1226                         return (0);
1227                 ddata->cur += 2;
1228                 if (*ddata->cur == '\0')
1229                         return (0);
1230                 return (cpp_demangle_read_encoding(ddata));
1231
1232         case SIMPLE_HASH('G', 'R'):
1233                 if (!cpp_demangle_push_str(ddata, "reference temporary #", 21))
1234                         return (0);
1235                 ddata->cur += 2;
1236                 if (*ddata->cur == '\0')
1237                         return (0);
1238                 if (!cpp_demangle_read_name_flat(ddata, &name))
1239                         return (0);
1240                 rtn = 0;
1241                 if (!cpp_demangle_read_number_as_string(ddata, &num_str))
1242                         goto clean1;
1243                 if (!cpp_demangle_push_str(ddata, num_str, strlen(num_str)))
1244                         goto clean2;
1245                 if (!cpp_demangle_push_str(ddata, " for ", 5))
1246                         goto clean2;
1247                 if (!cpp_demangle_push_str(ddata, name, strlen(name)))
1248                         goto clean2;
1249                 rtn = 1;
1250         clean2:
1251                 free(num_str);
1252         clean1:
1253                 free(name);
1254                 return (rtn);
1255
1256         case SIMPLE_HASH('G', 'T'):
1257                 ddata->cur += 2;
1258                 if (*ddata->cur == '\0')
1259                         return (0);
1260                 switch (*ddata->cur) {
1261                 case 'n':
1262                         if (!cpp_demangle_push_str(ddata,
1263                             "non-transaction clone for ", 26))
1264                                 return (0);
1265                         break;
1266                 case 't':
1267                 default:
1268                         if (!cpp_demangle_push_str(ddata,
1269                             "transaction clone for ", 22))
1270                                 return (0);
1271                         break;
1272                 }
1273                 ++ddata->cur;
1274                 return (cpp_demangle_read_encoding(ddata));
1275
1276         case SIMPLE_HASH('G', 'V'):
1277                 /* sentry object for 1 time init */
1278                 if (!cpp_demangle_push_str(ddata, "guard variable for ", 20))
1279                         return (0);
1280                 ddata->cur += 2;
1281                 break;
1282
1283         case SIMPLE_HASH('T', 'c'):
1284                 /* virtual function covariant override thunk */
1285                 if (!cpp_demangle_push_str(ddata,
1286                     "virtual function covariant override ", 36))
1287                         return (0);
1288                 ddata->cur += 2;
1289                 if (*ddata->cur == '\0')
1290                         return (0);
1291                 if (!cpp_demangle_read_offset(ddata))
1292                         return (0);
1293                 if (!cpp_demangle_read_offset(ddata))
1294                         return (0);
1295                 return (cpp_demangle_read_encoding(ddata));
1296
1297         case SIMPLE_HASH('T', 'C'):
1298                 /* construction vtable */
1299                 if (!cpp_demangle_push_str(ddata, "construction vtable for ",
1300                     24))
1301                         return (0);
1302                 ddata->cur += 2;
1303                 if (*ddata->cur == '\0')
1304                         return (0);
1305                 if (!cpp_demangle_read_type_flat(ddata, &type))
1306                         return (0);
1307                 rtn = 0;
1308                 if (!cpp_demangle_read_number(ddata, &offset))
1309                         goto clean3;
1310                 if (*ddata->cur++ != '_')
1311                         goto clean3;
1312                 if (!cpp_demangle_read_type(ddata, 0))
1313                         goto clean3;
1314                 if (!cpp_demangle_push_str(ddata, "-in-", 4))
1315                         goto clean3;
1316                 if (!cpp_demangle_push_str(ddata, type, strlen(type)))
1317                         goto clean3;
1318                 rtn = 1;
1319         clean3:
1320                 free(type);
1321                 return (rtn);
1322
1323         case SIMPLE_HASH('T', 'D'):
1324                 /* typeinfo common proxy */
1325                 break;
1326
1327         case SIMPLE_HASH('T', 'F'):
1328                 /* typeinfo fn */
1329                 if (!cpp_demangle_push_str(ddata, "typeinfo fn for ", 16))
1330                         return (0);
1331                 ddata->cur += 2;
1332                 if (*ddata->cur == '\0')
1333                         return (0);
1334                 return (cpp_demangle_read_type(ddata, 0));
1335
1336         case SIMPLE_HASH('T', 'h'):
1337                 /* virtual function non-virtual override thunk */
1338                 if (!cpp_demangle_push_str(ddata,
1339                     "virtual function non-virtual override ", 38))
1340                         return (0);
1341                 ddata->cur += 2;
1342                 if (*ddata->cur == '\0')
1343                         return (0);
1344                 if (!cpp_demangle_read_nv_offset(ddata))
1345                         return (0);
1346                 return (cpp_demangle_read_encoding(ddata));
1347
1348         case SIMPLE_HASH('T', 'H'):
1349                 /* TLS init function */
1350                 if (!cpp_demangle_push_str(ddata, "TLS init function for ",
1351                     22))
1352                         return (0);
1353                 ddata->cur += 2;
1354                 if (*ddata->cur == '\0')
1355                         return (0);
1356                 break;
1357
1358         case SIMPLE_HASH('T', 'I'):
1359                 /* typeinfo structure */
1360                 if (!cpp_demangle_push_str(ddata, "typeinfo for ", 13))
1361                         return (0);
1362                 ddata->cur += 2;
1363                 if (*ddata->cur == '\0')
1364                         return (0);
1365                 return (cpp_demangle_read_type(ddata, 0));
1366
1367         case SIMPLE_HASH('T', 'J'):
1368                 /* java class */
1369                 if (!cpp_demangle_push_str(ddata, "java Class for ", 15))
1370                         return (0);
1371                 ddata->cur += 2;
1372                 if (*ddata->cur == '\0')
1373                         return (0);
1374                 return (cpp_demangle_read_type(ddata, 0));
1375
1376         case SIMPLE_HASH('T', 'S'):
1377                 /* RTTI name (NTBS) */
1378                 if (!cpp_demangle_push_str(ddata, "typeinfo name for ", 18))
1379                         return (0);
1380                 ddata->cur += 2;
1381                 if (*ddata->cur == '\0')
1382                         return (0);
1383                 return (cpp_demangle_read_type(ddata, 0));
1384
1385         case SIMPLE_HASH('T', 'T'):
1386                 /* VTT table */
1387                 if (!cpp_demangle_push_str(ddata, "VTT for ", 8))
1388                         return (0);
1389                 ddata->cur += 2;
1390                 if (*ddata->cur == '\0')
1391                         return (0);
1392                 return (cpp_demangle_read_type(ddata, 0));
1393
1394         case SIMPLE_HASH('T', 'v'):
1395                 /* virtual function virtual override thunk */
1396                 if (!cpp_demangle_push_str(ddata,
1397                     "virtual function virtual override ", 34))
1398                         return (0);
1399                 ddata->cur += 2;
1400                 if (*ddata->cur == '\0')
1401                         return (0);
1402                 if (!cpp_demangle_read_v_offset(ddata))
1403                         return (0);
1404                 return (cpp_demangle_read_encoding(ddata));
1405
1406         case SIMPLE_HASH('T', 'V'):
1407                 /* virtual table */
1408                 if (!cpp_demangle_push_str(ddata, "vtable for ", 12))
1409                         return (0);
1410                 ddata->cur += 2;
1411                 if (*ddata->cur == '\0')
1412                         return (0);
1413                 return (cpp_demangle_read_type(ddata, 0));
1414
1415         case SIMPLE_HASH('T', 'W'):
1416                 /* TLS wrapper function */
1417                 if (!cpp_demangle_push_str(ddata, "TLS wrapper function for ",
1418                     25))
1419                         return (0);
1420                 ddata->cur += 2;
1421                 if (*ddata->cur == '\0')
1422                         return (0);
1423                 break;
1424         }
1425
1426         return (cpp_demangle_read_name(ddata));
1427 }
1428
1429 static int
1430 cpp_demangle_read_local_name(struct cpp_demangle_data *ddata)
1431 {
1432         size_t limit;
1433
1434         if (ddata == NULL)
1435                 return (0);
1436         if (*(++ddata->cur) == '\0')
1437                 return (0);
1438         if (!cpp_demangle_read_encoding(ddata))
1439                 return (0);
1440
1441         limit = 0;
1442         for (;;) {
1443                 if (!cpp_demangle_read_type(ddata, 1))
1444                         return (0);
1445                 if (*ddata->cur == 'E')
1446                         break;
1447                 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1448                         return (0);
1449         }
1450         if (*(++ddata->cur) == '\0')
1451                 return (0);
1452         if (ddata->paren == true) {
1453                 if (!cpp_demangle_push_str(ddata, ")", 1))
1454                         return (0);
1455                 ddata->paren = false;
1456         }
1457         if (*ddata->cur == 's')
1458                 ++ddata->cur;
1459         else {
1460                 if (!cpp_demangle_push_str(ddata, "::", 2))
1461                         return (0);
1462                 if (!cpp_demangle_read_name(ddata))
1463                         return (0);
1464         }
1465         if (*ddata->cur == '_') {
1466                 ++ddata->cur;
1467                 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
1468                         ++ddata->cur;
1469         }
1470
1471         return (1);
1472 }
1473
1474 static int
1475 cpp_demangle_read_name(struct cpp_demangle_data *ddata)
1476 {
1477         struct vector_str *output, v;
1478         size_t p_idx, subst_str_len;
1479         int rtn;
1480         char *subst_str;
1481
1482         if (ddata == NULL || *ddata->cur == '\0')
1483                 return (0);
1484
1485         output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
1486
1487         subst_str = NULL;
1488
1489         switch (*ddata->cur) {
1490         case 'S':
1491                 return (cpp_demangle_read_subst(ddata));
1492         case 'N':
1493                 return (cpp_demangle_read_nested_name(ddata));
1494         case 'Z':
1495                 return (cpp_demangle_read_local_name(ddata));
1496         }
1497
1498         if (!vector_str_init(&v))
1499                 return (0);
1500
1501         p_idx = output->size;
1502         rtn = 0;
1503         if (!cpp_demangle_read_uqname(ddata))
1504                 goto clean;
1505         if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
1506             &subst_str_len)) == NULL)
1507                 goto clean;
1508         if (subst_str_len > 8 && strstr(subst_str, "operator") != NULL) {
1509                 rtn = 1;
1510                 goto clean;
1511         }
1512         if (!vector_str_push(&v, subst_str, subst_str_len))
1513                 goto clean;
1514         if (!cpp_demangle_push_subst_v(ddata, &v))
1515                 goto clean;
1516
1517         if (*ddata->cur == 'I') {
1518                 p_idx = output->size;
1519                 if (!cpp_demangle_read_tmpl_args(ddata))
1520                         goto clean;
1521                 free(subst_str);
1522                 if ((subst_str = vector_str_substr(output, p_idx,
1523                     output->size - 1, &subst_str_len)) == NULL)
1524                         goto clean;
1525                 if (!vector_str_push(&v, subst_str, subst_str_len))
1526                         goto clean;
1527                 if (!cpp_demangle_push_subst_v(ddata, &v))
1528                         goto clean;
1529         }
1530
1531         rtn = 1;
1532
1533 clean:
1534         free(subst_str);
1535         vector_str_dest(&v);
1536
1537         return (rtn);
1538 }
1539
1540 static int
1541 cpp_demangle_read_name_flat(struct cpp_demangle_data *ddata, char **str)
1542 {
1543         struct vector_str *output;
1544         size_t i, p_idx, idx, name_len;
1545         char *name;
1546
1547         output = ddata->push_head > 0 ? &ddata->output_tmp :
1548             &ddata->output;
1549
1550         p_idx = output->size;
1551
1552         if (!cpp_demangle_read_name(ddata))
1553                 return (0);
1554
1555         if ((name = vector_str_substr(output, p_idx, output->size - 1,
1556             &name_len)) == NULL)
1557                 return (0);
1558
1559         idx = output->size;
1560         for (i = p_idx; i < idx; ++i) {
1561                 if (!vector_str_pop(output)) {
1562                         free(name);
1563                         return (0);
1564                 }
1565         }
1566
1567         *str = name;
1568
1569         return (1);
1570 }
1571
1572 static int
1573 cpp_demangle_read_nested_name(struct cpp_demangle_data *ddata)
1574 {
1575         struct vector_str *output, v;
1576         size_t limit, p_idx, subst_str_len;
1577         int rtn;
1578         char *subst_str;
1579
1580         if (ddata == NULL || *ddata->cur != 'N')
1581                 return (0);
1582         if (*(++ddata->cur) == '\0')
1583                 return (0);
1584
1585         while (*ddata->cur == 'r' || *ddata->cur == 'V' ||
1586             *ddata->cur == 'K') {
1587                 switch (*ddata->cur) {
1588                 case 'r':
1589                         ddata->mem_rst = true;
1590                         break;
1591                 case 'V':
1592                         ddata->mem_vat = true;
1593                         break;
1594                 case 'K':
1595                         ddata->mem_cst = true;
1596                         break;
1597                 }
1598                 ++ddata->cur;
1599         }
1600
1601         output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
1602         if (!vector_str_init(&v))
1603                 return (0);
1604
1605         rtn = 0;
1606         limit = 0;
1607         for (;;) {
1608                 p_idx = output->size;
1609                 switch (*ddata->cur) {
1610                 case 'I':
1611                         if (!cpp_demangle_read_tmpl_args(ddata))
1612                                 goto clean;
1613                         break;
1614                 case 'S':
1615                         if (!cpp_demangle_read_subst(ddata))
1616                                 goto clean;
1617                         break;
1618                 case 'T':
1619                         if (!cpp_demangle_read_tmpl_param(ddata))
1620                                 goto clean;
1621                         break;
1622                 default:
1623                         if (!cpp_demangle_read_uqname(ddata))
1624                                 goto clean;
1625                 }
1626
1627                 if ((subst_str = vector_str_substr(output, p_idx,
1628                     output->size - 1, &subst_str_len)) == NULL)
1629                         goto clean;
1630                 if (!vector_str_push(&v, subst_str, subst_str_len)) {
1631                         free(subst_str);
1632                         goto clean;
1633                 }
1634                 free(subst_str);
1635
1636                 if (!cpp_demangle_push_subst_v(ddata, &v))
1637                         goto clean;
1638                 if (*ddata->cur == 'E')
1639                         break;
1640                 else if (*ddata->cur != 'I' &&
1641                     *ddata->cur != 'C' && *ddata->cur != 'D') {
1642                         if (!cpp_demangle_push_str(ddata, "::", 2))
1643                                 goto clean;
1644                         if (!vector_str_push(&v, "::", 2))
1645                                 goto clean;
1646                 }
1647                 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1648                         goto clean;
1649         }
1650
1651         ++ddata->cur;
1652         rtn = 1;
1653
1654 clean:
1655         vector_str_dest(&v);
1656
1657         return (rtn);
1658 }
1659
1660 /*
1661  * read number
1662  * number ::= [n] <decimal>
1663  */
1664 static int
1665 cpp_demangle_read_number(struct cpp_demangle_data *ddata, long *rtn)
1666 {
1667         long len, negative_factor;
1668
1669         if (ddata == NULL || rtn == NULL)
1670                 return (0);
1671
1672         negative_factor = 1;
1673         if (*ddata->cur == 'n') {
1674                 negative_factor = -1;
1675
1676                 ++ddata->cur;
1677         }
1678         if (ELFTC_ISDIGIT(*ddata->cur) == 0)
1679                 return (0);
1680
1681         errno = 0;
1682         if ((len = strtol(ddata->cur, (char **) NULL, 10)) == 0 &&
1683             errno != 0)
1684                 return (0);
1685
1686         while (ELFTC_ISDIGIT(*ddata->cur) != 0)
1687                 ++ddata->cur;
1688
1689         assert(len >= 0);
1690         assert(negative_factor == 1 || negative_factor == -1);
1691
1692         *rtn = len * negative_factor;
1693
1694         return (1);
1695 }
1696
1697 static int
1698 cpp_demangle_read_number_as_string(struct cpp_demangle_data *ddata, char **str)
1699 {
1700         long n;
1701
1702         if (!cpp_demangle_read_number(ddata, &n)) {
1703                 *str = NULL;
1704                 return (0);
1705         }
1706
1707         if (asprintf(str, "%ld", n) < 0) {
1708                 *str = NULL;
1709                 return (0);
1710         }
1711
1712         return (1);
1713 }
1714
1715 static int
1716 cpp_demangle_read_nv_offset(struct cpp_demangle_data *ddata)
1717 {
1718
1719         if (ddata == NULL)
1720                 return (0);
1721
1722         if (!cpp_demangle_push_str(ddata, "offset : ", 9))
1723                 return (0);
1724
1725         return (cpp_demangle_read_offset_number(ddata));
1726 }
1727
1728 /* read offset, offset are nv-offset, v-offset */
1729 static int
1730 cpp_demangle_read_offset(struct cpp_demangle_data *ddata)
1731 {
1732
1733         if (ddata == NULL)
1734                 return (0);
1735
1736         if (*ddata->cur == 'h') {
1737                 ++ddata->cur;
1738                 return (cpp_demangle_read_nv_offset(ddata));
1739         } else if (*ddata->cur == 'v') {
1740                 ++ddata->cur;
1741                 return (cpp_demangle_read_v_offset(ddata));
1742         }
1743
1744         return (0);
1745 }
1746
1747 static int
1748 cpp_demangle_read_offset_number(struct cpp_demangle_data *ddata)
1749 {
1750         bool negative;
1751         const char *start;
1752
1753         if (ddata == NULL || *ddata->cur == '\0')
1754                 return (0);
1755
1756         /* offset could be negative */
1757         if (*ddata->cur == 'n') {
1758                 negative = true;
1759                 start = ddata->cur + 1;
1760         } else {
1761                 negative = false;
1762                 start = ddata->cur;
1763         }
1764
1765         while (*ddata->cur != '_')
1766                 ++ddata->cur;
1767
1768         if (negative && !cpp_demangle_push_str(ddata, "-", 1))
1769                 return (0);
1770
1771         assert(start != NULL);
1772
1773         if (!cpp_demangle_push_str(ddata, start, ddata->cur - start))
1774                 return (0);
1775         if (!cpp_demangle_push_str(ddata, " ", 1))
1776                 return (0);
1777
1778         ++ddata->cur;
1779
1780         return (1);
1781 }
1782
1783 static int
1784 cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *ddata)
1785 {
1786         size_t class_type_len, i, idx, p_idx;
1787         int p_func_type, rtn;
1788         char *class_type;
1789
1790         if (ddata == NULL || *ddata->cur != 'M' || *(++ddata->cur) == '\0')
1791                 return (0);
1792
1793         p_idx = ddata->output.size;
1794         if (!cpp_demangle_read_type(ddata, 0))
1795                 return (0);
1796
1797         if ((class_type = vector_str_substr(&ddata->output, p_idx,
1798             ddata->output.size - 1, &class_type_len)) == NULL)
1799                 return (0);
1800
1801         rtn = 0;
1802         idx = ddata->output.size;
1803         for (i = p_idx; i < idx; ++i)
1804                 if (!vector_str_pop(&ddata->output))
1805                         goto clean1;
1806
1807         if (!vector_read_cmd_push(&ddata->cmd, READ_PTRMEM))
1808                 goto clean1;
1809
1810         if (!vector_str_push(&ddata->class_type, class_type, class_type_len))
1811                 goto clean2;
1812
1813         p_func_type = ddata->func_type;
1814         if (!cpp_demangle_read_type(ddata, 0))
1815                 goto clean3;
1816
1817         if (p_func_type == ddata->func_type) {
1818                 if (!cpp_demangle_push_str(ddata, " ", 1))
1819                         goto clean3;
1820                 if (!cpp_demangle_push_str(ddata, class_type, class_type_len))
1821                         goto clean3;
1822                 if (!cpp_demangle_push_str(ddata, "::*", 3))
1823                         goto clean3;
1824         }
1825
1826         rtn = 1;
1827 clean3:
1828         if (!vector_str_pop(&ddata->class_type))
1829                 rtn = 0;
1830 clean2:
1831         if (!vector_read_cmd_pop(&ddata->cmd))
1832                 rtn = 0;
1833 clean1:
1834         free(class_type);
1835
1836         return (rtn);
1837 }
1838
1839 /* read source-name, source-name is <len> <ID> */
1840 static int
1841 cpp_demangle_read_sname(struct cpp_demangle_data *ddata)
1842 {
1843         long len;
1844         int err;
1845
1846         if (ddata == NULL || cpp_demangle_read_number(ddata, &len) == 0 ||
1847             len <= 0)
1848                 return (0);
1849
1850         if (len == 12 && (memcmp("_GLOBAL__N_1", ddata->cur, 12) == 0))
1851                 err = cpp_demangle_push_str(ddata, "(anonymous namespace)", 21);
1852         else
1853                 err = cpp_demangle_push_str(ddata, ddata->cur, len);
1854
1855         if (err == 0)
1856                 return (0);
1857
1858         assert(ddata->output.size > 0);
1859         if (vector_read_cmd_find(&ddata->cmd, READ_TMPL) == 0)
1860                 ddata->last_sname =
1861                     ddata->output.container[ddata->output.size - 1];
1862
1863         ddata->cur += len;
1864
1865         return (1);
1866 }
1867
1868 static int
1869 cpp_demangle_read_subst(struct cpp_demangle_data *ddata)
1870 {
1871         long nth;
1872
1873         if (ddata == NULL || *ddata->cur == '\0')
1874                 return (0);
1875
1876         /* abbreviations of the form Sx */
1877         switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1878         case SIMPLE_HASH('S', 'a'):
1879                 /* std::allocator */
1880                 if (cpp_demangle_push_str(ddata, "std::allocator", 14) == 0)
1881                         return (0);
1882                 ddata->cur += 2;
1883                 if (*ddata->cur == 'I')
1884                         return (cpp_demangle_read_subst_stdtmpl(ddata,
1885                             "std::allocator", 14));
1886                 return (1);
1887
1888         case SIMPLE_HASH('S', 'b'):
1889                 /* std::basic_string */
1890                 if (!cpp_demangle_push_str(ddata, "std::basic_string", 17))
1891                         return (0);
1892                 ddata->cur += 2;
1893                 if (*ddata->cur == 'I')
1894                         return (cpp_demangle_read_subst_stdtmpl(ddata,
1895                             "std::basic_string", 17));
1896                 return (1);
1897
1898         case SIMPLE_HASH('S', 'd'):
1899                 /* std::basic_iostream<char, std::char_traits<char> > */
1900                 if (!cpp_demangle_push_str(ddata, "std::basic_iostream", 19))
1901                         return (0);
1902                 ddata->last_sname = "basic_iostream";
1903                 ddata->cur += 2;
1904                 if (*ddata->cur == 'I')
1905                         return (cpp_demangle_read_subst_stdtmpl(ddata,
1906                             "std::basic_iostream", 19));
1907                 return (1);
1908
1909         case SIMPLE_HASH('S', 'i'):
1910                 /* std::basic_istream<char, std::char_traits<char> > */
1911                 if (!cpp_demangle_push_str(ddata, "std::basic_istream", 18))
1912                         return (0);
1913                 ddata->last_sname = "basic_istream";
1914                 ddata->cur += 2;
1915                 if (*ddata->cur == 'I')
1916                         return (cpp_demangle_read_subst_stdtmpl(ddata,
1917                             "std::basic_istream", 18));
1918                 return (1);
1919
1920         case SIMPLE_HASH('S', 'o'):
1921                 /* std::basic_ostream<char, std::char_traits<char> > */
1922                 if (!cpp_demangle_push_str(ddata, "std::basic_ostream", 18))
1923                         return (0);
1924                 ddata->last_sname = "basic_ostream";
1925                 ddata->cur += 2;
1926                 if (*ddata->cur == 'I')
1927                         return (cpp_demangle_read_subst_stdtmpl(ddata,
1928                             "std::basic_ostream", 18));
1929                 return (1);
1930
1931         case SIMPLE_HASH('S', 's'):
1932                 /*
1933                  * std::basic_string<char, std::char_traits<char>,
1934                  * std::allocator<char> >
1935                  *
1936                  * a.k.a std::string
1937                  */
1938                 if (!cpp_demangle_push_str(ddata, "std::string", 11))
1939                         return (0);
1940                 ddata->last_sname = "string";
1941                 ddata->cur += 2;
1942                 if (*ddata->cur == 'I')
1943                         return (cpp_demangle_read_subst_stdtmpl(ddata,
1944                             "std::string", 11));
1945                 return (1);
1946
1947         case SIMPLE_HASH('S', 't'):
1948                 /* std:: */
1949                 return (cpp_demangle_read_subst_std(ddata));
1950         }
1951
1952         if (*(++ddata->cur) == '\0')
1953                 return (0);
1954
1955         /* substitution */
1956         if (*ddata->cur == '_')
1957                 return (cpp_demangle_get_subst(ddata, 0));
1958         else {
1959                 errno = 0;
1960                 /* substitution number is base 36 */
1961                 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
1962                     errno != 0)
1963                         return (0);
1964
1965                 /* first was '_', so increase one */
1966                 ++nth;
1967
1968                 while (*ddata->cur != '_')
1969                         ++ddata->cur;
1970
1971                 assert(nth > 0);
1972
1973                 return (cpp_demangle_get_subst(ddata, nth));
1974         }
1975
1976         /* NOTREACHED */
1977         return (0);
1978 }
1979
1980 static int
1981 cpp_demangle_read_subst_std(struct cpp_demangle_data *ddata)
1982 {
1983         struct vector_str *output, v;
1984         size_t p_idx, subst_str_len;
1985         int rtn;
1986         char *subst_str;
1987
1988         if (ddata == NULL)
1989                 return (0);
1990
1991         if (!vector_str_init(&v))
1992                 return (0);
1993
1994         subst_str = NULL;
1995         rtn = 0;
1996         if (!cpp_demangle_push_str(ddata, "std::", 5))
1997                 goto clean;
1998
1999         if (!vector_str_push(&v, "std::", 5))
2000                 goto clean;
2001
2002         ddata->cur += 2;
2003
2004         output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
2005
2006         p_idx = output->size;
2007         if (!cpp_demangle_read_uqname(ddata))
2008                 goto clean;
2009
2010         if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
2011             &subst_str_len)) == NULL)
2012                 goto clean;
2013
2014         if (!vector_str_push(&v, subst_str, subst_str_len))
2015                 goto clean;
2016
2017         if (!cpp_demangle_push_subst_v(ddata, &v))
2018                 goto clean;
2019
2020         if (*ddata->cur == 'I') {
2021                 p_idx = output->size;
2022                 if (!cpp_demangle_read_tmpl_args(ddata))
2023                         goto clean;
2024                 free(subst_str);
2025                 if ((subst_str = vector_str_substr(output, p_idx,
2026                     output->size - 1, &subst_str_len)) == NULL)
2027                         goto clean;
2028                 if (!vector_str_push(&v, subst_str, subst_str_len))
2029                         goto clean;
2030                 if (!cpp_demangle_push_subst_v(ddata, &v))
2031                         goto clean;
2032         }
2033
2034         rtn = 1;
2035 clean:
2036         free(subst_str);
2037         vector_str_dest(&v);
2038
2039         return (rtn);
2040 }
2041
2042 static int
2043 cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *ddata,
2044     const char *str, size_t len)
2045 {
2046         struct vector_str *output;
2047         size_t p_idx, substr_len;
2048         int rtn;
2049         char *subst_str, *substr;
2050
2051         if (ddata == NULL || str == NULL || len == 0)
2052                 return (0);
2053
2054         output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
2055
2056         p_idx = output->size;
2057         substr = NULL;
2058         subst_str = NULL;
2059
2060         if (!cpp_demangle_read_tmpl_args(ddata))
2061                 return (0);
2062         if ((substr = vector_str_substr(output, p_idx, output->size - 1,
2063             &substr_len)) == NULL)
2064                 return (0);
2065
2066         rtn = 0;
2067         if ((subst_str = malloc(sizeof(char) * (substr_len + len + 1))) ==
2068             NULL)
2069                 goto clean;
2070
2071         memcpy(subst_str, str, len);
2072         memcpy(subst_str + len, substr, substr_len);
2073         subst_str[substr_len + len] = '\0';
2074
2075         if (!cpp_demangle_push_subst(ddata, subst_str, substr_len + len))
2076                 goto clean;
2077
2078         rtn = 1;
2079 clean:
2080         free(subst_str);
2081         free(substr);
2082
2083         return (rtn);
2084 }
2085
2086 static int
2087 cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *ddata)
2088 {
2089
2090         if (ddata == NULL || *ddata->cur == '\0')
2091                 return (0);
2092
2093         switch (*ddata->cur) {
2094         case 'L':
2095                 return (cpp_demangle_read_expr_primary(ddata));
2096         case 'X':
2097                 return (cpp_demangle_read_expression(ddata));
2098         }
2099
2100         return (cpp_demangle_read_type(ddata, 0));
2101 }
2102
2103 static int
2104 cpp_demangle_read_tmpl_args(struct cpp_demangle_data *ddata)
2105 {
2106         struct vector_str *v;
2107         size_t arg_len, idx, limit, size;
2108         char *arg;
2109
2110         if (ddata == NULL || *ddata->cur == '\0')
2111                 return (0);
2112
2113         ++ddata->cur;
2114
2115         if (!vector_read_cmd_push(&ddata->cmd, READ_TMPL))
2116                 return (0);
2117
2118         if (!cpp_demangle_push_str(ddata, "<", 1))
2119                 return (0);
2120
2121         limit = 0;
2122         v = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
2123         for (;;) {
2124                 idx = v->size;
2125                 if (!cpp_demangle_read_tmpl_arg(ddata))
2126                         return (0);
2127                 if ((arg = vector_str_substr(v, idx, v->size - 1, &arg_len)) ==
2128                     NULL)
2129                         return (0);
2130                 if (!vector_str_find(&ddata->tmpl, arg, arg_len) &&
2131                     !vector_str_push(&ddata->tmpl, arg, arg_len)) {
2132                         free(arg);
2133                         return (0);
2134                 }
2135
2136                 free(arg);
2137
2138                 if (*ddata->cur == 'E') {
2139                         ++ddata->cur;
2140                         size = v->size;
2141                         assert(size > 0);
2142                         if (!strncmp(v->container[size - 1], ">", 1)) {
2143                                 if (!cpp_demangle_push_str(ddata, " >", 2))
2144                                         return (0);
2145                         } else if (!cpp_demangle_push_str(ddata, ">", 1))
2146                                 return (0);
2147                         break;
2148                 } else if (*ddata->cur != 'I' &&
2149                     !cpp_demangle_push_str(ddata, ", ", 2))
2150                         return (0);
2151
2152                 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
2153                         return (0);
2154         }
2155
2156         return (vector_read_cmd_pop(&ddata->cmd));
2157 }
2158
2159 /*
2160  * Read template parameter that forms in 'T[number]_'.
2161  * This function much like to read_subst but only for types.
2162  */
2163 static int
2164 cpp_demangle_read_tmpl_param(struct cpp_demangle_data *ddata)
2165 {
2166         long nth;
2167
2168         if (ddata == NULL || *ddata->cur != 'T')
2169                 return (0);
2170
2171         ++ddata->cur;
2172
2173         if (*ddata->cur == '_')
2174                 return (cpp_demangle_get_tmpl_param(ddata, 0));
2175         else {
2176
2177                 errno = 0;
2178                 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
2179                     errno != 0)
2180                         return (0);
2181
2182                 /* T_ is first */
2183                 ++nth;
2184
2185                 while (*ddata->cur != '_')
2186                         ++ddata->cur;
2187
2188                 assert(nth > 0);
2189
2190                 return (cpp_demangle_get_tmpl_param(ddata, nth));
2191         }
2192
2193         /* NOTREACHED */
2194         return (0);
2195 }
2196
2197 static int
2198 cpp_demangle_read_type(struct cpp_demangle_data *ddata, int delimit)
2199 {
2200         struct vector_type_qualifier v;
2201         struct vector_str *output;
2202         size_t p_idx, type_str_len;
2203         int extern_c, is_builtin;
2204         long len;
2205         char *type_str, *exp_str, *num_str;
2206
2207         if (ddata == NULL)
2208                 return (0);
2209
2210         output = &ddata->output;
2211         if (!strncmp(ddata->output.container[ddata->output.size - 1], ">", 1)) {
2212                 ddata->push_head++;
2213                 output = &ddata->output_tmp;
2214         } else if (delimit == 1) {
2215                 if (ddata->paren == false) {
2216                         if (!cpp_demangle_push_str(ddata, "(", 1))
2217                                 return (0);
2218                         if (ddata->output.size < 2)
2219                                 return (0);
2220                         ddata->paren = true;
2221                         ddata->pfirst = true;
2222                         /* Need pop function name */
2223                         if (ddata->subst.size == 1 &&
2224                             !vector_str_pop(&ddata->subst))
2225                                 return (0);
2226                 }
2227
2228                 if (ddata->pfirst)
2229                         ddata->pfirst = false;
2230                 else if (*ddata->cur != 'I' &&
2231                     !cpp_demangle_push_str(ddata, ", ", 2))
2232                         return (0);
2233         }
2234
2235         assert(output != NULL);
2236         /*
2237          * [r, V, K] [P, R, C, G, U] builtin, function, class-enum, array
2238          * pointer-to-member, template-param, template-template-param, subst
2239          */
2240
2241         if (!vector_type_qualifier_init(&v))
2242                 return (0);
2243
2244         extern_c = 0;
2245         is_builtin = 1;
2246         p_idx = output->size;
2247         type_str = exp_str = num_str = NULL;
2248 again:
2249         /* builtin type */
2250         switch (*ddata->cur) {
2251         case 'a':
2252                 /* signed char */
2253                 if (!cpp_demangle_push_str(ddata, "signed char", 11))
2254                         goto clean;
2255                 ++ddata->cur;
2256                 goto rtn;
2257
2258         case 'A':
2259                 /* array type */
2260                 if (!cpp_demangle_read_array(ddata))
2261                         goto clean;
2262                 is_builtin = 0;
2263                 goto rtn;
2264
2265         case 'b':
2266                 /* bool */
2267                 if (!cpp_demangle_push_str(ddata, "bool", 4))
2268                         goto clean;
2269                 ++ddata->cur;
2270                 goto rtn;
2271
2272         case 'C':
2273                 /* complex pair */
2274                 if (!vector_type_qualifier_push(&v, TYPE_CMX))
2275                         goto clean;
2276                 ++ddata->cur;
2277                 goto again;
2278
2279         case 'c':
2280                 /* char */
2281                 if (!cpp_demangle_push_str(ddata, "char", 4))
2282                         goto clean;
2283                 ++ddata->cur;
2284                 goto rtn;
2285
2286         case 'd':
2287                 /* double */
2288                 if (!cpp_demangle_push_str(ddata, "double", 6))
2289                         goto clean;
2290                 ++ddata->cur;
2291                 goto rtn;
2292
2293         case 'D':
2294                 ++ddata->cur;
2295                 switch (*ddata->cur) {
2296                 case 'd':
2297                         /* IEEE 754r decimal floating point (64 bits) */
2298                         if (!cpp_demangle_push_str(ddata, "decimal64", 9))
2299                                 goto clean;
2300                         ++ddata->cur;
2301                         break;
2302                 case 'e':
2303                         /* IEEE 754r decimal floating point (128 bits) */
2304                         if (!cpp_demangle_push_str(ddata, "decimal128", 10))
2305                                 goto clean;
2306                         ++ddata->cur;
2307                         break;
2308                 case 'f':
2309                         /* IEEE 754r decimal floating point (32 bits) */
2310                         if (!cpp_demangle_push_str(ddata, "decimal32", 9))
2311                                 goto clean;
2312                         ++ddata->cur;
2313                         break;
2314                 case 'h':
2315                         /* IEEE 754r half-precision floating point (16 bits) */
2316                         if (!cpp_demangle_push_str(ddata, "half", 4))
2317                                 goto clean;
2318                         ++ddata->cur;
2319                         break;
2320                 case 'i':
2321                         /* char32_t */
2322                         if (!cpp_demangle_push_str(ddata, "char32_t", 8))
2323                                 goto clean;
2324                         ++ddata->cur;
2325                         break;
2326                 case 'n':
2327                         /* std::nullptr_t (i.e., decltype(nullptr)) */
2328                         if (!cpp_demangle_push_str(ddata, "decltype(nullptr)",
2329                             17))
2330                                 goto clean;
2331                         ++ddata->cur;
2332                         break;
2333                 case 's':
2334                         /* char16_t */
2335                         if (!cpp_demangle_push_str(ddata, "char16_t", 8))
2336                                 goto clean;
2337                         ++ddata->cur;
2338                         break;
2339                 case 'v':
2340                         /* gcc vector_size extension. */
2341                         ++ddata->cur;
2342                         if (*ddata->cur == '_') {
2343                                 ++ddata->cur;
2344                                 if (!cpp_demangle_read_expression_flat(ddata,
2345                                     &exp_str))
2346                                         goto clean;
2347                                 if (!vector_str_push(&v.ext_name, exp_str,
2348                                     strlen(exp_str)))
2349                                         goto clean;
2350                         } else {
2351                                 if (!cpp_demangle_read_number_as_string(ddata,
2352                                     &num_str))
2353                                         goto clean;
2354                                 if (!vector_str_push(&v.ext_name, num_str,
2355                                     strlen(num_str)))
2356                                         goto clean;
2357                         }
2358                         if (*ddata->cur != '_')
2359                                 goto clean;
2360                         ++ddata->cur;
2361                         if (!vector_type_qualifier_push(&v, TYPE_VEC))
2362                                 goto clean;
2363                         goto again;
2364                 default:
2365                         goto clean;
2366                 }
2367                 goto rtn;
2368
2369         case 'e':
2370                 /* long double */
2371                 if (!cpp_demangle_push_str(ddata, "long double", 11))
2372                         goto clean;
2373                 ++ddata->cur;
2374                 goto rtn;
2375
2376         case 'f':
2377                 /* float */
2378                 if (!cpp_demangle_push_str(ddata, "float", 5))
2379                         goto clean;
2380                 ++ddata->cur;
2381                 goto rtn;
2382
2383         case 'F':
2384                 /* function */
2385                 if (!cpp_demangle_read_function(ddata, &extern_c, &v))
2386                         goto clean;
2387                 is_builtin = 0;
2388                 goto rtn;
2389
2390         case 'g':
2391                 /* __float128 */
2392                 if (!cpp_demangle_push_str(ddata, "__float128", 10))
2393                         goto clean;
2394                 ++ddata->cur;
2395                 goto rtn;
2396
2397         case 'G':
2398                 /* imaginary */
2399                 if (!vector_type_qualifier_push(&v, TYPE_IMG))
2400                         goto clean;
2401                 ++ddata->cur;
2402                 goto again;
2403
2404         case 'h':
2405                 /* unsigned char */
2406                 if (!cpp_demangle_push_str(ddata, "unsigned char", 13))
2407                         goto clean;
2408                 ++ddata->cur;
2409                 goto rtn;
2410
2411         case 'i':
2412                 /* int */
2413                 if (!cpp_demangle_push_str(ddata, "int", 3))
2414                         goto clean;
2415                 ++ddata->cur;
2416                 goto rtn;
2417
2418         case 'j':
2419                 /* unsigned int */
2420                 if (!cpp_demangle_push_str(ddata, "unsigned int", 12))
2421                         goto clean;
2422                 ++ddata->cur;
2423                 goto rtn;
2424
2425         case 'K':
2426                 /* const */
2427                 if (!vector_type_qualifier_push(&v, TYPE_CST))
2428                         goto clean;
2429                 ++ddata->cur;
2430                 goto again;
2431
2432         case 'l':
2433                 /* long */
2434                 if (!cpp_demangle_push_str(ddata, "long", 4))
2435                         goto clean;
2436                 ++ddata->cur;
2437                 goto rtn;
2438
2439         case 'm':
2440                 /* unsigned long */
2441                 if (!cpp_demangle_push_str(ddata, "unsigned long", 13))
2442                         goto clean;
2443
2444                 ++ddata->cur;
2445
2446                 goto rtn;
2447         case 'M':
2448                 /* pointer to member */
2449                 if (!cpp_demangle_read_pointer_to_member(ddata))
2450                         goto clean;
2451                 is_builtin = 0;
2452                 goto rtn;
2453
2454         case 'n':
2455                 /* __int128 */
2456                 if (!cpp_demangle_push_str(ddata, "__int128", 8))
2457                         goto clean;
2458                 ++ddata->cur;
2459                 goto rtn;
2460
2461         case 'o':
2462                 /* unsigned __int128 */
2463                 if (!cpp_demangle_push_str(ddata, "unsigned __int128", 17))
2464                         goto clean;
2465                 ++ddata->cur;
2466                 goto rtn;
2467
2468         case 'P':
2469                 /* pointer */
2470                 if (!vector_type_qualifier_push(&v, TYPE_PTR))
2471                         goto clean;
2472                 ++ddata->cur;
2473                 goto again;
2474
2475         case 'r':
2476                 /* restrict */
2477                 if (!vector_type_qualifier_push(&v, TYPE_RST))
2478                         goto clean;
2479                 ++ddata->cur;
2480                 goto again;
2481
2482         case 'R':
2483                 /* reference */
2484                 if (!vector_type_qualifier_push(&v, TYPE_REF))
2485                         goto clean;
2486                 ++ddata->cur;
2487                 goto again;
2488
2489         case 's':
2490                 /* short, local string */
2491                 if (!cpp_demangle_push_str(ddata, "short", 5))
2492                         goto clean;
2493                 ++ddata->cur;
2494                 goto rtn;
2495
2496         case 'S':
2497                 /* substitution */
2498                 if (!cpp_demangle_read_subst(ddata))
2499                         goto clean;
2500                 is_builtin = 0;
2501                 goto rtn;
2502
2503         case 't':
2504                 /* unsigned short */
2505                 if (!cpp_demangle_push_str(ddata, "unsigned short", 14))
2506                         goto clean;
2507                 ++ddata->cur;
2508                 goto rtn;
2509
2510         case 'T':
2511                 /* template parameter */
2512                 if (!cpp_demangle_read_tmpl_param(ddata))
2513                         goto clean;
2514                 is_builtin = 0;
2515                 goto rtn;
2516
2517         case 'u':
2518                 /* vendor extended builtin */
2519                 ++ddata->cur;
2520                 if (!cpp_demangle_read_sname(ddata))
2521                         goto clean;
2522                 is_builtin = 0;
2523                 goto rtn;
2524
2525         case 'U':
2526                 /* vendor extended type qualifier */
2527                 if (!cpp_demangle_read_number(ddata, &len))
2528                         goto clean;
2529                 if (len <= 0)
2530                         goto clean;
2531                 if (!vector_str_push(&v.ext_name, ddata->cur, len))
2532                         return (0);
2533                 ddata->cur += len;
2534                 if (!vector_type_qualifier_push(&v, TYPE_EXT))
2535                         goto clean;
2536                 goto again;
2537
2538         case 'v':
2539                 /* void */
2540                 if (!cpp_demangle_push_str(ddata, "void", 4))
2541                         goto clean;
2542                 ++ddata->cur;
2543                 goto rtn;
2544
2545         case 'V':
2546                 /* volatile */
2547                 if (!vector_type_qualifier_push(&v, TYPE_VAT))
2548                         goto clean;
2549                 ++ddata->cur;
2550                 goto again;
2551
2552         case 'w':
2553                 /* wchar_t */
2554                 if (!cpp_demangle_push_str(ddata, "wchar_t", 7))
2555                         goto clean;
2556                 ++ddata->cur;
2557                 goto rtn;
2558
2559         case 'x':
2560                 /* long long */
2561                 if (!cpp_demangle_push_str(ddata, "long long", 9))
2562                         goto clean;
2563                 ++ddata->cur;
2564                 goto rtn;
2565
2566         case 'y':
2567                 /* unsigned long long */
2568                 if (!cpp_demangle_push_str(ddata, "unsigned long long", 18))
2569                         goto clean;
2570                 ++ddata->cur;
2571                 goto rtn;
2572
2573         case 'z':
2574                 /* ellipsis */
2575                 if (!cpp_demangle_push_str(ddata, "ellipsis", 8))
2576                         goto clean;
2577                 ++ddata->cur;
2578                 goto rtn;
2579         }
2580
2581         if (!cpp_demangle_read_name(ddata))
2582                 goto clean;
2583
2584         is_builtin = 0;
2585 rtn:
2586         if ((type_str = vector_str_substr(output, p_idx, output->size - 1,
2587             &type_str_len)) == NULL)
2588                 goto clean;
2589
2590         if (is_builtin == 0) {
2591                 if (!vector_str_find(&ddata->subst, type_str, type_str_len) &&
2592                     !vector_str_push(&ddata->subst, type_str, type_str_len))
2593                         goto clean;
2594         }
2595
2596         if (!cpp_demangle_push_type_qualifier(ddata, &v, type_str))
2597                 goto clean;
2598
2599         free(type_str);
2600         free(exp_str);
2601         free(num_str);
2602         vector_type_qualifier_dest(&v);
2603
2604         if (ddata->push_head > 0) {
2605                 if (*ddata->cur == 'I' && cpp_demangle_read_tmpl_args(ddata)
2606                     == 0)
2607                         return (0);
2608
2609                 if (--ddata->push_head > 0)
2610                         return (1);
2611
2612                 if (!vector_str_push(&ddata->output_tmp, " ", 1))
2613                         return (0);
2614
2615                 if (!vector_str_push_vector_head(&ddata->output,
2616                     &ddata->output_tmp))
2617                         return (0);
2618
2619                 vector_str_dest(&ddata->output_tmp);
2620                 if (!vector_str_init(&ddata->output_tmp))
2621                         return (0);
2622
2623                 if (!cpp_demangle_push_str(ddata, "(", 1))
2624                         return (0);
2625
2626                 ddata->paren = true;
2627                 ddata->pfirst = true;
2628         }
2629
2630         return (1);
2631 clean:
2632         free(type_str);
2633         free(exp_str);
2634         free(num_str);
2635         vector_type_qualifier_dest(&v);
2636
2637         return (0);
2638 }
2639
2640 static int
2641 cpp_demangle_read_type_flat(struct cpp_demangle_data *ddata, char **str)
2642 {
2643         struct vector_str *output;
2644         size_t i, p_idx, idx, type_len;
2645         char *type;
2646
2647         output = ddata->push_head > 0 ? &ddata->output_tmp :
2648             &ddata->output;
2649
2650         p_idx = output->size;
2651
2652         if (!cpp_demangle_read_type(ddata, 0))
2653                 return (0);
2654
2655         if ((type = vector_str_substr(output, p_idx, output->size - 1,
2656             &type_len)) == NULL)
2657                 return (0);
2658
2659         idx = output->size;
2660         for (i = p_idx; i < idx; ++i) {
2661                 if (!vector_str_pop(output)) {
2662                         free(type);
2663                         return (0);
2664                 }
2665         }
2666
2667         *str = type;
2668
2669         return (1);
2670 }
2671
2672 /*
2673  * read unqualified-name, unqualified name are operator-name, ctor-dtor-name,
2674  * source-name
2675  */
2676 static int
2677 cpp_demangle_read_uqname(struct cpp_demangle_data *ddata)
2678 {
2679         size_t len;
2680
2681         if (ddata == NULL || *ddata->cur == '\0')
2682                 return (0);
2683
2684         /* operator name */
2685         switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
2686         case SIMPLE_HASH('a', 'a'):
2687                 /* operator && */
2688                 if (!cpp_demangle_push_str(ddata, "operator&&", 10))
2689                         return (0);
2690                 ddata->cur += 2;
2691                 return (1);
2692
2693         case SIMPLE_HASH('a', 'd'):
2694                 /* operator & (unary) */
2695                 if (!cpp_demangle_push_str(ddata, "operator&", 9))
2696                         return (0);
2697                 ddata->cur += 2;
2698                 return (1);
2699
2700         case SIMPLE_HASH('a', 'n'):
2701                 /* operator & */
2702                 if (!cpp_demangle_push_str(ddata, "operator&", 9))
2703                         return (0);
2704                 ddata->cur += 2;
2705                 return (1);
2706
2707         case SIMPLE_HASH('a', 'N'):
2708                 /* operator &= */
2709                 if (!cpp_demangle_push_str(ddata, "operator&=", 10))
2710                         return (0);
2711                 ddata->cur += 2;
2712                 return (1);
2713
2714         case SIMPLE_HASH('a', 'S'):
2715                 /* operator = */
2716                 if (!cpp_demangle_push_str(ddata, "operator=", 9))
2717                         return (0);
2718                 ddata->cur += 2;
2719                 return (1);
2720
2721         case SIMPLE_HASH('c', 'l'):
2722                 /* operator () */
2723                 if (!cpp_demangle_push_str(ddata, "operator()", 10))
2724                         return (0);
2725                 ddata->cur += 2;
2726                 return (1);
2727
2728         case SIMPLE_HASH('c', 'm'):
2729                 /* operator , */
2730                 if (!cpp_demangle_push_str(ddata, "operator,", 9))
2731                         return (0);
2732                 ddata->cur += 2;
2733                 return (1);
2734
2735         case SIMPLE_HASH('c', 'o'):
2736                 /* operator ~ */
2737                 if (!cpp_demangle_push_str(ddata, "operator~", 9))
2738                         return (0);
2739                 ddata->cur += 2;
2740                 return (1);
2741
2742         case SIMPLE_HASH('c', 'v'):
2743                 /* operator (cast) */
2744                 if (!cpp_demangle_push_str(ddata, "operator(cast)", 14))
2745                         return (0);
2746                 ddata->cur += 2;
2747                 return (cpp_demangle_read_type(ddata, 1));
2748
2749         case SIMPLE_HASH('d', 'a'):
2750                 /* operator delete [] */
2751                 if (!cpp_demangle_push_str(ddata, "operator delete []", 18))
2752                         return (0);
2753                 ddata->cur += 2;
2754                 return (1);
2755
2756         case SIMPLE_HASH('d', 'e'):
2757                 /* operator * (unary) */
2758                 if (!cpp_demangle_push_str(ddata, "operator*", 9))
2759                         return (0);
2760                 ddata->cur += 2;
2761                 return (1);
2762
2763         case SIMPLE_HASH('d', 'l'):
2764                 /* operator delete */
2765                 if (!cpp_demangle_push_str(ddata, "operator delete", 15))
2766                         return (0);
2767                 ddata->cur += 2;
2768                 return (1);
2769
2770         case SIMPLE_HASH('d', 'v'):
2771                 /* operator / */
2772                 if (!cpp_demangle_push_str(ddata, "operator/", 9))
2773                         return (0);
2774                 ddata->cur += 2;
2775                 return (1);
2776
2777         case SIMPLE_HASH('d', 'V'):
2778                 /* operator /= */
2779                 if (!cpp_demangle_push_str(ddata, "operator/=", 10))
2780                         return (0);
2781                 ddata->cur += 2;
2782                 return (1);
2783
2784         case SIMPLE_HASH('e', 'o'):
2785                 /* operator ^ */
2786                 if (!cpp_demangle_push_str(ddata, "operator^", 9))
2787                         return (0);
2788                 ddata->cur += 2;
2789                 return (1);
2790
2791         case SIMPLE_HASH('e', 'O'):
2792                 /* operator ^= */
2793                 if (!cpp_demangle_push_str(ddata, "operator^=", 10))
2794                         return (0);
2795                 ddata->cur += 2;
2796                 return (1);
2797
2798         case SIMPLE_HASH('e', 'q'):
2799                 /* operator == */
2800                 if (!cpp_demangle_push_str(ddata, "operator==", 10))
2801                         return (0);
2802                 ddata->cur += 2;
2803                 return (1);
2804
2805         case SIMPLE_HASH('g', 'e'):
2806                 /* operator >= */
2807                 if (!cpp_demangle_push_str(ddata, "operator>=", 10))
2808                         return (0);
2809                 ddata->cur += 2;
2810                 return (1);
2811
2812         case SIMPLE_HASH('g', 't'):
2813                 /* operator > */
2814                 if (!cpp_demangle_push_str(ddata, "operator>", 9))
2815                         return (0);
2816                 ddata->cur += 2;
2817                 return (1);
2818
2819         case SIMPLE_HASH('i', 'x'):
2820                 /* operator [] */
2821                 if (!cpp_demangle_push_str(ddata, "operator[]", 10))
2822                         return (0);
2823                 ddata->cur += 2;
2824                 return (1);
2825
2826         case SIMPLE_HASH('l', 'e'):
2827                 /* operator <= */
2828                 if (!cpp_demangle_push_str(ddata, "operator<=", 10))
2829                         return (0);
2830                 ddata->cur += 2;
2831                 return (1);
2832
2833         case SIMPLE_HASH('l', 's'):
2834                 /* operator << */
2835                 if (!cpp_demangle_push_str(ddata, "operator<<", 10))
2836                         return (0);
2837                 ddata->cur += 2;
2838                 return (1);
2839
2840         case SIMPLE_HASH('l', 'S'):
2841                 /* operator <<= */
2842                 if (!cpp_demangle_push_str(ddata, "operator<<=", 11))
2843                         return (0);
2844                 ddata->cur += 2;
2845                 return (1);
2846
2847         case SIMPLE_HASH('l', 't'):
2848                 /* operator < */
2849                 if (!cpp_demangle_push_str(ddata, "operator<", 9))
2850                         return (0);
2851                 ddata->cur += 2;
2852                 return (1);
2853
2854         case SIMPLE_HASH('m', 'i'):
2855                 /* operator - */
2856                 if (!cpp_demangle_push_str(ddata, "operator-", 9))
2857                         return (0);
2858                 ddata->cur += 2;
2859                 return (1);
2860
2861         case SIMPLE_HASH('m', 'I'):
2862                 /* operator -= */
2863                 if (!cpp_demangle_push_str(ddata, "operator-=", 10))
2864                         return (0);
2865                 ddata->cur += 2;
2866                 return (1);
2867
2868         case SIMPLE_HASH('m', 'l'):
2869                 /* operator * */
2870                 if (!cpp_demangle_push_str(ddata, "operator*", 9))
2871                         return (0);
2872                 ddata->cur += 2;
2873                 return (1);
2874
2875         case SIMPLE_HASH('m', 'L'):
2876                 /* operator *= */
2877                 if (!cpp_demangle_push_str(ddata, "operator*=", 10))
2878                         return (0);
2879                 ddata->cur += 2;
2880                 return (1);
2881
2882         case SIMPLE_HASH('m', 'm'):
2883                 /* operator -- */
2884                 if (!cpp_demangle_push_str(ddata, "operator--", 10))
2885                         return (0);
2886                 ddata->cur += 2;
2887                 return (1);
2888
2889         case SIMPLE_HASH('n', 'a'):
2890                 /* operator new[] */
2891                 if (!cpp_demangle_push_str(ddata, "operator new []", 15))
2892                         return (0);
2893                 ddata->cur += 2;
2894                 return (1);
2895
2896         case SIMPLE_HASH('n', 'e'):
2897                 /* operator != */
2898                 if (!cpp_demangle_push_str(ddata, "operator!=", 10))
2899                         return (0);
2900                 ddata->cur += 2;
2901                 return (1);
2902
2903         case SIMPLE_HASH('n', 'g'):
2904                 /* operator - (unary) */
2905                 if (!cpp_demangle_push_str(ddata, "operator-", 9))
2906                         return (0);
2907                 ddata->cur += 2;
2908                 return (1);
2909
2910         case SIMPLE_HASH('n', 't'):
2911                 /* operator ! */
2912                 if (!cpp_demangle_push_str(ddata, "operator!", 9))
2913                         return (0);
2914                 ddata->cur += 2;
2915                 return (1);
2916
2917         case SIMPLE_HASH('n', 'w'):
2918                 /* operator new */
2919                 if (!cpp_demangle_push_str(ddata, "operator new", 12))
2920                         return (0);
2921                 ddata->cur += 2;
2922                 return (1);
2923
2924         case SIMPLE_HASH('o', 'o'):
2925                 /* operator || */
2926                 if (!cpp_demangle_push_str(ddata, "operator||", 10))
2927                         return (0);
2928                 ddata->cur += 2;
2929                 return (1);
2930
2931         case SIMPLE_HASH('o', 'r'):
2932                 /* operator | */
2933                 if (!cpp_demangle_push_str(ddata, "operator|", 9))
2934                         return (0);
2935                 ddata->cur += 2;
2936                 return (1);
2937
2938         case SIMPLE_HASH('o', 'R'):
2939                 /* operator |= */
2940                 if (!cpp_demangle_push_str(ddata, "operator|=", 10))
2941                         return (0);
2942                 ddata->cur += 2;
2943                 return (1);
2944
2945         case SIMPLE_HASH('p', 'l'):
2946                 /* operator + */
2947                 if (!cpp_demangle_push_str(ddata, "operator+", 9))
2948                         return (0);
2949                 ddata->cur += 2;
2950                 return (1);
2951
2952         case SIMPLE_HASH('p', 'L'):
2953                 /* operator += */
2954                 if (!cpp_demangle_push_str(ddata, "operator+=", 10))
2955                         return (0);
2956                 ddata->cur += 2;
2957                 return (1);
2958
2959         case SIMPLE_HASH('p', 'm'):
2960                 /* operator ->* */
2961                 if (!cpp_demangle_push_str(ddata, "operator->*", 11))
2962                         return (0);
2963                 ddata->cur += 2;
2964                 return (1);
2965
2966         case SIMPLE_HASH('p', 'p'):
2967                 /* operator ++ */
2968                 if (!cpp_demangle_push_str(ddata, "operator++", 10))
2969                         return (0);
2970                 ddata->cur += 2;
2971                 return (1);
2972
2973         case SIMPLE_HASH('p', 's'):
2974                 /* operator + (unary) */
2975                 if (!cpp_demangle_push_str(ddata, "operator+", 9))
2976                         return (0);
2977                 ddata->cur += 2;
2978                 return (1);
2979
2980         case SIMPLE_HASH('p', 't'):
2981                 /* operator -> */
2982                 if (!cpp_demangle_push_str(ddata, "operator->", 10))
2983                         return (0);
2984                 ddata->cur += 2;
2985                 return (1);
2986
2987         case SIMPLE_HASH('q', 'u'):
2988                 /* operator ? */
2989                 if (!cpp_demangle_push_str(ddata, "operator?", 9))
2990                         return (0);
2991                 ddata->cur += 2;
2992                 return (1);
2993
2994         case SIMPLE_HASH('r', 'm'):
2995                 /* operator % */
2996                 if (!cpp_demangle_push_str(ddata, "operator%", 9))
2997                         return (0);
2998                 ddata->cur += 2;
2999                 return (1);
3000
3001         case SIMPLE_HASH('r', 'M'):
3002                 /* operator %= */
3003                 if (!cpp_demangle_push_str(ddata, "operator%=", 10))
3004                         return (0);
3005                 ddata->cur += 2;
3006                 return (1);
3007
3008         case SIMPLE_HASH('r', 's'):
3009                 /* operator >> */
3010                 if (!cpp_demangle_push_str(ddata, "operator>>", 10))
3011                         return (0);
3012                 ddata->cur += 2;
3013                 return (1);
3014
3015         case SIMPLE_HASH('r', 'S'):
3016                 /* operator >>= */
3017                 if (!cpp_demangle_push_str(ddata, "operator>>=", 11))
3018                         return (0);
3019                 ddata->cur += 2;
3020                 return (1);
3021
3022         case SIMPLE_HASH('r', 'z'):
3023                 /* operator sizeof */
3024                 if (!cpp_demangle_push_str(ddata, "operator sizeof ", 16))
3025                         return (0);
3026                 ddata->cur += 2;
3027                 return (1);
3028
3029         case SIMPLE_HASH('s', 'r'):
3030                 /* scope resolution operator */
3031                 if (!cpp_demangle_push_str(ddata, "scope resolution operator ",
3032                     26))
3033                         return (0);
3034                 ddata->cur += 2;
3035                 return (1);
3036
3037         case SIMPLE_HASH('s', 'v'):
3038                 /* operator sizeof */
3039                 if (!cpp_demangle_push_str(ddata, "operator sizeof ", 16))
3040                         return (0);
3041                 ddata->cur += 2;
3042                 return (1);
3043         }
3044
3045         /* vendor extened operator */
3046         if (*ddata->cur == 'v' && ELFTC_ISDIGIT(*(ddata->cur + 1))) {
3047                 if (!cpp_demangle_push_str(ddata, "vendor extened operator ",
3048                     24))
3049                         return (0);
3050                 if (!cpp_demangle_push_str(ddata, ddata->cur + 1, 1))
3051                         return (0);
3052                 ddata->cur += 2;
3053                 return (cpp_demangle_read_sname(ddata));
3054         }
3055
3056         /* ctor-dtor-name */
3057         switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
3058         case SIMPLE_HASH('C', '1'):
3059                 /* FALLTHROUGH */
3060         case SIMPLE_HASH('C', '2'):
3061                 /* FALLTHROUGH */
3062         case SIMPLE_HASH('C', '3'):
3063                 if (ddata->last_sname == NULL)
3064                         return (0);
3065                 if ((len = strlen(ddata->last_sname)) == 0)
3066                         return (0);
3067                 if (!cpp_demangle_push_str(ddata, "::", 2))
3068                         return (0);
3069                 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
3070                         return (0);
3071                 ddata->cur +=2;
3072                 return (1);
3073
3074         case SIMPLE_HASH('D', '0'):
3075                 /* FALLTHROUGH */
3076         case SIMPLE_HASH('D', '1'):
3077                 /* FALLTHROUGH */
3078         case SIMPLE_HASH('D', '2'):
3079                 if (ddata->last_sname == NULL)
3080                         return (0);
3081                 if ((len = strlen(ddata->last_sname)) == 0)
3082                         return (0);
3083                 if (!cpp_demangle_push_str(ddata, "::~", 3))
3084                         return (0);
3085                 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
3086                         return (0);
3087                 ddata->cur +=2;
3088                 return (1);
3089         }
3090
3091         /* source name */
3092         if (ELFTC_ISDIGIT(*ddata->cur) != 0)
3093                 return (cpp_demangle_read_sname(ddata));
3094
3095         /* local source name */
3096         if (*ddata->cur == 'L')
3097                 return (cpp_demangle_local_source_name(ddata));
3098
3099         return (1);
3100 }
3101
3102 /*
3103  * Read local source name.
3104  *
3105  * References:
3106  *   http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31775
3107  *   http://gcc.gnu.org/viewcvs?view=rev&revision=124467
3108  */
3109 static int
3110 cpp_demangle_local_source_name(struct cpp_demangle_data *ddata)
3111 {
3112         /* L */
3113         if (ddata == NULL || *ddata->cur != 'L')
3114                 return (0);
3115         ++ddata->cur;
3116
3117         /* source name */
3118         if (!cpp_demangle_read_sname(ddata))
3119                 return (0);
3120
3121         /* discriminator */
3122         if (*ddata->cur == '_') {
3123                 ++ddata->cur;
3124                 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
3125                         ++ddata->cur;
3126         }
3127
3128         return (1);
3129 }
3130
3131 static int
3132 cpp_demangle_read_v_offset(struct cpp_demangle_data *ddata)
3133 {
3134
3135         if (ddata == NULL)
3136                 return (0);
3137
3138         if (!cpp_demangle_push_str(ddata, "offset : ", 9))
3139                 return (0);
3140
3141         if (!cpp_demangle_read_offset_number(ddata))
3142                 return (0);
3143
3144         if (!cpp_demangle_push_str(ddata, "virtual offset : ", 17))
3145                 return (0);
3146
3147         return (!cpp_demangle_read_offset_number(ddata));
3148 }
3149
3150 /*
3151  * Decode floating point representation to string
3152  * Return new allocated string or NULL
3153  *
3154  * Todo
3155  * Replace these functions to macro.
3156  */
3157 static char *
3158 decode_fp_to_double(const char *p, size_t len)
3159 {
3160         double f;
3161         size_t rtn_len, limit, i;
3162         int byte;
3163         char *rtn;
3164
3165         if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(double))
3166                 return (NULL);
3167
3168         memset(&f, 0, sizeof(double));
3169
3170         for (i = 0; i < len / 2; ++i) {
3171                 byte = hex_to_dec(p[len - i * 2 - 1]) +
3172                     hex_to_dec(p[len - i * 2 - 2]) * 16;
3173
3174                 if (byte < 0 || byte > 255)
3175                         return (NULL);
3176
3177 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3178                 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3179 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3180                 ((unsigned char *)&f)[sizeof(double) - i - 1] =
3181                     (unsigned char)(byte);
3182 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3183         }
3184
3185         rtn_len = 64;
3186         limit = 0;
3187 again:
3188         if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3189                 return (NULL);
3190
3191         if (snprintf(rtn, rtn_len, "%fld", f) >= (int)rtn_len) {
3192                 free(rtn);
3193                 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3194                         return (NULL);
3195                 rtn_len *= BUFFER_GROWFACTOR;
3196                 goto again;
3197         }
3198
3199         return rtn;
3200 }
3201
3202 static char *
3203 decode_fp_to_float(const char *p, size_t len)
3204 {
3205         size_t i, rtn_len, limit;
3206         float f;
3207         int byte;
3208         char *rtn;
3209
3210         if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(float))
3211                 return (NULL);
3212
3213         memset(&f, 0, sizeof(float));
3214
3215         for (i = 0; i < len / 2; ++i) {
3216                 byte = hex_to_dec(p[len - i * 2 - 1]) +
3217                     hex_to_dec(p[len - i * 2 - 2]) * 16;
3218                 if (byte < 0 || byte > 255)
3219                         return (NULL);
3220 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3221                 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3222 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3223                 ((unsigned char *)&f)[sizeof(float) - i - 1] =
3224                     (unsigned char)(byte);
3225 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3226         }
3227
3228         rtn_len = 64;
3229         limit = 0;
3230 again:
3231         if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3232                 return (NULL);
3233
3234         if (snprintf(rtn, rtn_len, "%ff", f) >= (int)rtn_len) {
3235                 free(rtn);
3236                 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3237                         return (NULL);
3238                 rtn_len *= BUFFER_GROWFACTOR;
3239                 goto again;
3240         }
3241
3242         return rtn;
3243 }
3244
3245 static char *
3246 decode_fp_to_float128(const char *p, size_t len)
3247 {
3248         long double f;
3249         size_t rtn_len, limit, i;
3250         int byte;
3251         unsigned char buf[FLOAT_QUADRUPLE_BYTES];
3252         char *rtn;
3253
3254         switch(sizeof(long double)) {
3255         case FLOAT_QUADRUPLE_BYTES:
3256                 return (decode_fp_to_long_double(p, len));
3257         case FLOAT_EXTENED_BYTES:
3258                 if (p == NULL || len == 0 || len % 2 != 0 ||
3259                     len / 2 > FLOAT_QUADRUPLE_BYTES)
3260                         return (NULL);
3261
3262                 memset(buf, 0, FLOAT_QUADRUPLE_BYTES);
3263
3264                 for (i = 0; i < len / 2; ++i) {
3265                         byte = hex_to_dec(p[len - i * 2 - 1]) +
3266                             hex_to_dec(p[len - i * 2 - 2]) * 16;
3267                         if (byte < 0 || byte > 255)
3268                                 return (NULL);
3269 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3270                         buf[i] = (unsigned char)(byte);
3271 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3272                         buf[FLOAT_QUADRUPLE_BYTES - i -1] =
3273                             (unsigned char)(byte);
3274 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3275                 }
3276                 memset(&f, 0, FLOAT_EXTENED_BYTES);
3277
3278 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3279                 memcpy(&f, buf, FLOAT_EXTENED_BYTES);
3280 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3281                 memcpy(&f, buf + 6, FLOAT_EXTENED_BYTES);
3282 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3283
3284                 rtn_len = 256;
3285                 limit = 0;
3286 again:
3287                 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3288                         return (NULL);
3289
3290                 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3291                         free(rtn);
3292                         if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3293                                 return (NULL);
3294                         rtn_len *= BUFFER_GROWFACTOR;
3295                         goto again;
3296                 }
3297
3298                 return (rtn);
3299         default:
3300                 return (NULL);
3301         }
3302 }
3303
3304 static char *
3305 decode_fp_to_float80(const char *p, size_t len)
3306 {
3307         long double f;
3308         size_t rtn_len, limit, i;
3309         int byte;
3310         unsigned char buf[FLOAT_EXTENED_BYTES];
3311         char *rtn;
3312
3313         switch(sizeof(long double)) {
3314         case FLOAT_QUADRUPLE_BYTES:
3315                 if (p == NULL || len == 0 || len % 2 != 0 ||
3316                     len / 2 > FLOAT_EXTENED_BYTES)
3317                         return (NULL);
3318
3319                 memset(buf, 0, FLOAT_EXTENED_BYTES);
3320
3321                 for (i = 0; i < len / 2; ++i) {
3322                         byte = hex_to_dec(p[len - i * 2 - 1]) +
3323                             hex_to_dec(p[len - i * 2 - 2]) * 16;
3324
3325                         if (byte < 0 || byte > 255)
3326                                 return (NULL);
3327
3328 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3329                         buf[i] = (unsigned char)(byte);
3330 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3331                         buf[FLOAT_EXTENED_BYTES - i -1] =
3332                             (unsigned char)(byte);
3333 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3334                 }
3335
3336                 memset(&f, 0, FLOAT_QUADRUPLE_BYTES);
3337
3338 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3339                 memcpy(&f, buf, FLOAT_EXTENED_BYTES);
3340 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3341                 memcpy((unsigned char *)(&f) + 6, buf, FLOAT_EXTENED_BYTES);
3342 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3343
3344                 rtn_len = 256;
3345                 limit = 0;
3346 again:
3347                 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3348                         return (NULL);
3349
3350                 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3351                         free(rtn);
3352                         if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3353                                 return (NULL);
3354                         rtn_len *= BUFFER_GROWFACTOR;
3355                         goto again;
3356                 }
3357
3358                 return (rtn);
3359         case FLOAT_EXTENED_BYTES:
3360                 return (decode_fp_to_long_double(p, len));
3361         default:
3362                 return (NULL);
3363         }
3364 }
3365
3366 static char *
3367 decode_fp_to_long_double(const char *p, size_t len)
3368 {
3369         long double f;
3370         size_t rtn_len, limit, i;
3371         int byte;
3372         char *rtn;
3373
3374         if (p == NULL || len == 0 || len % 2 != 0 ||
3375             len / 2 > sizeof(long double))
3376                 return (NULL);
3377
3378         memset(&f, 0, sizeof(long double));
3379
3380         for (i = 0; i < len / 2; ++i) {
3381                 byte = hex_to_dec(p[len - i * 2 - 1]) +
3382                     hex_to_dec(p[len - i * 2 - 2]) * 16;
3383
3384                 if (byte < 0 || byte > 255)
3385                         return (NULL);
3386
3387 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3388                 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3389 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3390                 ((unsigned char *)&f)[sizeof(long double) - i - 1] =
3391                     (unsigned char)(byte);
3392 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3393         }
3394
3395         rtn_len = 256;
3396         limit = 0;
3397 again:
3398         if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3399                 return (NULL);
3400
3401         if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3402                 free(rtn);
3403                 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3404                         return (NULL);
3405                 rtn_len *= BUFFER_GROWFACTOR;
3406                 goto again;
3407         }
3408
3409         return (rtn);
3410 }
3411
3412 /* Simple hex to integer function used by decode_to_* function. */
3413 static int
3414 hex_to_dec(char c)
3415 {
3416
3417         switch (c) {
3418         case '0':
3419                 return (0);
3420         case '1':
3421                 return (1);
3422         case '2':
3423                 return (2);
3424         case '3':
3425                 return (3);
3426         case '4':
3427                 return (4);
3428         case '5':
3429                 return (5);
3430         case '6':
3431                 return (6);
3432         case '7':
3433                 return (7);
3434         case '8':
3435                 return (8);
3436         case '9':
3437                 return (9);
3438         case 'a':
3439                 return (10);
3440         case 'b':
3441                 return (11);
3442         case 'c':
3443                 return (12);
3444         case 'd':
3445                 return (13);
3446         case 'e':
3447                 return (14);
3448         case 'f':
3449                 return (15);
3450         default:
3451                 return (-1);
3452         }
3453 }
3454
3455 /**
3456  * @brief Test input string is mangled by IA-64 C++ ABI style.
3457  *
3458  * Test string heads with "_Z" or "_GLOBAL__I_".
3459  * @return Return 0 at false.
3460  */
3461 bool
3462 is_cpp_mangled_gnu3(const char *org)
3463 {
3464         size_t len;
3465
3466         len = strlen(org);
3467         return ((len > 2 && *org == '_' && *(org + 1) == 'Z') ||
3468             (len > 11 && !strncmp(org, "_GLOBAL__I_", 11)));
3469 }
3470
3471 static void
3472 vector_read_cmd_dest(struct vector_read_cmd *v)
3473 {
3474
3475         if (v == NULL)
3476                 return;
3477
3478         free(v->r_container);
3479 }
3480
3481 /* return -1 at failed, 0 at not found, 1 at found. */
3482 static int
3483 vector_read_cmd_find(struct vector_read_cmd *v, enum read_cmd dst)
3484 {
3485         size_t i;
3486
3487         if (v == NULL || dst == READ_FAIL)
3488                 return (-1);
3489
3490         for (i = 0; i < v->size; ++i)
3491                 if (v->r_container[i] == dst)
3492                         return (1);
3493
3494         return (0);
3495 }
3496
3497 static int
3498 vector_read_cmd_init(struct vector_read_cmd *v)
3499 {
3500
3501         if (v == NULL)
3502                 return (0);
3503
3504         v->size = 0;
3505         v->capacity = VECTOR_DEF_CAPACITY;
3506
3507         if ((v->r_container = malloc(sizeof(enum read_cmd) * v->capacity))
3508             == NULL)
3509                 return (0);
3510
3511         return (1);
3512 }
3513
3514 static int
3515 vector_read_cmd_pop(struct vector_read_cmd *v)
3516 {
3517
3518         if (v == NULL || v->size == 0)
3519                 return (0);
3520
3521         --v->size;
3522         v->r_container[v->size] = READ_FAIL;
3523
3524         return (1);
3525 }
3526
3527 static int
3528 vector_read_cmd_push(struct vector_read_cmd *v, enum read_cmd cmd)
3529 {
3530         enum read_cmd *tmp_r_ctn;
3531         size_t tmp_cap;
3532         size_t i;
3533
3534         if (v == NULL)
3535                 return (0);
3536
3537         if (v->size == v->capacity) {
3538                 tmp_cap = v->capacity * BUFFER_GROWFACTOR;
3539                 if ((tmp_r_ctn = malloc(sizeof(enum read_cmd) * tmp_cap))
3540                     == NULL)
3541                         return (0);
3542                 for (i = 0; i < v->size; ++i)
3543                         tmp_r_ctn[i] = v->r_container[i];
3544                 free(v->r_container);
3545                 v->r_container = tmp_r_ctn;
3546                 v->capacity = tmp_cap;
3547         }
3548
3549         v->r_container[v->size] = cmd;
3550         ++v->size;
3551
3552         return (1);
3553 }
3554
3555 static void
3556 vector_type_qualifier_dest(struct vector_type_qualifier *v)
3557 {
3558
3559         if (v == NULL)
3560                 return;
3561
3562         free(v->q_container);
3563         vector_str_dest(&v->ext_name);
3564 }
3565
3566 /* size, capacity, ext_name */
3567 static int
3568 vector_type_qualifier_init(struct vector_type_qualifier *v)
3569 {
3570
3571         if (v == NULL)
3572                 return (0);
3573
3574         v->size = 0;
3575         v->capacity = VECTOR_DEF_CAPACITY;
3576
3577         if ((v->q_container = malloc(sizeof(enum type_qualifier) * v->capacity))
3578             == NULL)
3579                 return (0);
3580
3581         assert(v->q_container != NULL);
3582
3583         if (vector_str_init(&v->ext_name) == false) {
3584                 free(v->q_container);
3585                 return (0);
3586         }
3587
3588         return (1);
3589 }
3590
3591 static int
3592 vector_type_qualifier_push(struct vector_type_qualifier *v,
3593     enum type_qualifier t)
3594 {
3595         enum type_qualifier *tmp_ctn;
3596         size_t tmp_cap;
3597         size_t i;
3598
3599         if (v == NULL)
3600                 return (0);
3601
3602         if (v->size == v->capacity) {
3603                 tmp_cap = v->capacity * BUFFER_GROWFACTOR;
3604                 if ((tmp_ctn = malloc(sizeof(enum type_qualifier) * tmp_cap))
3605                     == NULL)
3606                         return (0);
3607                 for (i = 0; i < v->size; ++i)
3608                         tmp_ctn[i] = v->q_container[i];
3609                 free(v->q_container);
3610                 v->q_container = tmp_ctn;
3611                 v->capacity = tmp_cap;
3612         }
3613
3614         v->q_container[v->size] = t;
3615         ++v->size;
3616
3617         return (1);
3618 }