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
40ELFTC_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
52enum 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
57struct vector_type_qualifier {
58	size_t size, capacity;
59	enum type_qualifier *q_container;
60	struct vector_str ext_name;
61};
62
63enum read_cmd {
64	READ_FAIL, READ_NEST, READ_TMPL, READ_EXPR, READ_EXPL, READ_LOCAL,
65	READ_TYPE, READ_FUNC, READ_PTRMEM
66};
67
68struct read_cmd_item {
69	enum read_cmd cmd;
70	void *data;
71};
72
73struct vector_read_cmd {
74	size_t size, capacity;
75	struct read_cmd_item *r_container;
76};
77
78enum push_qualifier {
79	PUSH_ALL_QUALIFIER,
80	PUSH_CV_QUALIFIER,
81	PUSH_NON_CV_QUALIFIER,
82};
83
84struct 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
106struct 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
120static void	cpp_demangle_data_dest(struct cpp_demangle_data *);
121static int	cpp_demangle_data_init(struct cpp_demangle_data *,
122		    const char *);
123static int	cpp_demangle_get_subst(struct cpp_demangle_data *, size_t);
124static int	cpp_demangle_get_tmpl_param(struct cpp_demangle_data *, size_t);
125static int	cpp_demangle_push_fp(struct cpp_demangle_data *,
126		    char *(*)(const char *, size_t));
127static int	cpp_demangle_push_str(struct cpp_demangle_data *, const char *,
128		    size_t);
129static int	cpp_demangle_pop_str(struct cpp_demangle_data *);
130static int	cpp_demangle_push_subst(struct cpp_demangle_data *,
131		    const char *, size_t);
132static int	cpp_demangle_push_subst_v(struct cpp_demangle_data *,
133		    struct vector_str *);
134static int	cpp_demangle_push_type_qualifier(struct cpp_demangle_data *,
135		    struct vector_type_qualifier *, const char *);
136static int	cpp_demangle_read_array(struct cpp_demangle_data *);
137static int	cpp_demangle_read_encoding(struct cpp_demangle_data *);
138static int	cpp_demangle_read_expr_primary(struct cpp_demangle_data *);
139static int	cpp_demangle_read_expression(struct cpp_demangle_data *);
140static int	cpp_demangle_read_expression_flat(struct cpp_demangle_data *,
141		    char **);
142static int	cpp_demangle_read_expression_binary(struct cpp_demangle_data *,
143		    const char *, size_t);
144static int	cpp_demangle_read_expression_unary(struct cpp_demangle_data *,
145		    const char *, size_t);
146static int	cpp_demangle_read_expression_trinary(struct cpp_demangle_data *,
147		    const char *, size_t, const char *, size_t);
148static int	cpp_demangle_read_function(struct cpp_demangle_data *, int *,
149		    struct vector_type_qualifier *);
150static int	cpp_demangle_local_source_name(struct cpp_demangle_data *ddata);
151static int	cpp_demangle_read_local_name(struct cpp_demangle_data *);
152static int	cpp_demangle_read_name(struct cpp_demangle_data *);
153static int	cpp_demangle_read_name_flat(struct cpp_demangle_data *,
154		    char**);
155static int	cpp_demangle_read_nested_name(struct cpp_demangle_data *);
156static int	cpp_demangle_read_number(struct cpp_demangle_data *, long *);
157static int	cpp_demangle_read_number_as_string(struct cpp_demangle_data *,
158		    char **);
159static int	cpp_demangle_read_nv_offset(struct cpp_demangle_data *);
160static int	cpp_demangle_read_offset(struct cpp_demangle_data *);
161static int	cpp_demangle_read_offset_number(struct cpp_demangle_data *);
162static int	cpp_demangle_read_pointer_to_member(struct cpp_demangle_data *,
163		    struct vector_type_qualifier *);
164static int	cpp_demangle_read_sname(struct cpp_demangle_data *);
165static int	cpp_demangle_read_subst(struct cpp_demangle_data *);
166static int	cpp_demangle_read_subst_std(struct cpp_demangle_data *);
167static int	cpp_demangle_read_subst_stdtmpl(struct cpp_demangle_data *,
168		    const char *);
169static int	cpp_demangle_read_tmpl_arg(struct cpp_demangle_data *);
170static int	cpp_demangle_read_tmpl_args(struct cpp_demangle_data *);
171static int	cpp_demangle_read_tmpl_param(struct cpp_demangle_data *);
172static int	cpp_demangle_read_type(struct cpp_demangle_data *,
173		    struct type_delimit *);
174static int	cpp_demangle_read_type_flat(struct cpp_demangle_data *,
175		    char **);
176static int	cpp_demangle_read_uqname(struct cpp_demangle_data *);
177static int	cpp_demangle_read_v_offset(struct cpp_demangle_data *);
178static char	*decode_fp_to_double(const char *, size_t);
179static char	*decode_fp_to_float(const char *, size_t);
180static char	*decode_fp_to_float128(const char *, size_t);
181static char	*decode_fp_to_float80(const char *, size_t);
182static char	*decode_fp_to_long_double(const char *, size_t);
183static int	hex_to_dec(char);
184static void	vector_read_cmd_dest(struct vector_read_cmd *);
185static struct read_cmd_item *vector_read_cmd_find(struct vector_read_cmd *,
186		    enum read_cmd);
187static int	vector_read_cmd_init(struct vector_read_cmd *);
188static int	vector_read_cmd_pop(struct vector_read_cmd *);
189static int	vector_read_cmd_push(struct vector_read_cmd *, enum read_cmd,
190		    void *);
191static void	vector_type_qualifier_dest(struct vector_type_qualifier *);
192static int	vector_type_qualifier_init(struct vector_type_qualifier *);
193static 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 */
203char *
204cpp_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
315clean:
316	if (has_ret)
317		vector_str_dest(&ret_type);
318
319	cpp_demangle_data_dest(&ddata);
320
321	return (rtn);
322}
323
324static void
325cpp_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
338static int
339cpp_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
377clean4:
378	vector_str_dest(&d->class_type);
379clean3:
380	vector_str_dest(&d->tmpl);
381clean2:
382	vector_str_dest(&d->subst);
383clean1:
384	vector_str_dest(&d->output);
385
386	return (0);
387}
388
389static int
390cpp_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
419static int
420cpp_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
437static int
438cpp_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
447static int
448cpp_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
461static int
462cpp_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
481static int
482cpp_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;
726clean:
727	if (type_str != NULL)
728		vector_str_dest(&subst_v);
729
730	return (rtn);
731}
732
733static int
734cpp_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
751static int
752cpp_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
768static int
769cpp_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
851static int
852cpp_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
935static int
936cpp_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
1219static int
1220cpp_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
1250static int
1251cpp_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
1265static int
1266cpp_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
1278static int
1279cpp_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
1299static int
1300cpp_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 */
1438static int
1439cpp_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
1649static int
1650cpp_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
1739static int
1740cpp_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
1798clean:
1799	free(subst_str);
1800	vector_str_dest(&v);
1801
1802	return (rtn);
1803}
1804
1805static int
1806cpp_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
1836static int
1837cpp_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
1871next:
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
1929clean:
1930	vector_str_dest(&v);
1931
1932	return (rtn);
1933}
1934
1935/*
1936 * read number
1937 * number ::= [n] <decimal>
1938 */
1939static int
1940cpp_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
1972static int
1973cpp_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
1990static int
1991cpp_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 */
2004static int
2005cpp_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
2022static int
2023cpp_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
2058static int
2059cpp_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;
2103clean3:
2104	if (!vector_str_pop(&ddata->class_type))
2105		rtn = 0;
2106clean2:
2107	if (!vector_read_cmd_pop(&ddata->cmd))
2108		rtn = 0;
2109clean1:
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> */
2120static int
2121cpp_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->output.size > 0);
2139	if (vector_read_cmd_find(&ddata->cmd, READ_TMPL) == NULL)
2140		ddata->last_sname =
2141		    ddata->output.container[ddata->output.size - 1];
2142
2143	ddata->cur += len;
2144
2145	return (1);
2146}
2147
2148static int
2149cpp_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
2276static int
2277cpp_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;
2331clean:
2332	free(subst_str);
2333	vector_str_dest(&v);
2334
2335	return (rtn);
2336}
2337
2338static int
2339cpp_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;
2378clean:
2379	free(subst_str);
2380	free(substr);
2381
2382	return (rtn);
2383}
2384
2385static int
2386cpp_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
2405static int
2406cpp_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->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 */
2466static int
2467cpp_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
2500static int
2501cpp_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
2549again:
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;
2988rtn:
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);
3012clean:
3013	free(type_str);
3014	free(exp_str);
3015	free(num_str);
3016	vector_type_qualifier_dest(&v);
3017
3018	return (0);
3019}
3020
3021static int
3022cpp_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 */
3056static int
3057cpp_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 */
3483static int
3484cpp_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
3505static int
3506cpp_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 */
3531static char *
3532decode_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;
3561again:
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
3576static char *
3577decode_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;
3604again:
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
3619static char *
3620decode_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;
3660again:
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
3678static char *
3679decode_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;
3720again:
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
3740static char *
3741decode_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;
3771again:
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. */
3787static int
3788hex_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 */
3835bool
3836is_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
3845static void
3846vector_read_cmd_dest(struct vector_read_cmd *v)
3847{
3848
3849	if (v == NULL)
3850		return;
3851
3852	free(v->r_container);
3853}
3854
3855static struct read_cmd_item *
3856vector_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
3870static int
3871vector_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
3887static int
3888vector_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
3901static int
3902vector_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 = v->capacity * BUFFER_GROWFACTOR;
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
3929static void
3930vector_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 */
3941static int
3942vector_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
3965static int
3966vector_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 = v->capacity * BUFFER_GROWFACTOR;
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