2 * Copyright (c) 2007, 2008 Hyogeol Lee <hyogeollee@gmail.com>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer
10 * in this position and unchanged.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 #include <sys/types.h>
37 * @file cpp_demangle.c
38 * @brief Decode IA-64 C++ ABI style implementation.
40 * IA-64 standard ABI(Itanium C++ ABI) references.
42 * http://www.codesourcery.com/cxx-abi/abi.html#mangling \n
43 * http://www.codesourcery.com/cxx-abi/abi-mangling.html
46 /** @brief Dynamic vector data for string. */
56 #define BUFFER_GROWFACTOR 1.618
57 #define VECTOR_DEF_CAPACITY 8
58 #define ELFTC_ISDIGIT(C) (isdigit((C) & 0xFF))
61 TYPE_PTR, TYPE_REF, TYPE_CMX, TYPE_IMG, TYPE_EXT, TYPE_RST, TYPE_VAT,
65 struct vector_type_qualifier {
66 size_t size, capacity;
67 enum type_qualifier *q_container;
68 struct vector_str ext_name;
72 READ_FAIL, READ_NEST, READ_TMPL, READ_EXPR, READ_EXPL, READ_LOCAL,
73 READ_TYPE, READ_FUNC, READ_PTRMEM
76 struct vector_read_cmd {
77 size_t size, capacity;
78 enum read_cmd *r_container;
81 struct cpp_demangle_data {
82 struct vector_str output; /* output string vector */
83 struct vector_str output_tmp;
84 struct vector_str subst; /* substitution string vector */
85 struct vector_str tmpl;
86 struct vector_str class_type;
87 struct vector_read_cmd cmd;
88 bool paren; /* parenthesis opened */
89 bool pfirst; /* first element of parameter */
90 bool mem_rst; /* restrict member function */
91 bool mem_vat; /* volatile member function */
92 bool mem_cst; /* const member function */
94 const char *cur; /* current mangled name ptr */
95 const char *last_sname; /* last source name */
99 #define CPP_DEMANGLE_TRY_LIMIT 128
100 #define FLOAT_SPRINTF_TRY_LIMIT 5
101 #define FLOAT_QUADRUPLE_BYTES 16
102 #define FLOAT_EXTENED_BYTES 10
104 #define SIMPLE_HASH(x,y) (64 * x + y)
106 static size_t get_strlen_sum(const struct vector_str *v);
107 static bool vector_str_grow(struct vector_str *v);
110 get_strlen_sum(const struct vector_str *v)
119 for (i = 0; i < v->size; ++i)
120 len += strlen(v->container[i]);
126 * @brief Deallocate resource in vector_str.
129 vector_str_dest(struct vector_str *v)
136 for (i = 0; i < v->size; ++i)
137 free(v->container[i]);
143 * @brief Find string in vector_str.
144 * @param v Destination vector.
145 * @param o String to find.
146 * @param l Length of the string.
147 * @return -1 at failed, 0 at not found, 1 at found.
150 vector_str_find(const struct vector_str *v, const char *o, size_t l)
154 if (v == NULL || o == NULL)
157 for (i = 0; i < v->size; ++i)
158 if (strncmp(v->container[i], o, l) == 0)
165 * @brief Get new allocated flat string from vector.
167 * If l is not NULL, return length of the string.
168 * @param v Destination vector.
169 * @param l Length of the string.
170 * @return NULL at failed or NUL terminated new allocated string.
173 vector_str_get_flat(const struct vector_str *v, size_t *l)
175 ssize_t elem_pos, elem_size, rtn_size;
179 if (v == NULL || v->size == 0)
182 if ((rtn_size = get_strlen_sum(v)) == 0)
185 if ((rtn = malloc(sizeof(char) * (rtn_size + 1))) == NULL)
189 for (i = 0; i < v->size; ++i) {
190 elem_size = strlen(v->container[i]);
192 memcpy(rtn + elem_pos, v->container[i], elem_size);
194 elem_pos += elem_size;
197 rtn[rtn_size] = '\0';
206 vector_str_grow(struct vector_str *v)
214 assert(v->capacity > 0);
216 tmp_cap = v->capacity * BUFFER_GROWFACTOR;
218 assert(tmp_cap > v->capacity);
220 if ((tmp_ctn = malloc(sizeof(char *) * tmp_cap)) == NULL)
223 for (i = 0; i < v->size; ++i)
224 tmp_ctn[i] = v->container[i];
228 v->container = tmp_ctn;
229 v->capacity = tmp_cap;
235 * @brief Initialize vector_str.
236 * @return false at failed, true at success.
239 vector_str_init(struct vector_str *v)
246 v->capacity = VECTOR_DEF_CAPACITY;
248 assert(v->capacity > 0);
250 if ((v->container = malloc(sizeof(char *) * v->capacity)) == NULL)
253 assert(v->container != NULL);
259 * @brief Remove last element in vector_str.
260 * @return false at failed, true at success.
263 vector_str_pop(struct vector_str *v)
274 free(v->container[v->size]);
275 v->container[v->size] = NULL;
281 * @brief Push back string to vector.
282 * @return false at failed, true at success.
285 vector_str_push(struct vector_str *v, const char *str, size_t len)
288 if (v == NULL || str == NULL)
291 if (v->size == v->capacity && vector_str_grow(v) == false)
294 if ((v->container[v->size] = malloc(sizeof(char) * (len + 1))) == NULL)
297 snprintf(v->container[v->size], len + 1, "%s", str);
305 * @brief Push front org vector to det vector.
306 * @return false at failed, true at success.
309 vector_str_push_vector_head(struct vector_str *dst, struct vector_str *org)
311 size_t i, j, tmp_cap;
314 if (dst == NULL || org == NULL)
317 tmp_cap = (dst->size + org->size) * BUFFER_GROWFACTOR;
319 if ((tmp_ctn = malloc(sizeof(char *) * tmp_cap)) == NULL)
322 for (i = 0; i < org->size; ++i)
323 if ((tmp_ctn[i] = strdup(org->container[i])) == NULL) {
324 for (j = 0; j < i; ++j)
332 for (i = 0; i < dst->size; ++i)
333 tmp_ctn[i + org->size] = dst->container[i];
335 free(dst->container);
337 dst->container = tmp_ctn;
338 dst->capacity = tmp_cap;
339 dst->size += org->size;
345 * @brief Get new allocated flat string from vector between begin and end.
347 * If r_len is not NULL, string length will be returned.
348 * @return NULL at failed or NUL terminated new allocated string.
351 vector_str_substr(const struct vector_str *v, size_t begin, size_t end,
357 if (v == NULL || begin > end)
361 for (i = begin; i < end + 1; ++i)
362 len += strlen(v->container[i]);
364 if ((rtn = malloc(sizeof(char) * (len + 1))) == NULL)
371 for (i = begin; i < end + 1; ++i) {
372 len = strlen(v->container[i]);
373 memcpy(rtn + cur, v->container[i], len);
381 static void cpp_demangle_data_dest(struct cpp_demangle_data *);
382 static int cpp_demangle_data_init(struct cpp_demangle_data *,
384 static int cpp_demangle_get_subst(struct cpp_demangle_data *, size_t);
385 static int cpp_demangle_get_tmpl_param(struct cpp_demangle_data *, size_t);
386 static int cpp_demangle_push_fp(struct cpp_demangle_data *,
387 char *(*)(const char *, size_t));
388 static int cpp_demangle_push_str(struct cpp_demangle_data *, const char *,
390 static int cpp_demangle_push_subst(struct cpp_demangle_data *,
391 const char *, size_t);
392 static int cpp_demangle_push_subst_v(struct cpp_demangle_data *,
393 struct vector_str *);
394 static int cpp_demangle_push_type_qualifier(struct cpp_demangle_data *,
395 struct vector_type_qualifier *, const char *);
396 static int cpp_demangle_read_array(struct cpp_demangle_data *);
397 static int cpp_demangle_read_encoding(struct cpp_demangle_data *);
398 static int cpp_demangle_read_expr_primary(struct cpp_demangle_data *);
399 static int cpp_demangle_read_expression(struct cpp_demangle_data *);
400 static int cpp_demangle_read_expression_flat(struct cpp_demangle_data *,
402 static int cpp_demangle_read_expression_binary(struct cpp_demangle_data *,
403 const char *, size_t);
404 static int cpp_demangle_read_expression_unary(struct cpp_demangle_data *,
405 const char *, size_t);
406 static int cpp_demangle_read_expression_trinary(struct cpp_demangle_data *,
407 const char *, size_t, const char *, size_t);
408 static int cpp_demangle_read_function(struct cpp_demangle_data *, int *,
409 struct vector_type_qualifier *);
410 static int cpp_demangle_local_source_name(struct cpp_demangle_data *ddata);
411 static int cpp_demangle_read_local_name(struct cpp_demangle_data *);
412 static int cpp_demangle_read_name(struct cpp_demangle_data *);
413 static int cpp_demangle_read_name_flat(struct cpp_demangle_data *,
415 static int cpp_demangle_read_nested_name(struct cpp_demangle_data *);
416 static int cpp_demangle_read_number(struct cpp_demangle_data *, long *);
417 static int cpp_demangle_read_number_as_string(struct cpp_demangle_data *,
419 static int cpp_demangle_read_nv_offset(struct cpp_demangle_data *);
420 static int cpp_demangle_read_offset(struct cpp_demangle_data *);
421 static int cpp_demangle_read_offset_number(struct cpp_demangle_data *);
422 static int cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *);
423 static int cpp_demangle_read_sname(struct cpp_demangle_data *);
424 static int cpp_demangle_read_subst(struct cpp_demangle_data *);
425 static int cpp_demangle_read_subst_std(struct cpp_demangle_data *);
426 static int cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *,
427 const char *, size_t);
428 static int cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *);
429 static int cpp_demangle_read_tmpl_args(struct cpp_demangle_data *);
430 static int cpp_demangle_read_tmpl_param(struct cpp_demangle_data *);
431 static int cpp_demangle_read_type(struct cpp_demangle_data *, int);
432 static int cpp_demangle_read_type_flat(struct cpp_demangle_data *,
434 static int cpp_demangle_read_uqname(struct cpp_demangle_data *);
435 static int cpp_demangle_read_v_offset(struct cpp_demangle_data *);
436 static char *decode_fp_to_double(const char *, size_t);
437 static char *decode_fp_to_float(const char *, size_t);
438 static char *decode_fp_to_float128(const char *, size_t);
439 static char *decode_fp_to_float80(const char *, size_t);
440 static char *decode_fp_to_long_double(const char *, size_t);
441 static int hex_to_dec(char);
442 static void vector_read_cmd_dest(struct vector_read_cmd *);
443 static int vector_read_cmd_find(struct vector_read_cmd *, enum read_cmd);
444 static int vector_read_cmd_init(struct vector_read_cmd *);
445 static int vector_read_cmd_pop(struct vector_read_cmd *);
446 static int vector_read_cmd_push(struct vector_read_cmd *, enum read_cmd);
447 static void vector_type_qualifier_dest(struct vector_type_qualifier *);
448 static int vector_type_qualifier_init(struct vector_type_qualifier *);
449 static int vector_type_qualifier_push(struct vector_type_qualifier *,
450 enum type_qualifier);
453 * @brief Decode the input string by IA-64 C++ ABI style.
455 * GNU GCC v3 use IA-64 standard ABI.
456 * @return New allocated demangled string or NULL if failed.
457 * @todo 1. Testing and more test case. 2. Code cleaning.
460 __cxa_demangle_gnu3(const char *org)
462 struct cpp_demangle_data ddata;
470 org_len = strlen(org);
471 if (org_len > 11 && !strncmp(org, "_GLOBAL__I_", 11)) {
472 if ((rtn = malloc(org_len + 19)) == NULL)
474 snprintf(rtn, org_len + 19,
475 "global constructors keyed to %s", org + 11);
479 // Try demangling as a type for short encodings
480 if ((org_len < 2) || (org[0] != '_' || org[1] != 'Z' )) {
481 if (!cpp_demangle_data_init(&ddata, org))
483 if (!cpp_demangle_read_type(&ddata, 0))
485 rtn = vector_str_get_flat(&ddata.output, (size_t *) NULL);
490 if (!cpp_demangle_data_init(&ddata, org + 2))
495 if (!cpp_demangle_read_encoding(&ddata))
499 while (*ddata.cur != '\0') {
501 * Breaking at some gcc info at tail. e.g) @@GLIBCXX_3.4
503 if (*ddata.cur == '@' && *(ddata.cur + 1) == '@')
505 if (!cpp_demangle_read_type(&ddata, 1))
507 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
511 if (ddata.output.size == 0)
513 if (ddata.paren && !vector_str_push(&ddata.output, ")", 1))
515 if (ddata.mem_vat && !vector_str_push(&ddata.output, " volatile", 9))
517 if (ddata.mem_cst && !vector_str_push(&ddata.output, " const", 6))
519 if (ddata.mem_rst && !vector_str_push(&ddata.output, " restrict", 9))
522 rtn = vector_str_get_flat(&ddata.output, (size_t *) NULL);
525 cpp_demangle_data_dest(&ddata);
531 cpp_demangle_data_dest(struct cpp_demangle_data *d)
537 vector_read_cmd_dest(&d->cmd);
538 vector_str_dest(&d->class_type);
539 vector_str_dest(&d->tmpl);
540 vector_str_dest(&d->subst);
541 vector_str_dest(&d->output_tmp);
542 vector_str_dest(&d->output);
546 cpp_demangle_data_init(struct cpp_demangle_data *d, const char *cur)
549 if (d == NULL || cur == NULL)
552 if (!vector_str_init(&d->output))
554 if (!vector_str_init(&d->output_tmp))
556 if (!vector_str_init(&d->subst))
558 if (!vector_str_init(&d->tmpl))
560 if (!vector_str_init(&d->class_type))
562 if (!vector_read_cmd_init(&d->cmd))
565 assert(d->output.container != NULL);
566 assert(d->output_tmp.container != NULL);
567 assert(d->subst.container != NULL);
568 assert(d->tmpl.container != NULL);
569 assert(d->class_type.container != NULL);
578 d->last_sname = NULL;
584 vector_str_dest(&d->class_type);
586 vector_str_dest(&d->tmpl);
588 vector_str_dest(&d->subst);
590 vector_str_dest(&d->output_tmp);
592 vector_str_dest(&d->output);
598 cpp_demangle_push_fp(struct cpp_demangle_data *ddata,
599 char *(*decoder)(const char *, size_t))
606 if (ddata == NULL || decoder == NULL)
610 while (*ddata->cur != 'E')
613 if ((f = decoder(fp, ddata->cur - fp)) == NULL)
617 if ((len = strlen(f)) > 0)
618 rtn = cpp_demangle_push_str(ddata, f, len);
628 cpp_demangle_push_str(struct cpp_demangle_data *ddata, const char *str,
632 if (ddata == NULL || str == NULL || len == 0)
635 if (ddata->push_head > 0)
636 return (vector_str_push(&ddata->output_tmp, str, len));
638 return (vector_str_push(&ddata->output, str, len));
642 cpp_demangle_push_subst(struct cpp_demangle_data *ddata, const char *str,
646 if (ddata == NULL || str == NULL || len == 0)
649 if (!vector_str_find(&ddata->subst, str, len))
650 return (vector_str_push(&ddata->subst, str, len));
656 cpp_demangle_push_subst_v(struct cpp_demangle_data *ddata, struct vector_str *v)
662 if (ddata == NULL || v == NULL)
665 if ((str = vector_str_get_flat(v, &str_len)) == NULL)
668 rtn = cpp_demangle_push_subst(ddata, str, str_len);
676 cpp_demangle_push_type_qualifier(struct cpp_demangle_data *ddata,
677 struct vector_type_qualifier *v, const char *type_str)
679 struct vector_str subst_v;
680 size_t idx, e_idx, e_len;
684 if (ddata == NULL || v == NULL)
687 if ((idx = v->size) == 0)
691 if (type_str != NULL) {
692 if (!vector_str_init(&subst_v))
694 if (!vector_str_push(&subst_v, type_str, strlen(type_str)))
700 switch (v->q_container[idx - 1]) {
702 if (!cpp_demangle_push_str(ddata, "*", 1))
704 if (type_str != NULL) {
705 if (!vector_str_push(&subst_v, "*", 1))
707 if (!cpp_demangle_push_subst_v(ddata,
714 if (!cpp_demangle_push_str(ddata, "&", 1))
716 if (type_str != NULL) {
717 if (!vector_str_push(&subst_v, "&", 1))
719 if (!cpp_demangle_push_subst_v(ddata,
726 if (!cpp_demangle_push_str(ddata, " complex", 8))
728 if (type_str != NULL) {
729 if (!vector_str_push(&subst_v, " complex", 8))
731 if (!cpp_demangle_push_subst_v(ddata,
738 if (!cpp_demangle_push_str(ddata, " imaginary", 10))
740 if (type_str != NULL) {
741 if (!vector_str_push(&subst_v, " imaginary",
744 if (!cpp_demangle_push_subst_v(ddata,
751 if (v->ext_name.size == 0 ||
752 e_idx > v->ext_name.size - 1)
754 if ((e_len = strlen(v->ext_name.container[e_idx])) ==
757 if ((buf = malloc(e_len + 2)) == NULL)
759 snprintf(buf, e_len + 2, " %s",
760 v->ext_name.container[e_idx]);
762 if (!cpp_demangle_push_str(ddata, buf, e_len + 1)) {
767 if (type_str != NULL) {
768 if (!vector_str_push(&subst_v, buf,
773 if (!cpp_demangle_push_subst_v(ddata,
784 if (!cpp_demangle_push_str(ddata, " restrict", 9))
786 if (type_str != NULL) {
787 if (!vector_str_push(&subst_v, " restrict", 9))
789 if (!cpp_demangle_push_subst_v(ddata,
796 if (!cpp_demangle_push_str(ddata, " volatile", 9))
798 if (type_str != NULL) {
799 if (!vector_str_push(&subst_v, " volatile", 9))
801 if (!cpp_demangle_push_subst_v(ddata,
808 if (!cpp_demangle_push_str(ddata, " const", 6))
810 if (type_str != NULL) {
811 if (!vector_str_push(&subst_v, " const", 6))
813 if (!cpp_demangle_push_subst_v(ddata,
820 if (v->ext_name.size == 0 ||
821 e_idx > v->ext_name.size - 1)
823 if ((e_len = strlen(v->ext_name.container[e_idx])) ==
826 if ((buf = malloc(e_len + 12)) == NULL)
828 snprintf(buf, e_len + 12, " __vector(%s)",
829 v->ext_name.container[e_idx]);
830 if (!cpp_demangle_push_str(ddata, buf, e_len + 11)) {
834 if (type_str != NULL) {
835 if (!vector_str_push(&subst_v, buf,
840 if (!cpp_demangle_push_subst_v(ddata,
855 if (type_str != NULL)
856 vector_str_dest(&subst_v);
862 cpp_demangle_get_subst(struct cpp_demangle_data *ddata, size_t idx)
866 if (ddata == NULL || ddata->subst.size <= idx)
868 if ((len = strlen(ddata->subst.container[idx])) == 0)
870 if (!cpp_demangle_push_str(ddata, ddata->subst.container[idx], len))
880 cpp_demangle_get_tmpl_param(struct cpp_demangle_data *ddata, size_t idx)
884 if (ddata == NULL || ddata->tmpl.size <= idx)
886 if ((len = strlen(ddata->tmpl.container[idx])) == 0)
888 if (!cpp_demangle_push_str(ddata, ddata->tmpl.container[idx], len))
897 cpp_demangle_read_array(struct cpp_demangle_data *ddata)
899 size_t i, num_len, exp_len, p_idx, idx;
903 if (ddata == NULL || *(++ddata->cur) == '\0')
906 if (*ddata->cur == '_') {
907 if (*(++ddata->cur) == '\0')
910 if (!cpp_demangle_read_type(ddata, 0))
913 if (!cpp_demangle_push_str(ddata, "[]", 2))
916 if (ELFTC_ISDIGIT(*ddata->cur) != 0) {
918 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
920 if (*ddata->cur != '_')
922 num_len = ddata->cur - num;
924 if (*(++ddata->cur) == '\0')
926 if (!cpp_demangle_read_type(ddata, 0))
928 if (!cpp_demangle_push_str(ddata, "[", 1))
930 if (!cpp_demangle_push_str(ddata, num, num_len))
932 if (!cpp_demangle_push_str(ddata, "]", 1))
935 p_idx = ddata->output.size;
936 if (!cpp_demangle_read_expression(ddata))
938 if ((exp = vector_str_substr(&ddata->output, p_idx,
939 ddata->output.size - 1, &exp_len)) == NULL)
941 idx = ddata->output.size;
942 for (i = p_idx; i < idx; ++i)
943 if (!vector_str_pop(&ddata->output)) {
947 if (*ddata->cur != '_') {
952 if (*ddata->cur == '\0') {
956 if (!cpp_demangle_read_type(ddata, 0)) {
960 if (!cpp_demangle_push_str(ddata, "[", 1)) {
964 if (!cpp_demangle_push_str(ddata, exp, exp_len)) {
968 if (!cpp_demangle_push_str(ddata, "]", 1)) {
980 cpp_demangle_read_expr_primary(struct cpp_demangle_data *ddata)
984 if (ddata == NULL || *(++ddata->cur) == '\0')
987 if (*ddata->cur == '_' && *(ddata->cur + 1) == 'Z') {
989 if (*ddata->cur == '\0')
991 if (!cpp_demangle_read_encoding(ddata))
997 switch (*ddata->cur) {
999 if (*(ddata->cur + 2) != 'E')
1001 switch (*(++ddata->cur)) {
1004 return (cpp_demangle_push_str(ddata, "false", 5));
1007 return (cpp_demangle_push_str(ddata, "true", 4));
1014 return (cpp_demangle_push_fp(ddata, decode_fp_to_double));
1018 if (sizeof(long double) == 10)
1019 return (cpp_demangle_push_fp(ddata,
1020 decode_fp_to_double));
1021 return (cpp_demangle_push_fp(ddata, decode_fp_to_float80));
1025 return (cpp_demangle_push_fp(ddata, decode_fp_to_float));
1029 if (sizeof(long double) == 16)
1030 return (cpp_demangle_push_fp(ddata,
1031 decode_fp_to_double));
1032 return (cpp_demangle_push_fp(ddata, decode_fp_to_float128));
1043 if (*(++ddata->cur) == 'n') {
1044 if (!cpp_demangle_push_str(ddata, "-", 1))
1049 while (*ddata->cur != 'E') {
1050 if (!ELFTC_ISDIGIT(*ddata->cur))
1055 return (cpp_demangle_push_str(ddata, num,
1056 ddata->cur - num - 1));
1064 cpp_demangle_read_expression(struct cpp_demangle_data *ddata)
1067 if (ddata == NULL || *ddata->cur == '\0')
1070 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1071 case SIMPLE_HASH('s', 't'):
1073 return (cpp_demangle_read_type(ddata, 0));
1075 case SIMPLE_HASH('s', 'r'):
1077 if (!cpp_demangle_read_type(ddata, 0))
1079 if (!cpp_demangle_read_uqname(ddata))
1081 if (*ddata->cur == 'I')
1082 return (cpp_demangle_read_tmpl_args(ddata));
1085 case SIMPLE_HASH('a', 'a'):
1088 return (cpp_demangle_read_expression_binary(ddata, "&&", 2));
1090 case SIMPLE_HASH('a', 'd'):
1091 /* operator & (unary) */
1093 return (cpp_demangle_read_expression_unary(ddata, "&", 1));
1095 case SIMPLE_HASH('a', 'n'):
1098 return (cpp_demangle_read_expression_binary(ddata, "&", 1));
1100 case SIMPLE_HASH('a', 'N'):
1103 return (cpp_demangle_read_expression_binary(ddata, "&=", 2));
1105 case SIMPLE_HASH('a', 'S'):
1108 return (cpp_demangle_read_expression_binary(ddata, "=", 1));
1110 case SIMPLE_HASH('c', 'l'):
1113 return (cpp_demangle_read_expression_binary(ddata, "()", 2));
1115 case SIMPLE_HASH('c', 'm'):
1118 return (cpp_demangle_read_expression_binary(ddata, ",", 1));
1120 case SIMPLE_HASH('c', 'o'):
1123 return (cpp_demangle_read_expression_binary(ddata, "~", 1));
1125 case SIMPLE_HASH('c', 'v'):
1126 /* operator (cast) */
1128 return (cpp_demangle_read_expression_binary(ddata, "(cast)", 6));
1130 case SIMPLE_HASH('d', 'a'):
1131 /* operator delete [] */
1133 return (cpp_demangle_read_expression_unary(ddata, "delete []", 9));
1135 case SIMPLE_HASH('d', 'e'):
1136 /* operator * (unary) */
1138 return (cpp_demangle_read_expression_unary(ddata, "*", 1));
1140 case SIMPLE_HASH('d', 'l'):
1141 /* operator delete */
1143 return (cpp_demangle_read_expression_unary(ddata, "delete", 6));
1145 case SIMPLE_HASH('d', 'v'):
1148 return (cpp_demangle_read_expression_binary(ddata, "/", 1));
1150 case SIMPLE_HASH('d', 'V'):
1153 return (cpp_demangle_read_expression_binary(ddata, "/=", 2));
1155 case SIMPLE_HASH('e', 'o'):
1158 return (cpp_demangle_read_expression_binary(ddata, "^", 1));
1160 case SIMPLE_HASH('e', 'O'):
1163 return (cpp_demangle_read_expression_binary(ddata, "^=", 2));
1165 case SIMPLE_HASH('e', 'q'):
1168 return (cpp_demangle_read_expression_binary(ddata, "==", 2));
1170 case SIMPLE_HASH('g', 'e'):
1173 return (cpp_demangle_read_expression_binary(ddata, ">=", 2));
1175 case SIMPLE_HASH('g', 't'):
1178 return (cpp_demangle_read_expression_binary(ddata, ">", 1));
1180 case SIMPLE_HASH('i', 'x'):
1183 return (cpp_demangle_read_expression_binary(ddata, "[]", 2));
1185 case SIMPLE_HASH('l', 'e'):
1188 return (cpp_demangle_read_expression_binary(ddata, "<=", 2));
1190 case SIMPLE_HASH('l', 's'):
1193 return (cpp_demangle_read_expression_binary(ddata, "<<", 2));
1195 case SIMPLE_HASH('l', 'S'):
1198 return (cpp_demangle_read_expression_binary(ddata, "<<=", 3));
1200 case SIMPLE_HASH('l', 't'):
1203 return (cpp_demangle_read_expression_binary(ddata, "<", 1));
1205 case SIMPLE_HASH('m', 'i'):
1208 return (cpp_demangle_read_expression_binary(ddata, "-", 1));
1210 case SIMPLE_HASH('m', 'I'):
1213 return (cpp_demangle_read_expression_binary(ddata, "-=", 2));
1215 case SIMPLE_HASH('m', 'l'):
1218 return (cpp_demangle_read_expression_binary(ddata, "*", 1));
1220 case SIMPLE_HASH('m', 'L'):
1223 return (cpp_demangle_read_expression_binary(ddata, "*=", 2));
1225 case SIMPLE_HASH('m', 'm'):
1228 return (cpp_demangle_read_expression_binary(ddata, "--", 2));
1230 case SIMPLE_HASH('n', 'a'):
1231 /* operator new[] */
1233 return (cpp_demangle_read_expression_unary(ddata, "new []", 6));
1235 case SIMPLE_HASH('n', 'e'):
1238 return (cpp_demangle_read_expression_binary(ddata, "!=", 2));
1240 case SIMPLE_HASH('n', 'g'):
1241 /* operator - (unary) */
1243 return (cpp_demangle_read_expression_unary(ddata, "-", 1));
1245 case SIMPLE_HASH('n', 't'):
1248 return (cpp_demangle_read_expression_binary(ddata, "!", 1));
1250 case SIMPLE_HASH('n', 'w'):
1253 return (cpp_demangle_read_expression_unary(ddata, "new", 3));
1255 case SIMPLE_HASH('o', 'o'):
1258 return (cpp_demangle_read_expression_binary(ddata, "||", 2));
1260 case SIMPLE_HASH('o', 'r'):
1263 return (cpp_demangle_read_expression_binary(ddata, "|", 1));
1265 case SIMPLE_HASH('o', 'R'):
1268 return (cpp_demangle_read_expression_binary(ddata, "|=", 2));
1270 case SIMPLE_HASH('p', 'l'):
1273 return (cpp_demangle_read_expression_binary(ddata, "+", 1));
1275 case SIMPLE_HASH('p', 'L'):
1278 return (cpp_demangle_read_expression_binary(ddata, "+=", 2));
1280 case SIMPLE_HASH('p', 'm'):
1283 return (cpp_demangle_read_expression_binary(ddata, "->*", 3));
1285 case SIMPLE_HASH('p', 'p'):
1288 return (cpp_demangle_read_expression_binary(ddata, "++", 2));
1290 case SIMPLE_HASH('p', 's'):
1291 /* operator + (unary) */
1293 return (cpp_demangle_read_expression_unary(ddata, "+", 1));
1295 case SIMPLE_HASH('p', 't'):
1298 return (cpp_demangle_read_expression_binary(ddata, "->", 2));
1300 case SIMPLE_HASH('q', 'u'):
1303 return (cpp_demangle_read_expression_trinary(ddata, "?", 1,
1306 case SIMPLE_HASH('r', 'm'):
1309 return (cpp_demangle_read_expression_binary(ddata, "%", 1));
1311 case SIMPLE_HASH('r', 'M'):
1314 return (cpp_demangle_read_expression_binary(ddata, "%=", 2));
1316 case SIMPLE_HASH('r', 's'):
1319 return (cpp_demangle_read_expression_binary(ddata, ">>", 2));
1321 case SIMPLE_HASH('r', 'S'):
1324 return (cpp_demangle_read_expression_binary(ddata, ">>=", 3));
1326 case SIMPLE_HASH('r', 'z'):
1327 /* operator sizeof */
1329 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
1331 case SIMPLE_HASH('s', 'v'):
1332 /* operator sizeof */
1334 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
1337 switch (*ddata->cur) {
1339 return (cpp_demangle_read_expr_primary(ddata));
1341 return (cpp_demangle_read_tmpl_param(ddata));
1348 cpp_demangle_read_expression_flat(struct cpp_demangle_data *ddata, char **str)
1350 struct vector_str *output;
1351 size_t i, p_idx, idx, exp_len;
1354 output = ddata->push_head > 0 ? &ddata->output_tmp :
1357 p_idx = output->size;
1359 if (!cpp_demangle_read_expression(ddata))
1362 if ((exp = vector_str_substr(output, p_idx, output->size - 1,
1367 for (i = p_idx; i < idx; ++i) {
1368 if (!vector_str_pop(output)) {
1380 cpp_demangle_read_expression_binary(struct cpp_demangle_data *ddata,
1381 const char *name, size_t len)
1384 if (ddata == NULL || name == NULL || len == 0)
1386 if (!cpp_demangle_read_expression(ddata))
1388 if (!cpp_demangle_push_str(ddata, name, len))
1391 return (cpp_demangle_read_expression(ddata));
1395 cpp_demangle_read_expression_unary(struct cpp_demangle_data *ddata,
1396 const char *name, size_t len)
1399 if (ddata == NULL || name == NULL || len == 0)
1401 if (!cpp_demangle_read_expression(ddata))
1404 return (cpp_demangle_push_str(ddata, name, len));
1408 cpp_demangle_read_expression_trinary(struct cpp_demangle_data *ddata,
1409 const char *name1, size_t len1, const char *name2, size_t len2)
1412 if (ddata == NULL || name1 == NULL || len1 == 0 || name2 == NULL ||
1416 if (!cpp_demangle_read_expression(ddata))
1418 if (!cpp_demangle_push_str(ddata, name1, len1))
1420 if (!cpp_demangle_read_expression(ddata))
1422 if (!cpp_demangle_push_str(ddata, name2, len2))
1425 return (cpp_demangle_read_expression(ddata));
1429 cpp_demangle_read_function(struct cpp_demangle_data *ddata, int *ext_c,
1430 struct vector_type_qualifier *v)
1432 size_t class_type_size, class_type_len, limit;
1433 const char *class_type;
1435 if (ddata == NULL || *ddata->cur != 'F' || v == NULL)
1439 if (*ddata->cur == 'Y') {
1444 if (!cpp_demangle_read_type(ddata, 0))
1446 if (*ddata->cur != 'E') {
1447 if (!cpp_demangle_push_str(ddata, "(", 1))
1449 if (vector_read_cmd_find(&ddata->cmd, READ_PTRMEM)) {
1450 if ((class_type_size = ddata->class_type.size) == 0)
1453 ddata->class_type.container[class_type_size - 1];
1454 if (class_type == NULL)
1456 if ((class_type_len = strlen(class_type)) == 0)
1458 if (!cpp_demangle_push_str(ddata, class_type,
1461 if (!cpp_demangle_push_str(ddata, "::*", 3))
1465 if (!cpp_demangle_push_type_qualifier(ddata, v,
1466 (const char *) NULL))
1468 vector_type_qualifier_dest(v);
1469 if (!vector_type_qualifier_init(v))
1473 if (!cpp_demangle_push_str(ddata, ")(", 2))
1478 if (!cpp_demangle_read_type(ddata, 0))
1480 if (*ddata->cur == 'E')
1482 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1486 if (vector_read_cmd_find(&ddata->cmd, READ_PTRMEM) == 1) {
1487 if (!cpp_demangle_push_type_qualifier(ddata, v,
1488 (const char *) NULL))
1490 vector_type_qualifier_dest(v);
1491 if (!vector_type_qualifier_init(v))
1495 if (!cpp_demangle_push_str(ddata, ")", 1))
1504 /* read encoding, encoding are function name, data name, special-name */
1506 cpp_demangle_read_encoding(struct cpp_demangle_data *ddata)
1508 char *name, *type, *num_str;
1512 if (ddata == NULL || *ddata->cur == '\0')
1516 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1517 case SIMPLE_HASH('G', 'A'):
1518 if (!cpp_demangle_push_str(ddata, "hidden alias for ", 17))
1521 if (*ddata->cur == '\0')
1523 return (cpp_demangle_read_encoding(ddata));
1525 case SIMPLE_HASH('G', 'R'):
1526 if (!cpp_demangle_push_str(ddata, "reference temporary #", 21))
1529 if (*ddata->cur == '\0')
1531 if (!cpp_demangle_read_name_flat(ddata, &name))
1534 if (!cpp_demangle_read_number_as_string(ddata, &num_str))
1536 if (!cpp_demangle_push_str(ddata, num_str, strlen(num_str)))
1538 if (!cpp_demangle_push_str(ddata, " for ", 5))
1540 if (!cpp_demangle_push_str(ddata, name, strlen(name)))
1549 case SIMPLE_HASH('G', 'T'):
1551 if (*ddata->cur == '\0')
1553 switch (*ddata->cur) {
1555 if (!cpp_demangle_push_str(ddata,
1556 "non-transaction clone for ", 26))
1561 if (!cpp_demangle_push_str(ddata,
1562 "transaction clone for ", 22))
1567 return (cpp_demangle_read_encoding(ddata));
1569 case SIMPLE_HASH('G', 'V'):
1570 /* sentry object for 1 time init */
1571 if (!cpp_demangle_push_str(ddata, "guard variable for ", 20))
1576 case SIMPLE_HASH('T', 'c'):
1577 /* virtual function covariant override thunk */
1578 if (!cpp_demangle_push_str(ddata,
1579 "virtual function covariant override ", 36))
1582 if (*ddata->cur == '\0')
1584 if (!cpp_demangle_read_offset(ddata))
1586 if (!cpp_demangle_read_offset(ddata))
1588 return (cpp_demangle_read_encoding(ddata));
1590 case SIMPLE_HASH('T', 'C'):
1591 /* construction vtable */
1592 if (!cpp_demangle_push_str(ddata, "construction vtable for ",
1596 if (*ddata->cur == '\0')
1598 if (!cpp_demangle_read_type_flat(ddata, &type))
1601 if (!cpp_demangle_read_number(ddata, &offset))
1603 if (*ddata->cur++ != '_')
1605 if (!cpp_demangle_read_type(ddata, 0))
1607 if (!cpp_demangle_push_str(ddata, "-in-", 4))
1609 if (!cpp_demangle_push_str(ddata, type, strlen(type)))
1616 case SIMPLE_HASH('T', 'D'):
1617 /* typeinfo common proxy */
1620 case SIMPLE_HASH('T', 'F'):
1622 if (!cpp_demangle_push_str(ddata, "typeinfo fn for ", 16))
1625 if (*ddata->cur == '\0')
1627 return (cpp_demangle_read_type(ddata, 0));
1629 case SIMPLE_HASH('T', 'h'):
1630 /* virtual function non-virtual override thunk */
1631 if (!cpp_demangle_push_str(ddata,
1632 "virtual function non-virtual override ", 38))
1635 if (*ddata->cur == '\0')
1637 if (!cpp_demangle_read_nv_offset(ddata))
1639 return (cpp_demangle_read_encoding(ddata));
1641 case SIMPLE_HASH('T', 'H'):
1642 /* TLS init function */
1643 if (!cpp_demangle_push_str(ddata, "TLS init function for ",
1647 if (*ddata->cur == '\0')
1651 case SIMPLE_HASH('T', 'I'):
1652 /* typeinfo structure */
1653 if (!cpp_demangle_push_str(ddata, "typeinfo for ", 13))
1656 if (*ddata->cur == '\0')
1658 return (cpp_demangle_read_type(ddata, 0));
1660 case SIMPLE_HASH('T', 'J'):
1662 if (!cpp_demangle_push_str(ddata, "java Class for ", 15))
1665 if (*ddata->cur == '\0')
1667 return (cpp_demangle_read_type(ddata, 0));
1669 case SIMPLE_HASH('T', 'S'):
1670 /* RTTI name (NTBS) */
1671 if (!cpp_demangle_push_str(ddata, "typeinfo name for ", 18))
1674 if (*ddata->cur == '\0')
1676 return (cpp_demangle_read_type(ddata, 0));
1678 case SIMPLE_HASH('T', 'T'):
1680 if (!cpp_demangle_push_str(ddata, "VTT for ", 8))
1683 if (*ddata->cur == '\0')
1685 return (cpp_demangle_read_type(ddata, 0));
1687 case SIMPLE_HASH('T', 'v'):
1688 /* virtual function virtual override thunk */
1689 if (!cpp_demangle_push_str(ddata,
1690 "virtual function virtual override ", 34))
1693 if (*ddata->cur == '\0')
1695 if (!cpp_demangle_read_v_offset(ddata))
1697 return (cpp_demangle_read_encoding(ddata));
1699 case SIMPLE_HASH('T', 'V'):
1701 if (!cpp_demangle_push_str(ddata, "vtable for ", 12))
1704 if (*ddata->cur == '\0')
1706 return (cpp_demangle_read_type(ddata, 0));
1708 case SIMPLE_HASH('T', 'W'):
1709 /* TLS wrapper function */
1710 if (!cpp_demangle_push_str(ddata, "TLS wrapper function for ",
1714 if (*ddata->cur == '\0')
1719 return (cpp_demangle_read_name(ddata));
1723 cpp_demangle_read_local_name(struct cpp_demangle_data *ddata)
1729 if (*(++ddata->cur) == '\0')
1731 if (!cpp_demangle_read_encoding(ddata))
1736 if (!cpp_demangle_read_type(ddata, 1))
1738 if (*ddata->cur == 'E')
1740 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1743 if (*(++ddata->cur) == '\0')
1745 if (ddata->paren == true) {
1746 if (!cpp_demangle_push_str(ddata, ")", 1))
1748 ddata->paren = false;
1750 if (*ddata->cur == 's')
1753 if (!cpp_demangle_push_str(ddata, "::", 2))
1755 if (!cpp_demangle_read_name(ddata))
1758 if (*ddata->cur == '_') {
1760 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
1768 cpp_demangle_read_name(struct cpp_demangle_data *ddata)
1770 struct vector_str *output, v;
1771 size_t p_idx, subst_str_len;
1775 if (ddata == NULL || *ddata->cur == '\0')
1778 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
1782 switch (*ddata->cur) {
1784 return (cpp_demangle_read_subst(ddata));
1786 return (cpp_demangle_read_nested_name(ddata));
1788 return (cpp_demangle_read_local_name(ddata));
1791 if (!vector_str_init(&v))
1794 p_idx = output->size;
1796 if (!cpp_demangle_read_uqname(ddata))
1798 if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
1799 &subst_str_len)) == NULL)
1801 if (subst_str_len > 8 && strstr(subst_str, "operator") != NULL) {
1805 if (!vector_str_push(&v, subst_str, subst_str_len))
1807 if (!cpp_demangle_push_subst_v(ddata, &v))
1810 if (*ddata->cur == 'I') {
1811 p_idx = output->size;
1812 if (!cpp_demangle_read_tmpl_args(ddata))
1815 if ((subst_str = vector_str_substr(output, p_idx,
1816 output->size - 1, &subst_str_len)) == NULL)
1818 if (!vector_str_push(&v, subst_str, subst_str_len))
1820 if (!cpp_demangle_push_subst_v(ddata, &v))
1828 vector_str_dest(&v);
1834 cpp_demangle_read_name_flat(struct cpp_demangle_data *ddata, char **str)
1836 struct vector_str *output;
1837 size_t i, p_idx, idx, name_len;
1840 output = ddata->push_head > 0 ? &ddata->output_tmp :
1843 p_idx = output->size;
1845 if (!cpp_demangle_read_name(ddata))
1848 if ((name = vector_str_substr(output, p_idx, output->size - 1,
1849 &name_len)) == NULL)
1853 for (i = p_idx; i < idx; ++i) {
1854 if (!vector_str_pop(output)) {
1866 cpp_demangle_read_nested_name(struct cpp_demangle_data *ddata)
1868 struct vector_str *output, v;
1869 size_t limit, p_idx, subst_str_len;
1873 if (ddata == NULL || *ddata->cur != 'N')
1875 if (*(++ddata->cur) == '\0')
1878 while (*ddata->cur == 'r' || *ddata->cur == 'V' ||
1879 *ddata->cur == 'K') {
1880 switch (*ddata->cur) {
1882 ddata->mem_rst = true;
1885 ddata->mem_vat = true;
1888 ddata->mem_cst = true;
1894 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
1895 if (!vector_str_init(&v))
1901 p_idx = output->size;
1902 switch (*ddata->cur) {
1904 if (!cpp_demangle_read_tmpl_args(ddata))
1908 if (!cpp_demangle_read_subst(ddata))
1912 if (!cpp_demangle_read_tmpl_param(ddata))
1916 if (!cpp_demangle_read_uqname(ddata))
1920 if ((subst_str = vector_str_substr(output, p_idx,
1921 output->size - 1, &subst_str_len)) == NULL)
1923 if (!vector_str_push(&v, subst_str, subst_str_len)) {
1929 if (!cpp_demangle_push_subst_v(ddata, &v))
1931 if (*ddata->cur == 'E')
1933 else if (*ddata->cur != 'I' &&
1934 *ddata->cur != 'C' && *ddata->cur != 'D') {
1935 if (!cpp_demangle_push_str(ddata, "::", 2))
1937 if (!vector_str_push(&v, "::", 2))
1940 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1948 vector_str_dest(&v);
1955 * number ::= [n] <decimal>
1958 cpp_demangle_read_number(struct cpp_demangle_data *ddata, long *rtn)
1960 long len, negative_factor;
1962 if (ddata == NULL || rtn == NULL)
1965 negative_factor = 1;
1966 if (*ddata->cur == 'n') {
1967 negative_factor = -1;
1971 if (ELFTC_ISDIGIT(*ddata->cur) == 0)
1975 if ((len = strtol(ddata->cur, (char **) NULL, 10)) == 0 &&
1979 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
1983 assert(negative_factor == 1 || negative_factor == -1);
1985 *rtn = len * negative_factor;
1991 cpp_demangle_read_number_as_string(struct cpp_demangle_data *ddata, char **str)
1995 if (!cpp_demangle_read_number(ddata, &n)) {
2000 if (asprintf(str, "%ld", n) < 0) {
2009 cpp_demangle_read_nv_offset(struct cpp_demangle_data *ddata)
2015 if (!cpp_demangle_push_str(ddata, "offset : ", 9))
2018 return (cpp_demangle_read_offset_number(ddata));
2021 /* read offset, offset are nv-offset, v-offset */
2023 cpp_demangle_read_offset(struct cpp_demangle_data *ddata)
2029 if (*ddata->cur == 'h') {
2031 return (cpp_demangle_read_nv_offset(ddata));
2032 } else if (*ddata->cur == 'v') {
2034 return (cpp_demangle_read_v_offset(ddata));
2041 cpp_demangle_read_offset_number(struct cpp_demangle_data *ddata)
2046 if (ddata == NULL || *ddata->cur == '\0')
2049 /* offset could be negative */
2050 if (*ddata->cur == 'n') {
2052 start = ddata->cur + 1;
2058 while (*ddata->cur != '_')
2061 if (negative && !cpp_demangle_push_str(ddata, "-", 1))
2064 assert(start != NULL);
2066 if (!cpp_demangle_push_str(ddata, start, ddata->cur - start))
2068 if (!cpp_demangle_push_str(ddata, " ", 1))
2077 cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *ddata)
2079 size_t class_type_len, i, idx, p_idx;
2080 int p_func_type, rtn;
2083 if (ddata == NULL || *ddata->cur != 'M' || *(++ddata->cur) == '\0')
2086 p_idx = ddata->output.size;
2087 if (!cpp_demangle_read_type(ddata, 0))
2090 if ((class_type = vector_str_substr(&ddata->output, p_idx,
2091 ddata->output.size - 1, &class_type_len)) == NULL)
2095 idx = ddata->output.size;
2096 for (i = p_idx; i < idx; ++i)
2097 if (!vector_str_pop(&ddata->output))
2100 if (!vector_read_cmd_push(&ddata->cmd, READ_PTRMEM))
2103 if (!vector_str_push(&ddata->class_type, class_type, class_type_len))
2106 p_func_type = ddata->func_type;
2107 if (!cpp_demangle_read_type(ddata, 0))
2110 if (p_func_type == ddata->func_type) {
2111 if (!cpp_demangle_push_str(ddata, " ", 1))
2113 if (!cpp_demangle_push_str(ddata, class_type, class_type_len))
2115 if (!cpp_demangle_push_str(ddata, "::*", 3))
2121 if (!vector_str_pop(&ddata->class_type))
2124 if (!vector_read_cmd_pop(&ddata->cmd))
2132 /* read source-name, source-name is <len> <ID> */
2134 cpp_demangle_read_sname(struct cpp_demangle_data *ddata)
2139 if (ddata == NULL || cpp_demangle_read_number(ddata, &len) == 0 ||
2143 if (len == 12 && (memcmp("_GLOBAL__N_1", ddata->cur, 12) == 0))
2144 err = cpp_demangle_push_str(ddata, "(anonymous namespace)", 21);
2146 err = cpp_demangle_push_str(ddata, ddata->cur, len);
2151 assert(ddata->output.size > 0);
2152 if (vector_read_cmd_find(&ddata->cmd, READ_TMPL) == 0)
2154 ddata->output.container[ddata->output.size - 1];
2162 cpp_demangle_read_subst(struct cpp_demangle_data *ddata)
2166 if (ddata == NULL || *ddata->cur == '\0')
2169 /* abbreviations of the form Sx */
2170 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
2171 case SIMPLE_HASH('S', 'a'):
2172 /* std::allocator */
2173 if (cpp_demangle_push_str(ddata, "std::allocator", 14) == 0)
2176 if (*ddata->cur == 'I')
2177 return (cpp_demangle_read_subst_stdtmpl(ddata,
2178 "std::allocator", 14));
2181 case SIMPLE_HASH('S', 'b'):
2182 /* std::basic_string */
2183 if (!cpp_demangle_push_str(ddata, "std::basic_string", 17))
2186 if (*ddata->cur == 'I')
2187 return (cpp_demangle_read_subst_stdtmpl(ddata,
2188 "std::basic_string", 17));
2191 case SIMPLE_HASH('S', 'd'):
2192 /* std::basic_iostream<char, std::char_traits<char> > */
2193 if (!cpp_demangle_push_str(ddata, "std::basic_iostream", 19))
2195 ddata->last_sname = "basic_iostream";
2197 if (*ddata->cur == 'I')
2198 return (cpp_demangle_read_subst_stdtmpl(ddata,
2199 "std::basic_iostream", 19));
2202 case SIMPLE_HASH('S', 'i'):
2203 /* std::basic_istream<char, std::char_traits<char> > */
2204 if (!cpp_demangle_push_str(ddata, "std::basic_istream", 18))
2206 ddata->last_sname = "basic_istream";
2208 if (*ddata->cur == 'I')
2209 return (cpp_demangle_read_subst_stdtmpl(ddata,
2210 "std::basic_istream", 18));
2213 case SIMPLE_HASH('S', 'o'):
2214 /* std::basic_ostream<char, std::char_traits<char> > */
2215 if (!cpp_demangle_push_str(ddata, "std::basic_ostream", 18))
2217 ddata->last_sname = "basic_ostream";
2219 if (*ddata->cur == 'I')
2220 return (cpp_demangle_read_subst_stdtmpl(ddata,
2221 "std::basic_ostream", 18));
2224 case SIMPLE_HASH('S', 's'):
2226 * std::basic_string<char, std::char_traits<char>,
2227 * std::allocator<char> >
2231 if (!cpp_demangle_push_str(ddata, "std::string", 11))
2233 ddata->last_sname = "string";
2235 if (*ddata->cur == 'I')
2236 return (cpp_demangle_read_subst_stdtmpl(ddata,
2237 "std::string", 11));
2240 case SIMPLE_HASH('S', 't'):
2242 return (cpp_demangle_read_subst_std(ddata));
2245 if (*(++ddata->cur) == '\0')
2249 if (*ddata->cur == '_')
2250 return (cpp_demangle_get_subst(ddata, 0));
2253 /* substitution number is base 36 */
2254 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
2258 /* first was '_', so increase one */
2261 while (*ddata->cur != '_')
2266 return (cpp_demangle_get_subst(ddata, nth));
2274 cpp_demangle_read_subst_std(struct cpp_demangle_data *ddata)
2276 struct vector_str *output, v;
2277 size_t p_idx, subst_str_len;
2284 if (!vector_str_init(&v))
2289 if (!cpp_demangle_push_str(ddata, "std::", 5))
2292 if (!vector_str_push(&v, "std::", 5))
2297 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
2299 p_idx = output->size;
2300 if (!cpp_demangle_read_uqname(ddata))
2303 if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
2304 &subst_str_len)) == NULL)
2307 if (!vector_str_push(&v, subst_str, subst_str_len))
2310 if (!cpp_demangle_push_subst_v(ddata, &v))
2313 if (*ddata->cur == 'I') {
2314 p_idx = output->size;
2315 if (!cpp_demangle_read_tmpl_args(ddata))
2318 if ((subst_str = vector_str_substr(output, p_idx,
2319 output->size - 1, &subst_str_len)) == NULL)
2321 if (!vector_str_push(&v, subst_str, subst_str_len))
2323 if (!cpp_demangle_push_subst_v(ddata, &v))
2330 vector_str_dest(&v);
2336 cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *ddata,
2337 const char *str, size_t len)
2339 struct vector_str *output;
2340 size_t p_idx, substr_len;
2342 char *subst_str, *substr;
2344 if (ddata == NULL || str == NULL || len == 0)
2347 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
2349 p_idx = output->size;
2353 if (!cpp_demangle_read_tmpl_args(ddata))
2355 if ((substr = vector_str_substr(output, p_idx, output->size - 1,
2356 &substr_len)) == NULL)
2360 if ((subst_str = malloc(sizeof(char) * (substr_len + len + 1))) ==
2364 memcpy(subst_str, str, len);
2365 memcpy(subst_str + len, substr, substr_len);
2366 subst_str[substr_len + len] = '\0';
2368 if (!cpp_demangle_push_subst(ddata, subst_str, substr_len + len))
2380 cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *ddata)
2383 if (ddata == NULL || *ddata->cur == '\0')
2386 switch (*ddata->cur) {
2388 return (cpp_demangle_read_expr_primary(ddata));
2390 return (cpp_demangle_read_expression(ddata));
2393 return (cpp_demangle_read_type(ddata, 0));
2397 cpp_demangle_read_tmpl_args(struct cpp_demangle_data *ddata)
2399 struct vector_str *v;
2400 size_t arg_len, idx, limit, size;
2403 if (ddata == NULL || *ddata->cur == '\0')
2408 if (!vector_read_cmd_push(&ddata->cmd, READ_TMPL))
2411 if (!cpp_demangle_push_str(ddata, "<", 1))
2415 v = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
2418 if (!cpp_demangle_read_tmpl_arg(ddata))
2420 if ((arg = vector_str_substr(v, idx, v->size - 1, &arg_len)) ==
2423 if (!vector_str_find(&ddata->tmpl, arg, arg_len) &&
2424 !vector_str_push(&ddata->tmpl, arg, arg_len)) {
2431 if (*ddata->cur == 'E') {
2435 if (!strncmp(v->container[size - 1], ">", 1)) {
2436 if (!cpp_demangle_push_str(ddata, " >", 2))
2438 } else if (!cpp_demangle_push_str(ddata, ">", 1))
2441 } else if (*ddata->cur != 'I' &&
2442 !cpp_demangle_push_str(ddata, ", ", 2))
2445 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
2449 return (vector_read_cmd_pop(&ddata->cmd));
2453 * Read template parameter that forms in 'T[number]_'.
2454 * This function much like to read_subst but only for types.
2457 cpp_demangle_read_tmpl_param(struct cpp_demangle_data *ddata)
2461 if (ddata == NULL || *ddata->cur != 'T')
2466 if (*ddata->cur == '_')
2467 return (cpp_demangle_get_tmpl_param(ddata, 0));
2471 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
2478 while (*ddata->cur != '_')
2483 return (cpp_demangle_get_tmpl_param(ddata, nth));
2491 cpp_demangle_read_type(struct cpp_demangle_data *ddata, int delimit)
2493 struct vector_type_qualifier v;
2494 struct vector_str *output;
2495 size_t p_idx, type_str_len;
2496 int extern_c, is_builtin;
2498 char *type_str, *exp_str, *num_str;
2503 output = &ddata->output;
2504 if (ddata->output.size > 0 && !strncmp(ddata->output.container[ddata->output.size - 1], ">", 1)) {
2506 output = &ddata->output_tmp;
2507 } else if (delimit == 1) {
2508 if (ddata->paren == false) {
2509 if (!cpp_demangle_push_str(ddata, "(", 1))
2511 if (ddata->output.size < 2)
2513 ddata->paren = true;
2514 ddata->pfirst = true;
2515 /* Need pop function name */
2516 if (ddata->subst.size == 1 &&
2517 !vector_str_pop(&ddata->subst))
2522 ddata->pfirst = false;
2523 else if (*ddata->cur != 'I' &&
2524 !cpp_demangle_push_str(ddata, ", ", 2))
2528 assert(output != NULL);
2530 * [r, V, K] [P, R, C, G, U] builtin, function, class-enum, array
2531 * pointer-to-member, template-param, template-template-param, subst
2534 if (!vector_type_qualifier_init(&v))
2539 p_idx = output->size;
2540 type_str = exp_str = num_str = NULL;
2543 switch (*ddata->cur) {
2546 if (!cpp_demangle_push_str(ddata, "signed char", 11))
2553 if (!cpp_demangle_read_array(ddata))
2560 if (!cpp_demangle_push_str(ddata, "bool", 4))
2567 if (!vector_type_qualifier_push(&v, TYPE_CMX))
2574 if (!cpp_demangle_push_str(ddata, "char", 4))
2581 if (!cpp_demangle_push_str(ddata, "double", 6))
2588 switch (*ddata->cur) {
2590 /* IEEE 754r decimal floating point (64 bits) */
2591 if (!cpp_demangle_push_str(ddata, "decimal64", 9))
2596 /* IEEE 754r decimal floating point (128 bits) */
2597 if (!cpp_demangle_push_str(ddata, "decimal128", 10))
2602 /* IEEE 754r decimal floating point (32 bits) */
2603 if (!cpp_demangle_push_str(ddata, "decimal32", 9))
2608 /* IEEE 754r half-precision floating point (16 bits) */
2609 if (!cpp_demangle_push_str(ddata, "half", 4))
2615 if (!cpp_demangle_push_str(ddata, "char32_t", 8))
2620 /* std::nullptr_t (i.e., decltype(nullptr)) */
2621 if (!cpp_demangle_push_str(ddata, "decltype(nullptr)",
2628 if (!cpp_demangle_push_str(ddata, "char16_t", 8))
2633 /* gcc vector_size extension. */
2635 if (*ddata->cur == '_') {
2637 if (!cpp_demangle_read_expression_flat(ddata,
2640 if (!vector_str_push(&v.ext_name, exp_str,
2644 if (!cpp_demangle_read_number_as_string(ddata,
2647 if (!vector_str_push(&v.ext_name, num_str,
2651 if (*ddata->cur != '_')
2654 if (!vector_type_qualifier_push(&v, TYPE_VEC))
2664 if (!cpp_demangle_push_str(ddata, "long double", 11))
2671 if (!cpp_demangle_push_str(ddata, "float", 5))
2678 if (!cpp_demangle_read_function(ddata, &extern_c, &v))
2685 if (!cpp_demangle_push_str(ddata, "__float128", 10))
2692 if (!vector_type_qualifier_push(&v, TYPE_IMG))
2699 if (!cpp_demangle_push_str(ddata, "unsigned char", 13))
2706 if (!cpp_demangle_push_str(ddata, "int", 3))
2713 if (!cpp_demangle_push_str(ddata, "unsigned int", 12))
2720 if (!vector_type_qualifier_push(&v, TYPE_CST))
2727 if (!cpp_demangle_push_str(ddata, "long", 4))
2734 if (!cpp_demangle_push_str(ddata, "unsigned long", 13))
2741 /* pointer to member */
2742 if (!cpp_demangle_read_pointer_to_member(ddata))
2749 if (!cpp_demangle_push_str(ddata, "__int128", 8))
2755 /* unsigned __int128 */
2756 if (!cpp_demangle_push_str(ddata, "unsigned __int128", 17))
2763 if (!vector_type_qualifier_push(&v, TYPE_PTR))
2770 if (!vector_type_qualifier_push(&v, TYPE_RST))
2777 if (!vector_type_qualifier_push(&v, TYPE_REF))
2783 /* short, local string */
2784 if (!cpp_demangle_push_str(ddata, "short", 5))
2791 if (!cpp_demangle_read_subst(ddata))
2797 /* unsigned short */
2798 if (!cpp_demangle_push_str(ddata, "unsigned short", 14))
2804 /* template parameter */
2805 if (!cpp_demangle_read_tmpl_param(ddata))
2811 /* vendor extended builtin */
2813 if (!cpp_demangle_read_sname(ddata))
2819 /* vendor extended type qualifier */
2820 if (!cpp_demangle_read_number(ddata, &len))
2824 if (!vector_str_push(&v.ext_name, ddata->cur, len))
2827 if (!vector_type_qualifier_push(&v, TYPE_EXT))
2833 if (!cpp_demangle_push_str(ddata, "void", 4))
2840 if (!vector_type_qualifier_push(&v, TYPE_VAT))
2847 if (!cpp_demangle_push_str(ddata, "wchar_t", 7))
2854 if (!cpp_demangle_push_str(ddata, "long long", 9))
2860 /* unsigned long long */
2861 if (!cpp_demangle_push_str(ddata, "unsigned long long", 18))
2868 if (!cpp_demangle_push_str(ddata, "...", 3))
2874 if (!cpp_demangle_read_name(ddata))
2879 if ((type_str = vector_str_substr(output, p_idx, output->size - 1,
2880 &type_str_len)) == NULL)
2883 if (is_builtin == 0) {
2884 if (!vector_str_find(&ddata->subst, type_str, type_str_len) &&
2885 !vector_str_push(&ddata->subst, type_str, type_str_len))
2889 if (!cpp_demangle_push_type_qualifier(ddata, &v, type_str))
2895 vector_type_qualifier_dest(&v);
2897 if (ddata->push_head > 0) {
2898 if (*ddata->cur == 'I' && cpp_demangle_read_tmpl_args(ddata)
2902 if (--ddata->push_head > 0)
2905 if (!vector_str_push(&ddata->output_tmp, " ", 1))
2908 if (!vector_str_push_vector_head(&ddata->output,
2909 &ddata->output_tmp))
2912 vector_str_dest(&ddata->output_tmp);
2913 if (!vector_str_init(&ddata->output_tmp))
2916 if (!cpp_demangle_push_str(ddata, "(", 1))
2919 ddata->paren = true;
2920 ddata->pfirst = true;
2928 vector_type_qualifier_dest(&v);
2934 cpp_demangle_read_type_flat(struct cpp_demangle_data *ddata, char **str)
2936 struct vector_str *output;
2937 size_t i, p_idx, idx, type_len;
2940 output = ddata->push_head > 0 ? &ddata->output_tmp :
2943 p_idx = output->size;
2945 if (!cpp_demangle_read_type(ddata, 0))
2948 if ((type = vector_str_substr(output, p_idx, output->size - 1,
2949 &type_len)) == NULL)
2953 for (i = p_idx; i < idx; ++i) {
2954 if (!vector_str_pop(output)) {
2966 * read unqualified-name, unqualified name are operator-name, ctor-dtor-name,
2970 cpp_demangle_read_uqname(struct cpp_demangle_data *ddata)
2974 if (ddata == NULL || *ddata->cur == '\0')
2978 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
2979 case SIMPLE_HASH('a', 'a'):
2981 if (!cpp_demangle_push_str(ddata, "operator&&", 10))
2986 case SIMPLE_HASH('a', 'd'):
2987 /* operator & (unary) */
2988 if (!cpp_demangle_push_str(ddata, "operator&", 9))
2993 case SIMPLE_HASH('a', 'n'):
2995 if (!cpp_demangle_push_str(ddata, "operator&", 9))
3000 case SIMPLE_HASH('a', 'N'):
3002 if (!cpp_demangle_push_str(ddata, "operator&=", 10))
3007 case SIMPLE_HASH('a', 'S'):
3009 if (!cpp_demangle_push_str(ddata, "operator=", 9))
3014 case SIMPLE_HASH('c', 'l'):
3016 if (!cpp_demangle_push_str(ddata, "operator()", 10))
3021 case SIMPLE_HASH('c', 'm'):
3023 if (!cpp_demangle_push_str(ddata, "operator,", 9))
3028 case SIMPLE_HASH('c', 'o'):
3030 if (!cpp_demangle_push_str(ddata, "operator~", 9))
3035 case SIMPLE_HASH('c', 'v'):
3036 /* operator (cast) */
3037 if (!cpp_demangle_push_str(ddata, "operator(cast)", 14))
3040 return (cpp_demangle_read_type(ddata, 1));
3042 case SIMPLE_HASH('d', 'a'):
3043 /* operator delete [] */
3044 if (!cpp_demangle_push_str(ddata, "operator delete []", 18))
3049 case SIMPLE_HASH('d', 'e'):
3050 /* operator * (unary) */
3051 if (!cpp_demangle_push_str(ddata, "operator*", 9))
3056 case SIMPLE_HASH('d', 'l'):
3057 /* operator delete */
3058 if (!cpp_demangle_push_str(ddata, "operator delete", 15))
3063 case SIMPLE_HASH('d', 'v'):
3065 if (!cpp_demangle_push_str(ddata, "operator/", 9))
3070 case SIMPLE_HASH('d', 'V'):
3072 if (!cpp_demangle_push_str(ddata, "operator/=", 10))
3077 case SIMPLE_HASH('e', 'o'):
3079 if (!cpp_demangle_push_str(ddata, "operator^", 9))
3084 case SIMPLE_HASH('e', 'O'):
3086 if (!cpp_demangle_push_str(ddata, "operator^=", 10))
3091 case SIMPLE_HASH('e', 'q'):
3093 if (!cpp_demangle_push_str(ddata, "operator==", 10))
3098 case SIMPLE_HASH('g', 'e'):
3100 if (!cpp_demangle_push_str(ddata, "operator>=", 10))
3105 case SIMPLE_HASH('g', 't'):
3107 if (!cpp_demangle_push_str(ddata, "operator>", 9))
3112 case SIMPLE_HASH('i', 'x'):
3114 if (!cpp_demangle_push_str(ddata, "operator[]", 10))
3119 case SIMPLE_HASH('l', 'e'):
3121 if (!cpp_demangle_push_str(ddata, "operator<=", 10))
3126 case SIMPLE_HASH('l', 's'):
3128 if (!cpp_demangle_push_str(ddata, "operator<<", 10))
3133 case SIMPLE_HASH('l', 'S'):
3135 if (!cpp_demangle_push_str(ddata, "operator<<=", 11))
3140 case SIMPLE_HASH('l', 't'):
3142 if (!cpp_demangle_push_str(ddata, "operator<", 9))
3147 case SIMPLE_HASH('m', 'i'):
3149 if (!cpp_demangle_push_str(ddata, "operator-", 9))
3154 case SIMPLE_HASH('m', 'I'):
3156 if (!cpp_demangle_push_str(ddata, "operator-=", 10))
3161 case SIMPLE_HASH('m', 'l'):
3163 if (!cpp_demangle_push_str(ddata, "operator*", 9))
3168 case SIMPLE_HASH('m', 'L'):
3170 if (!cpp_demangle_push_str(ddata, "operator*=", 10))
3175 case SIMPLE_HASH('m', 'm'):
3177 if (!cpp_demangle_push_str(ddata, "operator--", 10))
3182 case SIMPLE_HASH('n', 'a'):
3183 /* operator new[] */
3184 if (!cpp_demangle_push_str(ddata, "operator new []", 15))
3189 case SIMPLE_HASH('n', 'e'):
3191 if (!cpp_demangle_push_str(ddata, "operator!=", 10))
3196 case SIMPLE_HASH('n', 'g'):
3197 /* operator - (unary) */
3198 if (!cpp_demangle_push_str(ddata, "operator-", 9))
3203 case SIMPLE_HASH('n', 't'):
3205 if (!cpp_demangle_push_str(ddata, "operator!", 9))
3210 case SIMPLE_HASH('n', 'w'):
3212 if (!cpp_demangle_push_str(ddata, "operator new", 12))
3217 case SIMPLE_HASH('o', 'o'):
3219 if (!cpp_demangle_push_str(ddata, "operator||", 10))
3224 case SIMPLE_HASH('o', 'r'):
3226 if (!cpp_demangle_push_str(ddata, "operator|", 9))
3231 case SIMPLE_HASH('o', 'R'):
3233 if (!cpp_demangle_push_str(ddata, "operator|=", 10))
3238 case SIMPLE_HASH('p', 'l'):
3240 if (!cpp_demangle_push_str(ddata, "operator+", 9))
3245 case SIMPLE_HASH('p', 'L'):
3247 if (!cpp_demangle_push_str(ddata, "operator+=", 10))
3252 case SIMPLE_HASH('p', 'm'):
3254 if (!cpp_demangle_push_str(ddata, "operator->*", 11))
3259 case SIMPLE_HASH('p', 'p'):
3261 if (!cpp_demangle_push_str(ddata, "operator++", 10))
3266 case SIMPLE_HASH('p', 's'):
3267 /* operator + (unary) */
3268 if (!cpp_demangle_push_str(ddata, "operator+", 9))
3273 case SIMPLE_HASH('p', 't'):
3275 if (!cpp_demangle_push_str(ddata, "operator->", 10))
3280 case SIMPLE_HASH('q', 'u'):
3282 if (!cpp_demangle_push_str(ddata, "operator?", 9))
3287 case SIMPLE_HASH('r', 'm'):
3289 if (!cpp_demangle_push_str(ddata, "operator%", 9))
3294 case SIMPLE_HASH('r', 'M'):
3296 if (!cpp_demangle_push_str(ddata, "operator%=", 10))
3301 case SIMPLE_HASH('r', 's'):
3303 if (!cpp_demangle_push_str(ddata, "operator>>", 10))
3308 case SIMPLE_HASH('r', 'S'):
3310 if (!cpp_demangle_push_str(ddata, "operator>>=", 11))
3315 case SIMPLE_HASH('r', 'z'):
3316 /* operator sizeof */
3317 if (!cpp_demangle_push_str(ddata, "operator sizeof ", 16))
3322 case SIMPLE_HASH('s', 'r'):
3323 /* scope resolution operator */
3324 if (!cpp_demangle_push_str(ddata, "scope resolution operator ",
3330 case SIMPLE_HASH('s', 'v'):
3331 /* operator sizeof */
3332 if (!cpp_demangle_push_str(ddata, "operator sizeof ", 16))
3338 /* vendor extened operator */
3339 if (*ddata->cur == 'v' && ELFTC_ISDIGIT(*(ddata->cur + 1))) {
3340 if (!cpp_demangle_push_str(ddata, "vendor extened operator ",
3343 if (!cpp_demangle_push_str(ddata, ddata->cur + 1, 1))
3346 return (cpp_demangle_read_sname(ddata));
3349 /* ctor-dtor-name */
3350 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
3351 case SIMPLE_HASH('C', '1'):
3353 case SIMPLE_HASH('C', '2'):
3355 case SIMPLE_HASH('C', '3'):
3356 if (ddata->last_sname == NULL)
3358 if ((len = strlen(ddata->last_sname)) == 0)
3360 if (!cpp_demangle_push_str(ddata, "::", 2))
3362 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
3367 case SIMPLE_HASH('D', '0'):
3369 case SIMPLE_HASH('D', '1'):
3371 case SIMPLE_HASH('D', '2'):
3372 if (ddata->last_sname == NULL)
3374 if ((len = strlen(ddata->last_sname)) == 0)
3376 if (!cpp_demangle_push_str(ddata, "::~", 3))
3378 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
3385 if (ELFTC_ISDIGIT(*ddata->cur) != 0)
3386 return (cpp_demangle_read_sname(ddata));
3388 /* local source name */
3389 if (*ddata->cur == 'L')
3390 return (cpp_demangle_local_source_name(ddata));
3396 * Read local source name.
3399 * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31775
3400 * http://gcc.gnu.org/viewcvs?view=rev&revision=124467
3403 cpp_demangle_local_source_name(struct cpp_demangle_data *ddata)
3406 if (ddata == NULL || *ddata->cur != 'L')
3411 if (!cpp_demangle_read_sname(ddata))
3415 if (*ddata->cur == '_') {
3417 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
3425 cpp_demangle_read_v_offset(struct cpp_demangle_data *ddata)
3431 if (!cpp_demangle_push_str(ddata, "offset : ", 9))
3434 if (!cpp_demangle_read_offset_number(ddata))
3437 if (!cpp_demangle_push_str(ddata, "virtual offset : ", 17))
3440 return (!cpp_demangle_read_offset_number(ddata));
3444 * Decode floating point representation to string
3445 * Return new allocated string or NULL
3448 * Replace these functions to macro.
3451 decode_fp_to_double(const char *p, size_t len)
3454 size_t rtn_len, limit, i;
3458 if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(double))
3461 memset(&f, 0, sizeof(double));
3463 for (i = 0; i < len / 2; ++i) {
3464 byte = hex_to_dec(p[len - i * 2 - 1]) +
3465 hex_to_dec(p[len - i * 2 - 2]) * 16;
3467 if (byte < 0 || byte > 255)
3470 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3471 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3472 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3473 ((unsigned char *)&f)[sizeof(double) - i - 1] =
3474 (unsigned char)(byte);
3475 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3481 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3484 if (snprintf(rtn, rtn_len, "%fld", f) >= (int)rtn_len) {
3486 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3488 rtn_len *= BUFFER_GROWFACTOR;
3496 decode_fp_to_float(const char *p, size_t len)
3498 size_t i, rtn_len, limit;
3503 if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(float))
3506 memset(&f, 0, sizeof(float));
3508 for (i = 0; i < len / 2; ++i) {
3509 byte = hex_to_dec(p[len - i * 2 - 1]) +
3510 hex_to_dec(p[len - i * 2 - 2]) * 16;
3511 if (byte < 0 || byte > 255)
3513 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3514 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3515 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3516 ((unsigned char *)&f)[sizeof(float) - i - 1] =
3517 (unsigned char)(byte);
3518 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3524 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3527 if (snprintf(rtn, rtn_len, "%ff", f) >= (int)rtn_len) {
3529 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3531 rtn_len *= BUFFER_GROWFACTOR;
3539 decode_fp_to_float128(const char *p, size_t len)
3542 size_t rtn_len, limit, i;
3544 unsigned char buf[FLOAT_QUADRUPLE_BYTES];
3547 switch(sizeof(long double)) {
3548 case FLOAT_QUADRUPLE_BYTES:
3549 return (decode_fp_to_long_double(p, len));
3550 case FLOAT_EXTENED_BYTES:
3551 if (p == NULL || len == 0 || len % 2 != 0 ||
3552 len / 2 > FLOAT_QUADRUPLE_BYTES)
3555 memset(buf, 0, FLOAT_QUADRUPLE_BYTES);
3557 for (i = 0; i < len / 2; ++i) {
3558 byte = hex_to_dec(p[len - i * 2 - 1]) +
3559 hex_to_dec(p[len - i * 2 - 2]) * 16;
3560 if (byte < 0 || byte > 255)
3562 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3563 buf[i] = (unsigned char)(byte);
3564 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3565 buf[FLOAT_QUADRUPLE_BYTES - i -1] =
3566 (unsigned char)(byte);
3567 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3569 memset(&f, 0, FLOAT_EXTENED_BYTES);
3571 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3572 memcpy(&f, buf, FLOAT_EXTENED_BYTES);
3573 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3574 memcpy(&f, buf + 6, FLOAT_EXTENED_BYTES);
3575 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3580 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3583 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3585 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3587 rtn_len *= BUFFER_GROWFACTOR;
3598 decode_fp_to_float80(const char *p, size_t len)
3601 size_t rtn_len, limit, i;
3603 unsigned char buf[FLOAT_EXTENED_BYTES];
3606 switch(sizeof(long double)) {
3607 case FLOAT_QUADRUPLE_BYTES:
3608 if (p == NULL || len == 0 || len % 2 != 0 ||
3609 len / 2 > FLOAT_EXTENED_BYTES)
3612 memset(buf, 0, FLOAT_EXTENED_BYTES);
3614 for (i = 0; i < len / 2; ++i) {
3615 byte = hex_to_dec(p[len - i * 2 - 1]) +
3616 hex_to_dec(p[len - i * 2 - 2]) * 16;
3618 if (byte < 0 || byte > 255)
3621 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3622 buf[i] = (unsigned char)(byte);
3623 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3624 buf[FLOAT_EXTENED_BYTES - i -1] =
3625 (unsigned char)(byte);
3626 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3629 memset(&f, 0, FLOAT_QUADRUPLE_BYTES);
3631 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3632 memcpy(&f, buf, FLOAT_EXTENED_BYTES);
3633 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3634 memcpy((unsigned char *)(&f) + 6, buf, FLOAT_EXTENED_BYTES);
3635 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3640 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3643 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3645 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3647 rtn_len *= BUFFER_GROWFACTOR;
3652 case FLOAT_EXTENED_BYTES:
3653 return (decode_fp_to_long_double(p, len));
3660 decode_fp_to_long_double(const char *p, size_t len)
3663 size_t rtn_len, limit, i;
3667 if (p == NULL || len == 0 || len % 2 != 0 ||
3668 len / 2 > sizeof(long double))
3671 memset(&f, 0, sizeof(long double));
3673 for (i = 0; i < len / 2; ++i) {
3674 byte = hex_to_dec(p[len - i * 2 - 1]) +
3675 hex_to_dec(p[len - i * 2 - 2]) * 16;
3677 if (byte < 0 || byte > 255)
3680 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3681 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3682 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3683 ((unsigned char *)&f)[sizeof(long double) - i - 1] =
3684 (unsigned char)(byte);
3685 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3691 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3694 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3696 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3698 rtn_len *= BUFFER_GROWFACTOR;
3705 /* Simple hex to integer function used by decode_to_* function. */
3749 vector_read_cmd_dest(struct vector_read_cmd *v)
3755 free(v->r_container);
3758 /* return -1 at failed, 0 at not found, 1 at found. */
3760 vector_read_cmd_find(struct vector_read_cmd *v, enum read_cmd dst)
3764 if (v == NULL || dst == READ_FAIL)
3767 for (i = 0; i < v->size; ++i)
3768 if (v->r_container[i] == dst)
3775 vector_read_cmd_init(struct vector_read_cmd *v)
3782 v->capacity = VECTOR_DEF_CAPACITY;
3784 if ((v->r_container = malloc(sizeof(enum read_cmd) * v->capacity))
3792 vector_read_cmd_pop(struct vector_read_cmd *v)
3795 if (v == NULL || v->size == 0)
3799 v->r_container[v->size] = READ_FAIL;
3805 vector_read_cmd_push(struct vector_read_cmd *v, enum read_cmd cmd)
3807 enum read_cmd *tmp_r_ctn;
3814 if (v->size == v->capacity) {
3815 tmp_cap = v->capacity * BUFFER_GROWFACTOR;
3816 if ((tmp_r_ctn = malloc(sizeof(enum read_cmd) * tmp_cap))
3819 for (i = 0; i < v->size; ++i)
3820 tmp_r_ctn[i] = v->r_container[i];
3821 free(v->r_container);
3822 v->r_container = tmp_r_ctn;
3823 v->capacity = tmp_cap;
3826 v->r_container[v->size] = cmd;
3833 vector_type_qualifier_dest(struct vector_type_qualifier *v)
3839 free(v->q_container);
3840 vector_str_dest(&v->ext_name);
3843 /* size, capacity, ext_name */
3845 vector_type_qualifier_init(struct vector_type_qualifier *v)
3852 v->capacity = VECTOR_DEF_CAPACITY;
3854 if ((v->q_container = malloc(sizeof(enum type_qualifier) * v->capacity))
3858 assert(v->q_container != NULL);
3860 if (vector_str_init(&v->ext_name) == false) {
3861 free(v->q_container);
3869 vector_type_qualifier_push(struct vector_type_qualifier *v,
3870 enum type_qualifier t)
3872 enum type_qualifier *tmp_ctn;
3879 if (v->size == v->capacity) {
3880 tmp_cap = v->capacity * BUFFER_GROWFACTOR;
3881 if ((tmp_ctn = malloc(sizeof(enum type_qualifier) * tmp_cap))
3884 for (i = 0; i < v->size; ++i)
3885 tmp_ctn[i] = v->q_container[i];
3886 free(v->q_container);
3887 v->q_container = tmp_ctn;
3888 v->capacity = tmp_cap;
3891 v->q_container[v->size] = t;