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 #include "_libelftc.h"
40 ELFTC_VCSID("$Id: libelftc_dem_gnu3.c 3560 2017-06-25 00:28:23Z kaiwang27 $");
43 * @file cpp_demangle.c
44 * @brief Decode IA-64 C++ ABI style implementation.
46 * IA-64 standard ABI(Itanium C++ ABI) references.
48 * http://www.codesourcery.com/cxx-abi/abi.html#mangling \n
49 * http://www.codesourcery.com/cxx-abi/abi-mangling.html
53 TYPE_PTR, TYPE_REF, TYPE_CMX, TYPE_IMG, TYPE_EXT, TYPE_RST, TYPE_VAT,
54 TYPE_CST, TYPE_VEC, TYPE_RREF
57 struct vector_type_qualifier {
58 size_t size, capacity;
59 enum type_qualifier *q_container;
60 struct vector_str ext_name;
64 READ_FAIL, READ_NEST, READ_TMPL, READ_EXPR, READ_EXPL, READ_LOCAL,
65 READ_TYPE, READ_FUNC, READ_PTRMEM
68 struct read_cmd_item {
73 struct vector_read_cmd {
74 size_t size, capacity;
75 struct read_cmd_item *r_container;
81 PUSH_NON_CV_QUALIFIER,
84 struct cpp_demangle_data {
85 struct vector_str output; /* output string vector */
86 struct vector_str subst; /* substitution string vector */
87 struct vector_str tmpl;
88 struct vector_str class_type;
89 struct vector_str *cur_output; /* ptr to current output vec */
90 struct vector_read_cmd cmd;
91 bool mem_rst; /* restrict member function */
92 bool mem_vat; /* volatile member function */
93 bool mem_cst; /* const member function */
94 bool mem_ref; /* lvalue-ref member func */
95 bool mem_rref; /* rvalue-ref member func */
96 bool is_tmpl; /* template args */
97 bool is_functype; /* function type */
98 bool ref_qualifier; /* ref qualifier */
99 enum type_qualifier ref_qualifier_type; /* ref qualifier type */
100 enum push_qualifier push_qualifier; /* which qualifiers to push */
102 const char *cur; /* current mangled name ptr */
103 const char *last_sname; /* last source name */
106 struct type_delimit {
111 #define CPP_DEMANGLE_TRY_LIMIT 128
112 #define FLOAT_SPRINTF_TRY_LIMIT 5
113 #define FLOAT_QUADRUPLE_BYTES 16
114 #define FLOAT_EXTENED_BYTES 10
116 #define SIMPLE_HASH(x,y) (64 * x + y)
117 #define DEM_PUSH_STR(d,s) cpp_demangle_push_str((d), (s), strlen((s)))
118 #define VEC_PUSH_STR(d,s) vector_str_push((d), (s), strlen((s)))
120 static void cpp_demangle_data_dest(struct cpp_demangle_data *);
121 static int cpp_demangle_data_init(struct cpp_demangle_data *,
123 static int cpp_demangle_get_subst(struct cpp_demangle_data *, size_t);
124 static int cpp_demangle_get_tmpl_param(struct cpp_demangle_data *, size_t);
125 static int cpp_demangle_push_fp(struct cpp_demangle_data *,
126 char *(*)(const char *, size_t));
127 static int cpp_demangle_push_str(struct cpp_demangle_data *, const char *,
129 static int cpp_demangle_pop_str(struct cpp_demangle_data *);
130 static int cpp_demangle_push_subst(struct cpp_demangle_data *,
131 const char *, size_t);
132 static int cpp_demangle_push_subst_v(struct cpp_demangle_data *,
133 struct vector_str *);
134 static int cpp_demangle_push_type_qualifier(struct cpp_demangle_data *,
135 struct vector_type_qualifier *, const char *);
136 static int cpp_demangle_read_array(struct cpp_demangle_data *);
137 static int cpp_demangle_read_encoding(struct cpp_demangle_data *);
138 static int cpp_demangle_read_expr_primary(struct cpp_demangle_data *);
139 static int cpp_demangle_read_expression(struct cpp_demangle_data *);
140 static int cpp_demangle_read_expression_flat(struct cpp_demangle_data *,
142 static int cpp_demangle_read_expression_binary(struct cpp_demangle_data *,
143 const char *, size_t);
144 static int cpp_demangle_read_expression_unary(struct cpp_demangle_data *,
145 const char *, size_t);
146 static int cpp_demangle_read_expression_trinary(struct cpp_demangle_data *,
147 const char *, size_t, const char *, size_t);
148 static int cpp_demangle_read_function(struct cpp_demangle_data *, int *,
149 struct vector_type_qualifier *);
150 static int cpp_demangle_local_source_name(struct cpp_demangle_data *ddata);
151 static int cpp_demangle_read_local_name(struct cpp_demangle_data *);
152 static int cpp_demangle_read_name(struct cpp_demangle_data *);
153 static int cpp_demangle_read_name_flat(struct cpp_demangle_data *,
155 static int cpp_demangle_read_nested_name(struct cpp_demangle_data *);
156 static int cpp_demangle_read_number(struct cpp_demangle_data *, long *);
157 static int cpp_demangle_read_number_as_string(struct cpp_demangle_data *,
159 static int cpp_demangle_read_nv_offset(struct cpp_demangle_data *);
160 static int cpp_demangle_read_offset(struct cpp_demangle_data *);
161 static int cpp_demangle_read_offset_number(struct cpp_demangle_data *);
162 static int cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *,
163 struct vector_type_qualifier *);
164 static int cpp_demangle_read_sname(struct cpp_demangle_data *);
165 static int cpp_demangle_read_subst(struct cpp_demangle_data *);
166 static int cpp_demangle_read_subst_std(struct cpp_demangle_data *);
167 static int cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *,
169 static int cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *);
170 static int cpp_demangle_read_tmpl_args(struct cpp_demangle_data *);
171 static int cpp_demangle_read_tmpl_param(struct cpp_demangle_data *);
172 static int cpp_demangle_read_type(struct cpp_demangle_data *,
173 struct type_delimit *);
174 static int cpp_demangle_read_type_flat(struct cpp_demangle_data *,
176 static int cpp_demangle_read_uqname(struct cpp_demangle_data *);
177 static int cpp_demangle_read_v_offset(struct cpp_demangle_data *);
178 static char *decode_fp_to_double(const char *, size_t);
179 static char *decode_fp_to_float(const char *, size_t);
180 static char *decode_fp_to_float128(const char *, size_t);
181 static char *decode_fp_to_float80(const char *, size_t);
182 static char *decode_fp_to_long_double(const char *, size_t);
183 static int hex_to_dec(char);
184 static void vector_read_cmd_dest(struct vector_read_cmd *);
185 static struct read_cmd_item *vector_read_cmd_find(struct vector_read_cmd *,
187 static int vector_read_cmd_init(struct vector_read_cmd *);
188 static int vector_read_cmd_pop(struct vector_read_cmd *);
189 static int vector_read_cmd_push(struct vector_read_cmd *, enum read_cmd,
191 static void vector_type_qualifier_dest(struct vector_type_qualifier *);
192 static int vector_type_qualifier_init(struct vector_type_qualifier *);
193 static int vector_type_qualifier_push(struct vector_type_qualifier *,
194 enum type_qualifier);
197 * @brief Decode the input string by IA-64 C++ ABI style.
199 * GNU GCC v3 use IA-64 standard ABI.
200 * @return New allocated demangled string or NULL if failed.
201 * @todo 1. Testing and more test case. 2. Code cleaning.
204 cpp_demangle_gnu3(const char *org)
206 struct cpp_demangle_data ddata;
207 struct vector_str ret_type;
208 struct type_delimit td;
212 bool has_ret, more_type;
214 if (org == NULL || (org_len = strlen(org)) < 2)
217 if (org_len > 11 && !strncmp(org, "_GLOBAL__I_", 11)) {
218 if ((rtn = malloc(org_len + 19)) == NULL)
220 snprintf(rtn, org_len + 19,
221 "global constructors keyed to %s", org + 11);
225 if (org[0] != '_' || org[1] != 'Z')
228 if (!cpp_demangle_data_init(&ddata, org + 2))
232 has_ret = more_type = false;
234 if (!cpp_demangle_read_encoding(&ddata))
238 * Pop function name from substitution candidate list.
240 if (*ddata.cur != 0 && ddata.subst.size >= 1) {
241 if (!vector_str_pop(&ddata.subst))
250 * The first type is a return type if we just demangled template
251 * args. (the template args is right next to the function name,
252 * which means it's a template function)
255 ddata.is_tmpl = false;
256 if (!vector_str_init(&ret_type))
258 ddata.cur_output = &ret_type;
262 while (*ddata.cur != '\0') {
264 * Breaking at some gcc info at tail. e.g) @@GLIBCXX_3.4
266 if (*ddata.cur == '@' && *(ddata.cur + 1) == '@')
270 /* Read return type */
271 if (!cpp_demangle_read_type(&ddata, NULL))
274 /* Read function arg type */
275 if (!cpp_demangle_read_type(&ddata, &td))
280 /* Push return type to the beginning */
281 if (!VEC_PUSH_STR(&ret_type, " "))
283 if (!vector_str_push_vector_head(&ddata.output,
286 ddata.cur_output = &ddata.output;
287 vector_str_dest(&ret_type);
290 } else if (more_type)
292 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
298 if (ddata.output.size == 0)
300 if (td.paren && !VEC_PUSH_STR(&ddata.output, ")"))
302 if (ddata.mem_vat && !VEC_PUSH_STR(&ddata.output, " volatile"))
304 if (ddata.mem_cst && !VEC_PUSH_STR(&ddata.output, " const"))
306 if (ddata.mem_rst && !VEC_PUSH_STR(&ddata.output, " restrict"))
308 if (ddata.mem_ref && !VEC_PUSH_STR(&ddata.output, " &"))
310 if (ddata.mem_rref && !VEC_PUSH_STR(&ddata.output, " &&"))
313 rtn = vector_str_get_flat(&ddata.output, (size_t *) NULL);
317 vector_str_dest(&ret_type);
319 cpp_demangle_data_dest(&ddata);
325 cpp_demangle_data_dest(struct cpp_demangle_data *d)
331 vector_read_cmd_dest(&d->cmd);
332 vector_str_dest(&d->class_type);
333 vector_str_dest(&d->tmpl);
334 vector_str_dest(&d->subst);
335 vector_str_dest(&d->output);
339 cpp_demangle_data_init(struct cpp_demangle_data *d, const char *cur)
342 if (d == NULL || cur == NULL)
345 if (!vector_str_init(&d->output))
347 if (!vector_str_init(&d->subst))
349 if (!vector_str_init(&d->tmpl))
351 if (!vector_str_init(&d->class_type))
353 if (!vector_read_cmd_init(&d->cmd))
356 assert(d->output.container != NULL);
357 assert(d->subst.container != NULL);
358 assert(d->tmpl.container != NULL);
359 assert(d->class_type.container != NULL);
367 d->is_functype = false;
368 d->ref_qualifier = false;
369 d->push_qualifier = PUSH_ALL_QUALIFIER;
372 d->cur_output = &d->output;
373 d->last_sname = NULL;
378 vector_str_dest(&d->class_type);
380 vector_str_dest(&d->tmpl);
382 vector_str_dest(&d->subst);
384 vector_str_dest(&d->output);
390 cpp_demangle_push_fp(struct cpp_demangle_data *ddata,
391 char *(*decoder)(const char *, size_t))
398 if (ddata == NULL || decoder == NULL)
402 while (*ddata->cur != 'E')
405 if ((f = decoder(fp, ddata->cur - fp)) == NULL)
409 if ((len = strlen(f)) > 0)
410 rtn = cpp_demangle_push_str(ddata, f, len);
420 cpp_demangle_push_str(struct cpp_demangle_data *ddata, const char *str,
424 if (ddata == NULL || str == NULL || len == 0)
428 * is_tmpl is used to check if the type (function arg) is right next
429 * to template args, and should always be cleared whenever new string
432 ddata->is_tmpl = false;
434 return (vector_str_push(ddata->cur_output, str, len));
438 cpp_demangle_pop_str(struct cpp_demangle_data *ddata)
444 return (vector_str_pop(ddata->cur_output));
448 cpp_demangle_push_subst(struct cpp_demangle_data *ddata, const char *str,
452 if (ddata == NULL || str == NULL || len == 0)
455 if (!vector_str_find(&ddata->subst, str, len))
456 return (vector_str_push(&ddata->subst, str, len));
462 cpp_demangle_push_subst_v(struct cpp_demangle_data *ddata, struct vector_str *v)
468 if (ddata == NULL || v == NULL)
471 if ((str = vector_str_get_flat(v, &str_len)) == NULL)
474 rtn = cpp_demangle_push_subst(ddata, str, str_len);
482 cpp_demangle_push_type_qualifier(struct cpp_demangle_data *ddata,
483 struct vector_type_qualifier *v, const char *type_str)
485 struct vector_str subst_v;
486 enum type_qualifier t;
487 size_t idx, e_idx, e_len;
492 if (ddata == NULL || v == NULL)
495 if ((idx = v->size) == 0)
499 if (type_str != NULL) {
500 if (!vector_str_init(&subst_v))
502 if (!VEC_PUSH_STR(&subst_v, type_str))
509 switch (v->q_container[idx - 1]) {
512 if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
514 if (!DEM_PUSH_STR(ddata, "*"))
516 if (type_str != NULL) {
517 if (!VEC_PUSH_STR(&subst_v, "*"))
519 if (!cpp_demangle_push_subst_v(ddata,
527 if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
529 if (!DEM_PUSH_STR(ddata, "&"))
531 if (type_str != NULL) {
532 if (!VEC_PUSH_STR(&subst_v, "&"))
534 if (!cpp_demangle_push_subst_v(ddata,
542 if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
544 if (!DEM_PUSH_STR(ddata, "&&"))
546 if (type_str != NULL) {
547 if (!VEC_PUSH_STR(&subst_v, "&&"))
549 if (!cpp_demangle_push_subst_v(ddata,
557 if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
559 if (!DEM_PUSH_STR(ddata, " complex"))
561 if (type_str != NULL) {
562 if (!VEC_PUSH_STR(&subst_v, " complex"))
564 if (!cpp_demangle_push_subst_v(ddata,
572 if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
574 if (!DEM_PUSH_STR(ddata, " imaginary"))
576 if (type_str != NULL) {
577 if (!vector_str_push(&subst_v, " imaginary",
580 if (!cpp_demangle_push_subst_v(ddata,
588 if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
590 if (v->ext_name.size == 0 ||
591 e_idx > v->ext_name.size - 1)
593 if ((e_len = strlen(v->ext_name.container[e_idx])) ==
596 if ((buf = malloc(e_len + 2)) == NULL)
598 snprintf(buf, e_len + 2, " %s",
599 v->ext_name.container[e_idx]);
601 if (!DEM_PUSH_STR(ddata, buf)) {
606 if (type_str != NULL) {
607 if (!VEC_PUSH_STR(&subst_v, buf)) {
611 if (!cpp_demangle_push_subst_v(ddata,
622 if (ddata->push_qualifier == PUSH_NON_CV_QUALIFIER &&
625 if (ddata->push_qualifier == PUSH_CV_QUALIFIER && !cv)
627 if (!DEM_PUSH_STR(ddata, " restrict"))
629 if (type_str != NULL) {
630 if (!VEC_PUSH_STR(&subst_v, " restrict"))
633 t = v->q_container[idx - 2];
634 if (t == TYPE_RST || t == TYPE_VAT ||
638 if (!cpp_demangle_push_subst_v(ddata,
645 if (ddata->push_qualifier == PUSH_NON_CV_QUALIFIER &&
648 if (ddata->push_qualifier == PUSH_CV_QUALIFIER && !cv)
650 if (!DEM_PUSH_STR(ddata, " volatile"))
652 if (type_str != NULL) {
653 if (!VEC_PUSH_STR(&subst_v, " volatile"))
656 t = v->q_container[idx - 2];
657 if (t == TYPE_RST || t == TYPE_VAT ||
661 if (!cpp_demangle_push_subst_v(ddata,
668 if (ddata->push_qualifier == PUSH_NON_CV_QUALIFIER &&
671 if (ddata->push_qualifier == PUSH_CV_QUALIFIER && !cv)
673 if (!DEM_PUSH_STR(ddata, " const"))
675 if (type_str != NULL) {
676 if (!VEC_PUSH_STR(&subst_v, " const"))
679 t = v->q_container[idx - 2];
680 if (t == TYPE_RST || t == TYPE_VAT ||
684 if (!cpp_demangle_push_subst_v(ddata,
692 if (ddata->push_qualifier == PUSH_CV_QUALIFIER)
694 if (v->ext_name.size == 0 ||
695 e_idx > v->ext_name.size - 1)
697 if ((e_len = strlen(v->ext_name.container[e_idx])) ==
700 if ((buf = malloc(e_len + 12)) == NULL)
702 snprintf(buf, e_len + 12, " __vector(%s)",
703 v->ext_name.container[e_idx]);
704 if (!DEM_PUSH_STR(ddata, buf)) {
708 if (type_str != NULL) {
709 if (!VEC_PUSH_STR(&subst_v, buf)) {
713 if (!cpp_demangle_push_subst_v(ddata,
728 if (type_str != NULL)
729 vector_str_dest(&subst_v);
735 cpp_demangle_get_subst(struct cpp_demangle_data *ddata, size_t idx)
739 if (ddata == NULL || ddata->subst.size <= idx)
741 if ((len = strlen(ddata->subst.container[idx])) == 0)
743 if (!cpp_demangle_push_str(ddata, ddata->subst.container[idx], len))
753 cpp_demangle_get_tmpl_param(struct cpp_demangle_data *ddata, size_t idx)
757 if (ddata == NULL || ddata->tmpl.size <= idx)
759 if ((len = strlen(ddata->tmpl.container[idx])) == 0)
761 if (!cpp_demangle_push_str(ddata, ddata->tmpl.container[idx], len))
770 cpp_demangle_read_array(struct cpp_demangle_data *ddata)
772 size_t i, num_len, exp_len, p_idx, idx;
776 if (ddata == NULL || *(++ddata->cur) == '\0')
779 if (*ddata->cur == '_') {
780 if (*(++ddata->cur) == '\0')
783 if (!cpp_demangle_read_type(ddata, NULL))
786 if (!DEM_PUSH_STR(ddata, "[]"))
789 if (ELFTC_ISDIGIT(*ddata->cur) != 0) {
791 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
793 if (*ddata->cur != '_')
795 num_len = ddata->cur - num;
797 if (*(++ddata->cur) == '\0')
799 if (!cpp_demangle_read_type(ddata, NULL))
801 if (!DEM_PUSH_STR(ddata, "["))
803 if (!cpp_demangle_push_str(ddata, num, num_len))
805 if (!DEM_PUSH_STR(ddata, "]"))
808 p_idx = ddata->output.size;
809 if (!cpp_demangle_read_expression(ddata))
811 if ((exp = vector_str_substr(&ddata->output, p_idx,
812 ddata->output.size - 1, &exp_len)) == NULL)
814 idx = ddata->output.size;
815 for (i = p_idx; i < idx; ++i)
816 if (!vector_str_pop(&ddata->output)) {
820 if (*ddata->cur != '_') {
825 if (*ddata->cur == '\0') {
829 if (!cpp_demangle_read_type(ddata, NULL)) {
833 if (!DEM_PUSH_STR(ddata, "[")) {
837 if (!cpp_demangle_push_str(ddata, exp, exp_len)) {
841 if (!DEM_PUSH_STR(ddata, "]")) {
853 cpp_demangle_read_expr_primary(struct cpp_demangle_data *ddata)
857 if (ddata == NULL || *(++ddata->cur) == '\0')
860 if (*ddata->cur == '_' && *(ddata->cur + 1) == 'Z') {
862 if (*ddata->cur == '\0')
864 if (!cpp_demangle_read_encoding(ddata))
870 switch (*ddata->cur) {
872 if (*(ddata->cur + 2) != 'E')
874 switch (*(++ddata->cur)) {
877 return (DEM_PUSH_STR(ddata, "false"));
880 return (DEM_PUSH_STR(ddata, "true"));
887 return (cpp_demangle_push_fp(ddata, decode_fp_to_double));
891 if (sizeof(long double) == 10)
892 return (cpp_demangle_push_fp(ddata,
893 decode_fp_to_double));
894 return (cpp_demangle_push_fp(ddata, decode_fp_to_float80));
898 return (cpp_demangle_push_fp(ddata, decode_fp_to_float));
902 if (sizeof(long double) == 16)
903 return (cpp_demangle_push_fp(ddata,
904 decode_fp_to_double));
905 return (cpp_demangle_push_fp(ddata, decode_fp_to_float128));
916 if (*(++ddata->cur) == 'n') {
917 if (!DEM_PUSH_STR(ddata, "-"))
922 while (*ddata->cur != 'E') {
923 if (!ELFTC_ISDIGIT(*ddata->cur))
928 return (cpp_demangle_push_str(ddata, num,
929 ddata->cur - num - 1));
937 cpp_demangle_read_expression(struct cpp_demangle_data *ddata)
940 if (ddata == NULL || *ddata->cur == '\0')
943 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
944 case SIMPLE_HASH('s', 't'):
946 return (cpp_demangle_read_type(ddata, NULL));
948 case SIMPLE_HASH('s', 'r'):
950 if (!cpp_demangle_read_type(ddata, NULL))
952 if (!cpp_demangle_read_uqname(ddata))
954 if (*ddata->cur == 'I')
955 return (cpp_demangle_read_tmpl_args(ddata));
958 case SIMPLE_HASH('a', 'a'):
961 return (cpp_demangle_read_expression_binary(ddata, "&&", 2));
963 case SIMPLE_HASH('a', 'd'):
964 /* operator & (unary) */
966 return (cpp_demangle_read_expression_unary(ddata, "&", 1));
968 case SIMPLE_HASH('a', 'n'):
971 return (cpp_demangle_read_expression_binary(ddata, "&", 1));
973 case SIMPLE_HASH('a', 'N'):
976 return (cpp_demangle_read_expression_binary(ddata, "&=", 2));
978 case SIMPLE_HASH('a', 'S'):
981 return (cpp_demangle_read_expression_binary(ddata, "=", 1));
983 case SIMPLE_HASH('c', 'l'):
986 return (cpp_demangle_read_expression_binary(ddata, "()", 2));
988 case SIMPLE_HASH('c', 'm'):
991 return (cpp_demangle_read_expression_binary(ddata, ",", 1));
993 case SIMPLE_HASH('c', 'o'):
996 return (cpp_demangle_read_expression_binary(ddata, "~", 1));
998 case SIMPLE_HASH('c', 'v'):
999 /* operator (cast) */
1001 return (cpp_demangle_read_expression_binary(ddata, "(cast)", 6));
1003 case SIMPLE_HASH('d', 'a'):
1004 /* operator delete [] */
1006 return (cpp_demangle_read_expression_unary(ddata, "delete []", 9));
1008 case SIMPLE_HASH('d', 'e'):
1009 /* operator * (unary) */
1011 return (cpp_demangle_read_expression_unary(ddata, "*", 1));
1013 case SIMPLE_HASH('d', 'l'):
1014 /* operator delete */
1016 return (cpp_demangle_read_expression_unary(ddata, "delete", 6));
1018 case SIMPLE_HASH('d', 'v'):
1021 return (cpp_demangle_read_expression_binary(ddata, "/", 1));
1023 case SIMPLE_HASH('d', 'V'):
1026 return (cpp_demangle_read_expression_binary(ddata, "/=", 2));
1028 case SIMPLE_HASH('e', 'o'):
1031 return (cpp_demangle_read_expression_binary(ddata, "^", 1));
1033 case SIMPLE_HASH('e', 'O'):
1036 return (cpp_demangle_read_expression_binary(ddata, "^=", 2));
1038 case SIMPLE_HASH('e', 'q'):
1041 return (cpp_demangle_read_expression_binary(ddata, "==", 2));
1043 case SIMPLE_HASH('g', 'e'):
1046 return (cpp_demangle_read_expression_binary(ddata, ">=", 2));
1048 case SIMPLE_HASH('g', 't'):
1051 return (cpp_demangle_read_expression_binary(ddata, ">", 1));
1053 case SIMPLE_HASH('i', 'x'):
1056 return (cpp_demangle_read_expression_binary(ddata, "[]", 2));
1058 case SIMPLE_HASH('l', 'e'):
1061 return (cpp_demangle_read_expression_binary(ddata, "<=", 2));
1063 case SIMPLE_HASH('l', 's'):
1066 return (cpp_demangle_read_expression_binary(ddata, "<<", 2));
1068 case SIMPLE_HASH('l', 'S'):
1071 return (cpp_demangle_read_expression_binary(ddata, "<<=", 3));
1073 case SIMPLE_HASH('l', 't'):
1076 return (cpp_demangle_read_expression_binary(ddata, "<", 1));
1078 case SIMPLE_HASH('m', 'i'):
1081 return (cpp_demangle_read_expression_binary(ddata, "-", 1));
1083 case SIMPLE_HASH('m', 'I'):
1086 return (cpp_demangle_read_expression_binary(ddata, "-=", 2));
1088 case SIMPLE_HASH('m', 'l'):
1091 return (cpp_demangle_read_expression_binary(ddata, "*", 1));
1093 case SIMPLE_HASH('m', 'L'):
1096 return (cpp_demangle_read_expression_binary(ddata, "*=", 2));
1098 case SIMPLE_HASH('m', 'm'):
1101 return (cpp_demangle_read_expression_binary(ddata, "--", 2));
1103 case SIMPLE_HASH('n', 'a'):
1104 /* operator new[] */
1106 return (cpp_demangle_read_expression_unary(ddata, "new []", 6));
1108 case SIMPLE_HASH('n', 'e'):
1111 return (cpp_demangle_read_expression_binary(ddata, "!=", 2));
1113 case SIMPLE_HASH('n', 'g'):
1114 /* operator - (unary) */
1116 return (cpp_demangle_read_expression_unary(ddata, "-", 1));
1118 case SIMPLE_HASH('n', 't'):
1121 return (cpp_demangle_read_expression_binary(ddata, "!", 1));
1123 case SIMPLE_HASH('n', 'w'):
1126 return (cpp_demangle_read_expression_unary(ddata, "new", 3));
1128 case SIMPLE_HASH('o', 'o'):
1131 return (cpp_demangle_read_expression_binary(ddata, "||", 2));
1133 case SIMPLE_HASH('o', 'r'):
1136 return (cpp_demangle_read_expression_binary(ddata, "|", 1));
1138 case SIMPLE_HASH('o', 'R'):
1141 return (cpp_demangle_read_expression_binary(ddata, "|=", 2));
1143 case SIMPLE_HASH('p', 'l'):
1146 return (cpp_demangle_read_expression_binary(ddata, "+", 1));
1148 case SIMPLE_HASH('p', 'L'):
1151 return (cpp_demangle_read_expression_binary(ddata, "+=", 2));
1153 case SIMPLE_HASH('p', 'm'):
1156 return (cpp_demangle_read_expression_binary(ddata, "->*", 3));
1158 case SIMPLE_HASH('p', 'p'):
1161 return (cpp_demangle_read_expression_binary(ddata, "++", 2));
1163 case SIMPLE_HASH('p', 's'):
1164 /* operator + (unary) */
1166 return (cpp_demangle_read_expression_unary(ddata, "+", 1));
1168 case SIMPLE_HASH('p', 't'):
1171 return (cpp_demangle_read_expression_binary(ddata, "->", 2));
1173 case SIMPLE_HASH('q', 'u'):
1176 return (cpp_demangle_read_expression_trinary(ddata, "?", 1,
1179 case SIMPLE_HASH('r', 'm'):
1182 return (cpp_demangle_read_expression_binary(ddata, "%", 1));
1184 case SIMPLE_HASH('r', 'M'):
1187 return (cpp_demangle_read_expression_binary(ddata, "%=", 2));
1189 case SIMPLE_HASH('r', 's'):
1192 return (cpp_demangle_read_expression_binary(ddata, ">>", 2));
1194 case SIMPLE_HASH('r', 'S'):
1197 return (cpp_demangle_read_expression_binary(ddata, ">>=", 3));
1199 case SIMPLE_HASH('r', 'z'):
1200 /* operator sizeof */
1202 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
1204 case SIMPLE_HASH('s', 'v'):
1205 /* operator sizeof */
1207 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
1210 switch (*ddata->cur) {
1212 return (cpp_demangle_read_expr_primary(ddata));
1214 return (cpp_demangle_read_tmpl_param(ddata));
1221 cpp_demangle_read_expression_flat(struct cpp_demangle_data *ddata, char **str)
1223 struct vector_str *output;
1224 size_t i, p_idx, idx, exp_len;
1227 output = &ddata->output;
1229 p_idx = output->size;
1231 if (!cpp_demangle_read_expression(ddata))
1234 if ((exp = vector_str_substr(output, p_idx, output->size - 1,
1239 for (i = p_idx; i < idx; ++i) {
1240 if (!vector_str_pop(output)) {
1252 cpp_demangle_read_expression_binary(struct cpp_demangle_data *ddata,
1253 const char *name, size_t len)
1256 if (ddata == NULL || name == NULL || len == 0)
1258 if (!cpp_demangle_read_expression(ddata))
1260 if (!cpp_demangle_push_str(ddata, name, len))
1263 return (cpp_demangle_read_expression(ddata));
1267 cpp_demangle_read_expression_unary(struct cpp_demangle_data *ddata,
1268 const char *name, size_t len)
1271 if (ddata == NULL || name == NULL || len == 0)
1273 if (!cpp_demangle_read_expression(ddata))
1276 return (cpp_demangle_push_str(ddata, name, len));
1280 cpp_demangle_read_expression_trinary(struct cpp_demangle_data *ddata,
1281 const char *name1, size_t len1, const char *name2, size_t len2)
1284 if (ddata == NULL || name1 == NULL || len1 == 0 || name2 == NULL ||
1288 if (!cpp_demangle_read_expression(ddata))
1290 if (!cpp_demangle_push_str(ddata, name1, len1))
1292 if (!cpp_demangle_read_expression(ddata))
1294 if (!cpp_demangle_push_str(ddata, name2, len2))
1297 return (cpp_demangle_read_expression(ddata));
1301 cpp_demangle_read_function(struct cpp_demangle_data *ddata, int *ext_c,
1302 struct vector_type_qualifier *v)
1304 struct type_delimit td;
1305 struct read_cmd_item *rc;
1306 size_t class_type_size, class_type_len, limit;
1307 const char *class_type;
1309 bool paren, non_cv_qualifier;
1311 if (ddata == NULL || *ddata->cur != 'F' || v == NULL)
1315 if (*ddata->cur == 'Y') {
1322 if (!cpp_demangle_read_type(ddata, NULL))
1325 if (*ddata->cur != 'E') {
1326 if (!DEM_PUSH_STR(ddata, " "))
1329 non_cv_qualifier = false;
1331 for (i = 0; (size_t) i < v->size; i++) {
1332 if (v->q_container[i] != TYPE_RST &&
1333 v->q_container[i] != TYPE_VAT &&
1334 v->q_container[i] != TYPE_CST) {
1335 non_cv_qualifier = true;
1342 rc = vector_read_cmd_find(&ddata->cmd, READ_PTRMEM);
1343 if (non_cv_qualifier || rc != NULL) {
1344 if (!DEM_PUSH_STR(ddata, "("))
1349 /* Push non-cv qualifiers. */
1350 ddata->push_qualifier = PUSH_NON_CV_QUALIFIER;
1351 if (!cpp_demangle_push_type_qualifier(ddata, v, NULL))
1355 if (non_cv_qualifier && !DEM_PUSH_STR(ddata, " "))
1357 if ((class_type_size = ddata->class_type.size) == 0)
1360 ddata->class_type.container[class_type_size - 1];
1361 if (class_type == NULL)
1363 if ((class_type_len = strlen(class_type)) == 0)
1365 if (!cpp_demangle_push_str(ddata, class_type,
1368 if (!DEM_PUSH_STR(ddata, "::*"))
1370 /* Push pointer-to-member qualifiers. */
1371 ddata->push_qualifier = PUSH_ALL_QUALIFIER;
1372 if (!cpp_demangle_push_type_qualifier(ddata, rc->data,
1379 if (!DEM_PUSH_STR(ddata, ")"))
1387 ddata->is_functype = true;
1389 if (!cpp_demangle_read_type(ddata, &td))
1391 if (*ddata->cur == 'E')
1393 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1396 ddata->is_functype = false;
1398 if (!DEM_PUSH_STR(ddata, ")"))
1403 /* Push CV qualifiers. */
1404 ddata->push_qualifier = PUSH_CV_QUALIFIER;
1405 if (!cpp_demangle_push_type_qualifier(ddata, v, NULL))
1408 ddata->push_qualifier = PUSH_ALL_QUALIFIER;
1410 /* Release type qualifier vector. */
1411 vector_type_qualifier_dest(v);
1412 if (!vector_type_qualifier_init(v))
1415 /* Push ref-qualifiers. */
1416 if (ddata->ref_qualifier) {
1417 switch (ddata->ref_qualifier_type) {
1419 if (!DEM_PUSH_STR(ddata, " &"))
1423 if (!DEM_PUSH_STR(ddata, " &&"))
1429 ddata->ref_qualifier = false;
1438 /* read encoding, encoding are function name, data name, special-name */
1440 cpp_demangle_read_encoding(struct cpp_demangle_data *ddata)
1442 char *name, *type, *num_str;
1446 if (ddata == NULL || *ddata->cur == '\0')
1450 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1451 case SIMPLE_HASH('G', 'A'):
1452 if (!DEM_PUSH_STR(ddata, "hidden alias for "))
1455 if (*ddata->cur == '\0')
1457 return (cpp_demangle_read_encoding(ddata));
1459 case SIMPLE_HASH('G', 'R'):
1460 if (!DEM_PUSH_STR(ddata, "reference temporary #"))
1463 if (*ddata->cur == '\0')
1465 if (!cpp_demangle_read_name_flat(ddata, &name))
1468 if (!cpp_demangle_read_number_as_string(ddata, &num_str))
1470 if (!DEM_PUSH_STR(ddata, num_str))
1472 if (!DEM_PUSH_STR(ddata, " for "))
1474 if (!DEM_PUSH_STR(ddata, name))
1483 case SIMPLE_HASH('G', 'T'):
1485 if (*ddata->cur == '\0')
1487 switch (*ddata->cur) {
1489 if (!DEM_PUSH_STR(ddata, "non-transaction clone for "))
1494 if (!DEM_PUSH_STR(ddata, "transaction clone for "))
1499 return (cpp_demangle_read_encoding(ddata));
1501 case SIMPLE_HASH('G', 'V'):
1502 /* sentry object for 1 time init */
1503 if (!DEM_PUSH_STR(ddata, "guard variable for "))
1508 case SIMPLE_HASH('T', 'c'):
1509 /* virtual function covariant override thunk */
1510 if (!DEM_PUSH_STR(ddata,
1511 "virtual function covariant override "))
1514 if (*ddata->cur == '\0')
1516 if (!cpp_demangle_read_offset(ddata))
1518 if (!cpp_demangle_read_offset(ddata))
1520 return (cpp_demangle_read_encoding(ddata));
1522 case SIMPLE_HASH('T', 'C'):
1523 /* construction vtable */
1524 if (!DEM_PUSH_STR(ddata, "construction vtable for "))
1527 if (*ddata->cur == '\0')
1529 if (!cpp_demangle_read_type_flat(ddata, &type))
1532 if (!cpp_demangle_read_number(ddata, &offset))
1534 if (*ddata->cur++ != '_')
1536 if (!cpp_demangle_read_type(ddata, NULL))
1538 if (!DEM_PUSH_STR(ddata, "-in-"))
1540 if (!DEM_PUSH_STR(ddata, type))
1547 case SIMPLE_HASH('T', 'D'):
1548 /* typeinfo common proxy */
1551 case SIMPLE_HASH('T', 'F'):
1553 if (!DEM_PUSH_STR(ddata, "typeinfo fn for "))
1556 if (*ddata->cur == '\0')
1558 return (cpp_demangle_read_type(ddata, NULL));
1560 case SIMPLE_HASH('T', 'h'):
1561 /* virtual function non-virtual override thunk */
1562 if (!DEM_PUSH_STR(ddata,
1563 "virtual function non-virtual override "))
1566 if (*ddata->cur == '\0')
1568 if (!cpp_demangle_read_nv_offset(ddata))
1570 return (cpp_demangle_read_encoding(ddata));
1572 case SIMPLE_HASH('T', 'H'):
1573 /* TLS init function */
1574 if (!DEM_PUSH_STR(ddata, "TLS init function for "))
1577 if (*ddata->cur == '\0')
1581 case SIMPLE_HASH('T', 'I'):
1582 /* typeinfo structure */
1583 if (!DEM_PUSH_STR(ddata, "typeinfo for "))
1586 if (*ddata->cur == '\0')
1588 return (cpp_demangle_read_type(ddata, NULL));
1590 case SIMPLE_HASH('T', 'J'):
1592 if (!DEM_PUSH_STR(ddata, "java Class for "))
1595 if (*ddata->cur == '\0')
1597 return (cpp_demangle_read_type(ddata, NULL));
1599 case SIMPLE_HASH('T', 'S'):
1600 /* RTTI name (NTBS) */
1601 if (!DEM_PUSH_STR(ddata, "typeinfo name for "))
1604 if (*ddata->cur == '\0')
1606 return (cpp_demangle_read_type(ddata, NULL));
1608 case SIMPLE_HASH('T', 'T'):
1610 if (!DEM_PUSH_STR(ddata, "VTT for "))
1613 if (*ddata->cur == '\0')
1615 return (cpp_demangle_read_type(ddata, NULL));
1617 case SIMPLE_HASH('T', 'v'):
1618 /* virtual function virtual override thunk */
1619 if (!DEM_PUSH_STR(ddata,
1620 "virtual function virtual override "))
1623 if (*ddata->cur == '\0')
1625 if (!cpp_demangle_read_v_offset(ddata))
1627 return (cpp_demangle_read_encoding(ddata));
1629 case SIMPLE_HASH('T', 'V'):
1631 if (!DEM_PUSH_STR(ddata, "vtable for "))
1634 if (*ddata->cur == '\0')
1636 return (cpp_demangle_read_type(ddata, NULL));
1638 case SIMPLE_HASH('T', 'W'):
1639 /* TLS wrapper function */
1640 if (!DEM_PUSH_STR(ddata, "TLS wrapper function for "))
1643 if (*ddata->cur == '\0')
1648 return (cpp_demangle_read_name(ddata));
1652 cpp_demangle_read_local_name(struct cpp_demangle_data *ddata)
1654 struct vector_str local_name;
1655 struct type_delimit td;
1661 if (*(++ddata->cur) == '\0')
1664 vector_str_init(&local_name);
1665 ddata->cur_output = &local_name;
1667 if (!cpp_demangle_read_encoding(ddata)) {
1668 vector_str_dest(&local_name);
1672 ddata->cur_output = &ddata->output;
1680 * The first type is a return type if we just demangled template
1681 * args. (the template args is right next to the function name,
1682 * which means it's a template function)
1684 if (ddata->is_tmpl) {
1685 ddata->is_tmpl = false;
1687 /* Read return type */
1688 if (!cpp_demangle_read_type(ddata, NULL)) {
1689 vector_str_dest(&local_name);
1696 /* Now we can push the name after possible return type is handled. */
1697 if (!vector_str_push_vector(&ddata->output, &local_name)) {
1698 vector_str_dest(&local_name);
1701 vector_str_dest(&local_name);
1703 while (*ddata->cur != '\0') {
1704 if (!cpp_demangle_read_type(ddata, &td))
1708 if (*ddata->cur == 'E')
1710 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1716 if (*(++ddata->cur) == '\0')
1718 if (td.paren == true) {
1719 if (!DEM_PUSH_STR(ddata, ")"))
1723 if (*ddata->cur == 's')
1726 if (!DEM_PUSH_STR(ddata, "::"))
1728 if (!cpp_demangle_read_name(ddata))
1731 if (*ddata->cur == '_') {
1733 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
1741 cpp_demangle_read_name(struct cpp_demangle_data *ddata)
1743 struct vector_str *output, v;
1744 size_t p_idx, subst_str_len;
1748 if (ddata == NULL || *ddata->cur == '\0')
1751 output = ddata->cur_output;
1755 switch (*ddata->cur) {
1757 return (cpp_demangle_read_subst(ddata));
1759 return (cpp_demangle_read_nested_name(ddata));
1761 return (cpp_demangle_read_local_name(ddata));
1764 if (!vector_str_init(&v))
1767 p_idx = output->size;
1769 if (!cpp_demangle_read_uqname(ddata))
1771 if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
1772 &subst_str_len)) == NULL)
1774 if (subst_str_len > 8 && strstr(subst_str, "operator") != NULL) {
1778 if (!vector_str_push(&v, subst_str, subst_str_len))
1780 if (!cpp_demangle_push_subst_v(ddata, &v))
1783 if (*ddata->cur == 'I') {
1784 p_idx = output->size;
1785 if (!cpp_demangle_read_tmpl_args(ddata))
1788 if ((subst_str = vector_str_substr(output, p_idx,
1789 output->size - 1, &subst_str_len)) == NULL)
1791 if (!vector_str_push(&v, subst_str, subst_str_len))
1793 if (!cpp_demangle_push_subst_v(ddata, &v))
1801 vector_str_dest(&v);
1807 cpp_demangle_read_name_flat(struct cpp_demangle_data *ddata, char **str)
1809 struct vector_str *output;
1810 size_t i, p_idx, idx, name_len;
1813 output = ddata->cur_output;
1815 p_idx = output->size;
1817 if (!cpp_demangle_read_name(ddata))
1820 if ((name = vector_str_substr(output, p_idx, output->size - 1,
1821 &name_len)) == NULL)
1825 for (i = p_idx; i < idx; ++i) {
1826 if (!vector_str_pop(output)) {
1838 cpp_demangle_read_nested_name(struct cpp_demangle_data *ddata)
1840 struct vector_str *output, v;
1841 size_t limit, p_idx, subst_str_len;
1845 if (ddata == NULL || *ddata->cur != 'N')
1847 if (*(++ddata->cur) == '\0')
1851 switch (*ddata->cur) {
1853 ddata->mem_rst = true;
1856 ddata->mem_vat = true;
1859 ddata->mem_cst = true;
1862 ddata->mem_ref = true;
1865 ddata->mem_rref = true;
1870 } while (*(++ddata->cur));
1873 output = ddata->cur_output;
1874 if (!vector_str_init(&v))
1880 p_idx = output->size;
1881 switch (*ddata->cur) {
1883 if (!cpp_demangle_read_tmpl_args(ddata))
1887 if (!cpp_demangle_read_subst(ddata))
1891 if (!cpp_demangle_read_tmpl_param(ddata))
1895 if (!cpp_demangle_read_uqname(ddata))
1899 if (p_idx == output->size)
1901 if ((subst_str = vector_str_substr(output, p_idx,
1902 output->size - 1, &subst_str_len)) == NULL)
1904 if (!vector_str_push(&v, subst_str, subst_str_len)) {
1910 if (!cpp_demangle_push_subst_v(ddata, &v))
1914 if (*ddata->cur == 'E')
1916 else if (*ddata->cur != 'I' && *ddata->cur != 'C' &&
1917 *ddata->cur != 'D' && p_idx != output->size) {
1918 if (!DEM_PUSH_STR(ddata, "::"))
1920 if (!VEC_PUSH_STR(&v, "::"))
1923 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1931 vector_str_dest(&v);
1938 * number ::= [n] <decimal>
1941 cpp_demangle_read_number(struct cpp_demangle_data *ddata, long *rtn)
1943 long len, negative_factor;
1945 if (ddata == NULL || rtn == NULL)
1948 negative_factor = 1;
1949 if (*ddata->cur == 'n') {
1950 negative_factor = -1;
1954 if (ELFTC_ISDIGIT(*ddata->cur) == 0)
1958 if ((len = strtol(ddata->cur, (char **) NULL, 10)) == 0 &&
1962 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
1966 assert(negative_factor == 1 || negative_factor == -1);
1968 *rtn = len * negative_factor;
1974 cpp_demangle_read_number_as_string(struct cpp_demangle_data *ddata, char **str)
1978 if (!cpp_demangle_read_number(ddata, &n)) {
1983 if (asprintf(str, "%ld", n) < 0) {
1992 cpp_demangle_read_nv_offset(struct cpp_demangle_data *ddata)
1998 if (!DEM_PUSH_STR(ddata, "offset : "))
2001 return (cpp_demangle_read_offset_number(ddata));
2004 /* read offset, offset are nv-offset, v-offset */
2006 cpp_demangle_read_offset(struct cpp_demangle_data *ddata)
2012 if (*ddata->cur == 'h') {
2014 return (cpp_demangle_read_nv_offset(ddata));
2015 } else if (*ddata->cur == 'v') {
2017 return (cpp_demangle_read_v_offset(ddata));
2024 cpp_demangle_read_offset_number(struct cpp_demangle_data *ddata)
2029 if (ddata == NULL || *ddata->cur == '\0')
2032 /* offset could be negative */
2033 if (*ddata->cur == 'n') {
2035 start = ddata->cur + 1;
2041 while (*ddata->cur != '_')
2044 if (negative && !DEM_PUSH_STR(ddata, "-"))
2047 assert(start != NULL);
2049 if (!cpp_demangle_push_str(ddata, start, ddata->cur - start))
2051 if (!DEM_PUSH_STR(ddata, " "))
2060 cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *ddata,
2061 struct vector_type_qualifier *v)
2063 size_t class_type_len, i, idx, p_idx;
2064 int p_func_type, rtn;
2067 if (ddata == NULL || *ddata->cur != 'M' || *(++ddata->cur) == '\0')
2070 p_idx = ddata->output.size;
2071 if (!cpp_demangle_read_type(ddata, NULL))
2074 if ((class_type = vector_str_substr(&ddata->output, p_idx,
2075 ddata->output.size - 1, &class_type_len)) == NULL)
2079 idx = ddata->output.size;
2080 for (i = p_idx; i < idx; ++i)
2081 if (!vector_str_pop(&ddata->output))
2084 if (!vector_read_cmd_push(&ddata->cmd, READ_PTRMEM, v))
2087 if (!vector_str_push(&ddata->class_type, class_type, class_type_len))
2090 p_func_type = ddata->func_type;
2091 if (!cpp_demangle_read_type(ddata, NULL))
2094 if (p_func_type == ddata->func_type) {
2095 if (!DEM_PUSH_STR(ddata, " "))
2097 if (!cpp_demangle_push_str(ddata, class_type, class_type_len))
2099 if (!DEM_PUSH_STR(ddata, "::*"))
2105 if (!vector_str_pop(&ddata->class_type))
2108 if (!vector_read_cmd_pop(&ddata->cmd))
2113 vector_type_qualifier_dest(v);
2114 if (!vector_type_qualifier_init(v))
2120 /* read source-name, source-name is <len> <ID> */
2122 cpp_demangle_read_sname(struct cpp_demangle_data *ddata)
2127 if (ddata == NULL || cpp_demangle_read_number(ddata, &len) == 0 ||
2131 if (len == 12 && (memcmp("_GLOBAL__N_1", ddata->cur, 12) == 0))
2132 err = DEM_PUSH_STR(ddata, "(anonymous namespace)");
2134 err = cpp_demangle_push_str(ddata, ddata->cur, len);
2139 assert(ddata->output.size > 0);
2140 if (vector_read_cmd_find(&ddata->cmd, READ_TMPL) == NULL)
2142 ddata->output.container[ddata->output.size - 1];
2150 cpp_demangle_read_subst(struct cpp_demangle_data *ddata)
2154 if (ddata == NULL || *ddata->cur == '\0')
2157 /* abbreviations of the form Sx */
2158 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
2159 case SIMPLE_HASH('S', 'a'):
2160 /* std::allocator */
2161 if (!DEM_PUSH_STR(ddata, "std::allocator"))
2164 if (*ddata->cur == 'I')
2165 return (cpp_demangle_read_subst_stdtmpl(ddata,
2169 case SIMPLE_HASH('S', 'b'):
2170 /* std::basic_string */
2171 if (!DEM_PUSH_STR(ddata, "std::basic_string"))
2174 if (*ddata->cur == 'I')
2175 return (cpp_demangle_read_subst_stdtmpl(ddata,
2176 "std::basic_string"));
2179 case SIMPLE_HASH('S', 'd'):
2180 /* std::basic_iostream<char, std::char_traits<char> > */
2181 if (!DEM_PUSH_STR(ddata, "std::basic_iostream<char, "
2182 "std::char_traits<char> >"))
2184 ddata->last_sname = "basic_iostream";
2186 if (*ddata->cur == 'I')
2187 return (cpp_demangle_read_subst_stdtmpl(ddata,
2188 "std::basic_iostream<char, std::char_traits"
2192 case SIMPLE_HASH('S', 'i'):
2193 /* std::basic_istream<char, std::char_traits<char> > */
2194 if (!DEM_PUSH_STR(ddata, "std::basic_istream<char, "
2195 "std::char_traits<char> >"))
2197 ddata->last_sname = "basic_istream";
2199 if (*ddata->cur == 'I')
2200 return (cpp_demangle_read_subst_stdtmpl(ddata,
2201 "std::basic_istream<char, std::char_traits"
2205 case SIMPLE_HASH('S', 'o'):
2206 /* std::basic_ostream<char, std::char_traits<char> > */
2207 if (!DEM_PUSH_STR(ddata, "std::basic_ostream<char, "
2208 "std::char_traits<char> >"))
2210 ddata->last_sname = "basic_ostream";
2212 if (*ddata->cur == 'I')
2213 return (cpp_demangle_read_subst_stdtmpl(ddata,
2214 "std::basic_ostream<char, std::char_traits"
2218 case SIMPLE_HASH('S', 's'):
2220 * std::basic_string<char, std::char_traits<char>,
2221 * std::allocator<char> >
2225 if (!DEM_PUSH_STR(ddata, "std::basic_string<char, "
2226 "std::char_traits<char>, std::allocator<char> >"))
2228 ddata->last_sname = "string";
2230 if (*ddata->cur == 'I')
2231 return (cpp_demangle_read_subst_stdtmpl(ddata,
2232 "std::basic_string<char, std::char_traits<char>,"
2233 " std::allocator<char> >"));
2236 case SIMPLE_HASH('S', 't'):
2238 return (cpp_demangle_read_subst_std(ddata));
2241 if (*(++ddata->cur) == '\0')
2244 /* Skip unknown substitution abbreviations. */
2245 if (!(*ddata->cur >= '0' && *ddata->cur <= '9') &&
2246 !(*ddata->cur >= 'A' && *ddata->cur <= 'Z') &&
2247 *ddata->cur != '_') {
2253 if (*ddata->cur == '_')
2254 return (cpp_demangle_get_subst(ddata, 0));
2257 /* substitution number is base 36 */
2258 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
2262 /* first was '_', so increase one */
2265 while (*ddata->cur != '_')
2270 return (cpp_demangle_get_subst(ddata, nth));
2278 cpp_demangle_read_subst_std(struct cpp_demangle_data *ddata)
2280 struct vector_str *output, v;
2281 size_t p_idx, subst_str_len;
2288 if (!vector_str_init(&v))
2293 if (!DEM_PUSH_STR(ddata, "std::"))
2296 if (!VEC_PUSH_STR(&v, "std::"))
2301 output = ddata->cur_output;
2303 p_idx = output->size;
2304 if (!cpp_demangle_read_uqname(ddata))
2307 if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
2308 &subst_str_len)) == NULL)
2311 if (!vector_str_push(&v, subst_str, subst_str_len))
2314 if (!cpp_demangle_push_subst_v(ddata, &v))
2317 if (*ddata->cur == 'I') {
2318 p_idx = output->size;
2319 if (!cpp_demangle_read_tmpl_args(ddata))
2322 if ((subst_str = vector_str_substr(output, p_idx,
2323 output->size - 1, &subst_str_len)) == NULL)
2325 if (!vector_str_push(&v, subst_str, subst_str_len))
2327 if (!cpp_demangle_push_subst_v(ddata, &v))
2334 vector_str_dest(&v);
2340 cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *ddata,
2343 struct vector_str *output;
2344 size_t p_idx, substr_len, len;
2346 char *subst_str, *substr;
2348 if (ddata == NULL || str == NULL)
2351 if ((len = strlen(str)) == 0)
2354 output = ddata->cur_output;
2356 p_idx = output->size;
2360 if (!cpp_demangle_read_tmpl_args(ddata))
2362 if ((substr = vector_str_substr(output, p_idx, output->size - 1,
2363 &substr_len)) == NULL)
2367 if ((subst_str = malloc(sizeof(char) * (substr_len + len + 1))) ==
2371 memcpy(subst_str, str, len);
2372 memcpy(subst_str + len, substr, substr_len);
2373 subst_str[substr_len + len] = '\0';
2375 if (!cpp_demangle_push_subst(ddata, subst_str, substr_len + len))
2387 cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *ddata)
2390 if (ddata == NULL || *ddata->cur == '\0')
2393 switch (*ddata->cur) {
2395 return (cpp_demangle_read_expr_primary(ddata));
2398 if (!cpp_demangle_read_expression(ddata))
2400 return (*ddata->cur++ == 'E');
2403 return (cpp_demangle_read_type(ddata, NULL));
2407 cpp_demangle_read_tmpl_args(struct cpp_demangle_data *ddata)
2409 struct vector_str *v;
2410 size_t arg_len, idx, limit, size;
2413 if (ddata == NULL || *ddata->cur == '\0')
2418 if (!vector_read_cmd_push(&ddata->cmd, READ_TMPL, NULL))
2421 if (!DEM_PUSH_STR(ddata, "<"))
2428 if (!cpp_demangle_read_tmpl_arg(ddata))
2430 if ((arg = vector_str_substr(v, idx, v->size - 1, &arg_len)) ==
2433 if (!vector_str_find(&ddata->tmpl, arg, arg_len) &&
2434 !vector_str_push(&ddata->tmpl, arg, arg_len)) {
2441 if (*ddata->cur == 'E') {
2445 if (!strncmp(v->container[size - 1], ">", 1)) {
2446 if (!DEM_PUSH_STR(ddata, " >"))
2448 } else if (!DEM_PUSH_STR(ddata, ">"))
2450 ddata->is_tmpl = true;
2452 } else if (*ddata->cur != 'I' &&
2453 !DEM_PUSH_STR(ddata, ", "))
2456 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
2460 return (vector_read_cmd_pop(&ddata->cmd));
2464 * Read template parameter that forms in 'T[number]_'.
2465 * This function much like to read_subst but only for types.
2468 cpp_demangle_read_tmpl_param(struct cpp_demangle_data *ddata)
2472 if (ddata == NULL || *ddata->cur != 'T')
2477 if (*ddata->cur == '_')
2478 return (cpp_demangle_get_tmpl_param(ddata, 0));
2482 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
2489 while (*ddata->cur != '_')
2494 return (cpp_demangle_get_tmpl_param(ddata, nth));
2502 cpp_demangle_read_type(struct cpp_demangle_data *ddata,
2503 struct type_delimit *td)
2505 struct vector_type_qualifier v;
2506 struct vector_str *output, sv;
2507 size_t p_idx, type_str_len, subst_str_len;
2508 int extern_c, is_builtin;
2511 char *type_str, *exp_str, *num_str, *subst_str;
2512 bool skip_ref_qualifier, omit_void;
2517 output = ddata->cur_output;
2519 if (td->paren == false) {
2520 if (!DEM_PUSH_STR(ddata, "("))
2522 if (ddata->output.size < 2)
2528 if (*ddata->cur != 'I') {
2529 if (!DEM_PUSH_STR(ddata, ", "))
2535 assert(output != NULL);
2537 * [r, V, K] [P, R, O, C, G, U] builtin, function, class-enum, array
2538 * pointer-to-member, template-param, template-template-param, subst
2541 if (!vector_type_qualifier_init(&v))
2546 p_idx = output->size;
2547 type_str = exp_str = num_str = NULL;
2548 skip_ref_qualifier = false;
2552 /* Clear ref-qualifier flag */
2553 if (*ddata->cur != 'R' && *ddata->cur != 'O' && *ddata->cur != 'E')
2554 ddata->ref_qualifier = false;
2557 switch (*ddata->cur) {
2560 if (!DEM_PUSH_STR(ddata, "signed char"))
2567 if (!cpp_demangle_read_array(ddata))
2574 if (!DEM_PUSH_STR(ddata, "bool"))
2581 if (!vector_type_qualifier_push(&v, TYPE_CMX))
2590 if (!DEM_PUSH_STR(ddata, "char"))
2597 if (!DEM_PUSH_STR(ddata, "double"))
2604 switch (*ddata->cur) {
2607 if (!DEM_PUSH_STR(ddata, "auto"))
2612 /* decltype(auto) */
2613 if (!DEM_PUSH_STR(ddata, "decltype(auto)"))
2618 /* IEEE 754r decimal floating point (64 bits) */
2619 if (!DEM_PUSH_STR(ddata, "decimal64"))
2624 /* IEEE 754r decimal floating point (128 bits) */
2625 if (!DEM_PUSH_STR(ddata, "decimal128"))
2630 /* IEEE 754r decimal floating point (32 bits) */
2631 if (!DEM_PUSH_STR(ddata, "decimal32"))
2636 /* IEEE 754r half-precision floating point (16 bits) */
2637 if (!DEM_PUSH_STR(ddata, "half"))
2643 if (!DEM_PUSH_STR(ddata, "char32_t"))
2648 /* std::nullptr_t (i.e., decltype(nullptr)) */
2649 if (!DEM_PUSH_STR(ddata, "decltype(nullptr)"))
2655 if (!DEM_PUSH_STR(ddata, "char16_t"))
2660 /* gcc vector_size extension. */
2662 if (*ddata->cur == '_') {
2664 if (!cpp_demangle_read_expression_flat(ddata,
2667 if (!VEC_PUSH_STR(&v.ext_name, exp_str))
2670 if (!cpp_demangle_read_number_as_string(ddata,
2673 if (!VEC_PUSH_STR(&v.ext_name, num_str))
2676 if (*ddata->cur != '_')
2679 if (!vector_type_qualifier_push(&v, TYPE_VEC))
2691 if (!DEM_PUSH_STR(ddata, "long double"))
2697 /* unexpected end except ref-qualifiers */
2698 if (ddata->ref_qualifier && ddata->is_functype) {
2699 skip_ref_qualifier = true;
2700 /* Pop the delimiter. */
2701 cpp_demangle_pop_str(ddata);
2708 if (!DEM_PUSH_STR(ddata, "float"))
2715 if (!cpp_demangle_read_function(ddata, &extern_c, &v))
2722 if (!DEM_PUSH_STR(ddata, "__float128"))
2729 if (!vector_type_qualifier_push(&v, TYPE_IMG))
2738 if (!DEM_PUSH_STR(ddata, "unsigned char"))
2745 if (!DEM_PUSH_STR(ddata, "int"))
2751 /* template args. */
2752 /* handles <substitute><template-args> */
2753 p_idx = output->size;
2754 if (!cpp_demangle_read_tmpl_args(ddata))
2756 if ((subst_str = vector_str_substr(output, p_idx,
2757 output->size - 1, &subst_str_len)) == NULL)
2759 if (!vector_str_init(&sv)) {
2763 if (!vector_str_push(&sv, subst_str, subst_str_len)) {
2765 vector_str_dest(&sv);
2769 if (!cpp_demangle_push_subst_v(ddata, &sv)) {
2770 vector_str_dest(&sv);
2773 vector_str_dest(&sv);
2778 if (!DEM_PUSH_STR(ddata, "unsigned int"))
2785 if (!vector_type_qualifier_push(&v, TYPE_CST))
2794 if (!DEM_PUSH_STR(ddata, "long"))
2801 if (!DEM_PUSH_STR(ddata, "unsigned long"))
2808 /* pointer to member */
2809 if (!cpp_demangle_read_pointer_to_member(ddata, &v))
2816 if (!DEM_PUSH_STR(ddata, "__int128"))
2822 /* unsigned __int128 */
2823 if (!DEM_PUSH_STR(ddata, "unsigned __int128"))
2829 /* rvalue reference */
2830 if (ddata->ref_qualifier)
2832 if (!vector_type_qualifier_push(&v, TYPE_RREF))
2834 ddata->ref_qualifier = true;
2835 ddata->ref_qualifier_type = TYPE_RREF;
2843 if (!vector_type_qualifier_push(&v, TYPE_PTR))
2852 if (!vector_type_qualifier_push(&v, TYPE_RST))
2861 if (ddata->ref_qualifier)
2863 if (!vector_type_qualifier_push(&v, TYPE_REF))
2865 ddata->ref_qualifier = true;
2866 ddata->ref_qualifier_type = TYPE_REF;
2873 /* short, local string */
2874 if (!DEM_PUSH_STR(ddata, "short"))
2881 if (!cpp_demangle_read_subst(ddata))
2887 /* unsigned short */
2888 if (!DEM_PUSH_STR(ddata, "unsigned short"))
2894 /* template parameter */
2895 if (!cpp_demangle_read_tmpl_param(ddata))
2901 /* vendor extended builtin */
2903 if (!cpp_demangle_read_sname(ddata))
2909 /* vendor extended type qualifier */
2911 if (!cpp_demangle_read_number(ddata, &len))
2915 if (!vector_str_push(&v.ext_name, ddata->cur, len))
2918 if (!vector_type_qualifier_push(&v, TYPE_EXT))
2927 if (td && td->firstp) {
2929 * peek into next bytes and see if we should omit
2933 for (p = ddata->cur + 1; *p != '\0'; p++) {
2936 if (*p != 'R' && *p != 'O') {
2942 if (!omit_void && !DEM_PUSH_STR(ddata, "void"))
2949 if (!vector_type_qualifier_push(&v, TYPE_VAT))
2958 if (!DEM_PUSH_STR(ddata, "wchar_t"))
2965 if (!DEM_PUSH_STR(ddata, "long long"))
2971 /* unsigned long long */
2972 if (!DEM_PUSH_STR(ddata, "unsigned long long"))
2979 if (!DEM_PUSH_STR(ddata, "..."))
2985 if (!cpp_demangle_read_name(ddata))
2991 type_str = vector_str_substr(output, p_idx, output->size - 1,
2994 if (is_builtin == 0) {
2995 if (!vector_str_find(&ddata->subst, type_str, type_str_len) &&
2996 !vector_str_push(&ddata->subst, type_str, type_str_len))
3000 if (!skip_ref_qualifier &&
3001 !cpp_demangle_push_type_qualifier(ddata, &v, type_str))
3010 vector_type_qualifier_dest(&v);
3017 vector_type_qualifier_dest(&v);
3023 cpp_demangle_read_type_flat(struct cpp_demangle_data *ddata, char **str)
3025 struct vector_str *output;
3026 size_t i, p_idx, idx, type_len;
3029 output = ddata->cur_output;
3031 p_idx = output->size;
3033 if (!cpp_demangle_read_type(ddata, NULL))
3036 if ((type = vector_str_substr(output, p_idx, output->size - 1,
3037 &type_len)) == NULL)
3041 for (i = p_idx; i < idx; ++i) {
3042 if (!vector_str_pop(output)) {
3054 * read unqualified-name, unqualified name are operator-name, ctor-dtor-name,
3058 cpp_demangle_read_uqname(struct cpp_demangle_data *ddata)
3062 if (ddata == NULL || *ddata->cur == '\0')
3066 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
3067 case SIMPLE_HASH('a', 'a'):
3069 if (!DEM_PUSH_STR(ddata, "operator&&"))
3074 case SIMPLE_HASH('a', 'd'):
3075 /* operator & (unary) */
3076 if (!DEM_PUSH_STR(ddata, "operator&"))
3081 case SIMPLE_HASH('a', 'n'):
3083 if (!DEM_PUSH_STR(ddata, "operator&"))
3088 case SIMPLE_HASH('a', 'N'):
3090 if (!DEM_PUSH_STR(ddata, "operator&="))
3095 case SIMPLE_HASH('a', 'S'):
3097 if (!DEM_PUSH_STR(ddata, "operator="))
3102 case SIMPLE_HASH('c', 'l'):
3104 if (!DEM_PUSH_STR(ddata, "operator()"))
3109 case SIMPLE_HASH('c', 'm'):
3111 if (!DEM_PUSH_STR(ddata, "operator,"))
3116 case SIMPLE_HASH('c', 'o'):
3118 if (!DEM_PUSH_STR(ddata, "operator~"))
3123 case SIMPLE_HASH('c', 'v'):
3124 /* operator (cast) */
3125 if (!DEM_PUSH_STR(ddata, "operator(cast)"))
3128 return (cpp_demangle_read_type(ddata, NULL));
3130 case SIMPLE_HASH('d', 'a'):
3131 /* operator delete [] */
3132 if (!DEM_PUSH_STR(ddata, "operator delete []"))
3137 case SIMPLE_HASH('d', 'e'):
3138 /* operator * (unary) */
3139 if (!DEM_PUSH_STR(ddata, "operator*"))
3144 case SIMPLE_HASH('d', 'l'):
3145 /* operator delete */
3146 if (!DEM_PUSH_STR(ddata, "operator delete"))
3151 case SIMPLE_HASH('d', 'v'):
3153 if (!DEM_PUSH_STR(ddata, "operator/"))
3158 case SIMPLE_HASH('d', 'V'):
3160 if (!DEM_PUSH_STR(ddata, "operator/="))
3165 case SIMPLE_HASH('e', 'o'):
3167 if (!DEM_PUSH_STR(ddata, "operator^"))
3172 case SIMPLE_HASH('e', 'O'):
3174 if (!DEM_PUSH_STR(ddata, "operator^="))
3179 case SIMPLE_HASH('e', 'q'):
3181 if (!DEM_PUSH_STR(ddata, "operator=="))
3186 case SIMPLE_HASH('g', 'e'):
3188 if (!DEM_PUSH_STR(ddata, "operator>="))
3193 case SIMPLE_HASH('g', 't'):
3195 if (!DEM_PUSH_STR(ddata, "operator>"))
3200 case SIMPLE_HASH('i', 'x'):
3202 if (!DEM_PUSH_STR(ddata, "operator[]"))
3207 case SIMPLE_HASH('l', 'e'):
3209 if (!DEM_PUSH_STR(ddata, "operator<="))
3214 case SIMPLE_HASH('l', 's'):
3216 if (!DEM_PUSH_STR(ddata, "operator<<"))
3221 case SIMPLE_HASH('l', 'S'):
3223 if (!DEM_PUSH_STR(ddata, "operator<<="))
3228 case SIMPLE_HASH('l', 't'):
3230 if (!DEM_PUSH_STR(ddata, "operator<"))
3235 case SIMPLE_HASH('m', 'i'):
3237 if (!DEM_PUSH_STR(ddata, "operator-"))
3242 case SIMPLE_HASH('m', 'I'):
3244 if (!DEM_PUSH_STR(ddata, "operator-="))
3249 case SIMPLE_HASH('m', 'l'):
3251 if (!DEM_PUSH_STR(ddata, "operator*"))
3256 case SIMPLE_HASH('m', 'L'):
3258 if (!DEM_PUSH_STR(ddata, "operator*="))
3263 case SIMPLE_HASH('m', 'm'):
3265 if (!DEM_PUSH_STR(ddata, "operator--"))
3270 case SIMPLE_HASH('n', 'a'):
3271 /* operator new[] */
3272 if (!DEM_PUSH_STR(ddata, "operator new []"))
3277 case SIMPLE_HASH('n', 'e'):
3279 if (!DEM_PUSH_STR(ddata, "operator!="))
3284 case SIMPLE_HASH('n', 'g'):
3285 /* operator - (unary) */
3286 if (!DEM_PUSH_STR(ddata, "operator-"))
3291 case SIMPLE_HASH('n', 't'):
3293 if (!DEM_PUSH_STR(ddata, "operator!"))
3298 case SIMPLE_HASH('n', 'w'):
3300 if (!DEM_PUSH_STR(ddata, "operator new"))
3305 case SIMPLE_HASH('o', 'o'):
3307 if (!DEM_PUSH_STR(ddata, "operator||"))
3312 case SIMPLE_HASH('o', 'r'):
3314 if (!DEM_PUSH_STR(ddata, "operator|"))
3319 case SIMPLE_HASH('o', 'R'):
3321 if (!DEM_PUSH_STR(ddata, "operator|="))
3326 case SIMPLE_HASH('p', 'l'):
3328 if (!DEM_PUSH_STR(ddata, "operator+"))
3333 case SIMPLE_HASH('p', 'L'):
3335 if (!DEM_PUSH_STR(ddata, "operator+="))
3340 case SIMPLE_HASH('p', 'm'):
3342 if (!DEM_PUSH_STR(ddata, "operator->*"))
3347 case SIMPLE_HASH('p', 'p'):
3349 if (!DEM_PUSH_STR(ddata, "operator++"))
3354 case SIMPLE_HASH('p', 's'):
3355 /* operator + (unary) */
3356 if (!DEM_PUSH_STR(ddata, "operator+"))
3361 case SIMPLE_HASH('p', 't'):
3363 if (!DEM_PUSH_STR(ddata, "operator->"))
3368 case SIMPLE_HASH('q', 'u'):
3370 if (!DEM_PUSH_STR(ddata, "operator?"))
3375 case SIMPLE_HASH('r', 'm'):
3377 if (!DEM_PUSH_STR(ddata, "operator%"))
3382 case SIMPLE_HASH('r', 'M'):
3384 if (!DEM_PUSH_STR(ddata, "operator%="))
3389 case SIMPLE_HASH('r', 's'):
3391 if (!DEM_PUSH_STR(ddata, "operator>>"))
3396 case SIMPLE_HASH('r', 'S'):
3398 if (!DEM_PUSH_STR(ddata, "operator>>="))
3403 case SIMPLE_HASH('r', 'z'):
3404 /* operator sizeof */
3405 if (!DEM_PUSH_STR(ddata, "operator sizeof "))
3410 case SIMPLE_HASH('s', 'r'):
3411 /* scope resolution operator */
3412 if (!DEM_PUSH_STR(ddata, "scope resolution operator "))
3417 case SIMPLE_HASH('s', 'v'):
3418 /* operator sizeof */
3419 if (!DEM_PUSH_STR(ddata, "operator sizeof "))
3425 /* vendor extened operator */
3426 if (*ddata->cur == 'v' && ELFTC_ISDIGIT(*(ddata->cur + 1))) {
3427 if (!DEM_PUSH_STR(ddata, "vendor extened operator "))
3429 if (!cpp_demangle_push_str(ddata, ddata->cur + 1, 1))
3432 return (cpp_demangle_read_sname(ddata));
3435 /* ctor-dtor-name */
3436 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
3437 case SIMPLE_HASH('C', '1'):
3438 case SIMPLE_HASH('C', '2'):
3439 case SIMPLE_HASH('C', '3'):
3440 if (ddata->last_sname == NULL)
3442 if ((len = strlen(ddata->last_sname)) == 0)
3444 if (!DEM_PUSH_STR(ddata, "::"))
3446 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
3451 case SIMPLE_HASH('D', '0'):
3452 case SIMPLE_HASH('D', '1'):
3453 case SIMPLE_HASH('D', '2'):
3454 if (ddata->last_sname == NULL)
3456 if ((len = strlen(ddata->last_sname)) == 0)
3458 if (!DEM_PUSH_STR(ddata, "::~"))
3460 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
3467 if (ELFTC_ISDIGIT(*ddata->cur) != 0)
3468 return (cpp_demangle_read_sname(ddata));
3470 /* local source name */
3471 if (*ddata->cur == 'L')
3472 return (cpp_demangle_local_source_name(ddata));
3478 * Read local source name.
3481 * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31775
3482 * http://gcc.gnu.org/viewcvs?view=rev&revision=124467
3485 cpp_demangle_local_source_name(struct cpp_demangle_data *ddata)
3488 if (ddata == NULL || *ddata->cur != 'L')
3493 if (!cpp_demangle_read_sname(ddata))
3497 if (*ddata->cur == '_') {
3499 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
3507 cpp_demangle_read_v_offset(struct cpp_demangle_data *ddata)
3513 if (!DEM_PUSH_STR(ddata, "offset : "))
3516 if (!cpp_demangle_read_offset_number(ddata))
3519 if (!DEM_PUSH_STR(ddata, "virtual offset : "))
3522 return (!cpp_demangle_read_offset_number(ddata));
3526 * Decode floating point representation to string
3527 * Return new allocated string or NULL
3530 * Replace these functions to macro.
3533 decode_fp_to_double(const char *p, size_t len)
3536 size_t rtn_len, limit, i;
3540 if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(double))
3543 memset(&f, 0, sizeof(double));
3545 for (i = 0; i < len / 2; ++i) {
3546 byte = hex_to_dec(p[len - i * 2 - 1]) +
3547 hex_to_dec(p[len - i * 2 - 2]) * 16;
3549 if (byte < 0 || byte > 255)
3552 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3553 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3554 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3555 ((unsigned char *)&f)[sizeof(double) - i - 1] =
3556 (unsigned char)(byte);
3557 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3563 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3566 if (snprintf(rtn, rtn_len, "%fld", f) >= (int)rtn_len) {
3568 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3570 rtn_len *= BUFFER_GROWFACTOR;
3578 decode_fp_to_float(const char *p, size_t len)
3580 size_t i, rtn_len, limit;
3585 if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(float))
3588 memset(&f, 0, sizeof(float));
3590 for (i = 0; i < len / 2; ++i) {
3591 byte = hex_to_dec(p[len - i * 2 - 1]) +
3592 hex_to_dec(p[len - i * 2 - 2]) * 16;
3593 if (byte < 0 || byte > 255)
3595 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3596 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3597 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3598 ((unsigned char *)&f)[sizeof(float) - i - 1] =
3599 (unsigned char)(byte);
3600 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3606 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3609 if (snprintf(rtn, rtn_len, "%ff", f) >= (int)rtn_len) {
3611 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3613 rtn_len *= BUFFER_GROWFACTOR;
3621 decode_fp_to_float128(const char *p, size_t len)
3624 size_t rtn_len, limit, i;
3626 unsigned char buf[FLOAT_QUADRUPLE_BYTES];
3629 switch(sizeof(long double)) {
3630 case FLOAT_QUADRUPLE_BYTES:
3631 return (decode_fp_to_long_double(p, len));
3632 case FLOAT_EXTENED_BYTES:
3633 if (p == NULL || len == 0 || len % 2 != 0 ||
3634 len / 2 > FLOAT_QUADRUPLE_BYTES)
3637 memset(buf, 0, FLOAT_QUADRUPLE_BYTES);
3639 for (i = 0; i < len / 2; ++i) {
3640 byte = hex_to_dec(p[len - i * 2 - 1]) +
3641 hex_to_dec(p[len - i * 2 - 2]) * 16;
3642 if (byte < 0 || byte > 255)
3644 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3645 buf[i] = (unsigned char)(byte);
3646 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3647 buf[FLOAT_QUADRUPLE_BYTES - i -1] =
3648 (unsigned char)(byte);
3649 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3651 memset(&f, 0, FLOAT_EXTENED_BYTES);
3653 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3654 memcpy(&f, buf, FLOAT_EXTENED_BYTES);
3655 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3656 memcpy(&f, buf + 6, FLOAT_EXTENED_BYTES);
3657 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3662 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3665 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3667 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3669 rtn_len *= BUFFER_GROWFACTOR;
3680 decode_fp_to_float80(const char *p, size_t len)
3683 size_t rtn_len, limit, i;
3685 unsigned char buf[FLOAT_EXTENED_BYTES];
3688 switch(sizeof(long double)) {
3689 case FLOAT_QUADRUPLE_BYTES:
3690 if (p == NULL || len == 0 || len % 2 != 0 ||
3691 len / 2 > FLOAT_EXTENED_BYTES)
3694 memset(buf, 0, FLOAT_EXTENED_BYTES);
3696 for (i = 0; i < len / 2; ++i) {
3697 byte = hex_to_dec(p[len - i * 2 - 1]) +
3698 hex_to_dec(p[len - i * 2 - 2]) * 16;
3700 if (byte < 0 || byte > 255)
3703 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3704 buf[i] = (unsigned char)(byte);
3705 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3706 buf[FLOAT_EXTENED_BYTES - i -1] =
3707 (unsigned char)(byte);
3708 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3711 memset(&f, 0, FLOAT_QUADRUPLE_BYTES);
3713 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3714 memcpy(&f, buf, FLOAT_EXTENED_BYTES);
3715 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3716 memcpy((unsigned char *)(&f) + 6, buf, FLOAT_EXTENED_BYTES);
3717 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3722 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3725 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3727 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3729 rtn_len *= BUFFER_GROWFACTOR;
3734 case FLOAT_EXTENED_BYTES:
3735 return (decode_fp_to_long_double(p, len));
3742 decode_fp_to_long_double(const char *p, size_t len)
3745 size_t rtn_len, limit, i;
3749 if (p == NULL || len == 0 || len % 2 != 0 ||
3750 len / 2 > sizeof(long double))
3753 memset(&f, 0, sizeof(long double));
3755 for (i = 0; i < len / 2; ++i) {
3756 byte = hex_to_dec(p[len - i * 2 - 1]) +
3757 hex_to_dec(p[len - i * 2 - 2]) * 16;
3759 if (byte < 0 || byte > 255)
3762 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3763 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3764 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3765 ((unsigned char *)&f)[sizeof(long double) - i - 1] =
3766 (unsigned char)(byte);
3767 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3773 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3776 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3778 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3780 rtn_len *= BUFFER_GROWFACTOR;
3787 /* Simple hex to integer function used by decode_to_* function. */
3831 * @brief Test input string is mangled by IA-64 C++ ABI style.
3833 * Test string heads with "_Z" or "_GLOBAL__I_".
3834 * @return Return 0 at false.
3837 is_cpp_mangled_gnu3(const char *org)
3842 return ((len > 2 && *org == '_' && *(org + 1) == 'Z') ||
3843 (len > 11 && !strncmp(org, "_GLOBAL__I_", 11)));
3847 vector_read_cmd_dest(struct vector_read_cmd *v)
3853 free(v->r_container);
3856 static struct read_cmd_item *
3857 vector_read_cmd_find(struct vector_read_cmd *v, enum read_cmd dst)
3861 if (v == NULL || dst == READ_FAIL)
3864 for (i = (int) v->size - 1; i >= 0; i--)
3865 if (v->r_container[i].cmd == dst)
3866 return (&v->r_container[i]);
3872 vector_read_cmd_init(struct vector_read_cmd *v)
3879 v->capacity = VECTOR_DEF_CAPACITY;
3881 if ((v->r_container = malloc(sizeof(*v->r_container) * v->capacity))
3889 vector_read_cmd_pop(struct vector_read_cmd *v)
3892 if (v == NULL || v->size == 0)
3896 v->r_container[v->size].cmd = READ_FAIL;
3897 v->r_container[v->size].data = NULL;
3903 vector_read_cmd_push(struct vector_read_cmd *v, enum read_cmd cmd, void *data)
3905 struct read_cmd_item *tmp_r_ctn;
3912 if (v->size == v->capacity) {
3913 tmp_cap = v->capacity * BUFFER_GROWFACTOR;
3914 if ((tmp_r_ctn = malloc(sizeof(*tmp_r_ctn) * tmp_cap)) == NULL)
3916 for (i = 0; i < v->size; ++i)
3917 tmp_r_ctn[i] = v->r_container[i];
3918 free(v->r_container);
3919 v->r_container = tmp_r_ctn;
3920 v->capacity = tmp_cap;
3923 v->r_container[v->size].cmd = cmd;
3924 v->r_container[v->size].data = data;
3931 vector_type_qualifier_dest(struct vector_type_qualifier *v)
3937 free(v->q_container);
3938 vector_str_dest(&v->ext_name);
3941 /* size, capacity, ext_name */
3943 vector_type_qualifier_init(struct vector_type_qualifier *v)
3950 v->capacity = VECTOR_DEF_CAPACITY;
3952 if ((v->q_container = malloc(sizeof(enum type_qualifier) * v->capacity))
3956 assert(v->q_container != NULL);
3958 if (vector_str_init(&v->ext_name) == false) {
3959 free(v->q_container);
3967 vector_type_qualifier_push(struct vector_type_qualifier *v,
3968 enum type_qualifier t)
3970 enum type_qualifier *tmp_ctn;
3977 if (v->size == v->capacity) {
3978 tmp_cap = v->capacity * BUFFER_GROWFACTOR;
3979 if ((tmp_ctn = malloc(sizeof(enum type_qualifier) * tmp_cap))
3982 for (i = 0; i < v->size; ++i)
3983 tmp_ctn[i] = v->q_container[i];
3984 free(v->q_container);
3985 v->q_container = tmp_ctn;
3986 v->capacity = tmp_cap;
3989 v->q_container[v->size] = t;