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