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