2 * Copyright (c) 2007 Hyogeol Lee <hyogeollee@gmail.com>
3 * Copyright (c) 2015-2017 Kai Wang <kaiwang27@gmail.com>
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
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.
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.
27 #include <sys/types.h>
38 * @file cpp_demangle.c
39 * @brief Decode IA-64 C++ ABI style implementation.
41 * IA-64 standard ABI(Itanium C++ ABI) references.
43 * http://www.codesourcery.com/cxx-abi/abi.html#mangling \n
44 * http://www.codesourcery.com/cxx-abi/abi-mangling.html
47 /** @brief Dynamic vector data for string. */
57 #define BUFFER_GROWFACTOR 1.618
58 #define BUFFER_GROW(x) (((x)+0.5)*BUFFER_GROWFACTOR)
60 #define ELFTC_FAILURE 0
61 #define ELFTC_ISDIGIT(C) (isdigit((C) & 0xFF))
62 #define ELFTC_SUCCESS 1
64 #define VECTOR_DEF_CAPACITY 8
67 TYPE_PTR, TYPE_REF, TYPE_CMX, TYPE_IMG, TYPE_EXT, TYPE_RST, TYPE_VAT,
68 TYPE_CST, TYPE_VEC, TYPE_RREF
71 struct vector_type_qualifier {
72 size_t size, capacity;
73 enum type_qualifier *q_container;
74 struct vector_str ext_name;
78 READ_FAIL, READ_NEST, READ_TMPL, READ_EXPR, READ_EXPL, READ_LOCAL,
79 READ_TYPE, READ_FUNC, READ_PTRMEM
82 struct read_cmd_item {
87 struct vector_read_cmd {
88 size_t size, capacity;
89 struct read_cmd_item *r_container;
95 PUSH_NON_CV_QUALIFIER,
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 */
116 const char *cur; /* current mangled name ptr */
117 const char *last_sname; /* last source name */
120 struct type_delimit {
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
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)))
134 static size_t get_strlen_sum(const struct vector_str *v);
135 static bool vector_str_grow(struct vector_str *v);
138 get_strlen_sum(const struct vector_str *v)
147 for (i = 0; i < v->size; ++i)
148 len += strlen(v->container[i]);
154 * @brief Deallocate resource in vector_str.
157 vector_str_dest(struct vector_str *v)
164 for (i = 0; i < v->size; ++i)
165 free(v->container[i]);
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.
178 vector_str_find(const struct vector_str *v, const char *o, size_t l)
182 if (v == NULL || o == NULL)
185 for (i = 0; i < v->size; ++i)
186 if (strncmp(v->container[i], o, l) == 0)
193 * @brief Get new allocated flat string from vector.
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.
201 vector_str_get_flat(const struct vector_str *v, size_t *l)
203 ssize_t elem_pos, elem_size, rtn_size;
207 if (v == NULL || v->size == 0)
210 if ((rtn_size = get_strlen_sum(v)) == 0)
213 if ((rtn = malloc(sizeof(char) * (rtn_size + 1))) == NULL)
217 for (i = 0; i < v->size; ++i) {
218 elem_size = strlen(v->container[i]);
220 memcpy(rtn + elem_pos, v->container[i], elem_size);
222 elem_pos += elem_size;
225 rtn[rtn_size] = '\0';
234 vector_str_grow(struct vector_str *v)
242 assert(v->capacity > 0);
244 tmp_cap = BUFFER_GROW(v->capacity);
246 assert(tmp_cap > v->capacity);
248 if ((tmp_ctn = malloc(sizeof(char *) * tmp_cap)) == NULL)
251 for (i = 0; i < v->size; ++i)
252 tmp_ctn[i] = v->container[i];
256 v->container = tmp_ctn;
257 v->capacity = tmp_cap;
263 * @brief Initialize vector_str.
264 * @return false at failed, true at success.
267 vector_str_init(struct vector_str *v)
274 v->capacity = VECTOR_DEF_CAPACITY;
276 assert(v->capacity > 0);
278 if ((v->container = malloc(sizeof(char *) * v->capacity)) == NULL)
281 assert(v->container != NULL);
287 * @brief Remove last element in vector_str.
288 * @return false at failed, true at success.
291 vector_str_pop(struct vector_str *v)
302 free(v->container[v->size]);
303 v->container[v->size] = NULL;
309 * @brief Push back string to vector.
310 * @return false at failed, true at success.
313 vector_str_push(struct vector_str *v, const char *str, size_t len)
316 if (v == NULL || str == NULL)
319 if (v->size == v->capacity && vector_str_grow(v) == false)
322 if ((v->container[v->size] = malloc(sizeof(char) * (len + 1))) == NULL)
325 snprintf(v->container[v->size], len + 1, "%s", str);
333 * @brief Push front org vector to det vector.
334 * @return false at failed, true at success.
337 vector_str_push_vector_head(struct vector_str *dst, struct vector_str *org)
339 size_t i, j, tmp_cap;
342 if (dst == NULL || org == NULL)
345 tmp_cap = BUFFER_GROW(dst->size + org->size);
347 if ((tmp_ctn = malloc(sizeof(char *) * tmp_cap)) == NULL)
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)
360 for (i = 0; i < dst->size; ++i)
361 tmp_ctn[i + org->size] = dst->container[i];
363 free(dst->container);
365 dst->container = tmp_ctn;
366 dst->capacity = tmp_cap;
367 dst->size += org->size;
373 * @brief Push org vector to the tail of det vector.
374 * @return false at failed, true at success.
377 vector_str_push_vector(struct vector_str *dst, struct vector_str *org)
379 size_t i, j, tmp_cap;
382 if (dst == NULL || org == NULL)
385 tmp_cap = BUFFER_GROW(dst->size + org->size);
387 if ((tmp_ctn = malloc(sizeof(char *) * tmp_cap)) == NULL)
390 for (i = 0; i < dst->size; ++i)
391 tmp_ctn[i] = dst->container[i];
393 for (i = 0; i < org->size; ++i)
394 if ((tmp_ctn[i + dst->size] = strdup(org->container[i])) ==
396 for (j = 0; j < i + dst->size; ++j)
404 free(dst->container);
406 dst->container = tmp_ctn;
407 dst->capacity = tmp_cap;
408 dst->size += org->size;
414 * @brief Get new allocated flat string from vector between begin and end.
416 * If r_len is not NULL, string length will be returned.
417 * @return NULL at failed or NUL terminated new allocated string.
420 vector_str_substr(const struct vector_str *v, size_t begin, size_t end,
426 if (v == NULL || begin > end)
430 for (i = begin; i < end + 1; ++i)
431 len += strlen(v->container[i]);
433 if ((rtn = malloc(sizeof(char) * (len + 1))) == NULL)
440 for (i = begin; i < end + 1; ++i) {
441 len = strlen(v->container[i]);
442 memcpy(rtn + cur, v->container[i], len);
450 static void cpp_demangle_data_dest(struct cpp_demangle_data *);
451 static int cpp_demangle_data_init(struct cpp_demangle_data *,
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 *,
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 *,
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 *,
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 *,
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 *,
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 *,
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 *,
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,
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);
527 * @brief Decode the input string by IA-64 C++ ABI style.
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.
534 __cxa_demangle_gnu3(const char *org)
536 struct cpp_demangle_data ddata;
537 struct vector_str ret_type;
538 struct type_delimit td;
542 bool has_ret, more_type;
544 if (org == NULL || (org_len = strlen(org)) < 2)
547 if (org_len > 11 && !strncmp(org, "_GLOBAL__I_", 11)) {
548 if ((rtn = malloc(org_len + 19)) == NULL)
550 snprintf(rtn, org_len + 19,
551 "global constructors keyed to %s", org + 11);
555 if (org[0] != '_' || org[1] != 'Z')
558 if (!cpp_demangle_data_init(&ddata, org + 2))
562 has_ret = more_type = false;
564 if (!cpp_demangle_read_encoding(&ddata))
568 * Pop function name from substitution candidate list.
570 if (*ddata.cur != 0 && ddata.subst.size >= 1) {
571 if (!vector_str_pop(&ddata.subst))
580 * The first type is a return type if we just demangled template
581 * args. (the template args is right next to the function name,
582 * which means it's a template function)
585 ddata.is_tmpl = false;
586 if (!vector_str_init(&ret_type))
588 ddata.cur_output = &ret_type;
592 while (*ddata.cur != '\0') {
594 * Breaking at some gcc info at tail. e.g) @@GLIBCXX_3.4
596 if (*ddata.cur == '@' && *(ddata.cur + 1) == '@')
600 /* Read return type */
601 if (!cpp_demangle_read_type(&ddata, NULL))
604 /* Read function arg type */
605 if (!cpp_demangle_read_type(&ddata, &td))
610 /* Push return type to the beginning */
611 if (!VEC_PUSH_STR(&ret_type, " "))
613 if (!vector_str_push_vector_head(&ddata.output,
616 ddata.cur_output = &ddata.output;
617 vector_str_dest(&ret_type);
620 } else if (more_type)
622 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
628 if (ddata.output.size == 0)
630 if (td.paren && !VEC_PUSH_STR(&ddata.output, ")"))
632 if (ddata.mem_vat && !VEC_PUSH_STR(&ddata.output, " volatile"))
634 if (ddata.mem_cst && !VEC_PUSH_STR(&ddata.output, " const"))
636 if (ddata.mem_rst && !VEC_PUSH_STR(&ddata.output, " restrict"))
638 if (ddata.mem_ref && !VEC_PUSH_STR(&ddata.output, " &"))
640 if (ddata.mem_rref && !VEC_PUSH_STR(&ddata.output, " &&"))
643 rtn = vector_str_get_flat(&ddata.output, (size_t *) NULL);
647 vector_str_dest(&ret_type);
649 cpp_demangle_data_dest(&ddata);
655 cpp_demangle_data_dest(struct cpp_demangle_data *d)
661 vector_read_cmd_dest(&d->cmd);
662 vector_str_dest(&d->class_type);
663 vector_str_dest(&d->tmpl);
664 vector_str_dest(&d->subst);
665 vector_str_dest(&d->output);
669 cpp_demangle_data_init(struct cpp_demangle_data *d, const char *cur)
672 if (d == NULL || cur == NULL)
675 if (!vector_str_init(&d->output))
677 if (!vector_str_init(&d->subst))
679 if (!vector_str_init(&d->tmpl))
681 if (!vector_str_init(&d->class_type))
683 if (!vector_read_cmd_init(&d->cmd))
686 assert(d->output.container != NULL);
687 assert(d->subst.container != NULL);
688 assert(d->tmpl.container != NULL);
689 assert(d->class_type.container != NULL);
697 d->is_functype = false;
698 d->ref_qualifier = false;
699 d->push_qualifier = PUSH_ALL_QUALIFIER;
702 d->cur_output = &d->output;
703 d->last_sname = NULL;
708 vector_str_dest(&d->class_type);
710 vector_str_dest(&d->tmpl);
712 vector_str_dest(&d->subst);
714 vector_str_dest(&d->output);
720 cpp_demangle_push_fp(struct cpp_demangle_data *ddata,
721 char *(*decoder)(const char *, size_t))
728 if (ddata == NULL || decoder == NULL)
732 while (*ddata->cur != 'E')
735 if ((f = decoder(fp, ddata->cur - fp)) == NULL)
739 if ((len = strlen(f)) > 0)
740 rtn = cpp_demangle_push_str(ddata, f, len);
750 cpp_demangle_push_str(struct cpp_demangle_data *ddata, const char *str,
754 if (ddata == NULL || str == NULL || len == 0)
758 * is_tmpl is used to check if the type (function arg) is right next
759 * to template args, and should always be cleared whenever new string
762 ddata->is_tmpl = false;
764 return (vector_str_push(ddata->cur_output, str, len));
768 cpp_demangle_pop_str(struct cpp_demangle_data *ddata)
774 return (vector_str_pop(ddata->cur_output));
778 cpp_demangle_push_subst(struct cpp_demangle_data *ddata, const char *str,
782 if (ddata == NULL || str == NULL || len == 0)
785 if (!vector_str_find(&ddata->subst, str, len))
786 return (vector_str_push(&ddata->subst, str, len));
792 cpp_demangle_push_subst_v(struct cpp_demangle_data *ddata, struct vector_str *v)
798 if (ddata == NULL || v == NULL)
801 if ((str = vector_str_get_flat(v, &str_len)) == NULL)
804 rtn = cpp_demangle_push_subst(ddata, str, str_len);
812 cpp_demangle_push_type_qualifier(struct cpp_demangle_data *ddata,
813 struct vector_type_qualifier *v, const char *type_str)
815 struct vector_str subst_v;
816 enum type_qualifier t;
817 size_t idx, e_idx, e_len;
822 if (ddata == NULL || v == NULL)
825 if ((idx = v->size) == 0)
829 if (type_str != NULL) {
830 if (!vector_str_init(&subst_v))
832 if (!VEC_PUSH_STR(&subst_v, type_str))
839 switch (v->q_container[idx - 1]) {
842 if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
844 if (!DEM_PUSH_STR(ddata, "*"))
846 if (type_str != NULL) {
847 if (!VEC_PUSH_STR(&subst_v, "*"))
849 if (!cpp_demangle_push_subst_v(ddata,
857 if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
859 if (!DEM_PUSH_STR(ddata, "&"))
861 if (type_str != NULL) {
862 if (!VEC_PUSH_STR(&subst_v, "&"))
864 if (!cpp_demangle_push_subst_v(ddata,
872 if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
874 if (!DEM_PUSH_STR(ddata, "&&"))
876 if (type_str != NULL) {
877 if (!VEC_PUSH_STR(&subst_v, "&&"))
879 if (!cpp_demangle_push_subst_v(ddata,
887 if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
889 if (!DEM_PUSH_STR(ddata, " complex"))
891 if (type_str != NULL) {
892 if (!VEC_PUSH_STR(&subst_v, " complex"))
894 if (!cpp_demangle_push_subst_v(ddata,
902 if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
904 if (!DEM_PUSH_STR(ddata, " imaginary"))
906 if (type_str != NULL) {
907 if (!VEC_PUSH_STR(&subst_v, " imaginary"))
909 if (!cpp_demangle_push_subst_v(ddata,
917 if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
919 if (v->ext_name.size == 0 ||
920 e_idx > v->ext_name.size - 1)
922 if ((e_len = strlen(v->ext_name.container[e_idx])) ==
925 if ((buf = malloc(e_len + 2)) == NULL)
927 snprintf(buf, e_len + 2, " %s",
928 v->ext_name.container[e_idx]);
930 if (!DEM_PUSH_STR(ddata, buf)) {
935 if (type_str != NULL) {
936 if (!VEC_PUSH_STR(&subst_v, buf)) {
940 if (!cpp_demangle_push_subst_v(ddata,
951 if (ddata->push_qualifier == PUSH_NON_CV_QUALIFIER &&
954 if (ddata->push_qualifier == PUSH_CV_QUALIFIER && !cv)
956 if (!DEM_PUSH_STR(ddata, " restrict"))
958 if (type_str != NULL) {
959 if (!VEC_PUSH_STR(&subst_v, " restrict"))
962 t = v->q_container[idx - 2];
963 if (t == TYPE_RST || t == TYPE_VAT ||
967 if (!cpp_demangle_push_subst_v(ddata,
974 if (ddata->push_qualifier == PUSH_NON_CV_QUALIFIER &&
977 if (ddata->push_qualifier == PUSH_CV_QUALIFIER && !cv)
979 if (!DEM_PUSH_STR(ddata, " volatile"))
981 if (type_str != NULL) {
982 if (!VEC_PUSH_STR(&subst_v, " volatile"))
985 t = v->q_container[idx - 2];
986 if (t == TYPE_RST || t == TYPE_VAT ||
990 if (!cpp_demangle_push_subst_v(ddata,
997 if (ddata->push_qualifier == PUSH_NON_CV_QUALIFIER &&
1000 if (ddata->push_qualifier == PUSH_CV_QUALIFIER && !cv)
1002 if (!DEM_PUSH_STR(ddata, " const"))
1004 if (type_str != NULL) {
1005 if (!VEC_PUSH_STR(&subst_v, " const"))
1008 t = v->q_container[idx - 2];
1009 if (t == TYPE_RST || t == TYPE_VAT ||
1013 if (!cpp_demangle_push_subst_v(ddata,
1021 if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
1023 if (v->ext_name.size == 0 ||
1024 e_idx > v->ext_name.size - 1)
1026 if ((e_len = strlen(v->ext_name.container[e_idx])) ==
1029 if ((buf = malloc(e_len + 12)) == NULL)
1031 snprintf(buf, e_len + 12, " __vector(%s)",
1032 v->ext_name.container[e_idx]);
1033 if (!DEM_PUSH_STR(ddata, buf)) {
1037 if (type_str != NULL) {
1038 if (!VEC_PUSH_STR(&subst_v, buf)) {
1042 if (!cpp_demangle_push_subst_v(ddata,
1057 if (type_str != NULL)
1058 vector_str_dest(&subst_v);
1064 cpp_demangle_get_subst(struct cpp_demangle_data *ddata, size_t idx)
1068 if (ddata == NULL || ddata->subst.size <= idx)
1070 if ((len = strlen(ddata->subst.container[idx])) == 0)
1072 if (!cpp_demangle_push_str(ddata, ddata->subst.container[idx], len))
1082 cpp_demangle_get_tmpl_param(struct cpp_demangle_data *ddata, size_t idx)
1086 if (ddata == NULL || ddata->tmpl.size <= idx)
1088 if ((len = strlen(ddata->tmpl.container[idx])) == 0)
1090 if (!cpp_demangle_push_str(ddata, ddata->tmpl.container[idx], len))
1099 cpp_demangle_read_array(struct cpp_demangle_data *ddata)
1101 size_t i, num_len, exp_len, p_idx, idx;
1105 if (ddata == NULL || *(++ddata->cur) == '\0')
1108 if (*ddata->cur == '_') {
1109 if (*(++ddata->cur) == '\0')
1112 if (!cpp_demangle_read_type(ddata, NULL))
1115 if (!DEM_PUSH_STR(ddata, "[]"))
1118 if (ELFTC_ISDIGIT(*ddata->cur) != 0) {
1120 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
1122 if (*ddata->cur != '_')
1124 num_len = ddata->cur - num;
1125 assert(num_len > 0);
1126 if (*(++ddata->cur) == '\0')
1128 if (!cpp_demangle_read_type(ddata, NULL))
1130 if (!DEM_PUSH_STR(ddata, "["))
1132 if (!cpp_demangle_push_str(ddata, num, num_len))
1134 if (!DEM_PUSH_STR(ddata, "]"))
1137 p_idx = ddata->output.size;
1138 if (!cpp_demangle_read_expression(ddata))
1140 if ((exp = vector_str_substr(&ddata->output, p_idx,
1141 ddata->output.size - 1, &exp_len)) == NULL)
1143 idx = ddata->output.size;
1144 for (i = p_idx; i < idx; ++i)
1145 if (!vector_str_pop(&ddata->output)) {
1149 if (*ddata->cur != '_') {
1154 if (*ddata->cur == '\0') {
1158 if (!cpp_demangle_read_type(ddata, NULL)) {
1162 if (!DEM_PUSH_STR(ddata, "[")) {
1166 if (!cpp_demangle_push_str(ddata, exp, exp_len)) {
1170 if (!DEM_PUSH_STR(ddata, "]")) {
1182 cpp_demangle_read_expr_primary(struct cpp_demangle_data *ddata)
1186 if (ddata == NULL || *(++ddata->cur) == '\0')
1189 if (*ddata->cur == '_' && *(ddata->cur + 1) == 'Z') {
1191 if (*ddata->cur == '\0')
1193 if (!cpp_demangle_read_encoding(ddata))
1199 switch (*ddata->cur) {
1201 if (*(ddata->cur + 2) != 'E')
1203 switch (*(++ddata->cur)) {
1206 return (DEM_PUSH_STR(ddata, "false"));
1209 return (DEM_PUSH_STR(ddata, "true"));
1216 return (cpp_demangle_push_fp(ddata, decode_fp_to_double));
1220 if (sizeof(long double) == 10)
1221 return (cpp_demangle_push_fp(ddata,
1222 decode_fp_to_double));
1223 return (cpp_demangle_push_fp(ddata, decode_fp_to_float80));
1227 return (cpp_demangle_push_fp(ddata, decode_fp_to_float));
1231 if (sizeof(long double) == 16)
1232 return (cpp_demangle_push_fp(ddata,
1233 decode_fp_to_double));
1234 return (cpp_demangle_push_fp(ddata, decode_fp_to_float128));
1245 if (*(++ddata->cur) == 'n') {
1246 if (!DEM_PUSH_STR(ddata, "-"))
1251 while (*ddata->cur != 'E') {
1252 if (!ELFTC_ISDIGIT(*ddata->cur))
1257 return (cpp_demangle_push_str(ddata, num,
1258 ddata->cur - num - 1));
1266 cpp_demangle_read_expression(struct cpp_demangle_data *ddata)
1269 if (ddata == NULL || *ddata->cur == '\0')
1272 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1273 case SIMPLE_HASH('s', 't'):
1275 return (cpp_demangle_read_type(ddata, NULL));
1277 case SIMPLE_HASH('s', 'r'):
1279 if (!cpp_demangle_read_type(ddata, NULL))
1281 if (!cpp_demangle_read_uqname(ddata))
1283 if (*ddata->cur == 'I')
1284 return (cpp_demangle_read_tmpl_args(ddata));
1287 case SIMPLE_HASH('a', 'a'):
1290 return (cpp_demangle_read_expression_binary(ddata, "&&", 2));
1292 case SIMPLE_HASH('a', 'd'):
1293 /* operator & (unary) */
1295 return (cpp_demangle_read_expression_unary(ddata, "&", 1));
1297 case SIMPLE_HASH('a', 'n'):
1300 return (cpp_demangle_read_expression_binary(ddata, "&", 1));
1302 case SIMPLE_HASH('a', 'N'):
1305 return (cpp_demangle_read_expression_binary(ddata, "&=", 2));
1307 case SIMPLE_HASH('a', 'S'):
1310 return (cpp_demangle_read_expression_binary(ddata, "=", 1));
1312 case SIMPLE_HASH('c', 'l'):
1315 return (cpp_demangle_read_expression_binary(ddata, "()", 2));
1317 case SIMPLE_HASH('c', 'm'):
1320 return (cpp_demangle_read_expression_binary(ddata, ",", 1));
1322 case SIMPLE_HASH('c', 'o'):
1325 return (cpp_demangle_read_expression_binary(ddata, "~", 1));
1327 case SIMPLE_HASH('c', 'v'):
1328 /* operator (cast) */
1330 return (cpp_demangle_read_expression_binary(ddata, "(cast)", 6));
1332 case SIMPLE_HASH('d', 'a'):
1333 /* operator delete [] */
1335 return (cpp_demangle_read_expression_unary(ddata, "delete []", 9));
1337 case SIMPLE_HASH('d', 'e'):
1338 /* operator * (unary) */
1340 return (cpp_demangle_read_expression_unary(ddata, "*", 1));
1342 case SIMPLE_HASH('d', 'l'):
1343 /* operator delete */
1345 return (cpp_demangle_read_expression_unary(ddata, "delete", 6));
1347 case SIMPLE_HASH('d', 'v'):
1350 return (cpp_demangle_read_expression_binary(ddata, "/", 1));
1352 case SIMPLE_HASH('d', 'V'):
1355 return (cpp_demangle_read_expression_binary(ddata, "/=", 2));
1357 case SIMPLE_HASH('e', 'o'):
1360 return (cpp_demangle_read_expression_binary(ddata, "^", 1));
1362 case SIMPLE_HASH('e', 'O'):
1365 return (cpp_demangle_read_expression_binary(ddata, "^=", 2));
1367 case SIMPLE_HASH('e', 'q'):
1370 return (cpp_demangle_read_expression_binary(ddata, "==", 2));
1372 case SIMPLE_HASH('g', 'e'):
1375 return (cpp_demangle_read_expression_binary(ddata, ">=", 2));
1377 case SIMPLE_HASH('g', 't'):
1380 return (cpp_demangle_read_expression_binary(ddata, ">", 1));
1382 case SIMPLE_HASH('i', 'x'):
1385 return (cpp_demangle_read_expression_binary(ddata, "[]", 2));
1387 case SIMPLE_HASH('l', 'e'):
1390 return (cpp_demangle_read_expression_binary(ddata, "<=", 2));
1392 case SIMPLE_HASH('l', 's'):
1395 return (cpp_demangle_read_expression_binary(ddata, "<<", 2));
1397 case SIMPLE_HASH('l', 'S'):
1400 return (cpp_demangle_read_expression_binary(ddata, "<<=", 3));
1402 case SIMPLE_HASH('l', 't'):
1405 return (cpp_demangle_read_expression_binary(ddata, "<", 1));
1407 case SIMPLE_HASH('m', 'i'):
1410 return (cpp_demangle_read_expression_binary(ddata, "-", 1));
1412 case SIMPLE_HASH('m', 'I'):
1415 return (cpp_demangle_read_expression_binary(ddata, "-=", 2));
1417 case SIMPLE_HASH('m', 'l'):
1420 return (cpp_demangle_read_expression_binary(ddata, "*", 1));
1422 case SIMPLE_HASH('m', 'L'):
1425 return (cpp_demangle_read_expression_binary(ddata, "*=", 2));
1427 case SIMPLE_HASH('m', 'm'):
1430 return (cpp_demangle_read_expression_binary(ddata, "--", 2));
1432 case SIMPLE_HASH('n', 'a'):
1433 /* operator new[] */
1435 return (cpp_demangle_read_expression_unary(ddata, "new []", 6));
1437 case SIMPLE_HASH('n', 'e'):
1440 return (cpp_demangle_read_expression_binary(ddata, "!=", 2));
1442 case SIMPLE_HASH('n', 'g'):
1443 /* operator - (unary) */
1445 return (cpp_demangle_read_expression_unary(ddata, "-", 1));
1447 case SIMPLE_HASH('n', 't'):
1450 return (cpp_demangle_read_expression_binary(ddata, "!", 1));
1452 case SIMPLE_HASH('n', 'w'):
1455 return (cpp_demangle_read_expression_unary(ddata, "new", 3));
1457 case SIMPLE_HASH('o', 'o'):
1460 return (cpp_demangle_read_expression_binary(ddata, "||", 2));
1462 case SIMPLE_HASH('o', 'r'):
1465 return (cpp_demangle_read_expression_binary(ddata, "|", 1));
1467 case SIMPLE_HASH('o', 'R'):
1470 return (cpp_demangle_read_expression_binary(ddata, "|=", 2));
1472 case SIMPLE_HASH('p', 'l'):
1475 return (cpp_demangle_read_expression_binary(ddata, "+", 1));
1477 case SIMPLE_HASH('p', 'L'):
1480 return (cpp_demangle_read_expression_binary(ddata, "+=", 2));
1482 case SIMPLE_HASH('p', 'm'):
1485 return (cpp_demangle_read_expression_binary(ddata, "->*", 3));
1487 case SIMPLE_HASH('p', 'p'):
1490 return (cpp_demangle_read_expression_binary(ddata, "++", 2));
1492 case SIMPLE_HASH('p', 's'):
1493 /* operator + (unary) */
1495 return (cpp_demangle_read_expression_unary(ddata, "+", 1));
1497 case SIMPLE_HASH('p', 't'):
1500 return (cpp_demangle_read_expression_binary(ddata, "->", 2));
1502 case SIMPLE_HASH('q', 'u'):
1505 return (cpp_demangle_read_expression_trinary(ddata, "?", 1,
1508 case SIMPLE_HASH('r', 'm'):
1511 return (cpp_demangle_read_expression_binary(ddata, "%", 1));
1513 case SIMPLE_HASH('r', 'M'):
1516 return (cpp_demangle_read_expression_binary(ddata, "%=", 2));
1518 case SIMPLE_HASH('r', 's'):
1521 return (cpp_demangle_read_expression_binary(ddata, ">>", 2));
1523 case SIMPLE_HASH('r', 'S'):
1526 return (cpp_demangle_read_expression_binary(ddata, ">>=", 3));
1528 case SIMPLE_HASH('r', 'z'):
1529 /* operator sizeof */
1531 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
1533 case SIMPLE_HASH('s', 'v'):
1534 /* operator sizeof */
1536 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
1539 switch (*ddata->cur) {
1541 return (cpp_demangle_read_expr_primary(ddata));
1543 return (cpp_demangle_read_tmpl_param(ddata));
1550 cpp_demangle_read_expression_flat(struct cpp_demangle_data *ddata, char **str)
1552 struct vector_str *output;
1553 size_t i, p_idx, idx, exp_len;
1556 output = &ddata->output;
1558 p_idx = output->size;
1560 if (!cpp_demangle_read_expression(ddata))
1563 if ((exp = vector_str_substr(output, p_idx, output->size - 1,
1568 for (i = p_idx; i < idx; ++i) {
1569 if (!vector_str_pop(output)) {
1581 cpp_demangle_read_expression_binary(struct cpp_demangle_data *ddata,
1582 const char *name, size_t len)
1585 if (ddata == NULL || name == NULL || len == 0)
1587 if (!cpp_demangle_read_expression(ddata))
1589 if (!cpp_demangle_push_str(ddata, name, len))
1592 return (cpp_demangle_read_expression(ddata));
1596 cpp_demangle_read_expression_unary(struct cpp_demangle_data *ddata,
1597 const char *name, size_t len)
1600 if (ddata == NULL || name == NULL || len == 0)
1602 if (!cpp_demangle_read_expression(ddata))
1605 return (cpp_demangle_push_str(ddata, name, len));
1609 cpp_demangle_read_expression_trinary(struct cpp_demangle_data *ddata,
1610 const char *name1, size_t len1, const char *name2, size_t len2)
1613 if (ddata == NULL || name1 == NULL || len1 == 0 || name2 == NULL ||
1617 if (!cpp_demangle_read_expression(ddata))
1619 if (!cpp_demangle_push_str(ddata, name1, len1))
1621 if (!cpp_demangle_read_expression(ddata))
1623 if (!cpp_demangle_push_str(ddata, name2, len2))
1626 return (cpp_demangle_read_expression(ddata));
1630 cpp_demangle_read_function(struct cpp_demangle_data *ddata, int *ext_c,
1631 struct vector_type_qualifier *v)
1633 struct type_delimit td;
1634 struct read_cmd_item *rc;
1635 size_t class_type_size, class_type_len, limit;
1636 const char *class_type;
1638 bool paren, non_cv_qualifier;
1640 if (ddata == NULL || *ddata->cur != 'F' || v == NULL)
1644 if (*ddata->cur == 'Y') {
1651 if (!cpp_demangle_read_type(ddata, NULL))
1654 if (*ddata->cur != 'E') {
1655 if (!DEM_PUSH_STR(ddata, " "))
1658 non_cv_qualifier = false;
1660 for (i = 0; (size_t) i < v->size; i++) {
1661 if (v->q_container[i] != TYPE_RST &&
1662 v->q_container[i] != TYPE_VAT &&
1663 v->q_container[i] != TYPE_CST) {
1664 non_cv_qualifier = true;
1671 rc = vector_read_cmd_find(&ddata->cmd, READ_PTRMEM);
1672 if (non_cv_qualifier || rc != NULL) {
1673 if (!DEM_PUSH_STR(ddata, "("))
1678 /* Push non-cv qualifiers. */
1679 ddata->push_qualifier = PUSH_NON_CV_QUALIFIER;
1680 if (!cpp_demangle_push_type_qualifier(ddata, v, NULL))
1684 if (non_cv_qualifier && !DEM_PUSH_STR(ddata, " "))
1686 if ((class_type_size = ddata->class_type.size) == 0)
1689 ddata->class_type.container[class_type_size - 1];
1690 if (class_type == NULL)
1692 if ((class_type_len = strlen(class_type)) == 0)
1694 if (!cpp_demangle_push_str(ddata, class_type,
1697 if (!DEM_PUSH_STR(ddata, "::*"))
1699 /* Push pointer-to-member qualifiers. */
1700 ddata->push_qualifier = PUSH_ALL_QUALIFIER;
1701 if (!cpp_demangle_push_type_qualifier(ddata, rc->data,
1708 if (!DEM_PUSH_STR(ddata, ")"))
1716 ddata->is_functype = true;
1718 if (!cpp_demangle_read_type(ddata, &td))
1720 if (*ddata->cur == 'E')
1722 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1725 ddata->is_functype = false;
1727 if (!DEM_PUSH_STR(ddata, ")"))
1732 /* Push CV qualifiers. */
1733 ddata->push_qualifier = PUSH_CV_QUALIFIER;
1734 if (!cpp_demangle_push_type_qualifier(ddata, v, NULL))
1737 ddata->push_qualifier = PUSH_ALL_QUALIFIER;
1739 /* Release type qualifier vector. */
1740 vector_type_qualifier_dest(v);
1741 if (!vector_type_qualifier_init(v))
1744 /* Push ref-qualifiers. */
1745 if (ddata->ref_qualifier) {
1746 switch (ddata->ref_qualifier_type) {
1748 if (!DEM_PUSH_STR(ddata, " &"))
1752 if (!DEM_PUSH_STR(ddata, " &&"))
1758 ddata->ref_qualifier = false;
1767 /* read encoding, encoding are function name, data name, special-name */
1769 cpp_demangle_read_encoding(struct cpp_demangle_data *ddata)
1771 char *name, *type, *num_str;
1775 if (ddata == NULL || *ddata->cur == '\0')
1779 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1780 case SIMPLE_HASH('G', 'A'):
1781 if (!DEM_PUSH_STR(ddata, "hidden alias for "))
1784 if (*ddata->cur == '\0')
1786 return (cpp_demangle_read_encoding(ddata));
1788 case SIMPLE_HASH('G', 'R'):
1789 if (!DEM_PUSH_STR(ddata, "reference temporary #"))
1792 if (*ddata->cur == '\0')
1794 if (!cpp_demangle_read_name_flat(ddata, &name))
1797 if (!cpp_demangle_read_number_as_string(ddata, &num_str))
1799 if (!DEM_PUSH_STR(ddata, num_str))
1801 if (!DEM_PUSH_STR(ddata, " for "))
1803 if (!DEM_PUSH_STR(ddata, name))
1812 case SIMPLE_HASH('G', 'T'):
1814 if (*ddata->cur == '\0')
1816 switch (*ddata->cur) {
1818 if (!DEM_PUSH_STR(ddata, "non-transaction clone for "))
1823 if (!DEM_PUSH_STR(ddata, "transaction clone for "))
1828 return (cpp_demangle_read_encoding(ddata));
1830 case SIMPLE_HASH('G', 'V'):
1831 /* sentry object for 1 time init */
1832 if (!DEM_PUSH_STR(ddata, "guard variable for "))
1837 case SIMPLE_HASH('T', 'c'):
1838 /* virtual function covariant override thunk */
1839 if (!DEM_PUSH_STR(ddata,
1840 "virtual function covariant override "))
1843 if (*ddata->cur == '\0')
1845 if (!cpp_demangle_read_offset(ddata))
1847 if (!cpp_demangle_read_offset(ddata))
1849 return (cpp_demangle_read_encoding(ddata));
1851 case SIMPLE_HASH('T', 'C'):
1852 /* construction vtable */
1853 if (!DEM_PUSH_STR(ddata, "construction vtable for "))
1856 if (*ddata->cur == '\0')
1858 if (!cpp_demangle_read_type_flat(ddata, &type))
1861 if (!cpp_demangle_read_number(ddata, &offset))
1863 if (*ddata->cur++ != '_')
1865 if (!cpp_demangle_read_type(ddata, NULL))
1867 if (!DEM_PUSH_STR(ddata, "-in-"))
1869 if (!DEM_PUSH_STR(ddata, type))
1876 case SIMPLE_HASH('T', 'D'):
1877 /* typeinfo common proxy */
1880 case SIMPLE_HASH('T', 'F'):
1882 if (!DEM_PUSH_STR(ddata, "typeinfo fn for "))
1885 if (*ddata->cur == '\0')
1887 return (cpp_demangle_read_type(ddata, NULL));
1889 case SIMPLE_HASH('T', 'h'):
1890 /* virtual function non-virtual override thunk */
1891 if (!DEM_PUSH_STR(ddata,
1892 "virtual function non-virtual override "))
1895 if (*ddata->cur == '\0')
1897 if (!cpp_demangle_read_nv_offset(ddata))
1899 return (cpp_demangle_read_encoding(ddata));
1901 case SIMPLE_HASH('T', 'H'):
1902 /* TLS init function */
1903 if (!DEM_PUSH_STR(ddata, "TLS init function for "))
1906 if (*ddata->cur == '\0')
1910 case SIMPLE_HASH('T', 'I'):
1911 /* typeinfo structure */
1912 if (!DEM_PUSH_STR(ddata, "typeinfo for "))
1915 if (*ddata->cur == '\0')
1917 return (cpp_demangle_read_type(ddata, NULL));
1919 case SIMPLE_HASH('T', 'J'):
1921 if (!DEM_PUSH_STR(ddata, "java Class for "))
1924 if (*ddata->cur == '\0')
1926 return (cpp_demangle_read_type(ddata, NULL));
1928 case SIMPLE_HASH('T', 'S'):
1929 /* RTTI name (NTBS) */
1930 if (!DEM_PUSH_STR(ddata, "typeinfo name for "))
1933 if (*ddata->cur == '\0')
1935 return (cpp_demangle_read_type(ddata, NULL));
1937 case SIMPLE_HASH('T', 'T'):
1939 if (!DEM_PUSH_STR(ddata, "VTT for "))
1942 if (*ddata->cur == '\0')
1944 return (cpp_demangle_read_type(ddata, NULL));
1946 case SIMPLE_HASH('T', 'v'):
1947 /* virtual function virtual override thunk */
1948 if (!DEM_PUSH_STR(ddata, "virtual function virtual override "))
1951 if (*ddata->cur == '\0')
1953 if (!cpp_demangle_read_v_offset(ddata))
1955 return (cpp_demangle_read_encoding(ddata));
1957 case SIMPLE_HASH('T', 'V'):
1959 if (!DEM_PUSH_STR(ddata, "vtable for "))
1962 if (*ddata->cur == '\0')
1964 return (cpp_demangle_read_type(ddata, NULL));
1966 case SIMPLE_HASH('T', 'W'):
1967 /* TLS wrapper function */
1968 if (!DEM_PUSH_STR(ddata, "TLS wrapper function for "))
1971 if (*ddata->cur == '\0')
1976 return (cpp_demangle_read_name(ddata));
1980 cpp_demangle_read_local_name(struct cpp_demangle_data *ddata)
1982 struct vector_str local_name;
1983 struct type_delimit td;
1989 if (*(++ddata->cur) == '\0')
1992 if (!vector_str_init(&local_name))
1994 ddata->cur_output = &local_name;
1996 if (!cpp_demangle_read_encoding(ddata)) {
1997 vector_str_dest(&local_name);
2001 ddata->cur_output = &ddata->output;
2009 * The first type is a return type if we just demangled template
2010 * args. (the template args is right next to the function name,
2011 * which means it's a template function)
2013 if (ddata->is_tmpl) {
2014 ddata->is_tmpl = false;
2016 /* Read return type */
2017 if (!cpp_demangle_read_type(ddata, NULL)) {
2018 vector_str_dest(&local_name);
2025 /* Now we can push the name after possible return type is handled. */
2026 if (!vector_str_push_vector(&ddata->output, &local_name)) {
2027 vector_str_dest(&local_name);
2030 vector_str_dest(&local_name);
2032 while (*ddata->cur != '\0') {
2033 if (!cpp_demangle_read_type(ddata, &td))
2037 if (*ddata->cur == 'E')
2039 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
2045 if (*(++ddata->cur) == '\0')
2047 if (td.paren == true) {
2048 if (!DEM_PUSH_STR(ddata, ")"))
2052 if (*ddata->cur == 's')
2055 if (!DEM_PUSH_STR(ddata, "::"))
2057 if (!cpp_demangle_read_name(ddata))
2060 if (*ddata->cur == '_') {
2062 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
2070 cpp_demangle_read_name(struct cpp_demangle_data *ddata)
2072 struct vector_str *output, v;
2073 size_t p_idx, subst_str_len;
2077 if (ddata == NULL || *ddata->cur == '\0')
2080 output = ddata->cur_output;
2084 switch (*ddata->cur) {
2086 return (cpp_demangle_read_subst(ddata));
2088 return (cpp_demangle_read_nested_name(ddata));
2090 return (cpp_demangle_read_local_name(ddata));
2093 if (!vector_str_init(&v))
2096 p_idx = output->size;
2098 if (!cpp_demangle_read_uqname(ddata))
2100 if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
2101 &subst_str_len)) == NULL)
2103 if (subst_str_len > 8 && strstr(subst_str, "operator") != NULL) {
2107 if (!vector_str_push(&v, subst_str, subst_str_len))
2109 if (!cpp_demangle_push_subst_v(ddata, &v))
2112 if (*ddata->cur == 'I') {
2113 p_idx = output->size;
2114 if (!cpp_demangle_read_tmpl_args(ddata))
2117 if ((subst_str = vector_str_substr(output, p_idx,
2118 output->size - 1, &subst_str_len)) == NULL)
2120 if (!vector_str_push(&v, subst_str, subst_str_len))
2122 if (!cpp_demangle_push_subst_v(ddata, &v))
2130 vector_str_dest(&v);
2136 cpp_demangle_read_name_flat(struct cpp_demangle_data *ddata, char **str)
2138 struct vector_str *output;
2139 size_t i, p_idx, idx, name_len;
2142 output = ddata->cur_output;
2144 p_idx = output->size;
2146 if (!cpp_demangle_read_name(ddata))
2149 if ((name = vector_str_substr(output, p_idx, output->size - 1,
2150 &name_len)) == NULL)
2154 for (i = p_idx; i < idx; ++i) {
2155 if (!vector_str_pop(output)) {
2167 cpp_demangle_read_nested_name(struct cpp_demangle_data *ddata)
2169 struct vector_str *output, v;
2170 size_t limit, p_idx, subst_str_len;
2174 if (ddata == NULL || *ddata->cur != 'N')
2176 if (*(++ddata->cur) == '\0')
2180 switch (*ddata->cur) {
2182 ddata->mem_rst = true;
2185 ddata->mem_vat = true;
2188 ddata->mem_cst = true;
2191 ddata->mem_ref = true;
2194 ddata->mem_rref = true;
2199 } while (*(++ddata->cur));
2202 output = ddata->cur_output;
2203 if (!vector_str_init(&v))
2209 p_idx = output->size;
2210 switch (*ddata->cur) {
2212 if (!cpp_demangle_read_tmpl_args(ddata))
2216 if (!cpp_demangle_read_subst(ddata))
2220 if (!cpp_demangle_read_tmpl_param(ddata))
2224 if (!cpp_demangle_read_uqname(ddata))
2228 if (p_idx == output->size)
2230 if ((subst_str = vector_str_substr(output, p_idx,
2231 output->size - 1, &subst_str_len)) == NULL)
2233 if (!vector_str_push(&v, subst_str, subst_str_len)) {
2239 if (!cpp_demangle_push_subst_v(ddata, &v))
2243 if (*ddata->cur == 'E')
2245 else if (*ddata->cur != 'I' && *ddata->cur != 'C' &&
2246 *ddata->cur != 'D' && p_idx != output->size) {
2247 if (!DEM_PUSH_STR(ddata, "::"))
2249 if (!VEC_PUSH_STR(&v, "::"))
2252 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
2260 vector_str_dest(&v);
2267 * number ::= [n] <decimal>
2270 cpp_demangle_read_number(struct cpp_demangle_data *ddata, long *rtn)
2272 long len, negative_factor;
2274 if (ddata == NULL || rtn == NULL)
2277 negative_factor = 1;
2278 if (*ddata->cur == 'n') {
2279 negative_factor = -1;
2283 if (ELFTC_ISDIGIT(*ddata->cur) == 0)
2287 if ((len = strtol(ddata->cur, (char **) NULL, 10)) == 0 &&
2291 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
2295 assert(negative_factor == 1 || negative_factor == -1);
2297 *rtn = len * negative_factor;
2303 cpp_demangle_read_number_as_string(struct cpp_demangle_data *ddata, char **str)
2307 if (!cpp_demangle_read_number(ddata, &n)) {
2312 if (asprintf(str, "%ld", n) < 0) {
2321 cpp_demangle_read_nv_offset(struct cpp_demangle_data *ddata)
2327 if (!DEM_PUSH_STR(ddata, "offset : "))
2330 return (cpp_demangle_read_offset_number(ddata));
2333 /* read offset, offset are nv-offset, v-offset */
2335 cpp_demangle_read_offset(struct cpp_demangle_data *ddata)
2341 if (*ddata->cur == 'h') {
2343 return (cpp_demangle_read_nv_offset(ddata));
2344 } else if (*ddata->cur == 'v') {
2346 return (cpp_demangle_read_v_offset(ddata));
2353 cpp_demangle_read_offset_number(struct cpp_demangle_data *ddata)
2358 if (ddata == NULL || *ddata->cur == '\0')
2361 /* offset could be negative */
2362 if (*ddata->cur == 'n') {
2364 start = ddata->cur + 1;
2370 while (*ddata->cur != '_')
2373 if (negative && !DEM_PUSH_STR(ddata, "-"))
2376 assert(start != NULL);
2378 if (!cpp_demangle_push_str(ddata, start, ddata->cur - start))
2380 if (!DEM_PUSH_STR(ddata, " "))
2389 cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *ddata,
2390 struct vector_type_qualifier *v)
2392 size_t class_type_len, i, idx, p_idx;
2393 int p_func_type, rtn;
2396 if (ddata == NULL || *ddata->cur != 'M' || *(++ddata->cur) == '\0')
2399 p_idx = ddata->output.size;
2400 if (!cpp_demangle_read_type(ddata, NULL))
2403 if ((class_type = vector_str_substr(&ddata->output, p_idx,
2404 ddata->output.size - 1, &class_type_len)) == NULL)
2408 idx = ddata->output.size;
2409 for (i = p_idx; i < idx; ++i)
2410 if (!vector_str_pop(&ddata->output))
2413 if (!vector_read_cmd_push(&ddata->cmd, READ_PTRMEM, v))
2416 if (!vector_str_push(&ddata->class_type, class_type, class_type_len))
2419 p_func_type = ddata->func_type;
2420 if (!cpp_demangle_read_type(ddata, NULL))
2423 if (p_func_type == ddata->func_type) {
2424 if (!DEM_PUSH_STR(ddata, " "))
2426 if (!cpp_demangle_push_str(ddata, class_type, class_type_len))
2428 if (!DEM_PUSH_STR(ddata, "::*"))
2434 if (!vector_str_pop(&ddata->class_type))
2437 if (!vector_read_cmd_pop(&ddata->cmd))
2442 vector_type_qualifier_dest(v);
2443 if (!vector_type_qualifier_init(v))
2449 /* read source-name, source-name is <len> <ID> */
2451 cpp_demangle_read_sname(struct cpp_demangle_data *ddata)
2456 if (ddata == NULL || cpp_demangle_read_number(ddata, &len) == 0 ||
2460 if (len == 12 && (memcmp("_GLOBAL__N_1", ddata->cur, 12) == 0))
2461 err = DEM_PUSH_STR(ddata, "(anonymous namespace)");
2463 err = cpp_demangle_push_str(ddata, ddata->cur, len);
2468 assert(ddata->cur_output->size > 0);
2469 if (vector_read_cmd_find(&ddata->cmd, READ_TMPL) == NULL)
2471 ddata->cur_output->container[ddata->output.size - 1];
2479 cpp_demangle_read_subst(struct cpp_demangle_data *ddata)
2483 if (ddata == NULL || *ddata->cur == '\0')
2486 /* abbreviations of the form Sx */
2487 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
2488 case SIMPLE_HASH('S', 'a'):
2489 /* std::allocator */
2490 if (!DEM_PUSH_STR(ddata, "std::allocator"))
2493 if (*ddata->cur == 'I')
2494 return (cpp_demangle_read_subst_stdtmpl(ddata,
2498 case SIMPLE_HASH('S', 'b'):
2499 /* std::basic_string */
2500 if (!DEM_PUSH_STR(ddata, "std::basic_string"))
2503 if (*ddata->cur == 'I')
2504 return (cpp_demangle_read_subst_stdtmpl(ddata,
2505 "std::basic_string"));
2508 case SIMPLE_HASH('S', 'd'):
2509 /* std::basic_iostream<char, std::char_traits<char> > */
2510 if (!DEM_PUSH_STR(ddata, "std::basic_iostream<char, "
2511 "std::char_traits<char> >"))
2513 ddata->last_sname = "basic_iostream";
2515 if (*ddata->cur == 'I')
2516 return (cpp_demangle_read_subst_stdtmpl(ddata,
2517 "std::basic_iostream<char, std::char_traits"
2521 case SIMPLE_HASH('S', 'i'):
2522 /* std::basic_istream<char, std::char_traits<char> > */
2523 if (!DEM_PUSH_STR(ddata, "std::basic_istream<char, "
2524 "std::char_traits<char> >"))
2526 ddata->last_sname = "basic_istream";
2528 if (*ddata->cur == 'I')
2529 return (cpp_demangle_read_subst_stdtmpl(ddata,
2530 "std::basic_istream<char, std::char_traits"
2534 case SIMPLE_HASH('S', 'o'):
2535 /* std::basic_ostream<char, std::char_traits<char> > */
2536 if (!DEM_PUSH_STR(ddata, "std::basic_ostream<char, "
2537 "std::char_traits<char> >"))
2539 ddata->last_sname = "basic_ostream";
2541 if (*ddata->cur == 'I')
2542 return (cpp_demangle_read_subst_stdtmpl(ddata,
2543 "std::basic_ostream<char, std::char_traits"
2547 case SIMPLE_HASH('S', 's'):
2549 * std::basic_string<char, std::char_traits<char>,
2550 * std::allocator<char> >
2554 if (!DEM_PUSH_STR(ddata, "std::basic_string<char, "
2555 "std::char_traits<char>, std::allocator<char> >"))
2557 ddata->last_sname = "string";
2559 if (*ddata->cur == 'I')
2560 return (cpp_demangle_read_subst_stdtmpl(ddata,
2561 "std::basic_string<char, std::char_traits<char>,"
2562 " std::allocator<char> >"));
2565 case SIMPLE_HASH('S', 't'):
2567 return (cpp_demangle_read_subst_std(ddata));
2570 if (*(++ddata->cur) == '\0')
2573 /* Skip unknown substitution abbreviations. */
2574 if (!(*ddata->cur >= '0' && *ddata->cur <= '9') &&
2575 !(*ddata->cur >= 'A' && *ddata->cur <= 'Z') &&
2576 *ddata->cur != '_') {
2582 if (*ddata->cur == '_')
2583 return (cpp_demangle_get_subst(ddata, 0));
2586 /* substitution number is base 36 */
2587 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
2591 /* first was '_', so increase one */
2594 while (*ddata->cur != '_')
2599 return (cpp_demangle_get_subst(ddata, nth));
2607 cpp_demangle_read_subst_std(struct cpp_demangle_data *ddata)
2609 struct vector_str *output, v;
2610 size_t p_idx, subst_str_len;
2617 if (!vector_str_init(&v))
2622 if (!DEM_PUSH_STR(ddata, "std::"))
2625 if (!VEC_PUSH_STR(&v, "std::"))
2630 output = ddata->cur_output;
2632 p_idx = output->size;
2633 if (!cpp_demangle_read_uqname(ddata))
2636 if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
2637 &subst_str_len)) == NULL)
2640 if (!vector_str_push(&v, subst_str, subst_str_len))
2643 if (!cpp_demangle_push_subst_v(ddata, &v))
2646 if (*ddata->cur == 'I') {
2647 p_idx = output->size;
2648 if (!cpp_demangle_read_tmpl_args(ddata))
2651 if ((subst_str = vector_str_substr(output, p_idx,
2652 output->size - 1, &subst_str_len)) == NULL)
2654 if (!vector_str_push(&v, subst_str, subst_str_len))
2656 if (!cpp_demangle_push_subst_v(ddata, &v))
2663 vector_str_dest(&v);
2669 cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *ddata,
2672 struct vector_str *output;
2673 size_t p_idx, substr_len, len;
2675 char *subst_str, *substr;
2677 if (ddata == NULL || str == NULL)
2680 if ((len = strlen(str)) == 0)
2683 output = ddata->cur_output;
2685 p_idx = output->size;
2689 if (!cpp_demangle_read_tmpl_args(ddata))
2691 if ((substr = vector_str_substr(output, p_idx, output->size - 1,
2692 &substr_len)) == NULL)
2696 if ((subst_str = malloc(sizeof(char) * (substr_len + len + 1))) ==
2700 memcpy(subst_str, str, len);
2701 memcpy(subst_str + len, substr, substr_len);
2702 subst_str[substr_len + len] = '\0';
2704 if (!cpp_demangle_push_subst(ddata, subst_str, substr_len + len))
2716 cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *ddata)
2719 if (ddata == NULL || *ddata->cur == '\0')
2722 switch (*ddata->cur) {
2724 return (cpp_demangle_read_expr_primary(ddata));
2727 if (!cpp_demangle_read_expression(ddata))
2729 return (*ddata->cur++ == 'E');
2732 return (cpp_demangle_read_type(ddata, NULL));
2736 cpp_demangle_read_tmpl_args(struct cpp_demangle_data *ddata)
2738 struct vector_str *v;
2739 size_t arg_len, idx, limit, size;
2742 if (ddata == NULL || *ddata->cur == '\0')
2747 if (!vector_read_cmd_push(&ddata->cmd, READ_TMPL, NULL))
2750 if (!DEM_PUSH_STR(ddata, "<"))
2754 v = ddata->cur_output;
2757 if (!cpp_demangle_read_tmpl_arg(ddata))
2759 if ((arg = vector_str_substr(v, idx, v->size - 1, &arg_len)) ==
2762 if (!vector_str_find(&ddata->tmpl, arg, arg_len) &&
2763 !vector_str_push(&ddata->tmpl, arg, arg_len)) {
2770 if (*ddata->cur == 'E') {
2774 if (!strncmp(v->container[size - 1], ">", 1)) {
2775 if (!DEM_PUSH_STR(ddata, " >"))
2777 } else if (!DEM_PUSH_STR(ddata, ">"))
2779 ddata->is_tmpl = true;
2781 } else if (*ddata->cur != 'I' &&
2782 !DEM_PUSH_STR(ddata, ", "))
2785 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
2789 return (vector_read_cmd_pop(&ddata->cmd));
2793 * Read template parameter that forms in 'T[number]_'.
2794 * This function much like to read_subst but only for types.
2797 cpp_demangle_read_tmpl_param(struct cpp_demangle_data *ddata)
2801 if (ddata == NULL || *ddata->cur != 'T')
2806 if (*ddata->cur == '_')
2807 return (cpp_demangle_get_tmpl_param(ddata, 0));
2811 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
2818 while (*ddata->cur != '_')
2823 return (cpp_demangle_get_tmpl_param(ddata, nth));
2831 cpp_demangle_read_type(struct cpp_demangle_data *ddata,
2832 struct type_delimit *td)
2834 struct vector_type_qualifier v;
2835 struct vector_str *output, sv;
2836 size_t p_idx, type_str_len, subst_str_len;
2837 int extern_c, is_builtin;
2840 char *type_str, *exp_str, *num_str, *subst_str;
2841 bool skip_ref_qualifier, omit_void;
2846 output = ddata->cur_output;
2848 if (td->paren == false) {
2849 if (!DEM_PUSH_STR(ddata, "("))
2851 if (ddata->output.size < 2)
2857 if (*ddata->cur != 'I') {
2858 if (!DEM_PUSH_STR(ddata, ", "))
2864 assert(output != NULL);
2866 * [r, V, K] [P, R, O, C, G, U] builtin, function, class-enum, array
2867 * pointer-to-member, template-param, template-template-param, subst
2870 if (!vector_type_qualifier_init(&v))
2875 p_idx = output->size;
2876 type_str = exp_str = num_str = NULL;
2877 skip_ref_qualifier = false;
2881 /* Clear ref-qualifier flag */
2882 if (*ddata->cur != 'R' && *ddata->cur != 'O' && *ddata->cur != 'E')
2883 ddata->ref_qualifier = false;
2886 switch (*ddata->cur) {
2889 if (!DEM_PUSH_STR(ddata, "signed char"))
2896 if (!cpp_demangle_read_array(ddata))
2903 if (!DEM_PUSH_STR(ddata, "bool"))
2910 if (!vector_type_qualifier_push(&v, TYPE_CMX))
2919 if (!DEM_PUSH_STR(ddata, "char"))
2926 if (!DEM_PUSH_STR(ddata, "double"))
2933 switch (*ddata->cur) {
2936 if (!DEM_PUSH_STR(ddata, "auto"))
2941 /* decltype(auto) */
2942 if (!DEM_PUSH_STR(ddata, "decltype(auto)"))
2947 /* IEEE 754r decimal floating point (64 bits) */
2948 if (!DEM_PUSH_STR(ddata, "decimal64"))
2953 /* IEEE 754r decimal floating point (128 bits) */
2954 if (!DEM_PUSH_STR(ddata, "decimal128"))
2959 /* IEEE 754r decimal floating point (32 bits) */
2960 if (!DEM_PUSH_STR(ddata, "decimal32"))
2965 /* IEEE 754r half-precision floating point (16 bits) */
2966 if (!DEM_PUSH_STR(ddata, "half"))
2972 if (!DEM_PUSH_STR(ddata, "char32_t"))
2977 /* std::nullptr_t (i.e., decltype(nullptr)) */
2978 if (!DEM_PUSH_STR(ddata, "decltype(nullptr)"))
2984 if (!DEM_PUSH_STR(ddata, "char16_t"))
2989 /* gcc vector_size extension. */
2991 if (*ddata->cur == '_') {
2993 if (!cpp_demangle_read_expression_flat(ddata,
2996 if (!VEC_PUSH_STR(&v.ext_name, exp_str))
2999 if (!cpp_demangle_read_number_as_string(ddata,
3002 if (!VEC_PUSH_STR(&v.ext_name, num_str))
3005 if (*ddata->cur != '_')
3008 if (!vector_type_qualifier_push(&v, TYPE_VEC))
3020 if (!DEM_PUSH_STR(ddata, "long double"))
3026 /* unexpected end except ref-qualifiers */
3027 if (ddata->ref_qualifier && ddata->is_functype) {
3028 skip_ref_qualifier = true;
3029 /* Pop the delimiter. */
3030 cpp_demangle_pop_str(ddata);
3037 if (!DEM_PUSH_STR(ddata, "float"))
3044 if (!cpp_demangle_read_function(ddata, &extern_c, &v))
3051 if (!DEM_PUSH_STR(ddata, "__float128"))
3058 if (!vector_type_qualifier_push(&v, TYPE_IMG))
3067 if (!DEM_PUSH_STR(ddata, "unsigned char"))
3074 if (!DEM_PUSH_STR(ddata, "int"))
3080 /* template args. */
3081 /* handles <substitute><template-args> */
3082 p_idx = output->size;
3083 if (!cpp_demangle_read_tmpl_args(ddata))
3085 if ((subst_str = vector_str_substr(output, p_idx,
3086 output->size - 1, &subst_str_len)) == NULL)
3088 if (!vector_str_init(&sv)) {
3092 if (!vector_str_push(&sv, subst_str, subst_str_len)) {
3094 vector_str_dest(&sv);
3098 if (!cpp_demangle_push_subst_v(ddata, &sv)) {
3099 vector_str_dest(&sv);
3102 vector_str_dest(&sv);
3107 if (!DEM_PUSH_STR(ddata, "unsigned int"))
3114 if (!vector_type_qualifier_push(&v, TYPE_CST))
3123 if (!DEM_PUSH_STR(ddata, "long"))
3130 if (!DEM_PUSH_STR(ddata, "unsigned long"))
3137 /* pointer to member */
3138 if (!cpp_demangle_read_pointer_to_member(ddata, &v))
3145 if (!DEM_PUSH_STR(ddata, "__int128"))
3151 /* unsigned __int128 */
3152 if (!DEM_PUSH_STR(ddata, "unsigned __int128"))
3158 /* rvalue reference */
3159 if (ddata->ref_qualifier)
3161 if (!vector_type_qualifier_push(&v, TYPE_RREF))
3163 ddata->ref_qualifier = true;
3164 ddata->ref_qualifier_type = TYPE_RREF;
3172 if (!vector_type_qualifier_push(&v, TYPE_PTR))
3181 if (!vector_type_qualifier_push(&v, TYPE_RST))
3190 if (ddata->ref_qualifier)
3192 if (!vector_type_qualifier_push(&v, TYPE_REF))
3194 ddata->ref_qualifier = true;
3195 ddata->ref_qualifier_type = TYPE_REF;
3202 /* short, local string */
3203 if (!DEM_PUSH_STR(ddata, "short"))
3210 if (!cpp_demangle_read_subst(ddata))
3216 /* unsigned short */
3217 if (!DEM_PUSH_STR(ddata, "unsigned short"))
3223 /* template parameter */
3224 if (!cpp_demangle_read_tmpl_param(ddata))
3230 /* vendor extended builtin */
3232 if (!cpp_demangle_read_sname(ddata))
3238 /* vendor extended type qualifier */
3240 if (!cpp_demangle_read_number(ddata, &len))
3244 if (!vector_str_push(&v.ext_name, ddata->cur, len))
3247 if (!vector_type_qualifier_push(&v, TYPE_EXT))
3256 if (td && td->firstp) {
3258 * peek into next bytes and see if we should omit
3262 for (p = ddata->cur + 1; *p != '\0'; p++) {
3265 if (*p != 'R' && *p != 'O') {
3271 if (!omit_void && !DEM_PUSH_STR(ddata, "void"))
3278 if (!vector_type_qualifier_push(&v, TYPE_VAT))
3287 if (!DEM_PUSH_STR(ddata, "wchar_t"))
3294 if (!DEM_PUSH_STR(ddata, "long long"))
3300 /* unsigned long long */
3301 if (!DEM_PUSH_STR(ddata, "unsigned long long"))
3308 if (!DEM_PUSH_STR(ddata, "..."))
3314 if (!cpp_demangle_read_name(ddata))
3320 type_str = vector_str_substr(output, p_idx, output->size - 1,
3323 if (is_builtin == 0) {
3324 if (!vector_str_find(&ddata->subst, type_str, type_str_len) &&
3325 !vector_str_push(&ddata->subst, type_str, type_str_len))
3329 if (!skip_ref_qualifier &&
3330 !cpp_demangle_push_type_qualifier(ddata, &v, type_str))
3339 vector_type_qualifier_dest(&v);
3346 vector_type_qualifier_dest(&v);
3352 cpp_demangle_read_type_flat(struct cpp_demangle_data *ddata, char **str)
3354 struct vector_str *output;
3355 size_t i, p_idx, idx, type_len;
3358 output = ddata->cur_output;
3360 p_idx = output->size;
3362 if (!cpp_demangle_read_type(ddata, NULL))
3365 if ((type = vector_str_substr(output, p_idx, output->size - 1,
3366 &type_len)) == NULL)
3370 for (i = p_idx; i < idx; ++i) {
3371 if (!vector_str_pop(output)) {
3383 * read unqualified-name, unqualified name are operator-name, ctor-dtor-name,
3387 cpp_demangle_read_uqname(struct cpp_demangle_data *ddata)
3391 if (ddata == NULL || *ddata->cur == '\0')
3395 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
3396 case SIMPLE_HASH('a', 'a'):
3398 if (!DEM_PUSH_STR(ddata, "operator&&"))
3403 case SIMPLE_HASH('a', 'd'):
3404 /* operator & (unary) */
3405 if (!DEM_PUSH_STR(ddata, "operator&"))
3410 case SIMPLE_HASH('a', 'n'):
3412 if (!DEM_PUSH_STR(ddata, "operator&"))
3417 case SIMPLE_HASH('a', 'N'):
3419 if (!DEM_PUSH_STR(ddata, "operator&="))
3424 case SIMPLE_HASH('a', 'S'):
3426 if (!DEM_PUSH_STR(ddata, "operator="))
3431 case SIMPLE_HASH('c', 'l'):
3433 if (!DEM_PUSH_STR(ddata, "operator()"))
3438 case SIMPLE_HASH('c', 'm'):
3440 if (!DEM_PUSH_STR(ddata, "operator,"))
3445 case SIMPLE_HASH('c', 'o'):
3447 if (!DEM_PUSH_STR(ddata, "operator~"))
3452 case SIMPLE_HASH('c', 'v'):
3453 /* operator (cast) */
3454 if (!DEM_PUSH_STR(ddata, "operator(cast)"))
3457 return (cpp_demangle_read_type(ddata, NULL));
3459 case SIMPLE_HASH('d', 'a'):
3460 /* operator delete [] */
3461 if (!DEM_PUSH_STR(ddata, "operator delete []"))
3466 case SIMPLE_HASH('d', 'e'):
3467 /* operator * (unary) */
3468 if (!DEM_PUSH_STR(ddata, "operator*"))
3473 case SIMPLE_HASH('d', 'l'):
3474 /* operator delete */
3475 if (!DEM_PUSH_STR(ddata, "operator delete"))
3480 case SIMPLE_HASH('d', 'v'):
3482 if (!DEM_PUSH_STR(ddata, "operator/"))
3487 case SIMPLE_HASH('d', 'V'):
3489 if (!DEM_PUSH_STR(ddata, "operator/="))
3494 case SIMPLE_HASH('e', 'o'):
3496 if (!DEM_PUSH_STR(ddata, "operator^"))
3501 case SIMPLE_HASH('e', 'O'):
3503 if (!DEM_PUSH_STR(ddata, "operator^="))
3508 case SIMPLE_HASH('e', 'q'):
3510 if (!DEM_PUSH_STR(ddata, "operator=="))
3515 case SIMPLE_HASH('g', 'e'):
3517 if (!DEM_PUSH_STR(ddata, "operator>="))
3522 case SIMPLE_HASH('g', 't'):
3524 if (!DEM_PUSH_STR(ddata, "operator>"))
3529 case SIMPLE_HASH('i', 'x'):
3531 if (!DEM_PUSH_STR(ddata, "operator[]"))
3536 case SIMPLE_HASH('l', 'e'):
3538 if (!DEM_PUSH_STR(ddata, "operator<="))
3543 case SIMPLE_HASH('l', 's'):
3545 if (!DEM_PUSH_STR(ddata, "operator<<"))
3550 case SIMPLE_HASH('l', 'S'):
3552 if (!DEM_PUSH_STR(ddata, "operator<<="))
3557 case SIMPLE_HASH('l', 't'):
3559 if (!DEM_PUSH_STR(ddata, "operator<"))
3564 case SIMPLE_HASH('m', 'i'):
3566 if (!DEM_PUSH_STR(ddata, "operator-"))
3571 case SIMPLE_HASH('m', 'I'):
3573 if (!DEM_PUSH_STR(ddata, "operator-="))
3578 case SIMPLE_HASH('m', 'l'):
3580 if (!DEM_PUSH_STR(ddata, "operator*"))
3585 case SIMPLE_HASH('m', 'L'):
3587 if (!DEM_PUSH_STR(ddata, "operator*="))
3592 case SIMPLE_HASH('m', 'm'):
3594 if (!DEM_PUSH_STR(ddata, "operator--"))
3599 case SIMPLE_HASH('n', 'a'):
3600 /* operator new[] */
3601 if (!DEM_PUSH_STR(ddata, "operator new []"))
3606 case SIMPLE_HASH('n', 'e'):
3608 if (!DEM_PUSH_STR(ddata, "operator!="))
3613 case SIMPLE_HASH('n', 'g'):
3614 /* operator - (unary) */
3615 if (!DEM_PUSH_STR(ddata, "operator-"))
3620 case SIMPLE_HASH('n', 't'):
3622 if (!DEM_PUSH_STR(ddata, "operator!"))
3627 case SIMPLE_HASH('n', 'w'):
3629 if (!DEM_PUSH_STR(ddata, "operator new"))
3634 case SIMPLE_HASH('o', 'o'):
3636 if (!DEM_PUSH_STR(ddata, "operator||"))
3641 case SIMPLE_HASH('o', 'r'):
3643 if (!DEM_PUSH_STR(ddata, "operator|"))
3648 case SIMPLE_HASH('o', 'R'):
3650 if (!DEM_PUSH_STR(ddata, "operator|="))
3655 case SIMPLE_HASH('p', 'l'):
3657 if (!DEM_PUSH_STR(ddata, "operator+"))
3662 case SIMPLE_HASH('p', 'L'):
3664 if (!DEM_PUSH_STR(ddata, "operator+="))
3669 case SIMPLE_HASH('p', 'm'):
3671 if (!DEM_PUSH_STR(ddata, "operator->*"))
3676 case SIMPLE_HASH('p', 'p'):
3678 if (!DEM_PUSH_STR(ddata, "operator++"))
3683 case SIMPLE_HASH('p', 's'):
3684 /* operator + (unary) */
3685 if (!DEM_PUSH_STR(ddata, "operator+"))
3690 case SIMPLE_HASH('p', 't'):
3692 if (!DEM_PUSH_STR(ddata, "operator->"))
3697 case SIMPLE_HASH('q', 'u'):
3699 if (!DEM_PUSH_STR(ddata, "operator?"))
3704 case SIMPLE_HASH('r', 'm'):
3706 if (!DEM_PUSH_STR(ddata, "operator%"))
3711 case SIMPLE_HASH('r', 'M'):
3713 if (!DEM_PUSH_STR(ddata, "operator%="))
3718 case SIMPLE_HASH('r', 's'):
3720 if (!DEM_PUSH_STR(ddata, "operator>>"))
3725 case SIMPLE_HASH('r', 'S'):
3727 if (!DEM_PUSH_STR(ddata, "operator>>="))
3732 case SIMPLE_HASH('r', 'z'):
3733 /* operator sizeof */
3734 if (!DEM_PUSH_STR(ddata, "operator sizeof "))
3739 case SIMPLE_HASH('s', 'r'):
3740 /* scope resolution operator */
3741 if (!DEM_PUSH_STR(ddata, "scope resolution operator "))
3746 case SIMPLE_HASH('s', 'v'):
3747 /* operator sizeof */
3748 if (!DEM_PUSH_STR(ddata, "operator sizeof "))
3754 /* vendor extened operator */
3755 if (*ddata->cur == 'v' && ELFTC_ISDIGIT(*(ddata->cur + 1))) {
3756 if (!DEM_PUSH_STR(ddata, "vendor extened operator "))
3758 if (!cpp_demangle_push_str(ddata, ddata->cur + 1, 1))
3761 return (cpp_demangle_read_sname(ddata));
3764 /* ctor-dtor-name */
3765 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
3766 case SIMPLE_HASH('C', '1'):
3767 case SIMPLE_HASH('C', '2'):
3768 case SIMPLE_HASH('C', '3'):
3769 if (ddata->last_sname == NULL)
3771 if ((len = strlen(ddata->last_sname)) == 0)
3773 if (!DEM_PUSH_STR(ddata, "::"))
3775 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
3780 case SIMPLE_HASH('D', '0'):
3781 case SIMPLE_HASH('D', '1'):
3782 case SIMPLE_HASH('D', '2'):
3783 if (ddata->last_sname == NULL)
3785 if ((len = strlen(ddata->last_sname)) == 0)
3787 if (!DEM_PUSH_STR(ddata, "::~"))
3789 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
3796 if (ELFTC_ISDIGIT(*ddata->cur) != 0)
3797 return (cpp_demangle_read_sname(ddata));
3799 /* local source name */
3800 if (*ddata->cur == 'L')
3801 return (cpp_demangle_local_source_name(ddata));
3807 * Read local source name.
3810 * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31775
3811 * http://gcc.gnu.org/viewcvs?view=rev&revision=124467
3814 cpp_demangle_local_source_name(struct cpp_demangle_data *ddata)
3817 if (ddata == NULL || *ddata->cur != 'L')
3822 if (!cpp_demangle_read_sname(ddata))
3826 if (*ddata->cur == '_') {
3828 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
3836 cpp_demangle_read_v_offset(struct cpp_demangle_data *ddata)
3842 if (!DEM_PUSH_STR(ddata, "offset : "))
3845 if (!cpp_demangle_read_offset_number(ddata))
3848 if (!DEM_PUSH_STR(ddata, "virtual offset : "))
3851 return (!cpp_demangle_read_offset_number(ddata));
3855 * Decode floating point representation to string
3856 * Return new allocated string or NULL
3859 * Replace these functions to macro.
3862 decode_fp_to_double(const char *p, size_t len)
3865 size_t rtn_len, limit, i;
3869 if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(double))
3872 memset(&f, 0, sizeof(double));
3874 for (i = 0; i < len / 2; ++i) {
3875 byte = hex_to_dec(p[len - i * 2 - 1]) +
3876 hex_to_dec(p[len - i * 2 - 2]) * 16;
3878 if (byte < 0 || byte > 255)
3881 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3882 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3883 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3884 ((unsigned char *)&f)[sizeof(double) - i - 1] =
3885 (unsigned char)(byte);
3886 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3892 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3895 if (snprintf(rtn, rtn_len, "%fld", f) >= (int)rtn_len) {
3897 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3899 rtn_len *= BUFFER_GROWFACTOR;
3907 decode_fp_to_float(const char *p, size_t len)
3909 size_t i, rtn_len, limit;
3914 if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(float))
3917 memset(&f, 0, sizeof(float));
3919 for (i = 0; i < len / 2; ++i) {
3920 byte = hex_to_dec(p[len - i * 2 - 1]) +
3921 hex_to_dec(p[len - i * 2 - 2]) * 16;
3922 if (byte < 0 || byte > 255)
3924 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3925 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3926 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3927 ((unsigned char *)&f)[sizeof(float) - i - 1] =
3928 (unsigned char)(byte);
3929 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3935 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3938 if (snprintf(rtn, rtn_len, "%ff", f) >= (int)rtn_len) {
3940 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3942 rtn_len *= BUFFER_GROWFACTOR;
3950 decode_fp_to_float128(const char *p, size_t len)
3953 size_t rtn_len, limit, i;
3955 unsigned char buf[FLOAT_QUADRUPLE_BYTES];
3958 switch(sizeof(long double)) {
3959 case FLOAT_QUADRUPLE_BYTES:
3960 return (decode_fp_to_long_double(p, len));
3961 case FLOAT_EXTENED_BYTES:
3962 if (p == NULL || len == 0 || len % 2 != 0 ||
3963 len / 2 > FLOAT_QUADRUPLE_BYTES)
3966 memset(buf, 0, FLOAT_QUADRUPLE_BYTES);
3968 for (i = 0; i < len / 2; ++i) {
3969 byte = hex_to_dec(p[len - i * 2 - 1]) +
3970 hex_to_dec(p[len - i * 2 - 2]) * 16;
3971 if (byte < 0 || byte > 255)
3973 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3974 buf[i] = (unsigned char)(byte);
3975 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3976 buf[FLOAT_QUADRUPLE_BYTES - i -1] =
3977 (unsigned char)(byte);
3978 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3980 memset(&f, 0, FLOAT_EXTENED_BYTES);
3982 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3983 memcpy(&f, buf, FLOAT_EXTENED_BYTES);
3984 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3985 memcpy(&f, buf + 6, FLOAT_EXTENED_BYTES);
3986 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3991 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3994 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3996 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3998 rtn_len *= BUFFER_GROWFACTOR;
4009 decode_fp_to_float80(const char *p, size_t len)
4012 size_t rtn_len, limit, i;
4014 unsigned char buf[FLOAT_EXTENED_BYTES];
4017 switch(sizeof(long double)) {
4018 case FLOAT_QUADRUPLE_BYTES:
4019 if (p == NULL || len == 0 || len % 2 != 0 ||
4020 len / 2 > FLOAT_EXTENED_BYTES)
4023 memset(buf, 0, FLOAT_EXTENED_BYTES);
4025 for (i = 0; i < len / 2; ++i) {
4026 byte = hex_to_dec(p[len - i * 2 - 1]) +
4027 hex_to_dec(p[len - i * 2 - 2]) * 16;
4029 if (byte < 0 || byte > 255)
4032 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
4033 buf[i] = (unsigned char)(byte);
4034 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
4035 buf[FLOAT_EXTENED_BYTES - i -1] =
4036 (unsigned char)(byte);
4037 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
4040 memset(&f, 0, FLOAT_QUADRUPLE_BYTES);
4042 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
4043 memcpy(&f, buf, FLOAT_EXTENED_BYTES);
4044 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
4045 memcpy((unsigned char *)(&f) + 6, buf, FLOAT_EXTENED_BYTES);
4046 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
4051 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
4054 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
4056 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
4058 rtn_len *= BUFFER_GROWFACTOR;
4063 case FLOAT_EXTENED_BYTES:
4064 return (decode_fp_to_long_double(p, len));
4071 decode_fp_to_long_double(const char *p, size_t len)
4074 size_t rtn_len, limit, i;
4078 if (p == NULL || len == 0 || len % 2 != 0 ||
4079 len / 2 > sizeof(long double))
4082 memset(&f, 0, sizeof(long double));
4084 for (i = 0; i < len / 2; ++i) {
4085 byte = hex_to_dec(p[len - i * 2 - 1]) +
4086 hex_to_dec(p[len - i * 2 - 2]) * 16;
4088 if (byte < 0 || byte > 255)
4091 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
4092 ((unsigned char *)&f)[i] = (unsigned char)(byte);
4093 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
4094 ((unsigned char *)&f)[sizeof(long double) - i - 1] =
4095 (unsigned char)(byte);
4096 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
4102 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
4105 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
4107 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
4109 rtn_len *= BUFFER_GROWFACTOR;
4116 /* Simple hex to integer function used by decode_to_* function. */
4160 * @brief Test input string is mangled by IA-64 C++ ABI style.
4162 * Test string heads with "_Z" or "_GLOBAL__I_".
4163 * @return Return 0 at false.
4166 is_cpp_mangled_gnu3(const char *org)
4171 return ((len > 2 && *org == '_' && *(org + 1) == 'Z') ||
4172 (len > 11 && !strncmp(org, "_GLOBAL__I_", 11)));
4176 vector_read_cmd_dest(struct vector_read_cmd *v)
4182 free(v->r_container);
4185 static struct read_cmd_item *
4186 vector_read_cmd_find(struct vector_read_cmd *v, enum read_cmd dst)
4190 if (v == NULL || dst == READ_FAIL)
4193 for (i = (int) v->size - 1; i >= 0; i--)
4194 if (v->r_container[i].cmd == dst)
4195 return (&v->r_container[i]);
4201 vector_read_cmd_init(struct vector_read_cmd *v)
4208 v->capacity = VECTOR_DEF_CAPACITY;
4210 if ((v->r_container = malloc(sizeof(*v->r_container) * v->capacity))
4218 vector_read_cmd_pop(struct vector_read_cmd *v)
4221 if (v == NULL || v->size == 0)
4225 v->r_container[v->size].cmd = READ_FAIL;
4226 v->r_container[v->size].data = NULL;
4232 vector_read_cmd_push(struct vector_read_cmd *v, enum read_cmd cmd, void *data)
4234 struct read_cmd_item *tmp_r_ctn;
4241 if (v->size == v->capacity) {
4242 tmp_cap = BUFFER_GROW(v->capacity);
4243 if ((tmp_r_ctn = malloc(sizeof(*tmp_r_ctn) * tmp_cap)) == NULL)
4245 for (i = 0; i < v->size; ++i)
4246 tmp_r_ctn[i] = v->r_container[i];
4247 free(v->r_container);
4248 v->r_container = tmp_r_ctn;
4249 v->capacity = tmp_cap;
4252 v->r_container[v->size].cmd = cmd;
4253 v->r_container[v->size].data = data;
4260 vector_type_qualifier_dest(struct vector_type_qualifier *v)
4266 free(v->q_container);
4267 vector_str_dest(&v->ext_name);
4270 /* size, capacity, ext_name */
4272 vector_type_qualifier_init(struct vector_type_qualifier *v)
4279 v->capacity = VECTOR_DEF_CAPACITY;
4281 if ((v->q_container = malloc(sizeof(enum type_qualifier) * v->capacity))
4285 assert(v->q_container != NULL);
4287 if (!vector_str_init(&v->ext_name)) {
4288 free(v->q_container);
4296 vector_type_qualifier_push(struct vector_type_qualifier *v,
4297 enum type_qualifier t)
4299 enum type_qualifier *tmp_ctn;
4306 if (v->size == v->capacity) {
4307 tmp_cap = BUFFER_GROW(v->capacity);
4308 if ((tmp_ctn = malloc(sizeof(enum type_qualifier) * tmp_cap))
4311 for (i = 0; i < v->size; ++i)
4312 tmp_ctn[i] = v->q_container[i];
4313 free(v->q_container);
4314 v->q_container = tmp_ctn;
4315 v->capacity = tmp_cap;
4318 v->q_container[v->size] = t;