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