libelftc_dem_gnu3.c

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