2 * Copyright (c) 2007 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 #include "_libelftc.h"
39 ELFTC_VCSID("$Id: libelftc_dem_gnu3.c 3447 2016-05-03 13:32:23Z emaste $");
42 * @file cpp_demangle.c
43 * @brief Decode IA-64 C++ ABI style implementation.
45 * IA-64 standard ABI(Itanium C++ ABI) references.
47 * http://www.codesourcery.com/cxx-abi/abi.html#mangling \n
48 * http://www.codesourcery.com/cxx-abi/abi-mangling.html
52 TYPE_PTR, TYPE_REF, TYPE_CMX, TYPE_IMG, TYPE_EXT, TYPE_RST, TYPE_VAT,
56 struct vector_type_qualifier {
57 size_t size, capacity;
58 enum type_qualifier *q_container;
59 struct vector_str ext_name;
63 READ_FAIL, READ_NEST, READ_TMPL, READ_EXPR, READ_EXPL, READ_LOCAL,
64 READ_TYPE, READ_FUNC, READ_PTRMEM
67 struct vector_read_cmd {
68 size_t size, capacity;
69 enum read_cmd *r_container;
72 struct cpp_demangle_data {
73 struct vector_str output; /* output string vector */
74 struct vector_str output_tmp;
75 struct vector_str subst; /* substitution string vector */
76 struct vector_str tmpl;
77 struct vector_str class_type;
78 struct vector_read_cmd cmd;
79 bool paren; /* parenthesis opened */
80 bool pfirst; /* first element of parameter */
81 bool mem_rst; /* restrict member function */
82 bool mem_vat; /* volatile member function */
83 bool mem_cst; /* const member function */
85 const char *cur; /* current mangled name ptr */
86 const char *last_sname; /* last source name */
90 #define CPP_DEMANGLE_TRY_LIMIT 128
91 #define FLOAT_SPRINTF_TRY_LIMIT 5
92 #define FLOAT_QUADRUPLE_BYTES 16
93 #define FLOAT_EXTENED_BYTES 10
95 #define SIMPLE_HASH(x,y) (64 * x + y)
97 static void cpp_demangle_data_dest(struct cpp_demangle_data *);
98 static int cpp_demangle_data_init(struct cpp_demangle_data *,
100 static int cpp_demangle_get_subst(struct cpp_demangle_data *, size_t);
101 static int cpp_demangle_get_tmpl_param(struct cpp_demangle_data *, size_t);
102 static int cpp_demangle_push_fp(struct cpp_demangle_data *,
103 char *(*)(const char *, size_t));
104 static int cpp_demangle_push_str(struct cpp_demangle_data *, const char *,
106 static int cpp_demangle_push_subst(struct cpp_demangle_data *,
107 const char *, size_t);
108 static int cpp_demangle_push_subst_v(struct cpp_demangle_data *,
109 struct vector_str *);
110 static int cpp_demangle_push_type_qualifier(struct cpp_demangle_data *,
111 struct vector_type_qualifier *, const char *);
112 static int cpp_demangle_read_array(struct cpp_demangle_data *);
113 static int cpp_demangle_read_encoding(struct cpp_demangle_data *);
114 static int cpp_demangle_read_expr_primary(struct cpp_demangle_data *);
115 static int cpp_demangle_read_expression(struct cpp_demangle_data *);
116 static int cpp_demangle_read_expression_flat(struct cpp_demangle_data *,
118 static int cpp_demangle_read_expression_binary(struct cpp_demangle_data *,
119 const char *, size_t);
120 static int cpp_demangle_read_expression_unary(struct cpp_demangle_data *,
121 const char *, size_t);
122 static int cpp_demangle_read_expression_trinary(struct cpp_demangle_data *,
123 const char *, size_t, const char *, size_t);
124 static int cpp_demangle_read_function(struct cpp_demangle_data *, int *,
125 struct vector_type_qualifier *);
126 static int cpp_demangle_local_source_name(struct cpp_demangle_data *ddata);
127 static int cpp_demangle_read_local_name(struct cpp_demangle_data *);
128 static int cpp_demangle_read_name(struct cpp_demangle_data *);
129 static int cpp_demangle_read_name_flat(struct cpp_demangle_data *,
131 static int cpp_demangle_read_nested_name(struct cpp_demangle_data *);
132 static int cpp_demangle_read_number(struct cpp_demangle_data *, long *);
133 static int cpp_demangle_read_number_as_string(struct cpp_demangle_data *,
135 static int cpp_demangle_read_nv_offset(struct cpp_demangle_data *);
136 static int cpp_demangle_read_offset(struct cpp_demangle_data *);
137 static int cpp_demangle_read_offset_number(struct cpp_demangle_data *);
138 static int cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *);
139 static int cpp_demangle_read_sname(struct cpp_demangle_data *);
140 static int cpp_demangle_read_subst(struct cpp_demangle_data *);
141 static int cpp_demangle_read_subst_std(struct cpp_demangle_data *);
142 static int cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *,
143 const char *, size_t);
144 static int cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *);
145 static int cpp_demangle_read_tmpl_args(struct cpp_demangle_data *);
146 static int cpp_demangle_read_tmpl_param(struct cpp_demangle_data *);
147 static int cpp_demangle_read_type(struct cpp_demangle_data *, int);
148 static int cpp_demangle_read_type_flat(struct cpp_demangle_data *,
150 static int cpp_demangle_read_uqname(struct cpp_demangle_data *);
151 static int cpp_demangle_read_v_offset(struct cpp_demangle_data *);
152 static char *decode_fp_to_double(const char *, size_t);
153 static char *decode_fp_to_float(const char *, size_t);
154 static char *decode_fp_to_float128(const char *, size_t);
155 static char *decode_fp_to_float80(const char *, size_t);
156 static char *decode_fp_to_long_double(const char *, size_t);
157 static int hex_to_dec(char);
158 static void vector_read_cmd_dest(struct vector_read_cmd *);
159 static int vector_read_cmd_find(struct vector_read_cmd *, enum read_cmd);
160 static int vector_read_cmd_init(struct vector_read_cmd *);
161 static int vector_read_cmd_pop(struct vector_read_cmd *);
162 static int vector_read_cmd_push(struct vector_read_cmd *, enum read_cmd);
163 static void vector_type_qualifier_dest(struct vector_type_qualifier *);
164 static int vector_type_qualifier_init(struct vector_type_qualifier *);
165 static int vector_type_qualifier_push(struct vector_type_qualifier *,
166 enum type_qualifier);
169 * @brief Decode the input string by IA-64 C++ ABI style.
171 * GNU GCC v3 use IA-64 standard ABI.
172 * @return New allocated demangled string or NULL if failed.
173 * @todo 1. Testing and more test case. 2. Code cleaning.
176 cpp_demangle_gnu3(const char *org)
178 struct cpp_demangle_data ddata;
183 if (org == NULL || (org_len = strlen(org)) < 2)
186 if (org_len > 11 && !strncmp(org, "_GLOBAL__I_", 11)) {
187 if ((rtn = malloc(org_len + 19)) == NULL)
189 snprintf(rtn, org_len + 19,
190 "global constructors keyed to %s", org + 11);
194 if (org[0] != '_' || org[1] != 'Z')
197 if (!cpp_demangle_data_init(&ddata, org + 2))
202 if (!cpp_demangle_read_encoding(&ddata))
206 while (*ddata.cur != '\0') {
208 * Breaking at some gcc info at tail. e.g) @@GLIBCXX_3.4
210 if (*ddata.cur == '@' && *(ddata.cur + 1) == '@')
212 if (!cpp_demangle_read_type(&ddata, 1))
214 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
218 if (ddata.output.size == 0)
220 if (ddata.paren && !vector_str_push(&ddata.output, ")", 1))
222 if (ddata.mem_vat && !vector_str_push(&ddata.output, " volatile", 9))
224 if (ddata.mem_cst && !vector_str_push(&ddata.output, " const", 6))
226 if (ddata.mem_rst && !vector_str_push(&ddata.output, " restrict", 9))
229 rtn = vector_str_get_flat(&ddata.output, (size_t *) NULL);
232 cpp_demangle_data_dest(&ddata);
238 cpp_demangle_data_dest(struct cpp_demangle_data *d)
244 vector_read_cmd_dest(&d->cmd);
245 vector_str_dest(&d->class_type);
246 vector_str_dest(&d->tmpl);
247 vector_str_dest(&d->subst);
248 vector_str_dest(&d->output_tmp);
249 vector_str_dest(&d->output);
253 cpp_demangle_data_init(struct cpp_demangle_data *d, const char *cur)
256 if (d == NULL || cur == NULL)
259 if (!vector_str_init(&d->output))
261 if (!vector_str_init(&d->output_tmp))
263 if (!vector_str_init(&d->subst))
265 if (!vector_str_init(&d->tmpl))
267 if (!vector_str_init(&d->class_type))
269 if (!vector_read_cmd_init(&d->cmd))
272 assert(d->output.container != NULL);
273 assert(d->output_tmp.container != NULL);
274 assert(d->subst.container != NULL);
275 assert(d->tmpl.container != NULL);
276 assert(d->class_type.container != NULL);
285 d->last_sname = NULL;
291 vector_str_dest(&d->class_type);
293 vector_str_dest(&d->tmpl);
295 vector_str_dest(&d->subst);
297 vector_str_dest(&d->output_tmp);
299 vector_str_dest(&d->output);
305 cpp_demangle_push_fp(struct cpp_demangle_data *ddata,
306 char *(*decoder)(const char *, size_t))
313 if (ddata == NULL || decoder == NULL)
317 while (*ddata->cur != 'E')
320 if ((f = decoder(fp, ddata->cur - fp)) == NULL)
324 if ((len = strlen(f)) > 0)
325 rtn = cpp_demangle_push_str(ddata, f, len);
335 cpp_demangle_push_str(struct cpp_demangle_data *ddata, const char *str,
339 if (ddata == NULL || str == NULL || len == 0)
342 if (ddata->push_head > 0)
343 return (vector_str_push(&ddata->output_tmp, str, len));
345 return (vector_str_push(&ddata->output, str, len));
349 cpp_demangle_push_subst(struct cpp_demangle_data *ddata, const char *str,
353 if (ddata == NULL || str == NULL || len == 0)
356 if (!vector_str_find(&ddata->subst, str, len))
357 return (vector_str_push(&ddata->subst, str, len));
363 cpp_demangle_push_subst_v(struct cpp_demangle_data *ddata, struct vector_str *v)
369 if (ddata == NULL || v == NULL)
372 if ((str = vector_str_get_flat(v, &str_len)) == NULL)
375 rtn = cpp_demangle_push_subst(ddata, str, str_len);
383 cpp_demangle_push_type_qualifier(struct cpp_demangle_data *ddata,
384 struct vector_type_qualifier *v, const char *type_str)
386 struct vector_str subst_v;
387 size_t idx, e_idx, e_len;
391 if (ddata == NULL || v == NULL)
394 if ((idx = v->size) == 0)
398 if (type_str != NULL) {
399 if (!vector_str_init(&subst_v))
401 if (!vector_str_push(&subst_v, type_str, strlen(type_str)))
407 switch (v->q_container[idx - 1]) {
409 if (!cpp_demangle_push_str(ddata, "*", 1))
411 if (type_str != NULL) {
412 if (!vector_str_push(&subst_v, "*", 1))
414 if (!cpp_demangle_push_subst_v(ddata,
421 if (!cpp_demangle_push_str(ddata, "&", 1))
423 if (type_str != NULL) {
424 if (!vector_str_push(&subst_v, "&", 1))
426 if (!cpp_demangle_push_subst_v(ddata,
433 if (!cpp_demangle_push_str(ddata, " complex", 8))
435 if (type_str != NULL) {
436 if (!vector_str_push(&subst_v, " complex", 8))
438 if (!cpp_demangle_push_subst_v(ddata,
445 if (!cpp_demangle_push_str(ddata, " imaginary", 10))
447 if (type_str != NULL) {
448 if (!vector_str_push(&subst_v, " imaginary",
451 if (!cpp_demangle_push_subst_v(ddata,
458 if (v->ext_name.size == 0 ||
459 e_idx > v->ext_name.size - 1)
461 if ((e_len = strlen(v->ext_name.container[e_idx])) ==
464 if ((buf = malloc(e_len + 2)) == NULL)
466 snprintf(buf, e_len + 2, " %s",
467 v->ext_name.container[e_idx]);
469 if (!cpp_demangle_push_str(ddata, buf, e_len + 1)) {
474 if (type_str != NULL) {
475 if (!vector_str_push(&subst_v, buf,
480 if (!cpp_demangle_push_subst_v(ddata,
491 if (!cpp_demangle_push_str(ddata, " restrict", 9))
493 if (type_str != NULL) {
494 if (!vector_str_push(&subst_v, " restrict", 9))
496 if (!cpp_demangle_push_subst_v(ddata,
503 if (!cpp_demangle_push_str(ddata, " volatile", 9))
505 if (type_str != NULL) {
506 if (!vector_str_push(&subst_v, " volatile", 9))
508 if (!cpp_demangle_push_subst_v(ddata,
515 if (!cpp_demangle_push_str(ddata, " const", 6))
517 if (type_str != NULL) {
518 if (!vector_str_push(&subst_v, " const", 6))
520 if (!cpp_demangle_push_subst_v(ddata,
527 if (v->ext_name.size == 0 ||
528 e_idx > v->ext_name.size - 1)
530 if ((e_len = strlen(v->ext_name.container[e_idx])) ==
533 if ((buf = malloc(e_len + 12)) == NULL)
535 snprintf(buf, e_len + 12, " __vector(%s)",
536 v->ext_name.container[e_idx]);
537 if (!cpp_demangle_push_str(ddata, buf, e_len + 11)) {
541 if (type_str != NULL) {
542 if (!vector_str_push(&subst_v, buf,
547 if (!cpp_demangle_push_subst_v(ddata,
562 if (type_str != NULL)
563 vector_str_dest(&subst_v);
569 cpp_demangle_get_subst(struct cpp_demangle_data *ddata, size_t idx)
573 if (ddata == NULL || ddata->subst.size <= idx)
575 if ((len = strlen(ddata->subst.container[idx])) == 0)
577 if (!cpp_demangle_push_str(ddata, ddata->subst.container[idx], len))
587 cpp_demangle_get_tmpl_param(struct cpp_demangle_data *ddata, size_t idx)
591 if (ddata == NULL || ddata->tmpl.size <= idx)
593 if ((len = strlen(ddata->tmpl.container[idx])) == 0)
595 if (!cpp_demangle_push_str(ddata, ddata->tmpl.container[idx], len))
604 cpp_demangle_read_array(struct cpp_demangle_data *ddata)
606 size_t i, num_len, exp_len, p_idx, idx;
610 if (ddata == NULL || *(++ddata->cur) == '\0')
613 if (*ddata->cur == '_') {
614 if (*(++ddata->cur) == '\0')
617 if (!cpp_demangle_read_type(ddata, 0))
620 if (!cpp_demangle_push_str(ddata, "[]", 2))
623 if (ELFTC_ISDIGIT(*ddata->cur) != 0) {
625 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
627 if (*ddata->cur != '_')
629 num_len = ddata->cur - num;
631 if (*(++ddata->cur) == '\0')
633 if (!cpp_demangle_read_type(ddata, 0))
635 if (!cpp_demangle_push_str(ddata, "[", 1))
637 if (!cpp_demangle_push_str(ddata, num, num_len))
639 if (!cpp_demangle_push_str(ddata, "]", 1))
642 p_idx = ddata->output.size;
643 if (!cpp_demangle_read_expression(ddata))
645 if ((exp = vector_str_substr(&ddata->output, p_idx,
646 ddata->output.size - 1, &exp_len)) == NULL)
648 idx = ddata->output.size;
649 for (i = p_idx; i < idx; ++i)
650 if (!vector_str_pop(&ddata->output)) {
654 if (*ddata->cur != '_') {
659 if (*ddata->cur == '\0') {
663 if (!cpp_demangle_read_type(ddata, 0)) {
667 if (!cpp_demangle_push_str(ddata, "[", 1)) {
671 if (!cpp_demangle_push_str(ddata, exp, exp_len)) {
675 if (!cpp_demangle_push_str(ddata, "]", 1)) {
687 cpp_demangle_read_expr_primary(struct cpp_demangle_data *ddata)
691 if (ddata == NULL || *(++ddata->cur) == '\0')
694 if (*ddata->cur == '_' && *(ddata->cur + 1) == 'Z') {
696 if (*ddata->cur == '\0')
698 if (!cpp_demangle_read_encoding(ddata))
704 switch (*ddata->cur) {
706 if (*(ddata->cur + 2) != 'E')
708 switch (*(++ddata->cur)) {
711 return (cpp_demangle_push_str(ddata, "false", 5));
714 return (cpp_demangle_push_str(ddata, "true", 4));
721 return (cpp_demangle_push_fp(ddata, decode_fp_to_double));
725 if (sizeof(long double) == 10)
726 return (cpp_demangle_push_fp(ddata,
727 decode_fp_to_double));
728 return (cpp_demangle_push_fp(ddata, decode_fp_to_float80));
732 return (cpp_demangle_push_fp(ddata, decode_fp_to_float));
736 if (sizeof(long double) == 16)
737 return (cpp_demangle_push_fp(ddata,
738 decode_fp_to_double));
739 return (cpp_demangle_push_fp(ddata, decode_fp_to_float128));
750 if (*(++ddata->cur) == 'n') {
751 if (!cpp_demangle_push_str(ddata, "-", 1))
756 while (*ddata->cur != 'E') {
757 if (!ELFTC_ISDIGIT(*ddata->cur))
762 return (cpp_demangle_push_str(ddata, num,
763 ddata->cur - num - 1));
771 cpp_demangle_read_expression(struct cpp_demangle_data *ddata)
774 if (ddata == NULL || *ddata->cur == '\0')
777 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
778 case SIMPLE_HASH('s', 't'):
780 return (cpp_demangle_read_type(ddata, 0));
782 case SIMPLE_HASH('s', 'r'):
784 if (!cpp_demangle_read_type(ddata, 0))
786 if (!cpp_demangle_read_uqname(ddata))
788 if (*ddata->cur == 'I')
789 return (cpp_demangle_read_tmpl_args(ddata));
792 case SIMPLE_HASH('a', 'a'):
795 return (cpp_demangle_read_expression_binary(ddata, "&&", 2));
797 case SIMPLE_HASH('a', 'd'):
798 /* operator & (unary) */
800 return (cpp_demangle_read_expression_unary(ddata, "&", 1));
802 case SIMPLE_HASH('a', 'n'):
805 return (cpp_demangle_read_expression_binary(ddata, "&", 1));
807 case SIMPLE_HASH('a', 'N'):
810 return (cpp_demangle_read_expression_binary(ddata, "&=", 2));
812 case SIMPLE_HASH('a', 'S'):
815 return (cpp_demangle_read_expression_binary(ddata, "=", 1));
817 case SIMPLE_HASH('c', 'l'):
820 return (cpp_demangle_read_expression_binary(ddata, "()", 2));
822 case SIMPLE_HASH('c', 'm'):
825 return (cpp_demangle_read_expression_binary(ddata, ",", 1));
827 case SIMPLE_HASH('c', 'o'):
830 return (cpp_demangle_read_expression_binary(ddata, "~", 1));
832 case SIMPLE_HASH('c', 'v'):
833 /* operator (cast) */
835 return (cpp_demangle_read_expression_binary(ddata, "(cast)", 6));
837 case SIMPLE_HASH('d', 'a'):
838 /* operator delete [] */
840 return (cpp_demangle_read_expression_unary(ddata, "delete []", 9));
842 case SIMPLE_HASH('d', 'e'):
843 /* operator * (unary) */
845 return (cpp_demangle_read_expression_unary(ddata, "*", 1));
847 case SIMPLE_HASH('d', 'l'):
848 /* operator delete */
850 return (cpp_demangle_read_expression_unary(ddata, "delete", 6));
852 case SIMPLE_HASH('d', 'v'):
855 return (cpp_demangle_read_expression_binary(ddata, "/", 1));
857 case SIMPLE_HASH('d', 'V'):
860 return (cpp_demangle_read_expression_binary(ddata, "/=", 2));
862 case SIMPLE_HASH('e', 'o'):
865 return (cpp_demangle_read_expression_binary(ddata, "^", 1));
867 case SIMPLE_HASH('e', 'O'):
870 return (cpp_demangle_read_expression_binary(ddata, "^=", 2));
872 case SIMPLE_HASH('e', 'q'):
875 return (cpp_demangle_read_expression_binary(ddata, "==", 2));
877 case SIMPLE_HASH('g', 'e'):
880 return (cpp_demangle_read_expression_binary(ddata, ">=", 2));
882 case SIMPLE_HASH('g', 't'):
885 return (cpp_demangle_read_expression_binary(ddata, ">", 1));
887 case SIMPLE_HASH('i', 'x'):
890 return (cpp_demangle_read_expression_binary(ddata, "[]", 2));
892 case SIMPLE_HASH('l', 'e'):
895 return (cpp_demangle_read_expression_binary(ddata, "<=", 2));
897 case SIMPLE_HASH('l', 's'):
900 return (cpp_demangle_read_expression_binary(ddata, "<<", 2));
902 case SIMPLE_HASH('l', 'S'):
905 return (cpp_demangle_read_expression_binary(ddata, "<<=", 3));
907 case SIMPLE_HASH('l', 't'):
910 return (cpp_demangle_read_expression_binary(ddata, "<", 1));
912 case SIMPLE_HASH('m', 'i'):
915 return (cpp_demangle_read_expression_binary(ddata, "-", 1));
917 case SIMPLE_HASH('m', 'I'):
920 return (cpp_demangle_read_expression_binary(ddata, "-=", 2));
922 case SIMPLE_HASH('m', 'l'):
925 return (cpp_demangle_read_expression_binary(ddata, "*", 1));
927 case SIMPLE_HASH('m', 'L'):
930 return (cpp_demangle_read_expression_binary(ddata, "*=", 2));
932 case SIMPLE_HASH('m', 'm'):
935 return (cpp_demangle_read_expression_binary(ddata, "--", 2));
937 case SIMPLE_HASH('n', 'a'):
940 return (cpp_demangle_read_expression_unary(ddata, "new []", 6));
942 case SIMPLE_HASH('n', 'e'):
945 return (cpp_demangle_read_expression_binary(ddata, "!=", 2));
947 case SIMPLE_HASH('n', 'g'):
948 /* operator - (unary) */
950 return (cpp_demangle_read_expression_unary(ddata, "-", 1));
952 case SIMPLE_HASH('n', 't'):
955 return (cpp_demangle_read_expression_binary(ddata, "!", 1));
957 case SIMPLE_HASH('n', 'w'):
960 return (cpp_demangle_read_expression_unary(ddata, "new", 3));
962 case SIMPLE_HASH('o', 'o'):
965 return (cpp_demangle_read_expression_binary(ddata, "||", 2));
967 case SIMPLE_HASH('o', 'r'):
970 return (cpp_demangle_read_expression_binary(ddata, "|", 1));
972 case SIMPLE_HASH('o', 'R'):
975 return (cpp_demangle_read_expression_binary(ddata, "|=", 2));
977 case SIMPLE_HASH('p', 'l'):
980 return (cpp_demangle_read_expression_binary(ddata, "+", 1));
982 case SIMPLE_HASH('p', 'L'):
985 return (cpp_demangle_read_expression_binary(ddata, "+=", 2));
987 case SIMPLE_HASH('p', 'm'):
990 return (cpp_demangle_read_expression_binary(ddata, "->*", 3));
992 case SIMPLE_HASH('p', 'p'):
995 return (cpp_demangle_read_expression_binary(ddata, "++", 2));
997 case SIMPLE_HASH('p', 's'):
998 /* operator + (unary) */
1000 return (cpp_demangle_read_expression_unary(ddata, "+", 1));
1002 case SIMPLE_HASH('p', 't'):
1005 return (cpp_demangle_read_expression_binary(ddata, "->", 2));
1007 case SIMPLE_HASH('q', 'u'):
1010 return (cpp_demangle_read_expression_trinary(ddata, "?", 1,
1013 case SIMPLE_HASH('r', 'm'):
1016 return (cpp_demangle_read_expression_binary(ddata, "%", 1));
1018 case SIMPLE_HASH('r', 'M'):
1021 return (cpp_demangle_read_expression_binary(ddata, "%=", 2));
1023 case SIMPLE_HASH('r', 's'):
1026 return (cpp_demangle_read_expression_binary(ddata, ">>", 2));
1028 case SIMPLE_HASH('r', 'S'):
1031 return (cpp_demangle_read_expression_binary(ddata, ">>=", 3));
1033 case SIMPLE_HASH('r', 'z'):
1034 /* operator sizeof */
1036 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
1038 case SIMPLE_HASH('s', 'v'):
1039 /* operator sizeof */
1041 return (cpp_demangle_read_expression_unary(ddata, "sizeof", 6));
1044 switch (*ddata->cur) {
1046 return (cpp_demangle_read_expr_primary(ddata));
1048 return (cpp_demangle_read_tmpl_param(ddata));
1055 cpp_demangle_read_expression_flat(struct cpp_demangle_data *ddata, char **str)
1057 struct vector_str *output;
1058 size_t i, p_idx, idx, exp_len;
1061 output = ddata->push_head > 0 ? &ddata->output_tmp :
1064 p_idx = output->size;
1066 if (!cpp_demangle_read_expression(ddata))
1069 if ((exp = vector_str_substr(output, p_idx, output->size - 1,
1074 for (i = p_idx; i < idx; ++i) {
1075 if (!vector_str_pop(output)) {
1087 cpp_demangle_read_expression_binary(struct cpp_demangle_data *ddata,
1088 const char *name, size_t len)
1091 if (ddata == NULL || name == NULL || len == 0)
1093 if (!cpp_demangle_read_expression(ddata))
1095 if (!cpp_demangle_push_str(ddata, name, len))
1098 return (cpp_demangle_read_expression(ddata));
1102 cpp_demangle_read_expression_unary(struct cpp_demangle_data *ddata,
1103 const char *name, size_t len)
1106 if (ddata == NULL || name == NULL || len == 0)
1108 if (!cpp_demangle_read_expression(ddata))
1111 return (cpp_demangle_push_str(ddata, name, len));
1115 cpp_demangle_read_expression_trinary(struct cpp_demangle_data *ddata,
1116 const char *name1, size_t len1, const char *name2, size_t len2)
1119 if (ddata == NULL || name1 == NULL || len1 == 0 || name2 == NULL ||
1123 if (!cpp_demangle_read_expression(ddata))
1125 if (!cpp_demangle_push_str(ddata, name1, len1))
1127 if (!cpp_demangle_read_expression(ddata))
1129 if (!cpp_demangle_push_str(ddata, name2, len2))
1132 return (cpp_demangle_read_expression(ddata));
1136 cpp_demangle_read_function(struct cpp_demangle_data *ddata, int *ext_c,
1137 struct vector_type_qualifier *v)
1139 size_t class_type_size, class_type_len, limit;
1140 const char *class_type;
1142 if (ddata == NULL || *ddata->cur != 'F' || v == NULL)
1146 if (*ddata->cur == 'Y') {
1151 if (!cpp_demangle_read_type(ddata, 0))
1153 if (*ddata->cur != 'E') {
1154 if (!cpp_demangle_push_str(ddata, "(", 1))
1156 if (vector_read_cmd_find(&ddata->cmd, READ_PTRMEM)) {
1157 if ((class_type_size = ddata->class_type.size) == 0)
1160 ddata->class_type.container[class_type_size - 1];
1161 if (class_type == NULL)
1163 if ((class_type_len = strlen(class_type)) == 0)
1165 if (!cpp_demangle_push_str(ddata, class_type,
1168 if (!cpp_demangle_push_str(ddata, "::*", 3))
1172 if (!cpp_demangle_push_type_qualifier(ddata, v,
1173 (const char *) NULL))
1175 vector_type_qualifier_dest(v);
1176 if (!vector_type_qualifier_init(v))
1180 if (!cpp_demangle_push_str(ddata, ")(", 2))
1185 if (!cpp_demangle_read_type(ddata, 0))
1187 if (*ddata->cur == 'E')
1189 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1193 if (vector_read_cmd_find(&ddata->cmd, READ_PTRMEM) == 1) {
1194 if (!cpp_demangle_push_type_qualifier(ddata, v,
1195 (const char *) NULL))
1197 vector_type_qualifier_dest(v);
1198 if (!vector_type_qualifier_init(v))
1202 if (!cpp_demangle_push_str(ddata, ")", 1))
1211 /* read encoding, encoding are function name, data name, special-name */
1213 cpp_demangle_read_encoding(struct cpp_demangle_data *ddata)
1215 char *name, *type, *num_str;
1219 if (ddata == NULL || *ddata->cur == '\0')
1223 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1224 case SIMPLE_HASH('G', 'A'):
1225 if (!cpp_demangle_push_str(ddata, "hidden alias for ", 17))
1228 if (*ddata->cur == '\0')
1230 return (cpp_demangle_read_encoding(ddata));
1232 case SIMPLE_HASH('G', 'R'):
1233 if (!cpp_demangle_push_str(ddata, "reference temporary #", 21))
1236 if (*ddata->cur == '\0')
1238 if (!cpp_demangle_read_name_flat(ddata, &name))
1241 if (!cpp_demangle_read_number_as_string(ddata, &num_str))
1243 if (!cpp_demangle_push_str(ddata, num_str, strlen(num_str)))
1245 if (!cpp_demangle_push_str(ddata, " for ", 5))
1247 if (!cpp_demangle_push_str(ddata, name, strlen(name)))
1256 case SIMPLE_HASH('G', 'T'):
1258 if (*ddata->cur == '\0')
1260 switch (*ddata->cur) {
1262 if (!cpp_demangle_push_str(ddata,
1263 "non-transaction clone for ", 26))
1268 if (!cpp_demangle_push_str(ddata,
1269 "transaction clone for ", 22))
1274 return (cpp_demangle_read_encoding(ddata));
1276 case SIMPLE_HASH('G', 'V'):
1277 /* sentry object for 1 time init */
1278 if (!cpp_demangle_push_str(ddata, "guard variable for ", 20))
1283 case SIMPLE_HASH('T', 'c'):
1284 /* virtual function covariant override thunk */
1285 if (!cpp_demangle_push_str(ddata,
1286 "virtual function covariant override ", 36))
1289 if (*ddata->cur == '\0')
1291 if (!cpp_demangle_read_offset(ddata))
1293 if (!cpp_demangle_read_offset(ddata))
1295 return (cpp_demangle_read_encoding(ddata));
1297 case SIMPLE_HASH('T', 'C'):
1298 /* construction vtable */
1299 if (!cpp_demangle_push_str(ddata, "construction vtable for ",
1303 if (*ddata->cur == '\0')
1305 if (!cpp_demangle_read_type_flat(ddata, &type))
1308 if (!cpp_demangle_read_number(ddata, &offset))
1310 if (*ddata->cur++ != '_')
1312 if (!cpp_demangle_read_type(ddata, 0))
1314 if (!cpp_demangle_push_str(ddata, "-in-", 4))
1316 if (!cpp_demangle_push_str(ddata, type, strlen(type)))
1323 case SIMPLE_HASH('T', 'D'):
1324 /* typeinfo common proxy */
1327 case SIMPLE_HASH('T', 'F'):
1329 if (!cpp_demangle_push_str(ddata, "typeinfo fn for ", 16))
1332 if (*ddata->cur == '\0')
1334 return (cpp_demangle_read_type(ddata, 0));
1336 case SIMPLE_HASH('T', 'h'):
1337 /* virtual function non-virtual override thunk */
1338 if (!cpp_demangle_push_str(ddata,
1339 "virtual function non-virtual override ", 38))
1342 if (*ddata->cur == '\0')
1344 if (!cpp_demangle_read_nv_offset(ddata))
1346 return (cpp_demangle_read_encoding(ddata));
1348 case SIMPLE_HASH('T', 'H'):
1349 /* TLS init function */
1350 if (!cpp_demangle_push_str(ddata, "TLS init function for ",
1354 if (*ddata->cur == '\0')
1358 case SIMPLE_HASH('T', 'I'):
1359 /* typeinfo structure */
1360 if (!cpp_demangle_push_str(ddata, "typeinfo for ", 13))
1363 if (*ddata->cur == '\0')
1365 return (cpp_demangle_read_type(ddata, 0));
1367 case SIMPLE_HASH('T', 'J'):
1369 if (!cpp_demangle_push_str(ddata, "java Class for ", 15))
1372 if (*ddata->cur == '\0')
1374 return (cpp_demangle_read_type(ddata, 0));
1376 case SIMPLE_HASH('T', 'S'):
1377 /* RTTI name (NTBS) */
1378 if (!cpp_demangle_push_str(ddata, "typeinfo name for ", 18))
1381 if (*ddata->cur == '\0')
1383 return (cpp_demangle_read_type(ddata, 0));
1385 case SIMPLE_HASH('T', 'T'):
1387 if (!cpp_demangle_push_str(ddata, "VTT for ", 8))
1390 if (*ddata->cur == '\0')
1392 return (cpp_demangle_read_type(ddata, 0));
1394 case SIMPLE_HASH('T', 'v'):
1395 /* virtual function virtual override thunk */
1396 if (!cpp_demangle_push_str(ddata,
1397 "virtual function virtual override ", 34))
1400 if (*ddata->cur == '\0')
1402 if (!cpp_demangle_read_v_offset(ddata))
1404 return (cpp_demangle_read_encoding(ddata));
1406 case SIMPLE_HASH('T', 'V'):
1408 if (!cpp_demangle_push_str(ddata, "vtable for ", 12))
1411 if (*ddata->cur == '\0')
1413 return (cpp_demangle_read_type(ddata, 0));
1415 case SIMPLE_HASH('T', 'W'):
1416 /* TLS wrapper function */
1417 if (!cpp_demangle_push_str(ddata, "TLS wrapper function for ",
1421 if (*ddata->cur == '\0')
1426 return (cpp_demangle_read_name(ddata));
1430 cpp_demangle_read_local_name(struct cpp_demangle_data *ddata)
1436 if (*(++ddata->cur) == '\0')
1438 if (!cpp_demangle_read_encoding(ddata))
1443 if (!cpp_demangle_read_type(ddata, 1))
1445 if (*ddata->cur == 'E')
1447 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1450 if (*(++ddata->cur) == '\0')
1452 if (ddata->paren == true) {
1453 if (!cpp_demangle_push_str(ddata, ")", 1))
1455 ddata->paren = false;
1457 if (*ddata->cur == 's')
1460 if (!cpp_demangle_push_str(ddata, "::", 2))
1462 if (!cpp_demangle_read_name(ddata))
1465 if (*ddata->cur == '_') {
1467 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
1475 cpp_demangle_read_name(struct cpp_demangle_data *ddata)
1477 struct vector_str *output, v;
1478 size_t p_idx, subst_str_len;
1482 if (ddata == NULL || *ddata->cur == '\0')
1485 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
1489 switch (*ddata->cur) {
1491 return (cpp_demangle_read_subst(ddata));
1493 return (cpp_demangle_read_nested_name(ddata));
1495 return (cpp_demangle_read_local_name(ddata));
1498 if (!vector_str_init(&v))
1501 p_idx = output->size;
1503 if (!cpp_demangle_read_uqname(ddata))
1505 if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
1506 &subst_str_len)) == NULL)
1508 if (subst_str_len > 8 && strstr(subst_str, "operator") != NULL) {
1512 if (!vector_str_push(&v, subst_str, subst_str_len))
1514 if (!cpp_demangle_push_subst_v(ddata, &v))
1517 if (*ddata->cur == 'I') {
1518 p_idx = output->size;
1519 if (!cpp_demangle_read_tmpl_args(ddata))
1522 if ((subst_str = vector_str_substr(output, p_idx,
1523 output->size - 1, &subst_str_len)) == NULL)
1525 if (!vector_str_push(&v, subst_str, subst_str_len))
1527 if (!cpp_demangle_push_subst_v(ddata, &v))
1535 vector_str_dest(&v);
1541 cpp_demangle_read_name_flat(struct cpp_demangle_data *ddata, char **str)
1543 struct vector_str *output;
1544 size_t i, p_idx, idx, name_len;
1547 output = ddata->push_head > 0 ? &ddata->output_tmp :
1550 p_idx = output->size;
1552 if (!cpp_demangle_read_name(ddata))
1555 if ((name = vector_str_substr(output, p_idx, output->size - 1,
1556 &name_len)) == NULL)
1560 for (i = p_idx; i < idx; ++i) {
1561 if (!vector_str_pop(output)) {
1573 cpp_demangle_read_nested_name(struct cpp_demangle_data *ddata)
1575 struct vector_str *output, v;
1576 size_t limit, p_idx, subst_str_len;
1580 if (ddata == NULL || *ddata->cur != 'N')
1582 if (*(++ddata->cur) == '\0')
1585 while (*ddata->cur == 'r' || *ddata->cur == 'V' ||
1586 *ddata->cur == 'K') {
1587 switch (*ddata->cur) {
1589 ddata->mem_rst = true;
1592 ddata->mem_vat = true;
1595 ddata->mem_cst = true;
1601 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
1602 if (!vector_str_init(&v))
1608 p_idx = output->size;
1609 switch (*ddata->cur) {
1611 if (!cpp_demangle_read_tmpl_args(ddata))
1615 if (!cpp_demangle_read_subst(ddata))
1619 if (!cpp_demangle_read_tmpl_param(ddata))
1623 if (!cpp_demangle_read_uqname(ddata))
1627 if ((subst_str = vector_str_substr(output, p_idx,
1628 output->size - 1, &subst_str_len)) == NULL)
1630 if (!vector_str_push(&v, subst_str, subst_str_len)) {
1636 if (!cpp_demangle_push_subst_v(ddata, &v))
1638 if (*ddata->cur == 'E')
1640 else if (*ddata->cur != 'I' &&
1641 *ddata->cur != 'C' && *ddata->cur != 'D') {
1642 if (!cpp_demangle_push_str(ddata, "::", 2))
1644 if (!vector_str_push(&v, "::", 2))
1647 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
1655 vector_str_dest(&v);
1662 * number ::= [n] <decimal>
1665 cpp_demangle_read_number(struct cpp_demangle_data *ddata, long *rtn)
1667 long len, negative_factor;
1669 if (ddata == NULL || rtn == NULL)
1672 negative_factor = 1;
1673 if (*ddata->cur == 'n') {
1674 negative_factor = -1;
1678 if (ELFTC_ISDIGIT(*ddata->cur) == 0)
1682 if ((len = strtol(ddata->cur, (char **) NULL, 10)) == 0 &&
1686 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
1690 assert(negative_factor == 1 || negative_factor == -1);
1692 *rtn = len * negative_factor;
1698 cpp_demangle_read_number_as_string(struct cpp_demangle_data *ddata, char **str)
1702 if (!cpp_demangle_read_number(ddata, &n)) {
1707 if (asprintf(str, "%ld", n) < 0) {
1716 cpp_demangle_read_nv_offset(struct cpp_demangle_data *ddata)
1722 if (!cpp_demangle_push_str(ddata, "offset : ", 9))
1725 return (cpp_demangle_read_offset_number(ddata));
1728 /* read offset, offset are nv-offset, v-offset */
1730 cpp_demangle_read_offset(struct cpp_demangle_data *ddata)
1736 if (*ddata->cur == 'h') {
1738 return (cpp_demangle_read_nv_offset(ddata));
1739 } else if (*ddata->cur == 'v') {
1741 return (cpp_demangle_read_v_offset(ddata));
1748 cpp_demangle_read_offset_number(struct cpp_demangle_data *ddata)
1753 if (ddata == NULL || *ddata->cur == '\0')
1756 /* offset could be negative */
1757 if (*ddata->cur == 'n') {
1759 start = ddata->cur + 1;
1765 while (*ddata->cur != '_')
1768 if (negative && !cpp_demangle_push_str(ddata, "-", 1))
1771 assert(start != NULL);
1773 if (!cpp_demangle_push_str(ddata, start, ddata->cur - start))
1775 if (!cpp_demangle_push_str(ddata, " ", 1))
1784 cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *ddata)
1786 size_t class_type_len, i, idx, p_idx;
1787 int p_func_type, rtn;
1790 if (ddata == NULL || *ddata->cur != 'M' || *(++ddata->cur) == '\0')
1793 p_idx = ddata->output.size;
1794 if (!cpp_demangle_read_type(ddata, 0))
1797 if ((class_type = vector_str_substr(&ddata->output, p_idx,
1798 ddata->output.size - 1, &class_type_len)) == NULL)
1802 idx = ddata->output.size;
1803 for (i = p_idx; i < idx; ++i)
1804 if (!vector_str_pop(&ddata->output))
1807 if (!vector_read_cmd_push(&ddata->cmd, READ_PTRMEM))
1810 if (!vector_str_push(&ddata->class_type, class_type, class_type_len))
1813 p_func_type = ddata->func_type;
1814 if (!cpp_demangle_read_type(ddata, 0))
1817 if (p_func_type == ddata->func_type) {
1818 if (!cpp_demangle_push_str(ddata, " ", 1))
1820 if (!cpp_demangle_push_str(ddata, class_type, class_type_len))
1822 if (!cpp_demangle_push_str(ddata, "::*", 3))
1828 if (!vector_str_pop(&ddata->class_type))
1831 if (!vector_read_cmd_pop(&ddata->cmd))
1839 /* read source-name, source-name is <len> <ID> */
1841 cpp_demangle_read_sname(struct cpp_demangle_data *ddata)
1846 if (ddata == NULL || cpp_demangle_read_number(ddata, &len) == 0 ||
1850 if (len == 12 && (memcmp("_GLOBAL__N_1", ddata->cur, 12) == 0))
1851 err = cpp_demangle_push_str(ddata, "(anonymous namespace)", 21);
1853 err = cpp_demangle_push_str(ddata, ddata->cur, len);
1858 assert(ddata->output.size > 0);
1859 if (vector_read_cmd_find(&ddata->cmd, READ_TMPL) == 0)
1861 ddata->output.container[ddata->output.size - 1];
1869 cpp_demangle_read_subst(struct cpp_demangle_data *ddata)
1873 if (ddata == NULL || *ddata->cur == '\0')
1876 /* abbreviations of the form Sx */
1877 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
1878 case SIMPLE_HASH('S', 'a'):
1879 /* std::allocator */
1880 if (cpp_demangle_push_str(ddata, "std::allocator", 14) == 0)
1883 if (*ddata->cur == 'I')
1884 return (cpp_demangle_read_subst_stdtmpl(ddata,
1885 "std::allocator", 14));
1888 case SIMPLE_HASH('S', 'b'):
1889 /* std::basic_string */
1890 if (!cpp_demangle_push_str(ddata, "std::basic_string", 17))
1893 if (*ddata->cur == 'I')
1894 return (cpp_demangle_read_subst_stdtmpl(ddata,
1895 "std::basic_string", 17));
1898 case SIMPLE_HASH('S', 'd'):
1899 /* std::basic_iostream<char, std::char_traits<char> > */
1900 if (!cpp_demangle_push_str(ddata, "std::basic_iostream", 19))
1902 ddata->last_sname = "basic_iostream";
1904 if (*ddata->cur == 'I')
1905 return (cpp_demangle_read_subst_stdtmpl(ddata,
1906 "std::basic_iostream", 19));
1909 case SIMPLE_HASH('S', 'i'):
1910 /* std::basic_istream<char, std::char_traits<char> > */
1911 if (!cpp_demangle_push_str(ddata, "std::basic_istream", 18))
1913 ddata->last_sname = "basic_istream";
1915 if (*ddata->cur == 'I')
1916 return (cpp_demangle_read_subst_stdtmpl(ddata,
1917 "std::basic_istream", 18));
1920 case SIMPLE_HASH('S', 'o'):
1921 /* std::basic_ostream<char, std::char_traits<char> > */
1922 if (!cpp_demangle_push_str(ddata, "std::basic_ostream", 18))
1924 ddata->last_sname = "basic_ostream";
1926 if (*ddata->cur == 'I')
1927 return (cpp_demangle_read_subst_stdtmpl(ddata,
1928 "std::basic_ostream", 18));
1931 case SIMPLE_HASH('S', 's'):
1933 * std::basic_string<char, std::char_traits<char>,
1934 * std::allocator<char> >
1938 if (!cpp_demangle_push_str(ddata, "std::string", 11))
1940 ddata->last_sname = "string";
1942 if (*ddata->cur == 'I')
1943 return (cpp_demangle_read_subst_stdtmpl(ddata,
1944 "std::string", 11));
1947 case SIMPLE_HASH('S', 't'):
1949 return (cpp_demangle_read_subst_std(ddata));
1952 if (*(++ddata->cur) == '\0')
1956 if (*ddata->cur == '_')
1957 return (cpp_demangle_get_subst(ddata, 0));
1960 /* substitution number is base 36 */
1961 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
1965 /* first was '_', so increase one */
1968 while (*ddata->cur != '_')
1973 return (cpp_demangle_get_subst(ddata, nth));
1981 cpp_demangle_read_subst_std(struct cpp_demangle_data *ddata)
1983 struct vector_str *output, v;
1984 size_t p_idx, subst_str_len;
1991 if (!vector_str_init(&v))
1996 if (!cpp_demangle_push_str(ddata, "std::", 5))
1999 if (!vector_str_push(&v, "std::", 5))
2004 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
2006 p_idx = output->size;
2007 if (!cpp_demangle_read_uqname(ddata))
2010 if ((subst_str = vector_str_substr(output, p_idx, output->size - 1,
2011 &subst_str_len)) == NULL)
2014 if (!vector_str_push(&v, subst_str, subst_str_len))
2017 if (!cpp_demangle_push_subst_v(ddata, &v))
2020 if (*ddata->cur == 'I') {
2021 p_idx = output->size;
2022 if (!cpp_demangle_read_tmpl_args(ddata))
2025 if ((subst_str = vector_str_substr(output, p_idx,
2026 output->size - 1, &subst_str_len)) == NULL)
2028 if (!vector_str_push(&v, subst_str, subst_str_len))
2030 if (!cpp_demangle_push_subst_v(ddata, &v))
2037 vector_str_dest(&v);
2043 cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *ddata,
2044 const char *str, size_t len)
2046 struct vector_str *output;
2047 size_t p_idx, substr_len;
2049 char *subst_str, *substr;
2051 if (ddata == NULL || str == NULL || len == 0)
2054 output = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
2056 p_idx = output->size;
2060 if (!cpp_demangle_read_tmpl_args(ddata))
2062 if ((substr = vector_str_substr(output, p_idx, output->size - 1,
2063 &substr_len)) == NULL)
2067 if ((subst_str = malloc(sizeof(char) * (substr_len + len + 1))) ==
2071 memcpy(subst_str, str, len);
2072 memcpy(subst_str + len, substr, substr_len);
2073 subst_str[substr_len + len] = '\0';
2075 if (!cpp_demangle_push_subst(ddata, subst_str, substr_len + len))
2087 cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *ddata)
2090 if (ddata == NULL || *ddata->cur == '\0')
2093 switch (*ddata->cur) {
2095 return (cpp_demangle_read_expr_primary(ddata));
2097 return (cpp_demangle_read_expression(ddata));
2100 return (cpp_demangle_read_type(ddata, 0));
2104 cpp_demangle_read_tmpl_args(struct cpp_demangle_data *ddata)
2106 struct vector_str *v;
2107 size_t arg_len, idx, limit, size;
2110 if (ddata == NULL || *ddata->cur == '\0')
2115 if (!vector_read_cmd_push(&ddata->cmd, READ_TMPL))
2118 if (!cpp_demangle_push_str(ddata, "<", 1))
2122 v = ddata->push_head > 0 ? &ddata->output_tmp : &ddata->output;
2125 if (!cpp_demangle_read_tmpl_arg(ddata))
2127 if ((arg = vector_str_substr(v, idx, v->size - 1, &arg_len)) ==
2130 if (!vector_str_find(&ddata->tmpl, arg, arg_len) &&
2131 !vector_str_push(&ddata->tmpl, arg, arg_len)) {
2138 if (*ddata->cur == 'E') {
2142 if (!strncmp(v->container[size - 1], ">", 1)) {
2143 if (!cpp_demangle_push_str(ddata, " >", 2))
2145 } else if (!cpp_demangle_push_str(ddata, ">", 1))
2148 } else if (*ddata->cur != 'I' &&
2149 !cpp_demangle_push_str(ddata, ", ", 2))
2152 if (limit++ > CPP_DEMANGLE_TRY_LIMIT)
2156 return (vector_read_cmd_pop(&ddata->cmd));
2160 * Read template parameter that forms in 'T[number]_'.
2161 * This function much like to read_subst but only for types.
2164 cpp_demangle_read_tmpl_param(struct cpp_demangle_data *ddata)
2168 if (ddata == NULL || *ddata->cur != 'T')
2173 if (*ddata->cur == '_')
2174 return (cpp_demangle_get_tmpl_param(ddata, 0));
2178 if ((nth = strtol(ddata->cur, (char **) NULL, 36)) == 0 &&
2185 while (*ddata->cur != '_')
2190 return (cpp_demangle_get_tmpl_param(ddata, nth));
2198 cpp_demangle_read_type(struct cpp_demangle_data *ddata, int delimit)
2200 struct vector_type_qualifier v;
2201 struct vector_str *output;
2202 size_t p_idx, type_str_len;
2203 int extern_c, is_builtin;
2205 char *type_str, *exp_str, *num_str;
2210 output = &ddata->output;
2211 if (!strncmp(ddata->output.container[ddata->output.size - 1], ">", 1)) {
2213 output = &ddata->output_tmp;
2214 } else if (delimit == 1) {
2215 if (ddata->paren == false) {
2216 if (!cpp_demangle_push_str(ddata, "(", 1))
2218 if (ddata->output.size < 2)
2220 ddata->paren = true;
2221 ddata->pfirst = true;
2222 /* Need pop function name */
2223 if (ddata->subst.size == 1 &&
2224 !vector_str_pop(&ddata->subst))
2229 ddata->pfirst = false;
2230 else if (*ddata->cur != 'I' &&
2231 !cpp_demangle_push_str(ddata, ", ", 2))
2235 assert(output != NULL);
2237 * [r, V, K] [P, R, C, G, U] builtin, function, class-enum, array
2238 * pointer-to-member, template-param, template-template-param, subst
2241 if (!vector_type_qualifier_init(&v))
2246 p_idx = output->size;
2247 type_str = exp_str = num_str = NULL;
2250 switch (*ddata->cur) {
2253 if (!cpp_demangle_push_str(ddata, "signed char", 11))
2260 if (!cpp_demangle_read_array(ddata))
2267 if (!cpp_demangle_push_str(ddata, "bool", 4))
2274 if (!vector_type_qualifier_push(&v, TYPE_CMX))
2281 if (!cpp_demangle_push_str(ddata, "char", 4))
2288 if (!cpp_demangle_push_str(ddata, "double", 6))
2295 switch (*ddata->cur) {
2297 /* IEEE 754r decimal floating point (64 bits) */
2298 if (!cpp_demangle_push_str(ddata, "decimal64", 9))
2303 /* IEEE 754r decimal floating point (128 bits) */
2304 if (!cpp_demangle_push_str(ddata, "decimal128", 10))
2309 /* IEEE 754r decimal floating point (32 bits) */
2310 if (!cpp_demangle_push_str(ddata, "decimal32", 9))
2315 /* IEEE 754r half-precision floating point (16 bits) */
2316 if (!cpp_demangle_push_str(ddata, "half", 4))
2322 if (!cpp_demangle_push_str(ddata, "char32_t", 8))
2327 /* std::nullptr_t (i.e., decltype(nullptr)) */
2328 if (!cpp_demangle_push_str(ddata, "decltype(nullptr)",
2335 if (!cpp_demangle_push_str(ddata, "char16_t", 8))
2340 /* gcc vector_size extension. */
2342 if (*ddata->cur == '_') {
2344 if (!cpp_demangle_read_expression_flat(ddata,
2347 if (!vector_str_push(&v.ext_name, exp_str,
2351 if (!cpp_demangle_read_number_as_string(ddata,
2354 if (!vector_str_push(&v.ext_name, num_str,
2358 if (*ddata->cur != '_')
2361 if (!vector_type_qualifier_push(&v, TYPE_VEC))
2371 if (!cpp_demangle_push_str(ddata, "long double", 11))
2378 if (!cpp_demangle_push_str(ddata, "float", 5))
2385 if (!cpp_demangle_read_function(ddata, &extern_c, &v))
2392 if (!cpp_demangle_push_str(ddata, "__float128", 10))
2399 if (!vector_type_qualifier_push(&v, TYPE_IMG))
2406 if (!cpp_demangle_push_str(ddata, "unsigned char", 13))
2413 if (!cpp_demangle_push_str(ddata, "int", 3))
2420 if (!cpp_demangle_push_str(ddata, "unsigned int", 12))
2427 if (!vector_type_qualifier_push(&v, TYPE_CST))
2434 if (!cpp_demangle_push_str(ddata, "long", 4))
2441 if (!cpp_demangle_push_str(ddata, "unsigned long", 13))
2448 /* pointer to member */
2449 if (!cpp_demangle_read_pointer_to_member(ddata))
2456 if (!cpp_demangle_push_str(ddata, "__int128", 8))
2462 /* unsigned __int128 */
2463 if (!cpp_demangle_push_str(ddata, "unsigned __int128", 17))
2470 if (!vector_type_qualifier_push(&v, TYPE_PTR))
2477 if (!vector_type_qualifier_push(&v, TYPE_RST))
2484 if (!vector_type_qualifier_push(&v, TYPE_REF))
2490 /* short, local string */
2491 if (!cpp_demangle_push_str(ddata, "short", 5))
2498 if (!cpp_demangle_read_subst(ddata))
2504 /* unsigned short */
2505 if (!cpp_demangle_push_str(ddata, "unsigned short", 14))
2511 /* template parameter */
2512 if (!cpp_demangle_read_tmpl_param(ddata))
2518 /* vendor extended builtin */
2520 if (!cpp_demangle_read_sname(ddata))
2526 /* vendor extended type qualifier */
2527 if (!cpp_demangle_read_number(ddata, &len))
2531 if (!vector_str_push(&v.ext_name, ddata->cur, len))
2534 if (!vector_type_qualifier_push(&v, TYPE_EXT))
2540 if (!cpp_demangle_push_str(ddata, "void", 4))
2547 if (!vector_type_qualifier_push(&v, TYPE_VAT))
2554 if (!cpp_demangle_push_str(ddata, "wchar_t", 7))
2561 if (!cpp_demangle_push_str(ddata, "long long", 9))
2567 /* unsigned long long */
2568 if (!cpp_demangle_push_str(ddata, "unsigned long long", 18))
2575 if (!cpp_demangle_push_str(ddata, "ellipsis", 8))
2581 if (!cpp_demangle_read_name(ddata))
2586 if ((type_str = vector_str_substr(output, p_idx, output->size - 1,
2587 &type_str_len)) == NULL)
2590 if (is_builtin == 0) {
2591 if (!vector_str_find(&ddata->subst, type_str, type_str_len) &&
2592 !vector_str_push(&ddata->subst, type_str, type_str_len))
2596 if (!cpp_demangle_push_type_qualifier(ddata, &v, type_str))
2602 vector_type_qualifier_dest(&v);
2604 if (ddata->push_head > 0) {
2605 if (*ddata->cur == 'I' && cpp_demangle_read_tmpl_args(ddata)
2609 if (--ddata->push_head > 0)
2612 if (!vector_str_push(&ddata->output_tmp, " ", 1))
2615 if (!vector_str_push_vector_head(&ddata->output,
2616 &ddata->output_tmp))
2619 vector_str_dest(&ddata->output_tmp);
2620 if (!vector_str_init(&ddata->output_tmp))
2623 if (!cpp_demangle_push_str(ddata, "(", 1))
2626 ddata->paren = true;
2627 ddata->pfirst = true;
2635 vector_type_qualifier_dest(&v);
2641 cpp_demangle_read_type_flat(struct cpp_demangle_data *ddata, char **str)
2643 struct vector_str *output;
2644 size_t i, p_idx, idx, type_len;
2647 output = ddata->push_head > 0 ? &ddata->output_tmp :
2650 p_idx = output->size;
2652 if (!cpp_demangle_read_type(ddata, 0))
2655 if ((type = vector_str_substr(output, p_idx, output->size - 1,
2656 &type_len)) == NULL)
2660 for (i = p_idx; i < idx; ++i) {
2661 if (!vector_str_pop(output)) {
2673 * read unqualified-name, unqualified name are operator-name, ctor-dtor-name,
2677 cpp_demangle_read_uqname(struct cpp_demangle_data *ddata)
2681 if (ddata == NULL || *ddata->cur == '\0')
2685 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
2686 case SIMPLE_HASH('a', 'a'):
2688 if (!cpp_demangle_push_str(ddata, "operator&&", 10))
2693 case SIMPLE_HASH('a', 'd'):
2694 /* operator & (unary) */
2695 if (!cpp_demangle_push_str(ddata, "operator&", 9))
2700 case SIMPLE_HASH('a', 'n'):
2702 if (!cpp_demangle_push_str(ddata, "operator&", 9))
2707 case SIMPLE_HASH('a', 'N'):
2709 if (!cpp_demangle_push_str(ddata, "operator&=", 10))
2714 case SIMPLE_HASH('a', 'S'):
2716 if (!cpp_demangle_push_str(ddata, "operator=", 9))
2721 case SIMPLE_HASH('c', 'l'):
2723 if (!cpp_demangle_push_str(ddata, "operator()", 10))
2728 case SIMPLE_HASH('c', 'm'):
2730 if (!cpp_demangle_push_str(ddata, "operator,", 9))
2735 case SIMPLE_HASH('c', 'o'):
2737 if (!cpp_demangle_push_str(ddata, "operator~", 9))
2742 case SIMPLE_HASH('c', 'v'):
2743 /* operator (cast) */
2744 if (!cpp_demangle_push_str(ddata, "operator(cast)", 14))
2747 return (cpp_demangle_read_type(ddata, 1));
2749 case SIMPLE_HASH('d', 'a'):
2750 /* operator delete [] */
2751 if (!cpp_demangle_push_str(ddata, "operator delete []", 18))
2756 case SIMPLE_HASH('d', 'e'):
2757 /* operator * (unary) */
2758 if (!cpp_demangle_push_str(ddata, "operator*", 9))
2763 case SIMPLE_HASH('d', 'l'):
2764 /* operator delete */
2765 if (!cpp_demangle_push_str(ddata, "operator delete", 15))
2770 case SIMPLE_HASH('d', 'v'):
2772 if (!cpp_demangle_push_str(ddata, "operator/", 9))
2777 case SIMPLE_HASH('d', 'V'):
2779 if (!cpp_demangle_push_str(ddata, "operator/=", 10))
2784 case SIMPLE_HASH('e', 'o'):
2786 if (!cpp_demangle_push_str(ddata, "operator^", 9))
2791 case SIMPLE_HASH('e', 'O'):
2793 if (!cpp_demangle_push_str(ddata, "operator^=", 10))
2798 case SIMPLE_HASH('e', 'q'):
2800 if (!cpp_demangle_push_str(ddata, "operator==", 10))
2805 case SIMPLE_HASH('g', 'e'):
2807 if (!cpp_demangle_push_str(ddata, "operator>=", 10))
2812 case SIMPLE_HASH('g', 't'):
2814 if (!cpp_demangle_push_str(ddata, "operator>", 9))
2819 case SIMPLE_HASH('i', 'x'):
2821 if (!cpp_demangle_push_str(ddata, "operator[]", 10))
2826 case SIMPLE_HASH('l', 'e'):
2828 if (!cpp_demangle_push_str(ddata, "operator<=", 10))
2833 case SIMPLE_HASH('l', 's'):
2835 if (!cpp_demangle_push_str(ddata, "operator<<", 10))
2840 case SIMPLE_HASH('l', 'S'):
2842 if (!cpp_demangle_push_str(ddata, "operator<<=", 11))
2847 case SIMPLE_HASH('l', 't'):
2849 if (!cpp_demangle_push_str(ddata, "operator<", 9))
2854 case SIMPLE_HASH('m', 'i'):
2856 if (!cpp_demangle_push_str(ddata, "operator-", 9))
2861 case SIMPLE_HASH('m', 'I'):
2863 if (!cpp_demangle_push_str(ddata, "operator-=", 10))
2868 case SIMPLE_HASH('m', 'l'):
2870 if (!cpp_demangle_push_str(ddata, "operator*", 9))
2875 case SIMPLE_HASH('m', 'L'):
2877 if (!cpp_demangle_push_str(ddata, "operator*=", 10))
2882 case SIMPLE_HASH('m', 'm'):
2884 if (!cpp_demangle_push_str(ddata, "operator--", 10))
2889 case SIMPLE_HASH('n', 'a'):
2890 /* operator new[] */
2891 if (!cpp_demangle_push_str(ddata, "operator new []", 15))
2896 case SIMPLE_HASH('n', 'e'):
2898 if (!cpp_demangle_push_str(ddata, "operator!=", 10))
2903 case SIMPLE_HASH('n', 'g'):
2904 /* operator - (unary) */
2905 if (!cpp_demangle_push_str(ddata, "operator-", 9))
2910 case SIMPLE_HASH('n', 't'):
2912 if (!cpp_demangle_push_str(ddata, "operator!", 9))
2917 case SIMPLE_HASH('n', 'w'):
2919 if (!cpp_demangle_push_str(ddata, "operator new", 12))
2924 case SIMPLE_HASH('o', 'o'):
2926 if (!cpp_demangle_push_str(ddata, "operator||", 10))
2931 case SIMPLE_HASH('o', 'r'):
2933 if (!cpp_demangle_push_str(ddata, "operator|", 9))
2938 case SIMPLE_HASH('o', 'R'):
2940 if (!cpp_demangle_push_str(ddata, "operator|=", 10))
2945 case SIMPLE_HASH('p', 'l'):
2947 if (!cpp_demangle_push_str(ddata, "operator+", 9))
2952 case SIMPLE_HASH('p', 'L'):
2954 if (!cpp_demangle_push_str(ddata, "operator+=", 10))
2959 case SIMPLE_HASH('p', 'm'):
2961 if (!cpp_demangle_push_str(ddata, "operator->*", 11))
2966 case SIMPLE_HASH('p', 'p'):
2968 if (!cpp_demangle_push_str(ddata, "operator++", 10))
2973 case SIMPLE_HASH('p', 's'):
2974 /* operator + (unary) */
2975 if (!cpp_demangle_push_str(ddata, "operator+", 9))
2980 case SIMPLE_HASH('p', 't'):
2982 if (!cpp_demangle_push_str(ddata, "operator->", 10))
2987 case SIMPLE_HASH('q', 'u'):
2989 if (!cpp_demangle_push_str(ddata, "operator?", 9))
2994 case SIMPLE_HASH('r', 'm'):
2996 if (!cpp_demangle_push_str(ddata, "operator%", 9))
3001 case SIMPLE_HASH('r', 'M'):
3003 if (!cpp_demangle_push_str(ddata, "operator%=", 10))
3008 case SIMPLE_HASH('r', 's'):
3010 if (!cpp_demangle_push_str(ddata, "operator>>", 10))
3015 case SIMPLE_HASH('r', 'S'):
3017 if (!cpp_demangle_push_str(ddata, "operator>>=", 11))
3022 case SIMPLE_HASH('r', 'z'):
3023 /* operator sizeof */
3024 if (!cpp_demangle_push_str(ddata, "operator sizeof ", 16))
3029 case SIMPLE_HASH('s', 'r'):
3030 /* scope resolution operator */
3031 if (!cpp_demangle_push_str(ddata, "scope resolution operator ",
3037 case SIMPLE_HASH('s', 'v'):
3038 /* operator sizeof */
3039 if (!cpp_demangle_push_str(ddata, "operator sizeof ", 16))
3045 /* vendor extened operator */
3046 if (*ddata->cur == 'v' && ELFTC_ISDIGIT(*(ddata->cur + 1))) {
3047 if (!cpp_demangle_push_str(ddata, "vendor extened operator ",
3050 if (!cpp_demangle_push_str(ddata, ddata->cur + 1, 1))
3053 return (cpp_demangle_read_sname(ddata));
3056 /* ctor-dtor-name */
3057 switch (SIMPLE_HASH(*ddata->cur, *(ddata->cur + 1))) {
3058 case SIMPLE_HASH('C', '1'):
3060 case SIMPLE_HASH('C', '2'):
3062 case SIMPLE_HASH('C', '3'):
3063 if (ddata->last_sname == NULL)
3065 if ((len = strlen(ddata->last_sname)) == 0)
3067 if (!cpp_demangle_push_str(ddata, "::", 2))
3069 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
3074 case SIMPLE_HASH('D', '0'):
3076 case SIMPLE_HASH('D', '1'):
3078 case SIMPLE_HASH('D', '2'):
3079 if (ddata->last_sname == NULL)
3081 if ((len = strlen(ddata->last_sname)) == 0)
3083 if (!cpp_demangle_push_str(ddata, "::~", 3))
3085 if (!cpp_demangle_push_str(ddata, ddata->last_sname, len))
3092 if (ELFTC_ISDIGIT(*ddata->cur) != 0)
3093 return (cpp_demangle_read_sname(ddata));
3095 /* local source name */
3096 if (*ddata->cur == 'L')
3097 return (cpp_demangle_local_source_name(ddata));
3103 * Read local source name.
3106 * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31775
3107 * http://gcc.gnu.org/viewcvs?view=rev&revision=124467
3110 cpp_demangle_local_source_name(struct cpp_demangle_data *ddata)
3113 if (ddata == NULL || *ddata->cur != 'L')
3118 if (!cpp_demangle_read_sname(ddata))
3122 if (*ddata->cur == '_') {
3124 while (ELFTC_ISDIGIT(*ddata->cur) != 0)
3132 cpp_demangle_read_v_offset(struct cpp_demangle_data *ddata)
3138 if (!cpp_demangle_push_str(ddata, "offset : ", 9))
3141 if (!cpp_demangle_read_offset_number(ddata))
3144 if (!cpp_demangle_push_str(ddata, "virtual offset : ", 17))
3147 return (!cpp_demangle_read_offset_number(ddata));
3151 * Decode floating point representation to string
3152 * Return new allocated string or NULL
3155 * Replace these functions to macro.
3158 decode_fp_to_double(const char *p, size_t len)
3161 size_t rtn_len, limit, i;
3165 if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(double))
3168 memset(&f, 0, sizeof(double));
3170 for (i = 0; i < len / 2; ++i) {
3171 byte = hex_to_dec(p[len - i * 2 - 1]) +
3172 hex_to_dec(p[len - i * 2 - 2]) * 16;
3174 if (byte < 0 || byte > 255)
3177 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3178 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3179 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3180 ((unsigned char *)&f)[sizeof(double) - i - 1] =
3181 (unsigned char)(byte);
3182 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3188 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3191 if (snprintf(rtn, rtn_len, "%fld", f) >= (int)rtn_len) {
3193 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3195 rtn_len *= BUFFER_GROWFACTOR;
3203 decode_fp_to_float(const char *p, size_t len)
3205 size_t i, rtn_len, limit;
3210 if (p == NULL || len == 0 || len % 2 != 0 || len / 2 > sizeof(float))
3213 memset(&f, 0, sizeof(float));
3215 for (i = 0; i < len / 2; ++i) {
3216 byte = hex_to_dec(p[len - i * 2 - 1]) +
3217 hex_to_dec(p[len - i * 2 - 2]) * 16;
3218 if (byte < 0 || byte > 255)
3220 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3221 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3222 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3223 ((unsigned char *)&f)[sizeof(float) - i - 1] =
3224 (unsigned char)(byte);
3225 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3231 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3234 if (snprintf(rtn, rtn_len, "%ff", f) >= (int)rtn_len) {
3236 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3238 rtn_len *= BUFFER_GROWFACTOR;
3246 decode_fp_to_float128(const char *p, size_t len)
3249 size_t rtn_len, limit, i;
3251 unsigned char buf[FLOAT_QUADRUPLE_BYTES];
3254 switch(sizeof(long double)) {
3255 case FLOAT_QUADRUPLE_BYTES:
3256 return (decode_fp_to_long_double(p, len));
3257 case FLOAT_EXTENED_BYTES:
3258 if (p == NULL || len == 0 || len % 2 != 0 ||
3259 len / 2 > FLOAT_QUADRUPLE_BYTES)
3262 memset(buf, 0, FLOAT_QUADRUPLE_BYTES);
3264 for (i = 0; i < len / 2; ++i) {
3265 byte = hex_to_dec(p[len - i * 2 - 1]) +
3266 hex_to_dec(p[len - i * 2 - 2]) * 16;
3267 if (byte < 0 || byte > 255)
3269 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3270 buf[i] = (unsigned char)(byte);
3271 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3272 buf[FLOAT_QUADRUPLE_BYTES - i -1] =
3273 (unsigned char)(byte);
3274 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3276 memset(&f, 0, FLOAT_EXTENED_BYTES);
3278 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3279 memcpy(&f, buf, FLOAT_EXTENED_BYTES);
3280 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3281 memcpy(&f, buf + 6, FLOAT_EXTENED_BYTES);
3282 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3287 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3290 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3292 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3294 rtn_len *= BUFFER_GROWFACTOR;
3305 decode_fp_to_float80(const char *p, size_t len)
3308 size_t rtn_len, limit, i;
3310 unsigned char buf[FLOAT_EXTENED_BYTES];
3313 switch(sizeof(long double)) {
3314 case FLOAT_QUADRUPLE_BYTES:
3315 if (p == NULL || len == 0 || len % 2 != 0 ||
3316 len / 2 > FLOAT_EXTENED_BYTES)
3319 memset(buf, 0, FLOAT_EXTENED_BYTES);
3321 for (i = 0; i < len / 2; ++i) {
3322 byte = hex_to_dec(p[len - i * 2 - 1]) +
3323 hex_to_dec(p[len - i * 2 - 2]) * 16;
3325 if (byte < 0 || byte > 255)
3328 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3329 buf[i] = (unsigned char)(byte);
3330 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3331 buf[FLOAT_EXTENED_BYTES - i -1] =
3332 (unsigned char)(byte);
3333 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3336 memset(&f, 0, FLOAT_QUADRUPLE_BYTES);
3338 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3339 memcpy(&f, buf, FLOAT_EXTENED_BYTES);
3340 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3341 memcpy((unsigned char *)(&f) + 6, buf, FLOAT_EXTENED_BYTES);
3342 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3347 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3350 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3352 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3354 rtn_len *= BUFFER_GROWFACTOR;
3359 case FLOAT_EXTENED_BYTES:
3360 return (decode_fp_to_long_double(p, len));
3367 decode_fp_to_long_double(const char *p, size_t len)
3370 size_t rtn_len, limit, i;
3374 if (p == NULL || len == 0 || len % 2 != 0 ||
3375 len / 2 > sizeof(long double))
3378 memset(&f, 0, sizeof(long double));
3380 for (i = 0; i < len / 2; ++i) {
3381 byte = hex_to_dec(p[len - i * 2 - 1]) +
3382 hex_to_dec(p[len - i * 2 - 2]) * 16;
3384 if (byte < 0 || byte > 255)
3387 #if ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN
3388 ((unsigned char *)&f)[i] = (unsigned char)(byte);
3389 #else /* ELFTC_BYTE_ORDER != ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3390 ((unsigned char *)&f)[sizeof(long double) - i - 1] =
3391 (unsigned char)(byte);
3392 #endif /* ELFTC_BYTE_ORDER == ELFTC_BYTE_ORDER_LITTLE_ENDIAN */
3398 if ((rtn = malloc(sizeof(char) * rtn_len)) == NULL)
3401 if (snprintf(rtn, rtn_len, "%Lfd", f) >= (int)rtn_len) {
3403 if (limit++ > FLOAT_SPRINTF_TRY_LIMIT)
3405 rtn_len *= BUFFER_GROWFACTOR;
3412 /* Simple hex to integer function used by decode_to_* function. */
3456 * @brief Test input string is mangled by IA-64 C++ ABI style.
3458 * Test string heads with "_Z" or "_GLOBAL__I_".
3459 * @return Return 0 at false.
3462 is_cpp_mangled_gnu3(const char *org)
3467 return ((len > 2 && *org == '_' && *(org + 1) == 'Z') ||
3468 (len > 11 && !strncmp(org, "_GLOBAL__I_", 11)));
3472 vector_read_cmd_dest(struct vector_read_cmd *v)
3478 free(v->r_container);
3481 /* return -1 at failed, 0 at not found, 1 at found. */
3483 vector_read_cmd_find(struct vector_read_cmd *v, enum read_cmd dst)
3487 if (v == NULL || dst == READ_FAIL)
3490 for (i = 0; i < v->size; ++i)
3491 if (v->r_container[i] == dst)
3498 vector_read_cmd_init(struct vector_read_cmd *v)
3505 v->capacity = VECTOR_DEF_CAPACITY;
3507 if ((v->r_container = malloc(sizeof(enum read_cmd) * v->capacity))
3515 vector_read_cmd_pop(struct vector_read_cmd *v)
3518 if (v == NULL || v->size == 0)
3522 v->r_container[v->size] = READ_FAIL;
3528 vector_read_cmd_push(struct vector_read_cmd *v, enum read_cmd cmd)
3530 enum read_cmd *tmp_r_ctn;
3537 if (v->size == v->capacity) {
3538 tmp_cap = v->capacity * BUFFER_GROWFACTOR;
3539 if ((tmp_r_ctn = malloc(sizeof(enum read_cmd) * tmp_cap))
3542 for (i = 0; i < v->size; ++i)
3543 tmp_r_ctn[i] = v->r_container[i];
3544 free(v->r_container);
3545 v->r_container = tmp_r_ctn;
3546 v->capacity = tmp_cap;
3549 v->r_container[v->size] = cmd;
3556 vector_type_qualifier_dest(struct vector_type_qualifier *v)
3562 free(v->q_container);
3563 vector_str_dest(&v->ext_name);
3566 /* size, capacity, ext_name */
3568 vector_type_qualifier_init(struct vector_type_qualifier *v)
3575 v->capacity = VECTOR_DEF_CAPACITY;
3577 if ((v->q_container = malloc(sizeof(enum type_qualifier) * v->capacity))
3581 assert(v->q_container != NULL);
3583 if (vector_str_init(&v->ext_name) == false) {
3584 free(v->q_container);
3592 vector_type_qualifier_push(struct vector_type_qualifier *v,
3593 enum type_qualifier t)
3595 enum type_qualifier *tmp_ctn;
3602 if (v->size == v->capacity) {
3603 tmp_cap = v->capacity * BUFFER_GROWFACTOR;
3604 if ((tmp_ctn = malloc(sizeof(enum type_qualifier) * tmp_cap))
3607 for (i = 0; i < v->size; ++i)
3608 tmp_ctn[i] = v->q_container[i];
3609 free(v->q_container);
3610 v->q_container = tmp_ctn;
3611 v->capacity = tmp_cap;
3614 v->q_container[v->size] = t;