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