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