WebSVN – Kolibri OS – Blame – /contrib/toolchain/binutils/binutils/stabs.c

Rev	Author	Line No.	Line
5217	serge	1	/* stabs.c -- Parse stabs debugging information
6324	serge	2	Copyright (C) 1995-2015 Free Software Foundation, Inc.
5217	serge	3	Written by Ian Lance Taylor .
		4
		5	This file is part of GNU Binutils.
		6
		7	This program is free software; you can redistribute it and/or modify
		8	it under the terms of the GNU General Public License as published by
		9	the Free Software Foundation; either version 3 of the License, or
		10	(at your option) any later version.
		11
		12	This program is distributed in the hope that it will be useful,
		13	but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		15	GNU General Public License for more details.
		16
		17	You should have received a copy of the GNU General Public License
		18	along with this program; if not, write to the Free Software
		19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
		20	02110-1301, USA. */
		21
		22	/* This file contains code which parses stabs debugging information.
		23	The organization of this code is based on the gdb stabs reading
		24	code. The job it does is somewhat different, because it is not
		25	trying to identify the correct address for anything. */
		26
		27	#include "sysdep.h"
		28	#include "bfd.h"
		29	#include "libiberty.h"
		30	#include "safe-ctype.h"
		31	#include "demangle.h"
		32	#include "debug.h"
		33	#include "budbg.h"
		34	#include "filenames.h"
		35	#include "aout/aout64.h"
		36	#include "aout/stab_gnu.h"
		37
		38	/* The number of predefined XCOFF types. */
		39
		40	#define XCOFF_TYPE_COUNT 34
		41
		42	/* This structure is used as a handle so that the stab parsing doesn't
		43	need to use any static variables. */
		44
		45	struct stab_handle
		46	{
		47	/* The BFD. */
		48	bfd *abfd;
		49	/* TRUE if this is stabs in sections. */
		50	bfd_boolean sections;
		51	/* The symbol table. */
		52	asymbol **syms;
		53	/* The number of symbols. */
		54	long symcount;
		55	/* The accumulated file name string. */
		56	char *so_string;
		57	/* The value of the last N_SO symbol. */
		58	bfd_vma so_value;
		59	/* The value of the start of the file, so that we can handle file
		60	relative N_LBRAC and N_RBRAC symbols. */
		61	bfd_vma file_start_offset;
		62	/* The offset of the start of the function, so that we can handle
		63	function relative N_LBRAC and N_RBRAC symbols. */
		64	bfd_vma function_start_offset;
		65	/* The version number of gcc which compiled the current compilation
		66	unit, 0 if not compiled by gcc. */
		67	int gcc_compiled;
		68	/* Whether an N_OPT symbol was seen that was not generated by gcc,
		69	so that we can detect the SunPRO compiler. */
		70	bfd_boolean n_opt_found;
		71	/* The main file name. */
		72	char *main_filename;
		73	/* A stack of unfinished N_BINCL files. */
		74	struct bincl_file *bincl_stack;
		75	/* A list of finished N_BINCL files. */
		76	struct bincl_file *bincl_list;
		77	/* Whether we are inside a function or not. */
		78	bfd_boolean within_function;
		79	/* The address of the end of the function, used if we have seen an
		80	N_FUN symbol while in a function. This is -1 if we have not seen
		81	an N_FUN (the normal case). */
		82	bfd_vma function_end;
		83	/* The depth of block nesting. */
		84	int block_depth;
		85	/* List of pending variable definitions. */
		86	struct stab_pending_var *pending;
		87	/* Number of files for which we have types. */
		88	unsigned int files;
		89	/* Lists of types per file. */
		90	struct stab_types **file_types;
		91	/* Predefined XCOFF types. */
		92	debug_type xcoff_types[XCOFF_TYPE_COUNT];
		93	/* Undefined tags. */
		94	struct stab_tag *tags;
		95	/* Set by parse_stab_type if it sees a structure defined as a cross
		96	reference to itself. Reset by parse_stab_type otherwise. */
		97	bfd_boolean self_crossref;
		98	};
		99
		100	/* A list of these structures is used to hold pending variable
		101	definitions seen before the N_LBRAC of a block. */
		102
		103	struct stab_pending_var
		104	{
		105	/* Next pending variable definition. */
		106	struct stab_pending_var *next;
		107	/* Name. */
		108	const char *name;
		109	/* Type. */
		110	debug_type type;
		111	/* Kind. */
		112	enum debug_var_kind kind;
		113	/* Value. */
		114	bfd_vma val;
		115	};
		116
		117	/* A list of these structures is used to hold the types for a single
		118	file. */
		119
		120	struct stab_types
		121	{
		122	/* Next set of slots for this file. */
		123	struct stab_types *next;
		124	/* Types indexed by type number. */
		125	#define STAB_TYPES_SLOTS (16)
		126	debug_type types[STAB_TYPES_SLOTS];
		127	};
		128
		129	/* We keep a list of undefined tags that we encounter, so that we can
		130	fill them in if the tag is later defined. */
		131
		132	struct stab_tag
		133	{
		134	/* Next undefined tag. */
		135	struct stab_tag *next;
		136	/* Tag name. */
		137	const char *name;
		138	/* Type kind. */
		139	enum debug_type_kind kind;
		140	/* Slot to hold real type when we discover it. If we don't, we fill
		141	in an undefined tag type. */
		142	debug_type slot;
		143	/* Indirect type we have created to point at slot. */
		144	debug_type type;
		145	};
		146
		147	static char savestring (const char , int);
		148	static bfd_vma parse_number (const char *, bfd_boolean );
		149	static void bad_stab (const char *);
		150	static void warn_stab (const char , const char );
		151	static bfd_boolean parse_stab_string
		152	(void , struct stab_handle , int, int, bfd_vma, const char *);
		153	static debug_type parse_stab_type
		154	(void , struct stab_handle , const char , const char , debug_type *);
		155	static bfd_boolean parse_stab_type_number (const char *, int );
		156	static debug_type parse_stab_range_type
		157	(void , struct stab_handle , const char , const char , const int );
		158	static debug_type parse_stab_sun_builtin_type (void , const char *);
		159	static debug_type parse_stab_sun_floating_type (void , const char *);
		160	static debug_type parse_stab_enum_type (void , const char *);
		161	static debug_type parse_stab_struct_type
		162	(void , struct stab_handle , const char , const char *,
		163	bfd_boolean, const int *);
		164	static bfd_boolean parse_stab_baseclasses
		165	(void , struct stab_handle , const char , debug_baseclass );
		166	static bfd_boolean parse_stab_struct_fields
		167	(void , struct stab_handle , const char , debug_field , bfd_boolean *);
		168	static bfd_boolean parse_stab_cpp_abbrev
		169	(void , struct stab_handle , const char *, debug_field );
		170	static bfd_boolean parse_stab_one_struct_field
		171	(void , struct stab_handle , const char *, const char ,
		172	debug_field , bfd_boolean );
		173	static bfd_boolean parse_stab_members
		174	(void , struct stab_handle , const char , const char , const int ,
		175	debug_method **);
		176	static debug_type parse_stab_argtypes
		177	(void , struct stab_handle , debug_type, const char , const char ,
		178	debug_type, const char , bfd_boolean, bfd_boolean, const char *);
		179	static bfd_boolean parse_stab_tilde_field
		180	(void , struct stab_handle , const char *, const int , debug_type *,
		181	bfd_boolean *);
		182	static debug_type parse_stab_array_type
		183	(void , struct stab_handle , const char **, bfd_boolean);
		184	static void push_bincl (struct stab_handle , const char , bfd_vma);
		185	static const char pop_bincl (struct stab_handle );
		186	static bfd_boolean find_excl (struct stab_handle , const char , bfd_vma);
		187	static bfd_boolean stab_record_variable
		188	(void , struct stab_handle , const char *, debug_type,
		189	enum debug_var_kind, bfd_vma);
		190	static bfd_boolean stab_emit_pending_vars (void , struct stab_handle );
		191	static debug_type stab_find_slot (struct stab_handle , const int *);
		192	static debug_type stab_find_type (void , struct stab_handle , const int *);
		193	static bfd_boolean stab_record_type
		194	(void , struct stab_handle , const int *, debug_type);
		195	static debug_type stab_xcoff_builtin_type
		196	(void , struct stab_handle , int);
		197	static debug_type stab_find_tagged_type
		198	(void , struct stab_handle , const char *, int, enum debug_type_kind);
		199	static debug_type *stab_demangle_argtypes
		200	(void , struct stab_handle , const char , bfd_boolean , unsigned int);
		201	static debug_type *stab_demangle_v3_argtypes
		202	(void , struct stab_handle , const char , bfd_boolean );
		203	static debug_type *stab_demangle_v3_arglist
		204	(void , struct stab_handle , struct demangle_component , bfd_boolean );
		205	static debug_type stab_demangle_v3_arg
		206	(void , struct stab_handle , struct demangle_component *, debug_type,
		207	bfd_boolean *);
		208
		209	/* Save a string in memory. */
		210
		211	static char *
		212	savestring (const char *start, int len)
		213	{
		214	char *ret;
		215
		216	ret = (char *) xmalloc (len + 1);
		217	memcpy (ret, start, len);
		218	ret[len] = '\0';
		219	return ret;
		220	}
		221
		222	/* Read a number from a string. */
		223
		224	static bfd_vma
		225	parse_number (const char *pp, bfd_boolean poverflow)
		226	{
		227	unsigned long ul;
		228	const char *orig;
		229
		230	if (poverflow != NULL)
		231	*poverflow = FALSE;
		232
		233	orig = *pp;
		234
		235	errno = 0;
		236	ul = strtoul (pp, (char *) pp, 0);
		237	if (ul + 1 != 0 \|\| errno == 0)
		238	{
		239	/* If bfd_vma is larger than unsigned long, and the number is
		240	meant to be negative, we have to make sure that we sign
		241	extend properly. */
		242	if (*orig == '-')
		243	return (bfd_vma) (bfd_signed_vma) (long) ul;
		244	return (bfd_vma) ul;
		245	}
		246
		247	/* Note that even though strtoul overflowed, it should have set *pp
		248	to the end of the number, which is where we want it. */
		249	if (sizeof (bfd_vma) > sizeof (unsigned long))
		250	{
		251	const char *p;
		252	bfd_boolean neg;
		253	int base;
		254	bfd_vma over, lastdig;
		255	bfd_boolean overflow;
		256	bfd_vma v;
		257
		258	/* Our own version of strtoul, for a bfd_vma. */
		259	p = orig;
		260
		261	neg = FALSE;
		262	if (*p == '+')
		263	++p;
		264	else if (*p == '-')
		265	{
		266	neg = TRUE;
		267	++p;
		268	}
		269
		270	base = 10;
		271	if (*p == '0')
		272	{
		273	if (p[1] == 'x' \|\| p[1] == 'X')
		274	{
		275	base = 16;
		276	p += 2;
		277	}
		278	else
		279	{
		280	base = 8;
		281	++p;
		282	}
		283	}
		284
		285	over = ((bfd_vma) (bfd_signed_vma) -1) / (bfd_vma) base;
		286	lastdig = ((bfd_vma) (bfd_signed_vma) -1) % (bfd_vma) base;
		287
		288	overflow = FALSE;
		289	v = 0;
		290	while (1)
		291	{
		292	int d;
		293
		294	d = *p++;
		295	if (ISDIGIT (d))
		296	d -= '0';
		297	else if (ISUPPER (d))
		298	d -= 'A';
		299	else if (ISLOWER (d))
		300	d -= 'a';
		301	else
		302	break;
		303
		304	if (d >= base)
		305	break;
		306
		307	if (v > over \|\| (v == over && (bfd_vma) d > lastdig))
		308	{
		309	overflow = TRUE;
		310	break;
		311	}
		312	}
		313
		314	if (! overflow)
		315	{
		316	if (neg)
		317	v = - v;
		318	return v;
		319	}
		320	}
		321
		322	/* If we get here, the number is too large to represent in a
		323	bfd_vma. */
		324	if (poverflow != NULL)
		325	*poverflow = TRUE;
		326	else
		327	warn_stab (orig, _("numeric overflow"));
		328
		329	return 0;
		330	}
		331
		332	/* Give an error for a bad stab string. */
		333
		334	static void
		335	bad_stab (const char *p)
		336	{
		337	fprintf (stderr, _("Bad stab: %s\n"), p);
		338	}
		339
		340	/* Warn about something in a stab string. */
		341
		342	static void
		343	warn_stab (const char p, const char err)
		344	{
		345	fprintf (stderr, _("Warning: %s: %s\n"), err, p);
		346	}
		347
		348	/* Create a handle to parse stabs symbols with. */
		349
		350	void *
		351	start_stab (void dhandle ATTRIBUTE_UNUSED, bfd abfd, bfd_boolean sections,
		352	asymbol **syms, long symcount)
		353	{
		354	struct stab_handle *ret;
		355
		356	ret = (struct stab_handle ) xmalloc (sizeof ret);
		357	memset (ret, 0, sizeof *ret);
		358	ret->abfd = abfd;
		359	ret->sections = sections;
		360	ret->syms = syms;
		361	ret->symcount = symcount;
		362	ret->files = 1;
		363	ret->file_types = (struct stab_types *) xmalloc (sizeof ret->file_types);
		364	ret->file_types[0] = NULL;
		365	ret->function_end = (bfd_vma) -1;
		366	return (void *) ret;
		367	}
		368
		369	/* When we have processed all the stabs information, we need to go
		370	through and fill in all the undefined tags. */
		371
		372	bfd_boolean
		373	finish_stab (void dhandle, void handle)
		374	{
		375	struct stab_handle info = (struct stab_handle ) handle;
		376	struct stab_tag *st;
		377
		378	if (info->within_function)
		379	{
		380	if (! stab_emit_pending_vars (dhandle, info)
		381	\|\| ! debug_end_function (dhandle, info->function_end))
		382	return FALSE;
		383	info->within_function = FALSE;
		384	info->function_end = (bfd_vma) -1;
		385	}
		386
		387	for (st = info->tags; st != NULL; st = st->next)
		388	{
		389	enum debug_type_kind kind;
		390
		391	kind = st->kind;
		392	if (kind == DEBUG_KIND_ILLEGAL)
		393	kind = DEBUG_KIND_STRUCT;
		394	st->slot = debug_make_undefined_tagged_type (dhandle, st->name, kind);
		395	if (st->slot == DEBUG_TYPE_NULL)
		396	return FALSE;
		397	}
		398
		399	return TRUE;
		400	}
		401
		402	/* Handle a single stabs symbol. */
		403
		404	bfd_boolean
		405	parse_stab (void dhandle, void handle, int type, int desc, bfd_vma value,
		406	const char *string)
		407	{
		408	struct stab_handle info = (struct stab_handle ) handle;
		409
		410	/* gcc will emit two N_SO strings per compilation unit, one for the
		411	directory name and one for the file name. We just collect N_SO
		412	strings as we see them, and start the new compilation unit when
		413	we see a non N_SO symbol. */
		414	if (info->so_string != NULL
		415	&& (type != N_SO \|\| *string == '\0' \|\| value != info->so_value))
		416	{
		417	if (! debug_set_filename (dhandle, info->so_string))
		418	return FALSE;
		419	info->main_filename = info->so_string;
		420
		421	info->gcc_compiled = 0;
		422	info->n_opt_found = FALSE;
		423
		424	/* Generally, for stabs in the symbol table, the N_LBRAC and
		425	N_RBRAC symbols are relative to the N_SO symbol value. */
		426	if (! info->sections)
		427	info->file_start_offset = info->so_value;
		428
		429	/* We need to reset the mapping from type numbers to types. We
		430	can't free the old mapping, because of the use of
		431	debug_make_indirect_type. */
		432	info->files = 1;
		433	info->file_types = ((struct stab_types **)
		434	xmalloc (sizeof *info->file_types));
		435	info->file_types[0] = NULL;
		436
		437	info->so_string = NULL;
		438
		439	/* Now process whatever type we just got. */
		440	}
		441
		442	switch (type)
		443	{
		444	case N_FN:
		445	case N_FN_SEQ:
		446	break;
		447
		448	case N_LBRAC:
		449	/* Ignore extra outermost context from SunPRO cc and acc. */
		450	if (info->n_opt_found && desc == 1)
		451	break;
		452
		453	if (! info->within_function)
		454	{
		455	fprintf (stderr, _("N_LBRAC not within function\n"));
		456	return FALSE;
		457	}
		458
		459	/* Start an inner lexical block. */
		460	if (! debug_start_block (dhandle,
		461	(value
		462	+ info->file_start_offset
		463	+ info->function_start_offset)))
		464	return FALSE;
		465
		466	/* Emit any pending variable definitions. */
		467	if (! stab_emit_pending_vars (dhandle, info))
		468	return FALSE;
		469
		470	++info->block_depth;
		471	break;
		472
		473	case N_RBRAC:
		474	/* Ignore extra outermost context from SunPRO cc and acc. */
		475	if (info->n_opt_found && desc == 1)
		476	break;
		477
		478	/* We shouldn't have any pending variable definitions here, but,
		479	if we do, we probably need to emit them before closing the
		480	block. */
		481	if (! stab_emit_pending_vars (dhandle, info))
		482	return FALSE;
		483
		484	/* End an inner lexical block. */
		485	if (! debug_end_block (dhandle,
		486	(value
		487	+ info->file_start_offset
		488	+ info->function_start_offset)))
		489	return FALSE;
		490
		491	--info->block_depth;
		492	if (info->block_depth < 0)
		493	{
		494	fprintf (stderr, _("Too many N_RBRACs\n"));
		495	return FALSE;
		496	}
		497	break;
		498
		499	case N_SO:
		500	/* This always ends a function. */
		501	if (info->within_function)
		502	{
		503	bfd_vma endval;
		504
		505	endval = value;
		506	if (*string != '\0'
		507	&& info->function_end != (bfd_vma) -1
		508	&& info->function_end < endval)
		509	endval = info->function_end;
		510	if (! stab_emit_pending_vars (dhandle, info)
		511	\|\| ! debug_end_function (dhandle, endval))
		512	return FALSE;
		513	info->within_function = FALSE;
		514	info->function_end = (bfd_vma) -1;
		515	}
		516
		517	/* An empty string is emitted by gcc at the end of a compilation
		518	unit. */
		519	if (*string == '\0')
		520	return TRUE;
		521
		522	/* Just accumulate strings until we see a non N_SO symbol. If
		523	the string starts with a directory separator or some other
		524	form of absolute path specification, we discard the previously
		525	accumulated strings. */
		526	if (info->so_string == NULL)
		527	info->so_string = xstrdup (string);
		528	else
		529	{
		530	char *f;
		531
		532	f = info->so_string;
		533
		534	if (IS_ABSOLUTE_PATH (string))
		535	info->so_string = xstrdup (string);
		536	else
		537	info->so_string = concat (info->so_string, string,
		538	(const char *) NULL);
		539	free (f);
		540	}
		541
		542	info->so_value = value;
		543
		544	break;
		545
		546	case N_SOL:
		547	/* Start an include file. */
		548	if (! debug_start_source (dhandle, string))
		549	return FALSE;
		550	break;
		551
		552	case N_BINCL:
		553	/* Start an include file which may be replaced. */
		554	push_bincl (info, string, value);
		555	if (! debug_start_source (dhandle, string))
		556	return FALSE;
		557	break;
		558
		559	case N_EINCL:
		560	/* End an N_BINCL include. */
		561	if (! debug_start_source (dhandle, pop_bincl (info)))
		562	return FALSE;
		563	break;
		564
		565	case N_EXCL:
		566	/* This is a duplicate of a header file named by N_BINCL which
		567	was eliminated by the linker. */
		568	if (! find_excl (info, string, value))
		569	return FALSE;
		570	break;
		571
		572	case N_SLINE:
		573	if (! debug_record_line (dhandle, desc,
		574	value + (info->within_function
		575	? info->function_start_offset : 0)))
		576	return FALSE;
		577	break;
		578
		579	case N_BCOMM:
		580	if (! debug_start_common_block (dhandle, string))
		581	return FALSE;
		582	break;
		583
		584	case N_ECOMM:
		585	if (! debug_end_common_block (dhandle, string))
		586	return FALSE;
		587	break;
		588
		589	case N_FUN:
		590	if (*string == '\0')
		591	{
		592	if (info->within_function)
		593	{
		594	/* This always marks the end of a function; we don't
		595	need to worry about info->function_end. */
		596	if (info->sections)
		597	value += info->function_start_offset;
		598	if (! stab_emit_pending_vars (dhandle, info)
		599	\|\| ! debug_end_function (dhandle, value))
		600	return FALSE;
		601	info->within_function = FALSE;
		602	info->function_end = (bfd_vma) -1;
		603	}
		604	break;
		605	}
		606
		607	/* A const static symbol in the .text section will have an N_FUN
		608	entry. We need to use these to mark the end of the function,
		609	in case we are looking at gcc output before it was changed to
		610	always emit an empty N_FUN. We can't call debug_end_function
		611	here, because it might be a local static symbol. */
		612	if (info->within_function
		613	&& (info->function_end == (bfd_vma) -1
		614	\|\| value < info->function_end))
		615	info->function_end = value;
		616
		617	/* Fall through. */
		618	/* FIXME: gdb checks the string for N_STSYM, N_LCSYM or N_ROSYM
		619	symbols, and if it does not start with :S, gdb relocates the
		620	value to the start of the section. gcc always seems to use
		621	:S, so we don't worry about this. */
		622	/* Fall through. */
		623	default:
		624	{
		625	const char *colon;
		626
		627	colon = strchr (string, ':');
		628	if (colon != NULL
		629	&& (colon[1] == 'f' \|\| colon[1] == 'F'))
		630	{
		631	if (info->within_function)
		632	{
		633	bfd_vma endval;
		634
		635	endval = value;
		636	if (info->function_end != (bfd_vma) -1
		637	&& info->function_end < endval)
		638	endval = info->function_end;
		639	if (! stab_emit_pending_vars (dhandle, info)
		640	\|\| ! debug_end_function (dhandle, endval))
		641	return FALSE;
		642	info->function_end = (bfd_vma) -1;
		643	}
		644	/* For stabs in sections, line numbers and block addresses
		645	are offsets from the start of the function. */
		646	if (info->sections)
		647	info->function_start_offset = value;
		648	info->within_function = TRUE;
		649	}
		650
		651	if (! parse_stab_string (dhandle, info, type, desc, value, string))
		652	return FALSE;
		653	}
		654	break;
		655
		656	case N_OPT:
		657	if (string != NULL && strcmp (string, "gcc2_compiled.") == 0)
		658	info->gcc_compiled = 2;
		659	else if (string != NULL && strcmp (string, "gcc_compiled.") == 0)
		660	info->gcc_compiled = 1;
		661	else
		662	info->n_opt_found = TRUE;
		663	break;
		664
		665	case N_OBJ:
		666	case N_ENDM:
		667	case N_MAIN:
		668	case N_WARNING:
		669	break;
		670	}
		671
		672	return TRUE;
		673	}
		674
		675	/* Parse the stabs string. */
		676
		677	static bfd_boolean
		678	parse_stab_string (void dhandle, struct stab_handle info, int stabtype,
		679	int desc ATTRIBUTE_UNUSED, bfd_vma value, const char *string)
		680	{
		681	const char *p;
		682	char *name;
		683	int type;
		684	debug_type dtype;
		685	bfd_boolean synonym;
		686	bfd_boolean self_crossref;
		687	debug_type *slot;
		688
		689	p = strchr (string, ':');
		690	if (p == NULL)
		691	return TRUE;
		692
		693	while (p[1] == ':')
		694	{
		695	p += 2;
		696	p = strchr (p, ':');
		697	if (p == NULL)
		698	{
		699	bad_stab (string);
		700	return FALSE;
		701	}
		702	}
		703
		704	/* FIXME: Sometimes the special C++ names start with '.'. */
		705	name = NULL;
		706	if (string[0] == '$')
		707	{
		708	switch (string[1])
		709	{
		710	case 't':
		711	name = "this";
		712	break;
		713	case 'v':
		714	/* Was: name = "vptr"; */
		715	break;
		716	case 'e':
		717	name = "eh_throw";
		718	break;
		719	case '_':
		720	/* This was an anonymous type that was never fixed up. */
		721	break;
		722	case 'X':
		723	/* SunPRO (3.0 at least) static variable encoding. */
		724	break;
		725	default:
		726	warn_stab (string, _("unknown C++ encoded name"));
		727	break;
		728	}
		729	}
		730
		731	if (name == NULL)
		732	{
		733	if (p == string \|\| (string[0] == ' ' && p == string + 1))
		734	name = NULL;
		735	else
		736	name = savestring (string, p - string);
		737	}
		738
		739	++p;
		740	if (ISDIGIT (p) \|\| p == '(' \|\| *p == '-')
		741	type = 'l';
		742	else
		743	type = *p++;
		744
		745	switch (type)
		746	{
		747	case 'c':
		748	/* c is a special case, not followed by a type-number.
		749	SYMBOL:c=iVALUE for an integer constant symbol.
		750	SYMBOL:c=rVALUE for a floating constant symbol.
		751	SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
		752	e.g. "b:c=e6,0" for "const b = blob1"
		753	(where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
		754	if (*p != '=')
		755	{
		756	bad_stab (string);
		757	return FALSE;
		758	}
		759	++p;
		760	switch (*p++)
		761	{
		762	case 'r':
		763	/* Floating point constant. */
		764	if (! debug_record_float_const (dhandle, name, atof (p)))
		765	return FALSE;
		766	break;
		767	case 'i':
		768	/* Integer constant. */
		769	/* Defining integer constants this way is kind of silly,
		770	since 'e' constants allows the compiler to give not only
		771	the value, but the type as well. C has at least int,
		772	long, unsigned int, and long long as constant types;
		773	other languages probably should have at least unsigned as
		774	well as signed constants. */
		775	if (! debug_record_int_const (dhandle, name, atoi (p)))
		776	return FALSE;
		777	break;
		778	case 'e':
		779	/* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
		780	can be represented as integral.
		781	e.g. "b:c=e6,0" for "const b = blob1"
		782	(where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
		783	dtype = parse_stab_type (dhandle, info, (const char *) NULL,
		784	&p, (debug_type **) NULL);
		785	if (dtype == DEBUG_TYPE_NULL)
		786	return FALSE;
		787	if (*p != ',')
		788	{
		789	bad_stab (string);
		790	return FALSE;
		791	}
		792	if (! debug_record_typed_const (dhandle, name, dtype, atoi (p)))
		793	return FALSE;
		794	break;
		795	default:
		796	bad_stab (string);
		797	return FALSE;
		798	}
		799
		800	break;
		801
		802	case 'C':
		803	/* The name of a caught exception. */
		804	dtype = parse_stab_type (dhandle, info, (const char *) NULL,
		805	&p, (debug_type **) NULL);
		806	if (dtype == DEBUG_TYPE_NULL)
		807	return FALSE;
		808	if (! debug_record_label (dhandle, name, dtype, value))
		809	return FALSE;
		810	break;
		811
		812	case 'f':
		813	case 'F':
		814	/* A function definition. */
		815	dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
		816	(debug_type **) NULL);
		817	if (dtype == DEBUG_TYPE_NULL)
		818	return FALSE;
		819	if (! debug_record_function (dhandle, name, dtype, type == 'F', value))
		820	return FALSE;
		821
		822	/* Sun acc puts declared types of arguments here. We don't care
		823	about their actual types (FIXME -- we should remember the whole
		824	function prototype), but the list may define some new types
		825	that we have to remember, so we must scan it now. */
		826	while (*p == ';')
		827	{
		828	++p;
		829	if (parse_stab_type (dhandle, info, (const char *) NULL, &p,
		830	(debug_type **) NULL)
		831	== DEBUG_TYPE_NULL)
		832	return FALSE;
		833	}
		834
		835	break;
		836
		837	case 'G':
		838	{
		839	asymbol **ps;
		840
		841	/* A global symbol. The value must be extracted from the
		842	symbol table. */
		843	dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
		844	(debug_type **) NULL);
		845	if (dtype == DEBUG_TYPE_NULL)
		846	return FALSE;
6324	serge	847	if (name != NULL)
		848	{
		849	char leading;
		850	long c;
		851
5217	serge	852	leading = bfd_get_symbol_leading_char (info->abfd);
		853	for (c = info->symcount, ps = info->syms; c > 0; --c, ++ps)
		854	{
		855	const char *n;
		856
		857	n = bfd_asymbol_name (*ps);
		858	if (leading != '\0' && *n == leading)
		859	++n;
		860	if (n == name && strcmp (n, name) == 0)
		861	break;
		862	}
6324	serge	863
5217	serge	864	if (c > 0)
		865	value = bfd_asymbol_value (*ps);
6324	serge	866	}
		867
5217	serge	868	if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_GLOBAL,
		869	value))
		870	return FALSE;
		871	}
		872	break;
		873
		874	/* This case is faked by a conditional above, when there is no
		875	code letter in the dbx data. Dbx data never actually
		876	contains 'l'. */
		877	case 'l':
		878	case 's':
		879	dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
		880	(debug_type **) NULL);
		881	if (dtype == DEBUG_TYPE_NULL)
		882	return FALSE;
		883	if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL,
		884	value))
		885	return FALSE;
		886	break;
		887
		888	case 'p':
		889	/* A function parameter. */
		890	if (*p != 'F')
		891	dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
		892	(debug_type **) NULL);
		893	else
		894	{
		895	/* pF is a two-letter code that means a function parameter in
		896	Fortran. The type-number specifies the type of the return
		897	value. Translate it into a pointer-to-function type. */
		898	++p;
		899	dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
		900	(debug_type **) NULL);
		901	if (dtype != DEBUG_TYPE_NULL)
		902	{
		903	debug_type ftype;
		904
		905	ftype = debug_make_function_type (dhandle, dtype,
		906	(debug_type *) NULL, FALSE);
		907	dtype = debug_make_pointer_type (dhandle, ftype);
		908	}
		909	}
		910	if (dtype == DEBUG_TYPE_NULL)
		911	return FALSE;
		912	if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_STACK,
		913	value))
		914	return FALSE;
		915
		916	/* FIXME: At this point gdb considers rearranging the parameter
		917	address on a big endian machine if it is smaller than an int.
		918	We have no way to do that, since we don't really know much
		919	about the target. */
		920	break;
		921
		922	case 'P':
		923	if (stabtype == N_FUN)
		924	{
		925	/* Prototype of a function referenced by this file. */
		926	while (*p == ';')
		927	{
		928	++p;
		929	if (parse_stab_type (dhandle, info, (const char *) NULL, &p,
		930	(debug_type **) NULL)
		931	== DEBUG_TYPE_NULL)
		932	return FALSE;
		933	}
		934	break;
		935	}
		936	/* Fall through. */
		937	case 'R':
		938	/* Parameter which is in a register. */
		939	dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
		940	(debug_type **) NULL);
		941	if (dtype == DEBUG_TYPE_NULL)
		942	return FALSE;
		943	if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REG,
		944	value))
		945	return FALSE;
		946	break;
		947
		948	case 'r':
		949	/* Register variable (either global or local). */
		950	dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
		951	(debug_type **) NULL);
		952	if (dtype == DEBUG_TYPE_NULL)
		953	return FALSE;
		954	if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_REGISTER,
		955	value))
		956	return FALSE;
		957
		958	/* FIXME: At this point gdb checks to combine pairs of 'p' and
		959	'r' stabs into a single 'P' stab. */
		960	break;
		961
		962	case 'S':
		963	/* Static symbol at top level of file. */
		964	dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
		965	(debug_type **) NULL);
		966	if (dtype == DEBUG_TYPE_NULL)
		967	return FALSE;
		968	if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_STATIC,
		969	value))
		970	return FALSE;
		971	break;
		972
		973	case 't':
		974	/* A typedef. */
		975	dtype = parse_stab_type (dhandle, info, name, &p, &slot);
		976	if (dtype == DEBUG_TYPE_NULL)
		977	return FALSE;
		978	if (name == NULL)
		979	{
		980	/* A nameless type. Nothing to do. */
		981	return TRUE;
		982	}
		983
		984	dtype = debug_name_type (dhandle, name, dtype);
		985	if (dtype == DEBUG_TYPE_NULL)
		986	return FALSE;
		987
		988	if (slot != NULL)
		989	*slot = dtype;
		990
		991	break;
		992
		993	case 'T':
		994	/* Struct, union, or enum tag. For GNU C++, this can be be followed
		995	by 't' which means we are typedef'ing it as well. */
		996	if (*p != 't')
		997	{
		998	synonym = FALSE;
		999	/* FIXME: gdb sets synonym to TRUE if the current language
		1000	is C++. */
		1001	}
		1002	else
		1003	{
		1004	synonym = TRUE;
		1005	++p;
		1006	}
		1007
		1008	dtype = parse_stab_type (dhandle, info, name, &p, &slot);
		1009	if (dtype == DEBUG_TYPE_NULL)
		1010	return FALSE;
		1011	if (name == NULL)
		1012	return TRUE;
		1013
		1014	/* INFO->SELF_CROSSREF is set by parse_stab_type if this type is
		1015	a cross reference to itself. These are generated by some
		1016	versions of g++. */
		1017	self_crossref = info->self_crossref;
		1018
		1019	dtype = debug_tag_type (dhandle, name, dtype);
		1020	if (dtype == DEBUG_TYPE_NULL)
		1021	return FALSE;
		1022	if (slot != NULL)
		1023	*slot = dtype;
		1024
		1025	/* See if we have a cross reference to this tag which we can now
		1026	fill in. Avoid filling in a cross reference to ourselves,
		1027	because that would lead to circular debugging information. */
		1028	if (! self_crossref)
		1029	{
		1030	register struct stab_tag **pst;
		1031
		1032	for (pst = &info->tags; pst != NULL; pst = &(pst)->next)
		1033	{
		1034	if ((*pst)->name[0] == name[0]
		1035	&& strcmp ((*pst)->name, name) == 0)
		1036	{
		1037	(*pst)->slot = dtype;
		1038	pst = (pst)->next;
		1039	break;
		1040	}
		1041	}
		1042	}
		1043
		1044	if (synonym)
		1045	{
		1046	dtype = debug_name_type (dhandle, name, dtype);
		1047	if (dtype == DEBUG_TYPE_NULL)
		1048	return FALSE;
		1049
		1050	if (slot != NULL)
		1051	*slot = dtype;
		1052	}
		1053
		1054	break;
		1055
		1056	case 'V':
		1057	/* Static symbol of local scope */
		1058	dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
		1059	(debug_type **) NULL);
		1060	if (dtype == DEBUG_TYPE_NULL)
		1061	return FALSE;
		1062	/* FIXME: gdb checks os9k_stabs here. */
		1063	if (! stab_record_variable (dhandle, info, name, dtype,
		1064	DEBUG_LOCAL_STATIC, value))
		1065	return FALSE;
		1066	break;
		1067
		1068	case 'v':
		1069	/* Reference parameter. */
		1070	dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
		1071	(debug_type **) NULL);
		1072	if (dtype == DEBUG_TYPE_NULL)
		1073	return FALSE;
		1074	if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REFERENCE,
		1075	value))
		1076	return FALSE;
		1077	break;
		1078
		1079	case 'a':
		1080	/* Reference parameter which is in a register. */
		1081	dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
		1082	(debug_type **) NULL);
		1083	if (dtype == DEBUG_TYPE_NULL)
		1084	return FALSE;
		1085	if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REF_REG,
		1086	value))
		1087	return FALSE;
		1088	break;
		1089
		1090	case 'X':
		1091	/* This is used by Sun FORTRAN for "function result value".
		1092	Sun claims ("dbx and dbxtool interfaces", 2nd ed)
		1093	that Pascal uses it too, but when I tried it Pascal used
		1094	"x:3" (local symbol) instead. */
		1095	dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
		1096	(debug_type **) NULL);
		1097	if (dtype == DEBUG_TYPE_NULL)
		1098	return FALSE;
		1099	if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL,
		1100	value))
		1101	return FALSE;
		1102	break;
		1103
		1104	case 'Y':
		1105	/* SUNPro C++ Namespace =Yn0. */
		1106	/* Skip the namespace mapping, as it is not used now. */
		1107	if ((++p) == 'n' && (++p) == '0')
		1108	{
		1109	/* =Yn0name; */
		1110	while (*p != ';')
		1111	++p;
		1112	++p;
		1113	return TRUE;
		1114	}
		1115	/* TODO SUNPro C++ support:
		1116	Support default arguments after F,P parameters
		1117	Ya = Anonymous unions
		1118	YM,YD = Pointers to class members
		1119	YT,YI = Templates
		1120	YR = Run-time type information (RTTI) */
		1121
		1122	/* Fall through. */
		1123
		1124	default:
		1125	bad_stab (string);
		1126	return FALSE;
		1127	}
		1128
		1129	/* FIXME: gdb converts structure values to structure pointers in a
		1130	couple of cases, depending upon the target. */
		1131
		1132	return TRUE;
		1133	}
		1134
		1135	/* Parse a stabs type. The typename argument is non-NULL if this is a
		1136	typedef or a tag definition. The pp argument points to the stab
		1137	string, and is updated. The slotp argument points to a place to
		1138	store the slot used if the type is being defined. */
		1139
		1140	static debug_type
		1141	parse_stab_type (void dhandle, struct stab_handle info, const char type_name, const char pp, debug_type *slotp)
		1142	{
		1143	const char *orig;
		1144	int typenums[2];
		1145	int size;
		1146	bfd_boolean stringp;
		1147	int descriptor;
		1148	debug_type dtype;
		1149
		1150	if (slotp != NULL)
		1151	*slotp = NULL;
		1152
		1153	orig = *pp;
		1154
		1155	size = -1;
		1156	stringp = FALSE;
		1157
		1158	info->self_crossref = FALSE;
		1159
		1160	/* Read type number if present. The type number may be omitted.
		1161	for instance in a two-dimensional array declared with type
		1162	"ar1;1;10;ar1;1;10;4". */
		1163	if (! ISDIGIT (pp) && pp != '(' && **pp != '-')
		1164	{
		1165	/* 'typenums=' not present, type is anonymous. Read and return
		1166	the definition, but don't put it in the type vector. */
		1167	typenums[0] = typenums[1] = -1;
		1168	}
		1169	else
		1170	{
		1171	if (! parse_stab_type_number (pp, typenums))
		1172	return DEBUG_TYPE_NULL;
		1173
		1174	if (**pp != '=')
		1175	/* Type is not being defined here. Either it already
		1176	exists, or this is a forward reference to it. */
		1177	return stab_find_type (dhandle, info, typenums);
		1178
		1179	/* Only set the slot if the type is being defined. This means
		1180	that the mapping from type numbers to types will only record
		1181	the name of the typedef which defines a type. If we don't do
		1182	this, then something like
		1183	typedef int foo;
		1184	int i;
		1185	will record that i is of type foo. Unfortunately, stabs
		1186	information is ambiguous about variable types. For this code,
		1187	typedef int foo;
		1188	int i;
		1189	foo j;
		1190	the stabs information records both i and j as having the same
		1191	type. This could be fixed by patching the compiler. */
		1192	if (slotp != NULL && typenums[0] >= 0 && typenums[1] >= 0)
		1193	*slotp = stab_find_slot (info, typenums);
		1194
		1195	/* Type is being defined here. */
		1196	/* Skip the '='. */
		1197	++*pp;
		1198
		1199	while (**pp == '@')
		1200	{
		1201	const char p = pp + 1;
		1202	const char *attr;
		1203
		1204	if (ISDIGIT (p) \|\| p == '(' \|\| *p == '-')
		1205	/* Member type. */
		1206	break;
		1207
		1208	/* Type attributes. */
		1209	attr = p;
		1210
		1211	for (; *p != ';'; ++p)
		1212	{
		1213	if (*p == '\0')
		1214	{
		1215	bad_stab (orig);
		1216	return DEBUG_TYPE_NULL;
		1217	}
		1218	}
		1219	*pp = p + 1;
		1220
		1221	switch (*attr)
		1222	{
		1223	case 's':
		1224	size = atoi (attr + 1);
		1225	size /= 8; /* Size is in bits. We store it in bytes. */
		1226	if (size <= 0)
		1227	size = -1;
		1228	break;
		1229
		1230	case 'S':
		1231	stringp = TRUE;
		1232	break;
		1233
		1234	default:
		1235	/* Ignore unrecognized type attributes, so future
		1236	compilers can invent new ones. */
		1237	break;
		1238	}
		1239	}
		1240	}
		1241
		1242	descriptor = **pp;
		1243	++*pp;
		1244
		1245	switch (descriptor)
		1246	{
		1247	case 'x':
		1248	{
		1249	enum debug_type_kind code;
		1250	const char q1, q2, *p;
		1251
		1252	/* A cross reference to another type. */
		1253	switch (**pp)
		1254	{
		1255	case 's':
		1256	code = DEBUG_KIND_STRUCT;
		1257	break;
		1258	case 'u':
		1259	code = DEBUG_KIND_UNION;
		1260	break;
		1261	case 'e':
		1262	code = DEBUG_KIND_ENUM;
		1263	break;
		1264	default:
		1265	/* Complain and keep going, so compilers can invent new
		1266	cross-reference types. */
		1267	warn_stab (orig, _("unrecognized cross reference type"));
		1268	code = DEBUG_KIND_STRUCT;
		1269	break;
		1270	}
		1271	++*pp;
		1272
		1273	q1 = strchr (*pp, '<');
		1274	p = strchr (*pp, ':');
		1275	if (p == NULL)
		1276	{
		1277	bad_stab (orig);
		1278	return DEBUG_TYPE_NULL;
		1279	}
		1280	if (q1 != NULL && p > q1 && p[1] == ':')
		1281	{
		1282	int nest = 0;
		1283
		1284	for (q2 = q1; *q2 != '\0'; ++q2)
		1285	{
		1286	if (*q2 == '<')
		1287	++nest;
		1288	else if (*q2 == '>')
		1289	--nest;
		1290	else if (*q2 == ':' && nest == 0)
		1291	break;
		1292	}
		1293	p = q2;
		1294	if (*p != ':')
		1295	{
		1296	bad_stab (orig);
		1297	return DEBUG_TYPE_NULL;
		1298	}
		1299	}
		1300
		1301	/* Some versions of g++ can emit stabs like
		1302	fleep:T20=xsfleep:
		1303	which define structures in terms of themselves. We need to
		1304	tell the caller to avoid building a circular structure. */
		1305	if (type_name != NULL
		1306	&& strncmp (type_name, pp, p - pp) == 0
		1307	&& type_name[p - *pp] == '\0')
		1308	info->self_crossref = TRUE;
		1309
		1310	dtype = stab_find_tagged_type (dhandle, info, pp, p - pp, code);
		1311
		1312	*pp = p + 1;
		1313	}
		1314	break;
		1315
		1316	case '-':
		1317	case '0':
		1318	case '1':
		1319	case '2':
		1320	case '3':
		1321	case '4':
		1322	case '5':
		1323	case '6':
		1324	case '7':
		1325	case '8':
		1326	case '9':
		1327	case '(':
		1328	{
		1329	const char *hold;
		1330	int xtypenums[2];
		1331
		1332	/* This type is defined as another type. */
		1333	(*pp)--;
		1334	hold = *pp;
		1335
		1336	/* Peek ahead at the number to detect void. */
		1337	if (! parse_stab_type_number (pp, xtypenums))
		1338	return DEBUG_TYPE_NULL;
		1339
		1340	if (typenums[0] == xtypenums[0] && typenums[1] == xtypenums[1])
		1341	{
		1342	/* This type is being defined as itself, which means that
		1343	it is void. */
		1344	dtype = debug_make_void_type (dhandle);
		1345	}
		1346	else
		1347	{
		1348	*pp = hold;
		1349
		1350	/* Go back to the number and have parse_stab_type get it.
		1351	This means that we can deal with something like
		1352	t(1,2)=(3,4)=... which the Lucid compiler uses. */
		1353	dtype = parse_stab_type (dhandle, info, (const char *) NULL,
		1354	pp, (debug_type **) NULL);
		1355	if (dtype == DEBUG_TYPE_NULL)
		1356	return DEBUG_TYPE_NULL;
		1357	}
		1358
		1359	if (typenums[0] != -1)
		1360	{
		1361	if (! stab_record_type (dhandle, info, typenums, dtype))
		1362	return DEBUG_TYPE_NULL;
		1363	}
		1364
		1365	break;
		1366	}
		1367
		1368	case '*':
		1369	dtype = debug_make_pointer_type (dhandle,
		1370	parse_stab_type (dhandle, info,
		1371	(const char *) NULL,
		1372	pp,
		1373	(debug_type **) NULL));
		1374	break;
		1375
		1376	case '&':
		1377	/* Reference to another type. */
		1378	dtype = (debug_make_reference_type
		1379	(dhandle,
		1380	parse_stab_type (dhandle, info, (const char *) NULL, pp,
		1381	(debug_type **) NULL)));
		1382	break;
		1383
		1384	case 'f':
		1385	/* Function returning another type. */
		1386	/* FIXME: gdb checks os9k_stabs here. */
		1387	dtype = (debug_make_function_type
		1388	(dhandle,
		1389	parse_stab_type (dhandle, info, (const char *) NULL, pp,
		1390	(debug_type **) NULL),
		1391	(debug_type *) NULL, FALSE));
		1392	break;
		1393
		1394	case 'k':
		1395	/* Const qualifier on some type (Sun). */
		1396	/* FIXME: gdb accepts 'c' here if os9k_stabs. */
		1397	dtype = debug_make_const_type (dhandle,
		1398	parse_stab_type (dhandle, info,
		1399	(const char *) NULL,
		1400	pp,
		1401	(debug_type **) NULL));
		1402	break;
		1403
		1404	case 'B':
		1405	/* Volatile qual on some type (Sun). */
		1406	/* FIXME: gdb accepts 'i' here if os9k_stabs. */
		1407	dtype = (debug_make_volatile_type
		1408	(dhandle,
		1409	parse_stab_type (dhandle, info, (const char *) NULL, pp,
		1410	(debug_type **) NULL)));
		1411	break;
		1412
		1413	case '@':
		1414	/* Offset (class & variable) type. This is used for a pointer
		1415	relative to an object. */
		1416	{
		1417	debug_type domain;
		1418	debug_type memtype;
		1419
		1420	/* Member type. */
		1421
		1422	domain = parse_stab_type (dhandle, info, (const char *) NULL, pp,
		1423	(debug_type **) NULL);
		1424	if (domain == DEBUG_TYPE_NULL)
		1425	return DEBUG_TYPE_NULL;
		1426
		1427	if (**pp != ',')
		1428	{
		1429	bad_stab (orig);
		1430	return DEBUG_TYPE_NULL;
		1431	}
		1432	++*pp;
		1433
		1434	memtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
		1435	(debug_type **) NULL);
		1436	if (memtype == DEBUG_TYPE_NULL)
		1437	return DEBUG_TYPE_NULL;
		1438
		1439	dtype = debug_make_offset_type (dhandle, domain, memtype);
		1440	}
		1441	break;
		1442
		1443	case '#':
		1444	/* Method (class & fn) type. */
		1445	if (**pp == '#')
		1446	{
		1447	debug_type return_type;
		1448
		1449	++*pp;
		1450	return_type = parse_stab_type (dhandle, info, (const char *) NULL,
		1451	pp, (debug_type **) NULL);
		1452	if (return_type == DEBUG_TYPE_NULL)
		1453	return DEBUG_TYPE_NULL;
		1454	if (**pp != ';')
		1455	{
		1456	bad_stab (orig);
		1457	return DEBUG_TYPE_NULL;
		1458	}
		1459	++*pp;
		1460	dtype = debug_make_method_type (dhandle, return_type,
		1461	DEBUG_TYPE_NULL,
		1462	(debug_type *) NULL, FALSE);
		1463	}
		1464	else
		1465	{
		1466	debug_type domain;
		1467	debug_type return_type;
		1468	debug_type *args;
		1469	unsigned int n;
		1470	unsigned int alloc;
		1471	bfd_boolean varargs;
		1472
		1473	domain = parse_stab_type (dhandle, info, (const char *) NULL,
		1474	pp, (debug_type **) NULL);
		1475	if (domain == DEBUG_TYPE_NULL)
		1476	return DEBUG_TYPE_NULL;
		1477
		1478	if (**pp != ',')
		1479	{
		1480	bad_stab (orig);
		1481	return DEBUG_TYPE_NULL;
		1482	}
		1483	++*pp;
		1484
		1485	return_type = parse_stab_type (dhandle, info, (const char *) NULL,
		1486	pp, (debug_type **) NULL);
		1487	if (return_type == DEBUG_TYPE_NULL)
		1488	return DEBUG_TYPE_NULL;
		1489
		1490	alloc = 10;
		1491	args = (debug_type ) xmalloc (alloc sizeof *args);
		1492	n = 0;
		1493	while (**pp != ';')
		1494	{
		1495	if (**pp != ',')
		1496	{
		1497	bad_stab (orig);
		1498	return DEBUG_TYPE_NULL;
		1499	}
		1500	++*pp;
		1501
		1502	if (n + 1 >= alloc)
		1503	{
		1504	alloc += 10;
		1505	args = ((debug_type *)
		1506	xrealloc (args, alloc * sizeof *args));
		1507	}
		1508
		1509	args[n] = parse_stab_type (dhandle, info, (const char *) NULL,
		1510	pp, (debug_type **) NULL);
		1511	if (args[n] == DEBUG_TYPE_NULL)
		1512	return DEBUG_TYPE_NULL;
		1513	++n;
		1514	}
		1515	++*pp;
		1516
		1517	/* If the last type is not void, then this function takes a
		1518	variable number of arguments. Otherwise, we must strip
		1519	the void type. */
		1520	if (n == 0
		1521	\|\| debug_get_type_kind (dhandle, args[n - 1]) != DEBUG_KIND_VOID)
		1522	varargs = TRUE;
		1523	else
		1524	{
		1525	--n;
		1526	varargs = FALSE;
		1527	}
		1528
		1529	args[n] = DEBUG_TYPE_NULL;
		1530
		1531	dtype = debug_make_method_type (dhandle, return_type, domain, args,
		1532	varargs);
		1533	}
		1534	break;
		1535
		1536	case 'r':
		1537	/* Range type. */
		1538	dtype = parse_stab_range_type (dhandle, info, type_name, pp, typenums);
		1539	break;
		1540
		1541	case 'b':
		1542	/* FIXME: gdb checks os9k_stabs here. */
		1543	/* Sun ACC builtin int type. */
		1544	dtype = parse_stab_sun_builtin_type (dhandle, pp);
		1545	break;
		1546
		1547	case 'R':
		1548	/* Sun ACC builtin float type. */
		1549	dtype = parse_stab_sun_floating_type (dhandle, pp);
		1550	break;
		1551
		1552	case 'e':
		1553	/* Enumeration type. */
		1554	dtype = parse_stab_enum_type (dhandle, pp);
		1555	break;
		1556
		1557	case 's':
		1558	case 'u':
		1559	/* Struct or union type. */
		1560	dtype = parse_stab_struct_type (dhandle, info, type_name, pp,
		1561	descriptor == 's', typenums);
		1562	break;
		1563
		1564	case 'a':
		1565	/* Array type. */
		1566	if (**pp != 'r')
		1567	{
		1568	bad_stab (orig);
		1569	return DEBUG_TYPE_NULL;
		1570	}
		1571	++*pp;
		1572
		1573	dtype = parse_stab_array_type (dhandle, info, pp, stringp);
		1574	break;
		1575
		1576	case 'S':
		1577	dtype = debug_make_set_type (dhandle,
		1578	parse_stab_type (dhandle, info,
		1579	(const char *) NULL,
		1580	pp,
		1581	(debug_type **) NULL),
		1582	stringp);
		1583	break;
		1584
		1585	default:
		1586	bad_stab (orig);
		1587	return DEBUG_TYPE_NULL;
		1588	}
		1589
		1590	if (dtype == DEBUG_TYPE_NULL)
		1591	return DEBUG_TYPE_NULL;
		1592
		1593	if (typenums[0] != -1)
		1594	{
		1595	if (! stab_record_type (dhandle, info, typenums, dtype))
		1596	return DEBUG_TYPE_NULL;
		1597	}
		1598
		1599	if (size != -1)
		1600	{
		1601	if (! debug_record_type_size (dhandle, dtype, (unsigned int) size))
		1602	return DEBUG_TYPE_NULL;
		1603	}
		1604
		1605	return dtype;
		1606	}
		1607
		1608	/* Read a number by which a type is referred to in dbx data, or
		1609	perhaps read a pair (FILENUM, TYPENUM) in parentheses. Just a
		1610	single number N is equivalent to (0,N). Return the two numbers by
		1611	storing them in the vector TYPENUMS. */
		1612
		1613	static bfd_boolean
		1614	parse_stab_type_number (const char *pp, int typenums)
		1615	{
		1616	const char *orig;
		1617
		1618	orig = *pp;
		1619
		1620	if (**pp != '(')
		1621	{
		1622	typenums[0] = 0;
		1623	typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL);
		1624	}
		1625	else
		1626	{
		1627	++*pp;
		1628	typenums[0] = (int) parse_number (pp, (bfd_boolean *) NULL);
		1629	if (**pp != ',')
		1630	{
		1631	bad_stab (orig);
		1632	return FALSE;
		1633	}
		1634	++*pp;
		1635	typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL);
		1636	if (**pp != ')')
		1637	{
		1638	bad_stab (orig);
		1639	return FALSE;
		1640	}
		1641	++*pp;
		1642	}
		1643
		1644	return TRUE;
		1645	}
		1646
		1647	/* Parse a range type. */
		1648
		1649	static debug_type
		1650	parse_stab_range_type (void dhandle, struct stab_handle info, const char type_name, const char pp, const int typenums)
		1651	{
		1652	const char *orig;
		1653	int rangenums[2];
		1654	bfd_boolean self_subrange;
		1655	debug_type index_type;
		1656	const char s2, s3;
		1657	bfd_signed_vma n2, n3;
		1658	bfd_boolean ov2, ov3;
		1659
		1660	orig = *pp;
		1661
		1662	index_type = DEBUG_TYPE_NULL;
		1663
		1664	/* First comes a type we are a subrange of.
		1665	In C it is usually 0, 1 or the type being defined. */
		1666	if (! parse_stab_type_number (pp, rangenums))
		1667	return DEBUG_TYPE_NULL;
		1668
		1669	self_subrange = (rangenums[0] == typenums[0]
		1670	&& rangenums[1] == typenums[1]);
		1671
		1672	if (**pp == '=')
		1673	{
		1674	*pp = orig;
		1675	index_type = parse_stab_type (dhandle, info, (const char *) NULL,
		1676	pp, (debug_type **) NULL);
		1677	if (index_type == DEBUG_TYPE_NULL)
		1678	return DEBUG_TYPE_NULL;
		1679	}
		1680
		1681	if (**pp == ';')
		1682	++*pp;
		1683
		1684	/* The remaining two operands are usually lower and upper bounds of
		1685	the range. But in some special cases they mean something else. */
		1686	s2 = *pp;
		1687	n2 = parse_number (pp, &ov2);
		1688	if (**pp != ';')
		1689	{
		1690	bad_stab (orig);
		1691	return DEBUG_TYPE_NULL;
		1692	}
		1693	++*pp;
		1694
		1695	s3 = *pp;
		1696	n3 = parse_number (pp, &ov3);
		1697	if (**pp != ';')
		1698	{
		1699	bad_stab (orig);
		1700	return DEBUG_TYPE_NULL;
		1701	}
		1702	++*pp;
		1703
		1704	if (ov2 \|\| ov3)
		1705	{
		1706	/* gcc will emit range stabs for long long types. Handle this
		1707	as a special case. FIXME: This needs to be more general. */
		1708	#define LLLOW "01000000000000000000000;"
		1709	#define LLHIGH "0777777777777777777777;"
		1710	#define ULLHIGH "01777777777777777777777;"
		1711	if (index_type == DEBUG_TYPE_NULL)
		1712	{
		1713	if (CONST_STRNEQ (s2, LLLOW)
		1714	&& CONST_STRNEQ (s3, LLHIGH))
		1715	return debug_make_int_type (dhandle, 8, FALSE);
		1716	if (! ov2
		1717	&& n2 == 0
		1718	&& CONST_STRNEQ (s3, ULLHIGH))
		1719	return debug_make_int_type (dhandle, 8, TRUE);
		1720	}
		1721
		1722	warn_stab (orig, _("numeric overflow"));
		1723	}
		1724
		1725	if (index_type == DEBUG_TYPE_NULL)
		1726	{
		1727	/* A type defined as a subrange of itself, with both bounds 0,
		1728	is void. */
		1729	if (self_subrange && n2 == 0 && n3 == 0)
		1730	return debug_make_void_type (dhandle);
		1731
		1732	/* A type defined as a subrange of itself, with n2 positive and
		1733	n3 zero, is a complex type, and n2 is the number of bytes. */
		1734	if (self_subrange && n3 == 0 && n2 > 0)
		1735	return debug_make_complex_type (dhandle, n2);
		1736
		1737	/* If n3 is zero and n2 is positive, this is a floating point
		1738	type, and n2 is the number of bytes. */
		1739	if (n3 == 0 && n2 > 0)
		1740	return debug_make_float_type (dhandle, n2);
		1741
		1742	/* If the upper bound is -1, this is an unsigned int. */
		1743	if (n2 == 0 && n3 == -1)
		1744	{
		1745	/* When gcc is used with -gstabs, but not -gstabs+, it will emit
		1746	long long int:t6=r1;0;-1;
		1747	long long unsigned int:t7=r1;0;-1;
		1748	We hack here to handle this reasonably. */
		1749	if (type_name != NULL)
		1750	{
		1751	if (strcmp (type_name, "long long int") == 0)
		1752	return debug_make_int_type (dhandle, 8, FALSE);
		1753	else if (strcmp (type_name, "long long unsigned int") == 0)
		1754	return debug_make_int_type (dhandle, 8, TRUE);
		1755	}
		1756	/* FIXME: The size here really depends upon the target. */
		1757	return debug_make_int_type (dhandle, 4, TRUE);
		1758	}
		1759
		1760	/* A range of 0 to 127 is char. */
		1761	if (self_subrange && n2 == 0 && n3 == 127)
		1762	return debug_make_int_type (dhandle, 1, FALSE);
		1763
		1764	/* FIXME: gdb checks for the language CHILL here. */
		1765
		1766	if (n2 == 0)
		1767	{
		1768	if (n3 < 0)
		1769	return debug_make_int_type (dhandle, - n3, TRUE);
		1770	else if (n3 == 0xff)
		1771	return debug_make_int_type (dhandle, 1, TRUE);
		1772	else if (n3 == 0xffff)
		1773	return debug_make_int_type (dhandle, 2, TRUE);
		1774	else if (n3 == (bfd_signed_vma) 0xffffffff)
		1775	return debug_make_int_type (dhandle, 4, TRUE);
		1776	#ifdef BFD64
6324	serge	1777	else if (n3 == (bfd_signed_vma) 0xffffffffffffffffLL)
5217	serge	1778	return debug_make_int_type (dhandle, 8, TRUE);
		1779	#endif
		1780	}
		1781	else if (n3 == 0
		1782	&& n2 < 0
		1783	&& (self_subrange \|\| n2 == -8))
		1784	return debug_make_int_type (dhandle, - n2, TRUE);
		1785	else if (n2 == - n3 - 1 \|\| n2 == n3 + 1)
		1786	{
		1787	if (n3 == 0x7f)
		1788	return debug_make_int_type (dhandle, 1, FALSE);
		1789	else if (n3 == 0x7fff)
		1790	return debug_make_int_type (dhandle, 2, FALSE);
		1791	else if (n3 == 0x7fffffff)
		1792	return debug_make_int_type (dhandle, 4, FALSE);
		1793	#ifdef BFD64
		1794	else if (n3 == ((((bfd_vma) 0x7fffffff) << 32) \| 0xffffffff))
		1795	return debug_make_int_type (dhandle, 8, FALSE);
		1796	#endif
		1797	}
		1798	}
		1799
		1800	/* At this point I don't have the faintest idea how to deal with a
		1801	self_subrange type; I'm going to assume that this is used as an
		1802	idiom, and that all of them are special cases. So . . . */
		1803	if (self_subrange)
		1804	{
		1805	bad_stab (orig);
		1806	return DEBUG_TYPE_NULL;
		1807	}
		1808
		1809	index_type = stab_find_type (dhandle, info, rangenums);
		1810	if (index_type == DEBUG_TYPE_NULL)
		1811	{
		1812	/* Does this actually ever happen? Is that why we are worrying
		1813	about dealing with it rather than just calling error_type? */
		1814	warn_stab (orig, _("missing index type"));
		1815	index_type = debug_make_int_type (dhandle, 4, FALSE);
		1816	}
		1817
		1818	return debug_make_range_type (dhandle, index_type, n2, n3);
		1819	}
		1820
		1821	/* Sun's ACC uses a somewhat saner method for specifying the builtin
		1822	typedefs in every file (for int, long, etc):
		1823
		1824	type = b ; ;
		1825	signed = u or s. Possible c in addition to u or s (for char?).
		1826	offset = offset from high order bit to start bit of type.
		1827	width is # bytes in object of this type, nbits is # bits in type.
		1828
		1829	The width/offset stuff appears to be for small objects stored in
		1830	larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
		1831	FIXME. */
		1832
		1833	static debug_type
		1834	parse_stab_sun_builtin_type (void dhandle, const char *pp)
		1835	{
		1836	const char *orig;
		1837	bfd_boolean unsignedp;
		1838	bfd_vma bits;
		1839
		1840	orig = *pp;
		1841
		1842	switch (**pp)
		1843	{
		1844	case 's':
		1845	unsignedp = FALSE;
		1846	break;
		1847	case 'u':
		1848	unsignedp = TRUE;
		1849	break;
		1850	default:
		1851	bad_stab (orig);
		1852	return DEBUG_TYPE_NULL;
		1853	}
		1854	++*pp;
		1855
		1856	/* OpenSolaris source code indicates that one of "cbv" characters
		1857	can come next and specify the intrinsic 'iformat' encoding.
		1858	'c' is character encoding, 'b' is boolean encoding, and 'v' is
		1859	varargs encoding. This field can be safely ignored because
		1860	the type of the field is determined from the bitwidth extracted
		1861	below. */
		1862	if (pp == 'c' \|\| pp == 'b' \|\| **pp == 'v')
		1863	++*pp;
		1864
		1865	/* The first number appears to be the number of bytes occupied
		1866	by this type, except that unsigned short is 4 instead of 2.
		1867	Since this information is redundant with the third number,
		1868	we will ignore it. */
		1869	(void) parse_number (pp, (bfd_boolean *) NULL);
		1870	if (**pp != ';')
		1871	{
		1872	bad_stab (orig);
		1873	return DEBUG_TYPE_NULL;
		1874	}
		1875	++*pp;
		1876
		1877	/* The second number is always 0, so ignore it too. */
		1878	(void) parse_number (pp, (bfd_boolean *) NULL);
		1879	if (**pp != ';')
		1880	{
		1881	bad_stab (orig);
		1882	return DEBUG_TYPE_NULL;
		1883	}
		1884	++*pp;
		1885
		1886	/* The third number is the number of bits for this type. */
		1887	bits = parse_number (pp, (bfd_boolean *) NULL);
		1888
		1889	/* The type should end with a semicolon. If it are embedded
		1890	in a larger type the semicolon may be the only way to know where
		1891	the type ends. If this type is at the end of the stabstring we
		1892	can deal with the omitted semicolon (but we don't have to like
		1893	it). Don't bother to complain(), Sun's compiler omits the semicolon
		1894	for "void". */
		1895	if (**pp == ';')
		1896	++*pp;
		1897
		1898	if (bits == 0)
		1899	return debug_make_void_type (dhandle);
		1900
		1901	return debug_make_int_type (dhandle, bits / 8, unsignedp);
		1902	}
		1903
		1904	/* Parse a builtin floating type generated by the Sun compiler. */
		1905
		1906	static debug_type
		1907	parse_stab_sun_floating_type (void dhandle, const char *pp)
		1908	{
		1909	const char *orig;
		1910	bfd_vma details;
		1911	bfd_vma bytes;
		1912
		1913	orig = *pp;
		1914
		1915	/* The first number has more details about the type, for example
		1916	FN_COMPLEX. */
		1917	details = parse_number (pp, (bfd_boolean *) NULL);
		1918	if (**pp != ';')
		1919	{
		1920	bad_stab (orig);
		1921	return DEBUG_TYPE_NULL;
		1922	}
		1923
		1924	/* The second number is the number of bytes occupied by this type */
		1925	bytes = parse_number (pp, (bfd_boolean *) NULL);
		1926	if (**pp != ';')
		1927	{
		1928	bad_stab (orig);
		1929	return DEBUG_TYPE_NULL;
		1930	}
		1931
		1932	if (details == NF_COMPLEX
		1933	\|\| details == NF_COMPLEX16
		1934	\|\| details == NF_COMPLEX32)
		1935	return debug_make_complex_type (dhandle, bytes);
		1936
		1937	return debug_make_float_type (dhandle, bytes);
		1938	}
		1939
		1940	/* Handle an enum type. */
		1941
		1942	static debug_type
		1943	parse_stab_enum_type (void dhandle, const char *pp)
		1944	{
		1945	const char *orig;
		1946	const char **names;
		1947	bfd_signed_vma *values;
		1948	unsigned int n;
		1949	unsigned int alloc;
		1950
		1951	orig = *pp;
		1952
		1953	/* FIXME: gdb checks os9k_stabs here. */
		1954
		1955	/* The aix4 compiler emits an extra field before the enum members;
		1956	my guess is it's a type of some sort. Just ignore it. */
		1957	if (**pp == '-')
		1958	{
		1959	while (**pp != ':')
		1960	++*pp;
		1961	++*pp;
		1962	}
		1963
		1964	/* Read the value-names and their values.
		1965	The input syntax is NAME:VALUE,NAME:VALUE, and so on.
		1966	A semicolon or comma instead of a NAME means the end. */
		1967	alloc = 10;
		1968	names = (const char *) xmalloc (alloc sizeof *names);
		1969	values = (bfd_signed_vma ) xmalloc (alloc sizeof *values);
		1970	n = 0;
		1971	while (pp != '\0' && pp != ';' && **pp != ',')
		1972	{
		1973	const char *p;
		1974	char *name;
		1975	bfd_signed_vma val;
		1976
		1977	p = *pp;
		1978	while (*p != ':')
		1979	++p;
		1980
		1981	name = savestring (pp, p - pp);
		1982
		1983	*pp = p + 1;
		1984	val = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
		1985	if (**pp != ',')
		1986	{
		1987	bad_stab (orig);
		1988	free (name);
		1989	free (names);
		1990	free (values);
		1991	return DEBUG_TYPE_NULL;
		1992	}
		1993	++*pp;
		1994
		1995	if (n + 1 >= alloc)
		1996	{
		1997	alloc += 10;
		1998	names = ((const char **)
		1999	xrealloc (names, alloc * sizeof *names));
		2000	values = ((bfd_signed_vma *)
		2001	xrealloc (values, alloc * sizeof *values));
		2002	}
		2003
		2004	names[n] = name;
		2005	values[n] = val;
		2006	++n;
		2007	}
		2008
		2009	names[n] = NULL;
		2010	values[n] = 0;
		2011
		2012	if (**pp == ';')
		2013	++*pp;
		2014
		2015	return debug_make_enum_type (dhandle, names, values);
		2016	}
		2017
		2018	/* Read the description of a structure (or union type) and return an object
		2019	describing the type.
		2020
		2021	PP points to a character pointer that points to the next unconsumed token
		2022	in the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
		2023	PP will point to "4a:1,0,32;;". /
		2024
		2025	static debug_type
		2026	parse_stab_struct_type (void dhandle, struct stab_handle info,
		2027	const char tagname, const char *pp,
		2028	bfd_boolean structp, const int *typenums)
		2029	{
		2030	bfd_vma size;
		2031	debug_baseclass *baseclasses;
		2032	debug_field *fields = NULL;
		2033	bfd_boolean statics;
		2034	debug_method *methods;
		2035	debug_type vptrbase;
		2036	bfd_boolean ownvptr;
		2037
		2038	/* Get the size. */
		2039	size = parse_number (pp, (bfd_boolean *) NULL);
		2040
		2041	/* Get the other information. */
		2042	if (! parse_stab_baseclasses (dhandle, info, pp, &baseclasses)
		2043	\|\| ! parse_stab_struct_fields (dhandle, info, pp, &fields, &statics)
		2044	\|\| ! parse_stab_members (dhandle, info, tagname, pp, typenums, &methods)
		2045	\|\| ! parse_stab_tilde_field (dhandle, info, pp, typenums, &vptrbase,
		2046	&ownvptr))
		2047	{
		2048	if (fields != NULL)
		2049	free (fields);
		2050	return DEBUG_TYPE_NULL;
		2051	}
		2052
		2053	if (! statics
		2054	&& baseclasses == NULL
		2055	&& methods == NULL
		2056	&& vptrbase == DEBUG_TYPE_NULL
		2057	&& ! ownvptr)
		2058	return debug_make_struct_type (dhandle, structp, size, fields);
		2059
		2060	return debug_make_object_type (dhandle, structp, size, fields, baseclasses,
		2061	methods, vptrbase, ownvptr);
		2062	}
		2063
		2064	/* The stabs for C++ derived classes contain baseclass information which
		2065	is marked by a '!' character after the total size. This function is
		2066	called when we encounter the baseclass marker, and slurps up all the
		2067	baseclass information.
		2068
		2069	Immediately following the '!' marker is the number of base classes that
		2070	the class is derived from, followed by information for each base class.
		2071	For each base class, there are two visibility specifiers, a bit offset
		2072	to the base class information within the derived class, a reference to
		2073	the type for the base class, and a terminating semicolon.
		2074
		2075	A typical example, with two base classes, would be "!2,020,19;0264,21;".
		2076	^^ ^ ^ ^ ^ ^ ^
		2077	Baseclass information marker __________________\|\| \| \| \| \| \| \|
		2078	Number of baseclasses __________________________\| \| \| \| \| \| \|
		2079	Visibility specifiers (2) ________________________\| \| \| \| \| \|
		2080	Offset in bits from start of class _________________\| \| \| \| \|
		2081	Type number for base class ___________________________\| \| \| \|
		2082	Visibility specifiers (2) _______________________________\| \| \|
		2083	Offset in bits from start of class ________________________\| \|
		2084	Type number of base class ____________________________________\|
		2085
		2086	Return TRUE for success, FALSE for failure. */
		2087
		2088	static bfd_boolean
		2089	parse_stab_baseclasses (void dhandle, struct stab_handle info,
		2090	const char pp, debug_baseclass retp)
		2091	{
		2092	const char *orig;
		2093	unsigned int c, i;
		2094	debug_baseclass *classes;
		2095
		2096	*retp = NULL;
		2097
		2098	orig = *pp;
		2099
		2100	if (**pp != '!')
		2101	{
		2102	/* No base classes. */
		2103	return TRUE;
		2104	}
		2105	++*pp;
		2106
		2107	c = (unsigned int) parse_number (pp, (bfd_boolean *) NULL);
		2108
		2109	if (**pp != ',')
		2110	{
		2111	bad_stab (orig);
		2112	return FALSE;
		2113	}
		2114	++*pp;
		2115
		2116	classes = (debug_baseclass ) xmalloc ((c + 1) sizeof (**retp));
		2117
		2118	for (i = 0; i < c; i++)
		2119	{
		2120	bfd_boolean is_virtual;
		2121	enum debug_visibility visibility;
		2122	bfd_vma bitpos;
		2123	debug_type type;
		2124
		2125	switch (**pp)
		2126	{
		2127	case '0':
		2128	is_virtual = FALSE;
		2129	break;
		2130	case '1':
		2131	is_virtual = TRUE;
		2132	break;
		2133	default:
		2134	warn_stab (orig, _("unknown virtual character for baseclass"));
		2135	is_virtual = FALSE;
		2136	break;
		2137	}
		2138	++*pp;
		2139
		2140	switch (**pp)
		2141	{
		2142	case '0':
		2143	visibility = DEBUG_VISIBILITY_PRIVATE;
		2144	break;
		2145	case '1':
		2146	visibility = DEBUG_VISIBILITY_PROTECTED;
		2147	break;
		2148	case '2':
		2149	visibility = DEBUG_VISIBILITY_PUBLIC;
		2150	break;
		2151	default:
		2152	warn_stab (orig, _("unknown visibility character for baseclass"));
		2153	visibility = DEBUG_VISIBILITY_PUBLIC;
		2154	break;
		2155	}
		2156	++*pp;
		2157
		2158	/* The remaining value is the bit offset of the portion of the
		2159	object corresponding to this baseclass. Always zero in the
		2160	absence of multiple inheritance. */
		2161	bitpos = parse_number (pp, (bfd_boolean *) NULL);
		2162	if (**pp != ',')
		2163	{
		2164	bad_stab (orig);
		2165	return FALSE;
		2166	}
		2167	++*pp;
		2168
		2169	type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
		2170	(debug_type **) NULL);
		2171	if (type == DEBUG_TYPE_NULL)
		2172	return FALSE;
		2173
		2174	classes[i] = debug_make_baseclass (dhandle, type, bitpos, is_virtual,
		2175	visibility);
		2176	if (classes[i] == DEBUG_BASECLASS_NULL)
		2177	return FALSE;
		2178
		2179	if (**pp != ';')
		2180	return FALSE;
		2181	++*pp;
		2182	}
		2183
		2184	classes[i] = DEBUG_BASECLASS_NULL;
		2185
		2186	*retp = classes;
		2187
		2188	return TRUE;
		2189	}
		2190
		2191	/* Read struct or class data fields. They have the form:
		2192
		2193	NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
		2194
		2195	At the end, we see a semicolon instead of a field.
		2196
		2197	In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
		2198	a static field.
		2199
		2200	The optional VISIBILITY is one of:
		2201
		2202	'/0' (VISIBILITY_PRIVATE)
		2203	'/1' (VISIBILITY_PROTECTED)
		2204	'/2' (VISIBILITY_PUBLIC)
		2205	'/9' (VISIBILITY_IGNORE)
		2206
		2207	or nothing, for C style fields with public visibility.
		2208
		2209	Returns 1 for success, 0 for failure. */
		2210
		2211	static bfd_boolean
		2212	parse_stab_struct_fields (void dhandle, struct stab_handle info,
		2213	const char pp, debug_field retp,
		2214	bfd_boolean *staticsp)
		2215	{
		2216	const char *orig;
		2217	const char *p;
		2218	debug_field *fields;
		2219	unsigned int c;
		2220	unsigned int alloc;
		2221
		2222	*retp = NULL;
		2223	*staticsp = FALSE;
		2224
		2225	orig = *pp;
		2226
		2227	c = 0;
		2228	alloc = 10;
		2229	fields = (debug_field ) xmalloc (alloc sizeof *fields);
		2230	while (**pp != ';')
		2231	{
		2232	/* FIXME: gdb checks os9k_stabs here. */
		2233
		2234	p = *pp;
		2235
		2236	/* Add 1 to c to leave room for NULL pointer at end. */
		2237	if (c + 1 >= alloc)
		2238	{
		2239	alloc += 10;
		2240	fields = ((debug_field *)
		2241	xrealloc (fields, alloc * sizeof *fields));
		2242	}
		2243
		2244	/* If it starts with CPLUS_MARKER it is a special abbreviation,
		2245	unless the CPLUS_MARKER is followed by an underscore, in
		2246	which case it is just the name of an anonymous type, which we
		2247	should handle like any other type name. We accept either '$'
		2248	or '.', because a field name can never contain one of these
		2249	characters except as a CPLUS_MARKER. */
		2250
		2251	if ((p == '$' \|\| p == '.') && p[1] != '_')
		2252	{
		2253	++*pp;
		2254	if (! parse_stab_cpp_abbrev (dhandle, info, pp, fields + c))
		2255	{
		2256	free (fields);
		2257	return FALSE;
		2258	}
		2259	++c;
		2260	continue;
		2261	}
		2262
		2263	/* Look for the ':' that separates the field name from the field
		2264	values. Data members are delimited by a single ':', while member
		2265	functions are delimited by a pair of ':'s. When we hit the member
		2266	functions (if any), terminate scan loop and return. */
		2267
		2268	p = strchr (p, ':');
		2269	if (p == NULL)
		2270	{
		2271	bad_stab (orig);
		2272	free (fields);
		2273	return FALSE;
		2274	}
		2275
		2276	if (p[1] == ':')
		2277	break;
		2278
		2279	if (! parse_stab_one_struct_field (dhandle, info, pp, p, fields + c,
		2280	staticsp))
		2281	return FALSE;
		2282
		2283	++c;
		2284	}
		2285
		2286	fields[c] = DEBUG_FIELD_NULL;
		2287
		2288	*retp = fields;
		2289
		2290	return TRUE;
		2291	}
		2292
		2293	/* Special GNU C++ name. */
		2294
		2295	static bfd_boolean
		2296	parse_stab_cpp_abbrev (void dhandle, struct stab_handle info,
		2297	const char *pp, debug_field retp)
		2298	{
		2299	const char *orig;
		2300	int cpp_abbrev;
		2301	debug_type context;
		2302	const char *name;
		2303	const char *type_name;
		2304	debug_type type;
		2305	bfd_vma bitpos;
		2306
		2307	*retp = DEBUG_FIELD_NULL;
		2308
		2309	orig = *pp;
		2310
		2311	if (**pp != 'v')
		2312	{
		2313	bad_stab (*pp);
		2314	return FALSE;
		2315	}
		2316	++*pp;
		2317
		2318	cpp_abbrev = **pp;
		2319	++*pp;
		2320
		2321	/* At this point, pp points to something like "22:23=22...", where
		2322	the type number before the ':' is the "context" and everything
		2323	after is a regular type definition. Lookup the type, find it's
		2324	name, and construct the field name. */
		2325
		2326	context = parse_stab_type (dhandle, info, (const char *) NULL, pp,
		2327	(debug_type **) NULL);
		2328	if (context == DEBUG_TYPE_NULL)
		2329	return FALSE;
		2330
		2331	switch (cpp_abbrev)
		2332	{
		2333	case 'f':
		2334	/* $vf -- a virtual function table pointer. */
		2335	name = "_vptr$";
		2336	break;
		2337	case 'b':
		2338	/* $vb -- a virtual bsomethingorother */
		2339	type_name = debug_get_type_name (dhandle, context);
		2340	if (type_name == NULL)
		2341	{
		2342	warn_stab (orig, _("unnamed $vb type"));
		2343	type_name = "FOO";
		2344	}
		2345	name = concat ("_vb$", type_name, (const char *) NULL);
		2346	break;
		2347	default:
		2348	warn_stab (orig, _("unrecognized C++ abbreviation"));
		2349	name = "INVALID_CPLUSPLUS_ABBREV";
		2350	break;
		2351	}
		2352
		2353	if (**pp != ':')
		2354	{
		2355	bad_stab (orig);
		2356	return FALSE;
		2357	}
		2358	++*pp;
		2359
		2360	type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
		2361	(debug_type **) NULL);
		2362	if (**pp != ',')
		2363	{
		2364	bad_stab (orig);
		2365	return FALSE;
		2366	}
		2367	++*pp;
		2368
		2369	bitpos = parse_number (pp, (bfd_boolean *) NULL);
		2370	if (**pp != ';')
		2371	{
		2372	bad_stab (orig);
		2373	return FALSE;
		2374	}
		2375	++*pp;
		2376
		2377	*retp = debug_make_field (dhandle, name, type, bitpos, 0,
		2378	DEBUG_VISIBILITY_PRIVATE);
		2379	if (*retp == DEBUG_FIELD_NULL)
		2380	return FALSE;
		2381
		2382	return TRUE;
		2383	}
		2384
		2385	/* Parse a single field in a struct or union. */
		2386
		2387	static bfd_boolean
		2388	parse_stab_one_struct_field (void dhandle, struct stab_handle info,
		2389	const char *pp, const char p,
		2390	debug_field retp, bfd_boolean staticsp)
		2391	{
		2392	const char *orig;
		2393	char *name;
		2394	enum debug_visibility visibility;
		2395	debug_type type;
		2396	bfd_vma bitpos;
		2397	bfd_vma bitsize;
		2398
		2399	orig = *pp;
		2400
		2401	/* FIXME: gdb checks ARM_DEMANGLING here. */
		2402
		2403	name = savestring (pp, p - pp);
		2404
		2405	*pp = p + 1;
		2406
		2407	if (**pp != '/')
		2408	visibility = DEBUG_VISIBILITY_PUBLIC;
		2409	else
		2410	{
		2411	++*pp;
		2412	switch (**pp)
		2413	{
		2414	case '0':
		2415	visibility = DEBUG_VISIBILITY_PRIVATE;
		2416	break;
		2417	case '1':
		2418	visibility = DEBUG_VISIBILITY_PROTECTED;
		2419	break;
		2420	case '2':
		2421	visibility = DEBUG_VISIBILITY_PUBLIC;
		2422	break;
		2423	default:
		2424	warn_stab (orig, _("unknown visibility character for field"));
		2425	visibility = DEBUG_VISIBILITY_PUBLIC;
		2426	break;
		2427	}
		2428	++*pp;
		2429	}
		2430
		2431	type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
		2432	(debug_type **) NULL);
		2433	if (type == DEBUG_TYPE_NULL)
		2434	{
		2435	free (name);
		2436	return FALSE;
		2437	}
		2438
		2439	if (**pp == ':')
		2440	{
		2441	char *varname;
		2442
		2443	/* This is a static class member. */
		2444	++*pp;
		2445	p = strchr (*pp, ';');
		2446	if (p == NULL)
		2447	{
		2448	bad_stab (orig);
		2449	free (name);
		2450	return FALSE;
		2451	}
		2452
		2453	varname = savestring (pp, p - pp);
		2454
		2455	*pp = p + 1;
		2456
		2457	*retp = debug_make_static_member (dhandle, name, type, varname,
		2458	visibility);
		2459	*staticsp = TRUE;
		2460
		2461	return TRUE;
		2462	}
		2463
		2464	if (**pp != ',')
		2465	{
		2466	bad_stab (orig);
		2467	free (name);
		2468	return FALSE;
		2469	}
		2470	++*pp;
		2471
		2472	bitpos = parse_number (pp, (bfd_boolean *) NULL);
		2473	if (**pp != ',')
		2474	{
		2475	bad_stab (orig);
		2476	free (name);
		2477	return FALSE;
		2478	}
		2479	++*pp;
		2480
		2481	bitsize = parse_number (pp, (bfd_boolean *) NULL);
		2482	if (**pp != ';')
		2483	{
		2484	bad_stab (orig);
		2485	free (name);
		2486	return FALSE;
		2487	}
		2488	++*pp;
		2489
		2490	if (bitpos == 0 && bitsize == 0)
		2491	{
		2492	/* This can happen in two cases: (1) at least for gcc 2.4.5 or
		2493	so, it is a field which has been optimized out. The correct
		2494	stab for this case is to use VISIBILITY_IGNORE, but that is a
		2495	recent invention. (2) It is a 0-size array. For example
		2496	union { int num; char str[0]; } foo. Printing ""
		2497	for str in "p foo" is OK, since foo.str (and thus foo.str[3])
		2498	will continue to work, and a 0-size array as a whole doesn't
		2499	have any contents to print.
		2500
		2501	I suspect this probably could also happen with gcc -gstabs
		2502	(not -gstabs+) for static fields, and perhaps other C++
		2503	extensions. Hopefully few people use -gstabs with gdb, since
		2504	it is intended for dbx compatibility. */
		2505	visibility = DEBUG_VISIBILITY_IGNORE;
		2506	}
		2507
		2508	/* FIXME: gdb does some stuff here to mark fields as unpacked. */
		2509
		2510	*retp = debug_make_field (dhandle, name, type, bitpos, bitsize, visibility);
		2511
		2512	return TRUE;
		2513	}
		2514
		2515	/* Read member function stabs info for C++ classes. The form of each member
		2516	function data is:
		2517
		2518	NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
		2519
		2520	An example with two member functions is:
		2521
		2522	afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
		2523
		2524	For the case of overloaded operators, the format is op$::*.funcs, where
		2525	$ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
		2526	name (such as `+=') and `.' marks the end of the operator name. */
		2527
		2528	static bfd_boolean
		2529	parse_stab_members (void dhandle, struct stab_handle info,
		2530	const char tagname, const char *pp,
		2531	const int typenums, debug_method *retp)
		2532	{
		2533	const char *orig;
		2534	debug_method *methods;
		2535	unsigned int c;
		2536	unsigned int alloc;
		2537	char *name = NULL;
		2538	debug_method_variant *variants = NULL;
		2539	char *argtypes = NULL;
		2540
		2541	*retp = NULL;
		2542
		2543	orig = *pp;
		2544
		2545	alloc = 0;
		2546	methods = NULL;
		2547	c = 0;
		2548
		2549	while (**pp != ';')
		2550	{
		2551	const char *p;
		2552	unsigned int cvars;
		2553	unsigned int allocvars;
		2554	debug_type look_ahead_type;
		2555
		2556	p = strchr (*pp, ':');
		2557	if (p == NULL \|\| p[1] != ':')
		2558	break;
		2559
		2560	/* FIXME: Some systems use something other than '$' here. */
		2561	if ((pp)[0] != 'o' \|\| (pp)[1] != 'p' \|\| (*pp)[2] != '$')
		2562	{
		2563	name = savestring (pp, p - pp);
		2564	*pp = p + 2;
		2565	}
		2566	else
		2567	{
		2568	/* This is a completely weird case. In order to stuff in the
		2569	names that might contain colons (the usual name delimiter),
		2570	Mike Tiemann defined a different name format which is
		2571	signalled if the identifier is "op$". In that case, the
		2572	format is "op$::XXXX." where XXXX is the name. This is
		2573	used for names like "+" or "=". YUUUUUUUK! FIXME! */
		2574	*pp = p + 2;
		2575	for (p = pp; p != '.' && *p != '\0'; p++)
		2576	;
		2577	if (*p != '.')
		2578	{
		2579	bad_stab (orig);
		2580	goto fail;
		2581	}
		2582	name = savestring (pp, p - pp);
		2583	*pp = p + 1;
		2584	}
		2585
		2586	allocvars = 10;
		2587	variants = ((debug_method_variant *)
		2588	xmalloc (allocvars * sizeof *variants));
		2589	cvars = 0;
		2590
		2591	look_ahead_type = DEBUG_TYPE_NULL;
		2592
		2593	do
		2594	{
		2595	debug_type type;
		2596	bfd_boolean stub;
		2597	enum debug_visibility visibility;
		2598	bfd_boolean constp, volatilep, staticp;
		2599	bfd_vma voffset;
		2600	debug_type context;
		2601	const char *physname;
		2602	bfd_boolean varargs;
		2603
		2604	if (look_ahead_type != DEBUG_TYPE_NULL)
		2605	{
		2606	/* g++ version 1 kludge */
		2607	type = look_ahead_type;
		2608	look_ahead_type = DEBUG_TYPE_NULL;
		2609	}
		2610	else
		2611	{
		2612	type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
		2613	(debug_type **) NULL);
		2614	if (type == DEBUG_TYPE_NULL)
		2615	goto fail;
		2616
		2617	if (**pp != ':')
		2618	{
		2619	bad_stab (orig);
		2620	goto fail;
		2621	}
		2622	}
		2623
		2624	++*pp;
		2625	p = strchr (*pp, ';');
		2626	if (p == NULL)
		2627	{
		2628	bad_stab (orig);
		2629	goto fail;
		2630	}
		2631
		2632	stub = FALSE;
		2633	if (debug_get_type_kind (dhandle, type) == DEBUG_KIND_METHOD
		2634	&& debug_get_parameter_types (dhandle, type, &varargs) == NULL)
		2635	stub = TRUE;
		2636
		2637	argtypes = savestring (pp, p - pp);
		2638	*pp = p + 1;
		2639
		2640	switch (**pp)
		2641	{
		2642	case '0':
		2643	visibility = DEBUG_VISIBILITY_PRIVATE;
		2644	break;
		2645	case '1':
		2646	visibility = DEBUG_VISIBILITY_PROTECTED;
		2647	break;
		2648	default:
		2649	visibility = DEBUG_VISIBILITY_PUBLIC;
		2650	break;
		2651	}
		2652	++*pp;
		2653
		2654	constp = FALSE;
		2655	volatilep = FALSE;
		2656	switch (**pp)
		2657	{
		2658	case 'A':
		2659	/* Normal function. */
		2660	++*pp;
		2661	break;
		2662	case 'B':
		2663	/* const member function. */
		2664	constp = TRUE;
		2665	++*pp;
		2666	break;
		2667	case 'C':
		2668	/* volatile member function. */
		2669	volatilep = TRUE;
		2670	++*pp;
		2671	break;
		2672	case 'D':
		2673	/* const volatile member function. */
		2674	constp = TRUE;
		2675	volatilep = TRUE;
		2676	++*pp;
		2677	break;
		2678	case '*':
		2679	case '?':
		2680	case '.':
		2681	/* File compiled with g++ version 1; no information. */
		2682	break;
		2683	default:
		2684	warn_stab (orig, _("const/volatile indicator missing"));
		2685	break;
		2686	}
		2687
		2688	staticp = FALSE;
		2689	switch (**pp)
		2690	{
		2691	case '*':
		2692	/* virtual member function, followed by index. The sign
		2693	bit is supposedly set to distinguish
		2694	pointers-to-methods from virtual function indicies. */
		2695	++*pp;
		2696	voffset = parse_number (pp, (bfd_boolean *) NULL);
		2697	if (**pp != ';')
		2698	{
		2699	bad_stab (orig);
		2700	goto fail;
		2701	}
		2702	++*pp;
		2703	voffset &= 0x7fffffff;
		2704
		2705	if (*pp == ';' \|\| pp == '\0')
		2706	{
		2707	/* Must be g++ version 1. */
		2708	context = DEBUG_TYPE_NULL;
		2709	}
		2710	else
		2711	{
		2712	/* Figure out from whence this virtual function
		2713	came. It may belong to virtual function table of
		2714	one of its baseclasses. */
		2715	look_ahead_type = parse_stab_type (dhandle, info,
		2716	(const char *) NULL,
		2717	pp,
		2718	(debug_type **) NULL);
		2719	if (**pp == ':')
		2720	{
		2721	/* g++ version 1 overloaded methods. */
		2722	context = DEBUG_TYPE_NULL;
		2723	}
		2724	else
		2725	{
		2726	context = look_ahead_type;
		2727	look_ahead_type = DEBUG_TYPE_NULL;
		2728	if (**pp != ';')
		2729	{
		2730	bad_stab (orig);
		2731	goto fail;
		2732	}
		2733	++*pp;
		2734	}
		2735	}
		2736	break;
		2737
		2738	case '?':
		2739	/* static member function. */
		2740	++*pp;
		2741	staticp = TRUE;
		2742	voffset = 0;
		2743	context = DEBUG_TYPE_NULL;
		2744	if (strncmp (argtypes, name, strlen (name)) != 0)
		2745	stub = TRUE;
		2746	break;
		2747
		2748	default:
		2749	warn_stab (orig, "member function type missing");
		2750	voffset = 0;
		2751	context = DEBUG_TYPE_NULL;
		2752	break;
		2753
		2754	case '.':
		2755	++*pp;
		2756	voffset = 0;
		2757	context = DEBUG_TYPE_NULL;
		2758	break;
		2759	}
		2760
		2761	/* If the type is not a stub, then the argtypes string is
		2762	the physical name of the function. Otherwise the
		2763	argtypes string is the mangled form of the argument
		2764	types, and the full type and the physical name must be
		2765	extracted from them. */
		2766	physname = argtypes;
		2767	if (stub)
		2768	{
		2769	debug_type class_type, return_type;
		2770
		2771	class_type = stab_find_type (dhandle, info, typenums);
		2772	if (class_type == DEBUG_TYPE_NULL)
		2773	goto fail;
		2774	return_type = debug_get_return_type (dhandle, type);
		2775	if (return_type == DEBUG_TYPE_NULL)
		2776	{
		2777	bad_stab (orig);
		2778	goto fail;
		2779	}
		2780	type = parse_stab_argtypes (dhandle, info, class_type, name,
		2781	tagname, return_type, argtypes,
		2782	constp, volatilep, &physname);
		2783	if (type == DEBUG_TYPE_NULL)
		2784	goto fail;
		2785	}
		2786
		2787	if (cvars + 1 >= allocvars)
		2788	{
		2789	allocvars += 10;
		2790	variants = ((debug_method_variant *)
		2791	xrealloc (variants,
		2792	allocvars * sizeof *variants));
		2793	}
		2794
		2795	if (! staticp)
		2796	variants[cvars] = debug_make_method_variant (dhandle, physname,
		2797	type, visibility,
		2798	constp, volatilep,
		2799	voffset, context);
		2800	else
		2801	variants[cvars] = debug_make_static_method_variant (dhandle,
		2802	physname,
		2803	type,
		2804	visibility,
		2805	constp,
		2806	volatilep);
		2807	if (variants[cvars] == DEBUG_METHOD_VARIANT_NULL)
		2808	goto fail;
		2809
		2810	++cvars;
		2811	}
		2812	while (pp != ';' && pp != '\0');
		2813
		2814	variants[cvars] = DEBUG_METHOD_VARIANT_NULL;
		2815
		2816	if (**pp != '\0')
		2817	++*pp;
		2818
		2819	if (c + 1 >= alloc)
		2820	{
		2821	alloc += 10;
		2822	methods = ((debug_method *)
		2823	xrealloc (methods, alloc * sizeof *methods));
		2824	}
		2825
		2826	methods[c] = debug_make_method (dhandle, name, variants);
		2827
		2828	++c;
		2829	}
		2830
		2831	if (methods != NULL)
		2832	methods[c] = DEBUG_METHOD_NULL;
		2833
		2834	*retp = methods;
		2835
		2836	return TRUE;
		2837
		2838	fail:
		2839	if (name != NULL)
		2840	free (name);
		2841	if (variants != NULL)
		2842	free (variants);
		2843	if (argtypes != NULL)
		2844	free (argtypes);
		2845	return FALSE;
		2846	}
		2847
		2848	/* Parse a string representing argument types for a method. Stabs
		2849	tries to save space by packing argument types into a mangled
		2850	string. This string should give us enough information to extract
		2851	both argument types and the physical name of the function, given
		2852	the tag name. */
		2853
		2854	static debug_type
		2855	parse_stab_argtypes (void dhandle, struct stab_handle info,
		2856	debug_type class_type, const char *fieldname,
		2857	const char *tagname, debug_type return_type,
		2858	const char *argtypes, bfd_boolean constp,
		2859	bfd_boolean volatilep, const char **pphysname)
		2860	{
		2861	bfd_boolean is_full_physname_constructor;
		2862	bfd_boolean is_constructor;
		2863	bfd_boolean is_destructor;
		2864	bfd_boolean is_v3;
		2865	debug_type *args;
		2866	bfd_boolean varargs;
		2867	unsigned int physname_len = 0;
		2868
		2869	/* Constructors are sometimes handled specially. */
		2870	is_full_physname_constructor = ((argtypes[0] == '_'
		2871	&& argtypes[1] == '_'
		2872	&& (ISDIGIT (argtypes[2])
		2873	\|\| argtypes[2] == 'Q'
		2874	\|\| argtypes[2] == 't'))
		2875	\|\| CONST_STRNEQ (argtypes, "__ct"));
		2876
		2877	is_constructor = (is_full_physname_constructor
		2878	\|\| (tagname != NULL
		2879	&& strcmp (fieldname, tagname) == 0));
		2880	is_destructor = ((argtypes[0] == '_'
		2881	&& (argtypes[1] == '$' \|\| argtypes[1] == '.')
		2882	&& argtypes[2] == '_')
		2883	\|\| CONST_STRNEQ (argtypes, "__dt"));
		2884	is_v3 = argtypes[0] == '_' && argtypes[1] == 'Z';
		2885
		2886	if (!(is_destructor \|\| is_full_physname_constructor \|\| is_v3))
		2887	{
		2888	unsigned int len;
		2889	const char *const_prefix;
		2890	const char *volatile_prefix;
		2891	char buf[20];
		2892	unsigned int mangled_name_len;
		2893	char *physname;
		2894
		2895	len = tagname == NULL ? 0 : strlen (tagname);
		2896	const_prefix = constp ? "C" : "";
		2897	volatile_prefix = volatilep ? "V" : "";
		2898
		2899	if (len == 0)
		2900	sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
		2901	else if (tagname != NULL && strchr (tagname, '<') != NULL)
		2902	{
		2903	/* Template methods are fully mangled. */
		2904	sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
		2905	tagname = NULL;
		2906	len = 0;
		2907	}
		2908	else
		2909	sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
		2910
		2911	mangled_name_len = ((is_constructor ? 0 : strlen (fieldname))
		2912	+ strlen (buf)
		2913	+ len
		2914	+ strlen (argtypes)
		2915	+ 1);
		2916
		2917	if (fieldname[0] == 'o'
		2918	&& fieldname[1] == 'p'
		2919	&& (fieldname[2] == '$' \|\| fieldname[2] == '.'))
		2920	{
		2921	const char *opname;
		2922
		2923	opname = cplus_mangle_opname (fieldname + 3, 0);
		2924	if (opname == NULL)
		2925	{
		2926	fprintf (stderr, _("No mangling for \"%s\"\n"), fieldname);
		2927	return DEBUG_TYPE_NULL;
		2928	}
		2929	mangled_name_len += strlen (opname);
		2930	physname = (char *) xmalloc (mangled_name_len);
		2931	strncpy (physname, fieldname, 3);
		2932	strcpy (physname + 3, opname);
		2933	}
		2934	else
		2935	{
		2936	physname = (char *) xmalloc (mangled_name_len);
		2937	if (is_constructor)
		2938	physname[0] = '\0';
		2939	else
		2940	strcpy (physname, fieldname);
		2941	}
		2942
		2943	physname_len = strlen (physname);
		2944	strcat (physname, buf);
		2945	if (tagname != NULL)
		2946	strcat (physname, tagname);
		2947	strcat (physname, argtypes);
		2948
		2949	*pphysname = physname;
		2950	}
		2951
		2952	if (*argtypes == '\0' \|\| is_destructor)
		2953	{
		2954	args = (debug_type ) xmalloc (sizeof args);
		2955	*args = NULL;
		2956	return debug_make_method_type (dhandle, return_type, class_type, args,
		2957	FALSE);
		2958	}
		2959
		2960	args = stab_demangle_argtypes (dhandle, info, *pphysname, &varargs, physname_len);
		2961	if (args == NULL)
		2962	return DEBUG_TYPE_NULL;
		2963
		2964	return debug_make_method_type (dhandle, return_type, class_type, args,
		2965	varargs);
		2966	}
		2967
		2968	/* The tail end of stabs for C++ classes that contain a virtual function
		2969	pointer contains a tilde, a %, and a type number.
		2970	The type number refers to the base class (possibly this class itself) which
		2971	contains the vtable pointer for the current class.
		2972
		2973	This function is called when we have parsed all the method declarations,
		2974	so we can look for the vptr base class info. */
		2975
		2976	static bfd_boolean
		2977	parse_stab_tilde_field (void dhandle, struct stab_handle info,
		2978	const char *pp, const int typenums,
		2979	debug_type retvptrbase, bfd_boolean retownvptr)
		2980	{
		2981	const char *orig;
		2982	const char *hold;
		2983	int vtypenums[2];
		2984
		2985	*retvptrbase = DEBUG_TYPE_NULL;
		2986	*retownvptr = FALSE;
		2987
		2988	orig = *pp;
		2989
		2990	/* If we are positioned at a ';', then skip it. */
		2991	if (**pp == ';')
		2992	++*pp;
		2993
		2994	if (**pp != '~')
		2995	return TRUE;
		2996
		2997	++*pp;
		2998
		2999	if (pp == '=' \|\| pp == '+' \|\| **pp == '-')
		3000	{
		3001	/* Obsolete flags that used to indicate the presence of
		3002	constructors and/or destructors. */
		3003	++*pp;
		3004	}
		3005
		3006	if (**pp != '%')
		3007	return TRUE;
		3008
		3009	++*pp;
		3010
		3011	hold = *pp;
		3012
		3013	/* The next number is the type number of the base class (possibly
		3014	our own class) which supplies the vtable for this class. */
		3015	if (! parse_stab_type_number (pp, vtypenums))
		3016	return FALSE;
		3017
		3018	if (vtypenums[0] == typenums[0]
		3019	&& vtypenums[1] == typenums[1])
		3020	*retownvptr = TRUE;
		3021	else
		3022	{
		3023	debug_type vtype;
		3024	const char *p;
		3025
		3026	*pp = hold;
		3027
		3028	vtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
		3029	(debug_type **) NULL);
		3030	for (p = pp; p != ';' && *p != '\0'; p++)
		3031	;
		3032	if (*p != ';')
		3033	{
		3034	bad_stab (orig);
		3035	return FALSE;
		3036	}
		3037
		3038	*retvptrbase = vtype;
		3039
		3040	*pp = p + 1;
		3041	}
		3042
		3043	return TRUE;
		3044	}
		3045
		3046	/* Read a definition of an array type. */
		3047
		3048	static debug_type
		3049	parse_stab_array_type (void dhandle, struct stab_handle info,
		3050	const char **pp, bfd_boolean stringp)
		3051	{
		3052	const char *orig;
		3053	const char *p;
		3054	int typenums[2];
		3055	debug_type index_type;
		3056	bfd_boolean adjustable;
		3057	bfd_signed_vma lower, upper;
		3058	debug_type element_type;
		3059
		3060	/* Format of an array type:
		3061	"ar;lower;upper;".
		3062	OS9000: "arlower,upper;".
		3063
		3064	Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
		3065	for these, produce a type like float[][]. */
		3066
		3067	orig = *pp;
		3068
		3069	/* FIXME: gdb checks os9k_stabs here. */
		3070
		3071	/* If the index type is type 0, we take it as int. */
		3072	p = *pp;
		3073	if (! parse_stab_type_number (&p, typenums))
		3074	return DEBUG_TYPE_NULL;
		3075	if (typenums[0] == 0 && typenums[1] == 0 && **pp != '=')
		3076	{
		3077	index_type = debug_find_named_type (dhandle, "int");
		3078	if (index_type == DEBUG_TYPE_NULL)
		3079	{
		3080	index_type = debug_make_int_type (dhandle, 4, FALSE);
		3081	if (index_type == DEBUG_TYPE_NULL)
		3082	return DEBUG_TYPE_NULL;
		3083	}
		3084	*pp = p;
		3085	}
		3086	else
		3087	{
		3088	index_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
		3089	(debug_type **) NULL);
		3090	}
		3091
		3092	if (**pp != ';')
		3093	{
		3094	bad_stab (orig);
		3095	return DEBUG_TYPE_NULL;
		3096	}
		3097	++*pp;
		3098
		3099	adjustable = FALSE;
		3100
		3101	if (! ISDIGIT (pp) && pp != '-')
		3102	{
		3103	++*pp;
		3104	adjustable = TRUE;
		3105	}
		3106
		3107	lower = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
		3108	if (**pp != ';')
		3109	{
		3110	bad_stab (orig);
		3111	return DEBUG_TYPE_NULL;
		3112	}
		3113	++*pp;
		3114
		3115	if (! ISDIGIT (pp) && pp != '-')
		3116	{
		3117	++*pp;
		3118	adjustable = TRUE;
		3119	}
		3120
		3121	upper = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
		3122	if (**pp != ';')
		3123	{
		3124	bad_stab (orig);
		3125	return DEBUG_TYPE_NULL;
		3126	}
		3127	++*pp;
		3128
		3129	element_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
		3130	(debug_type **) NULL);
		3131	if (element_type == DEBUG_TYPE_NULL)
		3132	return DEBUG_TYPE_NULL;
		3133
		3134	if (adjustable)
		3135	{
		3136	lower = 0;
		3137	upper = -1;
		3138	}
		3139
		3140	return debug_make_array_type (dhandle, element_type, index_type, lower,
		3141	upper, stringp);
		3142	}
		3143
		3144	/* This struct holds information about files we have seen using
		3145	N_BINCL. */
		3146
		3147	struct bincl_file
		3148	{
		3149	/* The next N_BINCL file. */
		3150	struct bincl_file *next;
		3151	/* The next N_BINCL on the stack. */
		3152	struct bincl_file *next_stack;
		3153	/* The file name. */
		3154	const char *name;
		3155	/* The hash value. */
		3156	bfd_vma hash;
		3157	/* The file index. */
		3158	unsigned int file;
		3159	/* The list of types defined in this file. */
		3160	struct stab_types *file_types;
		3161	};
		3162
		3163	/* Start a new N_BINCL file, pushing it onto the stack. */
		3164
		3165	static void
		3166	push_bincl (struct stab_handle info, const char name, bfd_vma hash)
		3167	{
		3168	struct bincl_file *n;
		3169
		3170	n = (struct bincl_file ) xmalloc (sizeof n);
		3171	n->next = info->bincl_list;
		3172	n->next_stack = info->bincl_stack;
		3173	n->name = name;
		3174	n->hash = hash;
		3175	n->file = info->files;
		3176	n->file_types = NULL;
		3177	info->bincl_list = n;
		3178	info->bincl_stack = n;
		3179
		3180	++info->files;
		3181	info->file_types = ((struct stab_types **)
		3182	xrealloc (info->file_types,
		3183	(info->files
		3184	* sizeof *info->file_types)));
		3185	info->file_types[n->file] = NULL;
		3186	}
		3187
		3188	/* Finish an N_BINCL file, at an N_EINCL, popping the name off the
		3189	stack. */
		3190
		3191	static const char *
		3192	pop_bincl (struct stab_handle *info)
		3193	{
		3194	struct bincl_file *o;
		3195
		3196	o = info->bincl_stack;
		3197	if (o == NULL)
		3198	return info->main_filename;
		3199	info->bincl_stack = o->next_stack;
		3200
		3201	o->file_types = info->file_types[o->file];
		3202
		3203	if (info->bincl_stack == NULL)
		3204	return info->main_filename;
		3205	return info->bincl_stack->name;
		3206	}
		3207
		3208	/* Handle an N_EXCL: get the types from the corresponding N_BINCL. */
		3209
		3210	static bfd_boolean
		3211	find_excl (struct stab_handle info, const char name, bfd_vma hash)
		3212	{
		3213	struct bincl_file *l;
		3214
		3215	++info->files;
		3216	info->file_types = ((struct stab_types **)
		3217	xrealloc (info->file_types,
		3218	(info->files
		3219	* sizeof *info->file_types)));
		3220
		3221	for (l = info->bincl_list; l != NULL; l = l->next)
		3222	if (l->hash == hash && strcmp (l->name, name) == 0)
		3223	break;
		3224	if (l == NULL)
		3225	{
		3226	warn_stab (name, _("Undefined N_EXCL"));
		3227	info->file_types[info->files - 1] = NULL;
		3228	return TRUE;
		3229	}
		3230
		3231	info->file_types[info->files - 1] = l->file_types;
		3232
		3233	return TRUE;
		3234	}
		3235
		3236	/* Handle a variable definition. gcc emits variable definitions for a
		3237	block before the N_LBRAC, so we must hold onto them until we see
		3238	it. The SunPRO compiler emits variable definitions after the
		3239	N_LBRAC, so we can call debug_record_variable immediately. */
		3240
		3241	static bfd_boolean
		3242	stab_record_variable (void dhandle, struct stab_handle info,
		3243	const char *name, debug_type type,
		3244	enum debug_var_kind kind, bfd_vma val)
		3245	{
		3246	struct stab_pending_var *v;
		3247
		3248	if ((kind == DEBUG_GLOBAL \|\| kind == DEBUG_STATIC)
		3249	\|\| ! info->within_function
		3250	\|\| (info->gcc_compiled == 0 && info->n_opt_found))
		3251	return debug_record_variable (dhandle, name, type, kind, val);
		3252
		3253	v = (struct stab_pending_var ) xmalloc (sizeof v);
		3254	memset (v, 0, sizeof *v);
		3255
		3256	v->next = info->pending;
		3257	v->name = name;
		3258	v->type = type;
		3259	v->kind = kind;
		3260	v->val = val;
		3261	info->pending = v;
		3262
		3263	return TRUE;
		3264	}
		3265
		3266	/* Emit pending variable definitions. This is called after we see the
		3267	N_LBRAC that starts the block. */
		3268
		3269	static bfd_boolean
		3270	stab_emit_pending_vars (void dhandle, struct stab_handle info)
		3271	{
		3272	struct stab_pending_var *v;
		3273
		3274	v = info->pending;
		3275	while (v != NULL)
		3276	{
		3277	struct stab_pending_var *next;
		3278
		3279	if (! debug_record_variable (dhandle, v->name, v->type, v->kind, v->val))
		3280	return FALSE;
		3281
		3282	next = v->next;
		3283	free (v);
		3284	v = next;
		3285	}
		3286
		3287	info->pending = NULL;
		3288
		3289	return TRUE;
		3290	}
		3291
		3292	/* Find the slot for a type in the database. */
		3293
		3294	static debug_type *
		3295	stab_find_slot (struct stab_handle info, const int typenums)
		3296	{
		3297	int filenum;
		3298	int tindex;
		3299	struct stab_types **ps;
		3300
		3301	filenum = typenums[0];
		3302	tindex = typenums[1];
		3303
		3304	if (filenum < 0 \|\| (unsigned int) filenum >= info->files)
		3305	{
		3306	fprintf (stderr, _("Type file number %d out of range\n"), filenum);
		3307	return NULL;
		3308	}
		3309	if (tindex < 0)
		3310	{
		3311	fprintf (stderr, _("Type index number %d out of range\n"), tindex);
		3312	return NULL;
		3313	}
		3314
		3315	ps = info->file_types + filenum;
		3316
		3317	while (tindex >= STAB_TYPES_SLOTS)
		3318	{
		3319	if (*ps == NULL)
		3320	{
		3321	ps = (struct stab_types ) xmalloc (sizeof **ps);
		3322	memset (ps, 0, sizeof *ps);
		3323	}
		3324	ps = &(*ps)->next;
		3325	tindex -= STAB_TYPES_SLOTS;
		3326	}
		3327	if (*ps == NULL)
		3328	{
		3329	ps = (struct stab_types ) xmalloc (sizeof **ps);
		3330	memset (ps, 0, sizeof *ps);
		3331	}
		3332
		3333	return (*ps)->types + tindex;
		3334	}
		3335
		3336	/* Find a type given a type number. If the type has not been
		3337	allocated yet, create an indirect type. */
		3338
		3339	static debug_type
		3340	stab_find_type (void dhandle, struct stab_handle info, const int *typenums)
		3341	{
		3342	debug_type *slot;
		3343
		3344	if (typenums[0] == 0 && typenums[1] < 0)
		3345	{
		3346	/* A negative type number indicates an XCOFF builtin type. */
		3347	return stab_xcoff_builtin_type (dhandle, info, typenums[1]);
		3348	}
		3349
		3350	slot = stab_find_slot (info, typenums);
		3351	if (slot == NULL)
		3352	return DEBUG_TYPE_NULL;
		3353
		3354	if (*slot == DEBUG_TYPE_NULL)
		3355	return debug_make_indirect_type (dhandle, slot, (const char *) NULL);
		3356
		3357	return *slot;
		3358	}
		3359
		3360	/* Record that a given type number refers to a given type. */
		3361
		3362	static bfd_boolean
		3363	stab_record_type (void dhandle ATTRIBUTE_UNUSED, struct stab_handle info,
		3364	const int *typenums, debug_type type)
		3365	{
		3366	debug_type *slot;
		3367
		3368	slot = stab_find_slot (info, typenums);
		3369	if (slot == NULL)
		3370	return FALSE;
		3371
		3372	/* gdb appears to ignore type redefinitions, so we do as well. */
		3373
		3374	*slot = type;
		3375
		3376	return TRUE;
		3377	}
		3378
		3379	/* Return an XCOFF builtin type. */
		3380
		3381	static debug_type
		3382	stab_xcoff_builtin_type (void dhandle, struct stab_handle info,
		3383	int typenum)
		3384	{
		3385	debug_type rettype;
		3386	const char *name;
		3387
		3388	if (typenum >= 0 \|\| typenum < -XCOFF_TYPE_COUNT)
		3389	{
		3390	fprintf (stderr, _("Unrecognized XCOFF type %d\n"), typenum);
		3391	return DEBUG_TYPE_NULL;
		3392	}
		3393	if (info->xcoff_types[-typenum] != NULL)
		3394	return info->xcoff_types[-typenum];
		3395
		3396	switch (-typenum)
		3397	{
		3398	case 1:
		3399	/* The size of this and all the other types are fixed, defined
		3400	by the debugging format. */
		3401	name = "int";
		3402	rettype = debug_make_int_type (dhandle, 4, FALSE);
		3403	break;
		3404	case 2:
		3405	name = "char";
		3406	rettype = debug_make_int_type (dhandle, 1, FALSE);
		3407	break;
		3408	case 3:
		3409	name = "short";
		3410	rettype = debug_make_int_type (dhandle, 2, FALSE);
		3411	break;
		3412	case 4:
		3413	name = "long";
		3414	rettype = debug_make_int_type (dhandle, 4, FALSE);
		3415	break;
		3416	case 5:
		3417	name = "unsigned char";
		3418	rettype = debug_make_int_type (dhandle, 1, TRUE);
		3419	break;
		3420	case 6:
		3421	name = "signed char";
		3422	rettype = debug_make_int_type (dhandle, 1, FALSE);
		3423	break;
		3424	case 7:
		3425	name = "unsigned short";
		3426	rettype = debug_make_int_type (dhandle, 2, TRUE);
		3427	break;
		3428	case 8:
		3429	name = "unsigned int";
		3430	rettype = debug_make_int_type (dhandle, 4, TRUE);
		3431	break;
		3432	case 9:
		3433	name = "unsigned";
		3434	rettype = debug_make_int_type (dhandle, 4, TRUE);
		3435	case 10:
		3436	name = "unsigned long";
		3437	rettype = debug_make_int_type (dhandle, 4, TRUE);
		3438	break;
		3439	case 11:
		3440	name = "void";
		3441	rettype = debug_make_void_type (dhandle);
		3442	break;
		3443	case 12:
		3444	/* IEEE single precision (32 bit). */
		3445	name = "float";
		3446	rettype = debug_make_float_type (dhandle, 4);
		3447	break;
		3448	case 13:
		3449	/* IEEE double precision (64 bit). */
		3450	name = "double";
		3451	rettype = debug_make_float_type (dhandle, 8);
		3452	break;
		3453	case 14:
		3454	/* This is an IEEE double on the RS/6000, and different machines
		3455	with different sizes for "long double" should use different
		3456	negative type numbers. See stabs.texinfo. */
		3457	name = "long double";
		3458	rettype = debug_make_float_type (dhandle, 8);
		3459	break;
		3460	case 15:
		3461	name = "integer";
		3462	rettype = debug_make_int_type (dhandle, 4, FALSE);
		3463	break;
		3464	case 16:
		3465	name = "boolean";
		3466	rettype = debug_make_bool_type (dhandle, 4);
		3467	break;
		3468	case 17:
		3469	name = "short real";
		3470	rettype = debug_make_float_type (dhandle, 4);
		3471	break;
		3472	case 18:
		3473	name = "real";
		3474	rettype = debug_make_float_type (dhandle, 8);
		3475	break;
		3476	case 19:
		3477	/* FIXME */
		3478	name = "stringptr";
		3479	rettype = NULL;
		3480	break;
		3481	case 20:
		3482	/* FIXME */
		3483	name = "character";
		3484	rettype = debug_make_int_type (dhandle, 1, TRUE);
		3485	break;
		3486	case 21:
		3487	name = "logical*1";
		3488	rettype = debug_make_bool_type (dhandle, 1);
		3489	break;
		3490	case 22:
		3491	name = "logical*2";
		3492	rettype = debug_make_bool_type (dhandle, 2);
		3493	break;
		3494	case 23:
		3495	name = "logical*4";
		3496	rettype = debug_make_bool_type (dhandle, 4);
		3497	break;
		3498	case 24:
		3499	name = "logical";
		3500	rettype = debug_make_bool_type (dhandle, 4);
		3501	break;
		3502	case 25:
		3503	/* Complex type consisting of two IEEE single precision values. */
		3504	name = "complex";
		3505	rettype = debug_make_complex_type (dhandle, 8);
		3506	break;
		3507	case 26:
		3508	/* Complex type consisting of two IEEE double precision values. */
		3509	name = "double complex";
		3510	rettype = debug_make_complex_type (dhandle, 16);
		3511	break;
		3512	case 27:
		3513	name = "integer*1";
		3514	rettype = debug_make_int_type (dhandle, 1, FALSE);
		3515	break;
		3516	case 28:
		3517	name = "integer*2";
		3518	rettype = debug_make_int_type (dhandle, 2, FALSE);
		3519	break;
		3520	case 29:
		3521	name = "integer*4";
		3522	rettype = debug_make_int_type (dhandle, 4, FALSE);
		3523	break;
		3524	case 30:
		3525	/* FIXME */
		3526	name = "wchar";
		3527	rettype = debug_make_int_type (dhandle, 2, FALSE);
		3528	break;
		3529	case 31:
		3530	name = "long long";
		3531	rettype = debug_make_int_type (dhandle, 8, FALSE);
		3532	break;
		3533	case 32:
		3534	name = "unsigned long long";
		3535	rettype = debug_make_int_type (dhandle, 8, TRUE);
		3536	break;
		3537	case 33:
		3538	name = "logical*8";
		3539	rettype = debug_make_bool_type (dhandle, 8);
		3540	break;
		3541	case 34:
		3542	name = "integer*8";
		3543	rettype = debug_make_int_type (dhandle, 8, FALSE);
		3544	break;
		3545	default:
		3546	abort ();
		3547	}
		3548
		3549	rettype = debug_name_type (dhandle, name, rettype);
		3550
		3551	info->xcoff_types[-typenum] = rettype;
		3552
		3553	return rettype;
		3554	}
		3555
		3556	/* Find or create a tagged type. */
		3557
		3558	static debug_type
		3559	stab_find_tagged_type (void dhandle, struct stab_handle info,
		3560	const char *p, int len, enum debug_type_kind kind)
		3561	{
		3562	char *name;
		3563	debug_type dtype;
		3564	struct stab_tag *st;
		3565
		3566	name = savestring (p, len);
		3567
		3568	/* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same
		3569	namespace. This is right for C, and I don't know how to handle
		3570	other languages. FIXME. */
		3571	dtype = debug_find_tagged_type (dhandle, name, DEBUG_KIND_ILLEGAL);
		3572	if (dtype != DEBUG_TYPE_NULL)
		3573	{
		3574	free (name);
		3575	return dtype;
		3576	}
		3577
		3578	/* We need to allocate an entry on the undefined tag list. */
		3579	for (st = info->tags; st != NULL; st = st->next)
		3580	{
		3581	if (st->name[0] == name[0]
		3582	&& strcmp (st->name, name) == 0)
		3583	{
		3584	if (st->kind == DEBUG_KIND_ILLEGAL)
		3585	st->kind = kind;
		3586	free (name);
		3587	break;
		3588	}
		3589	}
		3590	if (st == NULL)
		3591	{
		3592	st = (struct stab_tag ) xmalloc (sizeof st);
		3593	memset (st, 0, sizeof *st);
		3594
		3595	st->next = info->tags;
		3596	st->name = name;
		3597	st->kind = kind;
		3598	st->slot = DEBUG_TYPE_NULL;
		3599	st->type = debug_make_indirect_type (dhandle, &st->slot, name);
		3600	info->tags = st;
		3601	}
		3602
		3603	return st->type;
		3604	}
		3605
		3606	/* In order to get the correct argument types for a stubbed method, we
		3607	need to extract the argument types from a C++ mangled string.
		3608	Since the argument types can refer back to the return type, this
		3609	means that we must demangle the entire physical name. In gdb this
		3610	is done by calling cplus_demangle and running the results back
		3611	through the C++ expression parser. Since we have no expression
		3612	parser, we must duplicate much of the work of cplus_demangle here.
		3613
		3614	We assume that GNU style demangling is used, since this is only
		3615	done for method stubs, and only g++ should output that form of
		3616	debugging information. */
		3617
		3618	/* This structure is used to hold a pointer to type information which
		3619	demangling a string. */
		3620
		3621	struct stab_demangle_typestring
		3622	{
		3623	/* The start of the type. This is not null terminated. */
		3624	const char *typestring;
		3625	/* The length of the type. */
		3626	unsigned int len;
		3627	};
		3628
		3629	/* This structure is used to hold information while demangling a
		3630	string. */
		3631
		3632	struct stab_demangle_info
		3633	{
		3634	/* The debugging information handle. */
		3635	void *dhandle;
		3636	/* The stab information handle. */
		3637	struct stab_handle *info;
		3638	/* The array of arguments we are building. */
		3639	debug_type *args;
		3640	/* Whether the method takes a variable number of arguments. */
		3641	bfd_boolean varargs;
		3642	/* The array of types we have remembered. */
		3643	struct stab_demangle_typestring *typestrings;
		3644	/* The number of typestrings. */
		3645	unsigned int typestring_count;
		3646	/* The number of typestring slots we have allocated. */
		3647	unsigned int typestring_alloc;
		3648	};
		3649
		3650	static void stab_bad_demangle (const char *);
		3651	static unsigned int stab_demangle_count (const char **);
		3652	static bfd_boolean stab_demangle_get_count (const char *, unsigned int );
		3653	static bfd_boolean stab_demangle_prefix
		3654	(struct stab_demangle_info , const char *, unsigned int);
		3655	static bfd_boolean stab_demangle_function_name
		3656	(struct stab_demangle_info , const char , const char );
		3657	static bfd_boolean stab_demangle_signature
		3658	(struct stab_demangle_info , const char *);
		3659	static bfd_boolean stab_demangle_qualified
		3660	(struct stab_demangle_info , const char , debug_type );
		3661	static bfd_boolean stab_demangle_template
		3662	(struct stab_demangle_info , const char , char *);
		3663	static bfd_boolean stab_demangle_class
		3664	(struct stab_demangle_info , const char , const char *);
		3665	static bfd_boolean stab_demangle_args
		3666	(struct stab_demangle_info , const char , debug_type , bfd_boolean );
		3667	static bfd_boolean stab_demangle_arg
		3668	(struct stab_demangle_info , const char , debug_type *,
		3669	unsigned int , unsigned int );
		3670	static bfd_boolean stab_demangle_type
		3671	(struct stab_demangle_info , const char , debug_type );
		3672	static bfd_boolean stab_demangle_fund_type
		3673	(struct stab_demangle_info , const char , debug_type );
		3674	static bfd_boolean stab_demangle_remember_type
		3675	(struct stab_demangle_info , const char , int);
		3676
		3677	/* Warn about a bad demangling. */
		3678
		3679	static void
		3680	stab_bad_demangle (const char *s)
		3681	{
		3682	fprintf (stderr, _("bad mangled name `%s'\n"), s);
		3683	}
		3684
		3685	/* Get a count from a stab string. */
		3686
		3687	static unsigned int
		3688	stab_demangle_count (const char **pp)
		3689	{
		3690	unsigned int count;
		3691
		3692	count = 0;
		3693	while (ISDIGIT (**pp))
		3694	{
		3695	count *= 10;
		3696	count += **pp - '0';
		3697	++*pp;
		3698	}
		3699	return count;
		3700	}
		3701
		3702	/* Require a count in a string. The count may be multiple digits, in
		3703	which case it must end in an underscore. */
		3704
		3705	static bfd_boolean
		3706	stab_demangle_get_count (const char *pp, unsigned int pi)
		3707	{
		3708	if (! ISDIGIT (**pp))
		3709	return FALSE;
		3710
		3711	pi = *pp - '0';
		3712	++*pp;
		3713	if (ISDIGIT (**pp))
		3714	{
		3715	unsigned int count;
		3716	const char *p;
		3717
		3718	count = *pi;
		3719	p = *pp;
		3720	do
		3721	{
		3722	count *= 10;
		3723	count += *p - '0';
		3724	++p;
		3725	}
		3726	while (ISDIGIT (*p));
		3727	if (*p == '_')
		3728	{
		3729	*pp = p + 1;
		3730	*pi = count;
		3731	}
		3732	}
		3733
		3734	return TRUE;
		3735	}
		3736
		3737	/* This function demangles a physical name, returning a NULL
		3738	terminated array of argument types. */
		3739
		3740	static debug_type *
		3741	stab_demangle_argtypes (void dhandle, struct stab_handle info,
		3742	const char physname, bfd_boolean pvarargs,
		3743	unsigned int physname_len)
		3744	{
		3745	struct stab_demangle_info minfo;
		3746
		3747	/* Check for the g++ V3 ABI. */
		3748	if (physname[0] == '_' && physname[1] == 'Z')
		3749	return stab_demangle_v3_argtypes (dhandle, info, physname, pvarargs);
		3750
		3751	minfo.dhandle = dhandle;
		3752	minfo.info = info;
		3753	minfo.args = NULL;
		3754	minfo.varargs = FALSE;
		3755	minfo.typestring_alloc = 10;
		3756	minfo.typestrings = ((struct stab_demangle_typestring *)
		3757	xmalloc (minfo.typestring_alloc
		3758	* sizeof *minfo.typestrings));
		3759	minfo.typestring_count = 0;
		3760
		3761	/* cplus_demangle checks for special GNU mangled forms, but we can't
		3762	see any of them in mangled method argument types. */
		3763
		3764	if (! stab_demangle_prefix (&minfo, &physname, physname_len))
		3765	goto error_return;
		3766
		3767	if (*physname != '\0')
		3768	{
		3769	if (! stab_demangle_signature (&minfo, &physname))
		3770	goto error_return;
		3771	}
		3772
		3773	free (minfo.typestrings);
		3774	minfo.typestrings = NULL;
		3775
		3776	if (minfo.args == NULL)
		3777	fprintf (stderr, _("no argument types in mangled string\n"));
		3778
		3779	*pvarargs = minfo.varargs;
		3780	return minfo.args;
		3781
		3782	error_return:
		3783	if (minfo.typestrings != NULL)
		3784	free (minfo.typestrings);
		3785	return NULL;
		3786	}
		3787
		3788	/* Demangle the prefix of the mangled name. */
		3789
		3790	static bfd_boolean
		3791	stab_demangle_prefix (struct stab_demangle_info minfo, const char *pp,
		3792	unsigned int physname_len)
		3793	{
		3794	const char *scan;
		3795	unsigned int i;
		3796
		3797	/* cplus_demangle checks for global constructors and destructors,
		3798	but we can't see them in mangled argument types. */
		3799
		3800	if (physname_len)
		3801	scan = *pp + physname_len;
		3802	else
		3803	{
		3804	/* Look for `__'. */
		3805	scan = *pp;
		3806	do
		3807	scan = strchr (scan, '_');
		3808	while (scan != NULL && *++scan != '_');
		3809
		3810	if (scan == NULL)
		3811	{
		3812	stab_bad_demangle (*pp);
		3813	return FALSE;
		3814	}
		3815
		3816	--scan;
		3817
		3818	/* We found `__'; move ahead to the last contiguous `__' pair. */
		3819	i = strspn (scan, "_");
		3820	if (i > 2)
		3821	scan += i - 2;
		3822	}
		3823
		3824	if (scan == *pp
		3825	&& (ISDIGIT (scan[2])
		3826	\|\| scan[2] == 'Q'
		3827	\|\| scan[2] == 't'))
		3828	{
		3829	/* This is a GNU style constructor name. */
		3830	*pp = scan + 2;
		3831	return TRUE;
		3832	}
		3833	else if (scan == *pp
		3834	&& ! ISDIGIT (scan[2])
		3835	&& scan[2] != 't')
		3836	{
		3837	/* Look for the `__' that separates the prefix from the
		3838	signature. */
		3839	while (*scan == '_')
		3840	++scan;
		3841	scan = strstr (scan, "__");
		3842	if (scan == NULL \|\| scan[2] == '\0')
		3843	{
		3844	stab_bad_demangle (*pp);
		3845	return FALSE;
		3846	}
		3847
		3848	return stab_demangle_function_name (minfo, pp, scan);
		3849	}
		3850	else if (scan[2] != '\0')
		3851	{
		3852	/* The name doesn't start with `__', but it does contain `__'. */
		3853	return stab_demangle_function_name (minfo, pp, scan);
		3854	}
		3855	else
		3856	{
		3857	stab_bad_demangle (*pp);
		3858	return FALSE;
		3859	}
		3860	/NOTREACHED/
		3861	}
		3862
		3863	/* Demangle a function name prefix. The scan argument points to the
		3864	double underscore which separates the function name from the
		3865	signature. */
		3866
		3867	static bfd_boolean
		3868	stab_demangle_function_name (struct stab_demangle_info *minfo,
		3869	const char *pp, const char scan)
		3870	{
		3871	const char *name;
		3872
		3873	/* The string from *pp to scan is the name of the function. We
		3874	don't care about the name, since we just looking for argument
		3875	types. However, for conversion operators, the name may include a
		3876	type which we must remember in order to handle backreferences. */
		3877
		3878	name = *pp;
		3879	*pp = scan + 2;
		3880
		3881	if (*pp - name >= 5
		3882	&& CONST_STRNEQ (name, "type")
		3883	&& (name[4] == '$' \|\| name[4] == '.'))
		3884	{
		3885	const char *tem;
		3886
		3887	/* This is a type conversion operator. */
		3888	tem = name + 5;
		3889	if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
		3890	return FALSE;
		3891	}
		3892	else if (name[0] == '_'
		3893	&& name[1] == '_'
		3894	&& name[2] == 'o'
		3895	&& name[3] == 'p')
		3896	{
		3897	const char *tem;
		3898
		3899	/* This is a type conversion operator. */
		3900	tem = name + 4;
		3901	if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
		3902	return FALSE;
		3903	}
		3904
		3905	return TRUE;
		3906	}
		3907
		3908	/* Demangle the signature. This is where the argument types are
		3909	found. */
		3910
		3911	static bfd_boolean
		3912	stab_demangle_signature (struct stab_demangle_info minfo, const char *pp)
		3913	{
		3914	const char *orig;
		3915	bfd_boolean expect_func, func_done;
		3916	const char *hold;
		3917
		3918	orig = *pp;
		3919
		3920	expect_func = FALSE;
		3921	func_done = FALSE;
		3922	hold = NULL;
		3923
		3924	while (**pp != '\0')
		3925	{
		3926	switch (**pp)
		3927	{
		3928	case 'Q':
		3929	hold = *pp;
		3930	if (! stab_demangle_qualified (minfo, pp, (debug_type *) NULL)
		3931	\|\| ! stab_demangle_remember_type (minfo, hold, *pp - hold))
		3932	return FALSE;
		3933	expect_func = TRUE;
		3934	hold = NULL;
		3935	break;
		3936
		3937	case 'S':
		3938	/* Static member function. FIXME: Can this happen? */
		3939	if (hold == NULL)
		3940	hold = *pp;
		3941	++*pp;
		3942	break;
		3943
		3944	case 'C':
		3945	/* Const member function. */
		3946	if (hold == NULL)
		3947	hold = *pp;
		3948	++*pp;
		3949	break;
		3950
		3951	case '0': case '1': case '2': case '3': case '4':
		3952	case '5': case '6': case '7': case '8': case '9':
		3953	if (hold == NULL)
		3954	hold = *pp;
		3955	if (! stab_demangle_class (minfo, pp, (const char **) NULL)
		3956	\|\| ! stab_demangle_remember_type (minfo, hold, *pp - hold))
		3957	return FALSE;
		3958	expect_func = TRUE;
		3959	hold = NULL;
		3960	break;
		3961
		3962	case 'F':
		3963	/* Function. I don't know if this actually happens with g++
		3964	output. */
		3965	hold = NULL;
		3966	func_done = TRUE;
		3967	++*pp;
		3968	if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
		3969	return FALSE;
		3970	break;
		3971
		3972	case 't':
		3973	/* Template. */
		3974	if (hold == NULL)
		3975	hold = *pp;
		3976	if (! stab_demangle_template (minfo, pp, (char **) NULL)
		3977	\|\| ! stab_demangle_remember_type (minfo, hold, *pp - hold))
		3978	return FALSE;
		3979	hold = NULL;
		3980	expect_func = TRUE;
		3981	break;
		3982
		3983	case '_':
		3984	/* At the outermost level, we cannot have a return type
		3985	specified, so if we run into another '_' at this point we
		3986	are dealing with a mangled name that is either bogus, or
		3987	has been mangled by some algorithm we don't know how to
		3988	deal with. So just reject the entire demangling. */
		3989	stab_bad_demangle (orig);
		3990	return FALSE;
		3991
		3992	default:
		3993	/* Assume we have stumbled onto the first outermost function
		3994	argument token, and start processing args. */
		3995	func_done = TRUE;
		3996	if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
		3997	return FALSE;
		3998	break;
		3999	}
		4000
		4001	if (expect_func)
		4002	{
		4003	func_done = TRUE;
		4004	if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
		4005	return FALSE;
		4006	}
		4007	}
		4008
		4009	if (! func_done)
		4010	{
		4011	/* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
		4012	bar__3fooi is 'foo::bar(int)'. We get here when we find the
		4013	first case, and need to ensure that the '(void)' gets added
		4014	to the current declp. */
		4015	if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
		4016	return FALSE;
		4017	}
		4018
		4019	return TRUE;
		4020	}
		4021
		4022	/* Demangle a qualified name, such as "Q25Outer5Inner" which is the
		4023	mangled form of "Outer::Inner". */
		4024
		4025	static bfd_boolean
		4026	stab_demangle_qualified (struct stab_demangle_info minfo, const char *pp,
		4027	debug_type *ptype)
		4028	{
		4029	const char *orig;
		4030	const char *p;
		4031	unsigned int qualifiers;
		4032	debug_type context;
		4033
		4034	orig = *pp;
		4035
		4036	switch ((*pp)[1])
		4037	{
		4038	case '_':
		4039	/* GNU mangled name with more than 9 classes. The count is
		4040	preceded by an underscore (to distinguish it from the <= 9
		4041	case) and followed by an underscore. */
		4042	p = *pp + 2;
		4043	if (! ISDIGIT (p) \|\| p == '0')
		4044	{
		4045	stab_bad_demangle (orig);
		4046	return FALSE;
		4047	}
		4048	qualifiers = atoi (p);
		4049	while (ISDIGIT (*p))
		4050	++p;
		4051	if (*p != '_')
		4052	{
		4053	stab_bad_demangle (orig);
		4054	return FALSE;
		4055	}
		4056	*pp = p + 1;
		4057	break;
		4058
		4059	case '1': case '2': case '3': case '4': case '5':
		4060	case '6': case '7': case '8': case '9':
		4061	qualifiers = (*pp)[1] - '0';
		4062	/* Skip an optional underscore after the count. */
		4063	if ((*pp)[2] == '_')
		4064	++*pp;
		4065	*pp += 2;
		4066	break;
		4067
		4068	case '0':
		4069	default:
		4070	stab_bad_demangle (orig);
		4071	return FALSE;
		4072	}
		4073
		4074	context = DEBUG_TYPE_NULL;
		4075
		4076	/* Pick off the names. */
		4077	while (qualifiers-- > 0)
		4078	{
		4079	if (**pp == '_')
		4080	++*pp;
		4081	if (**pp == 't')
		4082	{
		4083	char *name;
		4084
		4085	if (! stab_demangle_template (minfo, pp,
		4086	ptype != NULL ? &name : NULL))
		4087	return FALSE;
		4088
		4089	if (ptype != NULL)
		4090	{
		4091	context = stab_find_tagged_type (minfo->dhandle, minfo->info,
		4092	name, strlen (name),
		4093	DEBUG_KIND_CLASS);
		4094	free (name);
		4095	if (context == DEBUG_TYPE_NULL)
		4096	return FALSE;
		4097	}
		4098	}
		4099	else
		4100	{
		4101	unsigned int len;
		4102
		4103	len = stab_demangle_count (pp);
		4104	if (strlen (*pp) < len)
		4105	{
		4106	stab_bad_demangle (orig);
		4107	return FALSE;
		4108	}
		4109
		4110	if (ptype != NULL)
		4111	{
		4112	const debug_field *fields;
		4113
		4114	fields = NULL;
		4115	if (context != DEBUG_TYPE_NULL)
		4116	fields = debug_get_fields (minfo->dhandle, context);
		4117
		4118	context = DEBUG_TYPE_NULL;
		4119
		4120	if (fields != NULL)
		4121	{
		4122	char *name;
		4123
		4124	/* Try to find the type by looking through the
		4125	fields of context until we find a field with the
		4126	same type. This ought to work for a class
		4127	defined within a class, but it won't work for,
		4128	e.g., an enum defined within a class. stabs does
		4129	not give us enough information to figure out the
		4130	latter case. */
		4131
		4132	name = savestring (*pp, len);
		4133
		4134	for (; *fields != DEBUG_FIELD_NULL; fields++)
		4135	{
		4136	debug_type ft;
		4137	const char *dn;
		4138
		4139	ft = debug_get_field_type (minfo->dhandle, *fields);
		4140	if (ft == NULL)
		4141	{
		4142	free (name);
		4143	return FALSE;
		4144	}
		4145	dn = debug_get_type_name (minfo->dhandle, ft);
		4146	if (dn != NULL && strcmp (dn, name) == 0)
		4147	{
		4148	context = ft;
		4149	break;
		4150	}
		4151	}
		4152
		4153	free (name);
		4154	}
		4155
		4156	if (context == DEBUG_TYPE_NULL)
		4157	{
		4158	/* We have to fall back on finding the type by name.
		4159	If there are more types to come, then this must
		4160	be a class. Otherwise, it could be anything. */
		4161
		4162	if (qualifiers == 0)
		4163	{
		4164	char *name;
		4165
		4166	name = savestring (*pp, len);
		4167	context = debug_find_named_type (minfo->dhandle,
		4168	name);
		4169	free (name);
		4170	}
		4171
		4172	if (context == DEBUG_TYPE_NULL)
		4173	{
		4174	context = stab_find_tagged_type (minfo->dhandle,
		4175	minfo->info,
		4176	*pp, len,
		4177	(qualifiers == 0
		4178	? DEBUG_KIND_ILLEGAL
		4179	: DEBUG_KIND_CLASS));
		4180	if (context == DEBUG_TYPE_NULL)
		4181	return FALSE;
		4182	}
		4183	}
		4184	}
		4185
		4186	*pp += len;
		4187	}
		4188	}
		4189
		4190	if (ptype != NULL)
		4191	*ptype = context;
		4192
		4193	return TRUE;
		4194	}
		4195
		4196	/* Demangle a template. If PNAME is not NULL, this sets *PNAME to a
		4197	string representation of the template. */
		4198
		4199	static bfd_boolean
		4200	stab_demangle_template (struct stab_demangle_info minfo, const char *pp,
		4201	char **pname)
		4202	{
		4203	const char *orig;
		4204	unsigned int r, i;
		4205
		4206	orig = *pp;
		4207
		4208	++*pp;
		4209
		4210	/* Skip the template name. */
		4211	r = stab_demangle_count (pp);
		4212	if (r == 0 \|\| strlen (*pp) < r)
		4213	{
		4214	stab_bad_demangle (orig);
		4215	return FALSE;
		4216	}
		4217	*pp += r;
		4218
		4219	/* Get the size of the parameter list. */
		4220	if (stab_demangle_get_count (pp, &r) == 0)
		4221	{
		4222	stab_bad_demangle (orig);
		4223	return FALSE;
		4224	}
		4225
		4226	for (i = 0; i < r; i++)
		4227	{
		4228	if (**pp == 'Z')
		4229	{
		4230	/* This is a type parameter. */
		4231	++*pp;
		4232	if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
		4233	return FALSE;
		4234	}
		4235	else
		4236	{
		4237	const char *old_p;
		4238	bfd_boolean pointerp, realp, integralp, charp, boolp;
		4239	bfd_boolean done;
		4240
		4241	old_p = *pp;
		4242	pointerp = FALSE;
		4243	realp = FALSE;
		4244	integralp = FALSE;
		4245	charp = FALSE;
		4246	boolp = FALSE;
		4247	done = FALSE;
		4248
		4249	/* This is a value parameter. */
		4250
		4251	if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
		4252	return FALSE;
		4253
		4254	while (*old_p != '\0' && ! done)
		4255	{
		4256	switch (*old_p)
		4257	{
		4258	case 'P':
		4259	case 'p':
		4260	case 'R':
		4261	pointerp = TRUE;
		4262	done = TRUE;
		4263	break;
		4264	case 'C': /* Const. */
		4265	case 'S': /* Signed. */
		4266	case 'U': /* Unsigned. */
		4267	case 'V': /* Volatile. */
		4268	case 'F': /* Function. */
		4269	case 'M': /* Member function. */
		4270	case 'O': /* ??? */
		4271	++old_p;
		4272	break;
		4273	case 'Q': /* Qualified name. */
		4274	integralp = TRUE;
		4275	done = TRUE;
		4276	break;
		4277	case 'T': /* Remembered type. */
		4278	abort ();
		4279	case 'v': /* Void. */
		4280	abort ();
		4281	case 'x': /* Long long. */
		4282	case 'l': /* Long. */
		4283	case 'i': /* Int. */
		4284	case 's': /* Short. */
		4285	case 'w': /* Wchar_t. */
		4286	integralp = TRUE;
		4287	done = TRUE;
		4288	break;
		4289	case 'b': /* Bool. */
		4290	boolp = TRUE;
		4291	done = TRUE;
		4292	break;
		4293	case 'c': /* Char. */
		4294	charp = TRUE;
		4295	done = TRUE;
		4296	break;
		4297	case 'r': /* Long double. */
		4298	case 'd': /* Double. */
		4299	case 'f': /* Float. */
		4300	realp = TRUE;
		4301	done = TRUE;
		4302	break;
		4303	default:
		4304	/* Assume it's a user defined integral type. */
		4305	integralp = TRUE;
		4306	done = TRUE;
		4307	break;
		4308	}
		4309	}
		4310
		4311	if (integralp)
		4312	{
		4313	if (**pp == 'm')
		4314	++*pp;
		4315	while (ISDIGIT (**pp))
		4316	++*pp;
		4317	}
		4318	else if (charp)
		4319	{
		4320	unsigned int val;
		4321
		4322	if (**pp == 'm')
		4323	++*pp;
		4324	val = stab_demangle_count (pp);
		4325	if (val == 0)
		4326	{
		4327	stab_bad_demangle (orig);
		4328	return FALSE;
		4329	}
		4330	}
		4331	else if (boolp)
		4332	{
		4333	unsigned int val;
		4334
		4335	val = stab_demangle_count (pp);
		4336	if (val != 0 && val != 1)
		4337	{
		4338	stab_bad_demangle (orig);
		4339	return FALSE;
		4340	}
		4341	}
		4342	else if (realp)
		4343	{
		4344	if (**pp == 'm')
		4345	++*pp;
		4346	while (ISDIGIT (**pp))
		4347	++*pp;
		4348	if (**pp == '.')
		4349	{
		4350	++*pp;
		4351	while (ISDIGIT (**pp))
		4352	++*pp;
		4353	}
		4354	if (**pp == 'e')
		4355	{
		4356	++*pp;
		4357	while (ISDIGIT (**pp))
		4358	++*pp;
		4359	}
		4360	}
		4361	else if (pointerp)
		4362	{
		4363	unsigned int len;
		4364
		4365	len = stab_demangle_count (pp);
		4366	if (len == 0)
		4367	{
		4368	stab_bad_demangle (orig);
		4369	return FALSE;
		4370	}
		4371	*pp += len;
		4372	}
		4373	}
		4374	}
		4375
		4376	/* We can translate this to a string fairly easily by invoking the
		4377	regular demangling routine. */
		4378	if (pname != NULL)
		4379	{
		4380	char s1, s2, s3, s4 = NULL;
		4381	char from, to;
		4382
		4383	s1 = savestring (orig, *pp - orig);
		4384
		4385	s2 = concat ("NoSuchStrinG__", s1, (const char *) NULL);
		4386
		4387	free (s1);
		4388
		4389	s3 = cplus_demangle (s2, DMGL_ANSI);
		4390
		4391	free (s2);
		4392
		4393	if (s3 != NULL)
		4394	s4 = strstr (s3, "::NoSuchStrinG");
		4395	if (s3 == NULL \|\| s4 == NULL)
		4396	{
		4397	stab_bad_demangle (orig);
		4398	if (s3 != NULL)
		4399	free (s3);
		4400	return FALSE;
		4401	}
		4402
		4403	/* Eliminating all spaces, except those between > characters,
		4404	makes it more likely that the demangled name will match the
		4405	name which g++ used as the structure name. */
		4406	for (from = to = s3; from != s4; ++from)
		4407	if (*from != ' '
		4408	\|\| (from[1] == '>' && from > s3 && from[-1] == '>'))
		4409	to++ = from;
		4410
		4411	*pname = savestring (s3, to - s3);
		4412
		4413	free (s3);
		4414	}
		4415
		4416	return TRUE;
		4417	}
		4418
		4419	/* Demangle a class name. */
		4420
		4421	static bfd_boolean
		4422	stab_demangle_class (struct stab_demangle_info *minfo ATTRIBUTE_UNUSED,
		4423	const char pp, const char pstart)
		4424	{
		4425	const char *orig;
		4426	unsigned int n;
		4427
		4428	orig = *pp;
		4429
		4430	n = stab_demangle_count (pp);
		4431	if (strlen (*pp) < n)
		4432	{
		4433	stab_bad_demangle (orig);
		4434	return FALSE;
		4435	}
		4436
		4437	if (pstart != NULL)
		4438	pstart = pp;
		4439
		4440	*pp += n;
		4441
		4442	return TRUE;
		4443	}
		4444
		4445	/* Demangle function arguments. If the pargs argument is not NULL, it
		4446	is set to a NULL terminated array holding the arguments. */
		4447
		4448	static bfd_boolean
		4449	stab_demangle_args (struct stab_demangle_info minfo, const char *pp,
		4450	debug_type *pargs, bfd_boolean pvarargs)
		4451	{
		4452	const char *orig;
		4453	unsigned int alloc, count;
		4454
		4455	orig = *pp;
		4456
		4457	alloc = 10;
		4458	if (pargs != NULL)
		4459	{
		4460	pargs = (debug_type ) xmalloc (alloc * sizeof **pargs);
		4461	*pvarargs = FALSE;
		4462	}
		4463	count = 0;
		4464
		4465	while (pp != '_' && pp != '\0' && **pp != 'e')
		4466	{
		4467	if (pp == 'N' \|\| pp == 'T')
		4468	{
		4469	char temptype;
		4470	unsigned int r, t;
		4471
		4472	temptype = **pp;
		4473	++*pp;
		4474
		4475	if (temptype == 'T')
		4476	r = 1;
		4477	else
		4478	{
		4479	if (! stab_demangle_get_count (pp, &r))
		4480	{
		4481	stab_bad_demangle (orig);
		4482	return FALSE;
		4483	}
		4484	}
		4485
		4486	if (! stab_demangle_get_count (pp, &t))
		4487	{
		4488	stab_bad_demangle (orig);
		4489	return FALSE;
		4490	}
		4491
		4492	if (t >= minfo->typestring_count)
		4493	{
		4494	stab_bad_demangle (orig);
		4495	return FALSE;
		4496	}
		4497	while (r-- > 0)
		4498	{
		4499	const char *tem;
		4500
		4501	tem = minfo->typestrings[t].typestring;
		4502	if (! stab_demangle_arg (minfo, &tem, pargs, &count, &alloc))
		4503	return FALSE;
		4504	}
		4505	}
		4506	else
		4507	{
		4508	if (! stab_demangle_arg (minfo, pp, pargs, &count, &alloc))
		4509	return FALSE;
		4510	}
		4511	}
		4512
		4513	if (pargs != NULL)
		4514	(*pargs)[count] = DEBUG_TYPE_NULL;
		4515
		4516	if (**pp == 'e')
		4517	{
		4518	if (pargs != NULL)
		4519	*pvarargs = TRUE;
		4520	++*pp;
		4521	}
		4522
		4523	return TRUE;
		4524	}
		4525
		4526	/* Demangle a single argument. */
		4527
		4528	static bfd_boolean
		4529	stab_demangle_arg (struct stab_demangle_info minfo, const char *pp,
		4530	debug_type *pargs, unsigned int pcount,
		4531	unsigned int *palloc)
		4532	{
		4533	const char *start;
		4534	debug_type type;
		4535
		4536	start = *pp;
		4537	if (! stab_demangle_type (minfo, pp,
		4538	pargs == NULL ? (debug_type *) NULL : &type)
		4539	\|\| ! stab_demangle_remember_type (minfo, start, *pp - start))
		4540	return FALSE;
		4541
		4542	if (pargs != NULL)
		4543	{
		4544	if (type == DEBUG_TYPE_NULL)
		4545	return FALSE;
		4546
		4547	if (pcount + 1 >= palloc)
		4548	{
		4549	*palloc += 10;
		4550	pargs = ((debug_type )
		4551	xrealloc (pargs, palloc * sizeof **pargs));
		4552	}
		4553	(pargs)[pcount] = type;
		4554	++*pcount;
		4555	}
		4556
		4557	return TRUE;
		4558	}
		4559
		4560	/* Demangle a type. If the ptype argument is not NULL, *ptype is set
		4561	to the newly allocated type. */
		4562
		4563	static bfd_boolean
		4564	stab_demangle_type (struct stab_demangle_info minfo, const char *pp,
		4565	debug_type *ptype)
		4566	{
		4567	const char *orig;
		4568
		4569	orig = *pp;
		4570
		4571	switch (**pp)
		4572	{
		4573	case 'P':
		4574	case 'p':
		4575	/* A pointer type. */
		4576	++*pp;
		4577	if (! stab_demangle_type (minfo, pp, ptype))
		4578	return FALSE;
		4579	if (ptype != NULL)
		4580	ptype = debug_make_pointer_type (minfo->dhandle, ptype);
		4581	break;
		4582
		4583	case 'R':
		4584	/* A reference type. */
		4585	++*pp;
		4586	if (! stab_demangle_type (minfo, pp, ptype))
		4587	return FALSE;
		4588	if (ptype != NULL)
		4589	ptype = debug_make_reference_type (minfo->dhandle, ptype);
		4590	break;
		4591
		4592	case 'A':
		4593	/* An array. */
		4594	{
		4595	unsigned long high;
		4596
		4597	++*pp;
		4598	high = 0;
		4599	while (pp != '\0' && pp != '_')
		4600	{
		4601	if (! ISDIGIT (**pp))
		4602	{
		4603	stab_bad_demangle (orig);
		4604	return FALSE;
		4605	}
		4606	high *= 10;
		4607	high += **pp - '0';
		4608	++*pp;
		4609	}
		4610	if (**pp != '_')
		4611	{
		4612	stab_bad_demangle (orig);
		4613	return FALSE;
		4614	}
		4615	++*pp;
		4616
		4617	if (! stab_demangle_type (minfo, pp, ptype))
		4618	return FALSE;
		4619	if (ptype != NULL)
		4620	{
		4621	debug_type int_type;
		4622
		4623	int_type = debug_find_named_type (minfo->dhandle, "int");
		4624	if (int_type == NULL)
		4625	int_type = debug_make_int_type (minfo->dhandle, 4, FALSE);
		4626	ptype = debug_make_array_type (minfo->dhandle, ptype, int_type,
		4627	0, high, FALSE);
		4628	}
		4629	}
		4630	break;
		4631
		4632	case 'T':
		4633	/* A back reference to a remembered type. */
		4634	{
		4635	unsigned int i;
		4636	const char *p;
		4637
		4638	++*pp;
		4639	if (! stab_demangle_get_count (pp, &i))
		4640	{
		4641	stab_bad_demangle (orig);
		4642	return FALSE;
		4643	}
		4644	if (i >= minfo->typestring_count)
		4645	{
		4646	stab_bad_demangle (orig);
		4647	return FALSE;
		4648	}
		4649	p = minfo->typestrings[i].typestring;
		4650	if (! stab_demangle_type (minfo, &p, ptype))
		4651	return FALSE;
		4652	}
		4653	break;
		4654
		4655	case 'F':
		4656	/* A function. */
		4657	{
		4658	debug_type *args;
		4659	bfd_boolean varargs;
		4660
		4661	++*pp;
		4662	if (! stab_demangle_args (minfo, pp,
		4663	(ptype == NULL
		4664	? (debug_type **) NULL
		4665	: &args),
		4666	(ptype == NULL
		4667	? (bfd_boolean *) NULL
		4668	: &varargs)))
		4669	return FALSE;
		4670	if (**pp != '_')
		4671	{
		4672	/* cplus_demangle will accept a function without a return
		4673	type, but I don't know when that will happen, or what
		4674	to do if it does. */
		4675	stab_bad_demangle (orig);
		4676	return FALSE;
		4677	}
		4678	++*pp;
		4679	if (! stab_demangle_type (minfo, pp, ptype))
		4680	return FALSE;
		4681	if (ptype != NULL)
		4682	ptype = debug_make_function_type (minfo->dhandle, ptype, args,
		4683	varargs);
		4684
		4685	}
		4686	break;
		4687
		4688	case 'M':
		4689	case 'O':
		4690	{
		4691	bfd_boolean memberp;
		4692	debug_type class_type = DEBUG_TYPE_NULL;
		4693	debug_type *args;
		4694	bfd_boolean varargs;
		4695	unsigned int n;
		4696	const char *name;
		4697
		4698	memberp = **pp == 'M';
		4699	args = NULL;
		4700	varargs = FALSE;
		4701
		4702	++*pp;
		4703	if (ISDIGIT (**pp))
		4704	{
		4705	n = stab_demangle_count (pp);
		4706	if (strlen (*pp) < n)
		4707	{
		4708	stab_bad_demangle (orig);
		4709	return FALSE;
		4710	}
		4711	name = *pp;
		4712	*pp += n;
		4713
		4714	if (ptype != NULL)
		4715	{
		4716	class_type = stab_find_tagged_type (minfo->dhandle,
		4717	minfo->info,
		4718	name, (int) n,
		4719	DEBUG_KIND_CLASS);
		4720	if (class_type == DEBUG_TYPE_NULL)
		4721	return FALSE;
		4722	}
		4723	}
		4724	else if (**pp == 'Q')
		4725	{
		4726	if (! stab_demangle_qualified (minfo, pp,
		4727	(ptype == NULL
		4728	? (debug_type *) NULL
		4729	: &class_type)))
		4730	return FALSE;
		4731	}
		4732	else
		4733	{
		4734	stab_bad_demangle (orig);
		4735	return FALSE;
		4736	}
		4737
		4738	if (memberp)
		4739	{
		4740	if (**pp == 'C')
		4741	{
		4742	++*pp;
		4743	}
		4744	else if (**pp == 'V')
		4745	{
		4746	++*pp;
		4747	}
		4748	if (**pp != 'F')
		4749	{
		4750	stab_bad_demangle (orig);
		4751	return FALSE;
		4752	}
		4753	++*pp;
		4754	if (! stab_demangle_args (minfo, pp,
		4755	(ptype == NULL
		4756	? (debug_type **) NULL
		4757	: &args),
		4758	(ptype == NULL
		4759	? (bfd_boolean *) NULL
		4760	: &varargs)))
		4761	return FALSE;
		4762	}
		4763
		4764	if (**pp != '_')
		4765	{
		4766	stab_bad_demangle (orig);
		4767	return FALSE;
		4768	}
		4769	++*pp;
		4770
		4771	if (! stab_demangle_type (minfo, pp, ptype))
		4772	return FALSE;
		4773
		4774	if (ptype != NULL)
		4775	{
		4776	if (! memberp)
		4777	*ptype = debug_make_offset_type (minfo->dhandle, class_type,
		4778	*ptype);
		4779	else
		4780	{
		4781	/* FIXME: We have no way to record constp or
		4782	volatilep. */
		4783	ptype = debug_make_method_type (minfo->dhandle, ptype,
		4784	class_type, args, varargs);
		4785	}
		4786	}
		4787	}
		4788	break;
		4789
		4790	case 'G':
		4791	++*pp;
		4792	if (! stab_demangle_type (minfo, pp, ptype))
		4793	return FALSE;
		4794	break;
		4795
		4796	case 'C':
		4797	++*pp;
		4798	if (! stab_demangle_type (minfo, pp, ptype))
		4799	return FALSE;
		4800	if (ptype != NULL)
		4801	ptype = debug_make_const_type (minfo->dhandle, ptype);
		4802	break;
		4803
		4804	case 'Q':
		4805	{
		4806	if (! stab_demangle_qualified (minfo, pp, ptype))
		4807	return FALSE;
		4808	}
		4809	break;
		4810
		4811	default:
		4812	if (! stab_demangle_fund_type (minfo, pp, ptype))
		4813	return FALSE;
		4814	break;
		4815	}
		4816
		4817	return TRUE;
		4818	}
		4819
		4820	/* Demangle a fundamental type. If the ptype argument is not NULL,
		4821	ptype is set to the newly allocated type. /
		4822
		4823	static bfd_boolean
		4824	stab_demangle_fund_type (struct stab_demangle_info minfo, const char *pp,
		4825	debug_type *ptype)
		4826	{
		4827	const char *orig;
		4828	bfd_boolean constp, volatilep, unsignedp, signedp;
		4829	bfd_boolean done;
		4830
		4831	orig = *pp;
		4832
		4833	constp = FALSE;
		4834	volatilep = FALSE;
		4835	unsignedp = FALSE;
		4836	signedp = FALSE;
		4837
		4838	done = FALSE;
		4839	while (! done)
		4840	{
		4841	switch (**pp)
		4842	{
		4843	case 'C':
		4844	constp = TRUE;
		4845	++*pp;
		4846	break;
		4847
		4848	case 'U':
		4849	unsignedp = TRUE;
		4850	++*pp;
		4851	break;
		4852
		4853	case 'S':
		4854	signedp = TRUE;
		4855	++*pp;
		4856	break;
		4857
		4858	case 'V':
		4859	volatilep = TRUE;
		4860	++*pp;
		4861	break;
		4862
		4863	default:
		4864	done = TRUE;
		4865	break;
		4866	}
		4867	}
		4868
		4869	switch (**pp)
		4870	{
		4871	case '\0':
		4872	case '_':
		4873	/* cplus_demangle permits this, but I don't know what it means. */
		4874	stab_bad_demangle (orig);
		4875	break;
		4876
		4877	case 'v': /* void */
		4878	if (ptype != NULL)
		4879	{
		4880	*ptype = debug_find_named_type (minfo->dhandle, "void");
		4881	if (*ptype == DEBUG_TYPE_NULL)
		4882	*ptype = debug_make_void_type (minfo->dhandle);
		4883	}
		4884	++*pp;
		4885	break;
		4886
		4887	case 'x': /* long long */
		4888	if (ptype != NULL)
		4889	{
		4890	*ptype = debug_find_named_type (minfo->dhandle,
		4891	(unsignedp
		4892	? "long long unsigned int"
		4893	: "long long int"));
		4894	if (*ptype == DEBUG_TYPE_NULL)
		4895	*ptype = debug_make_int_type (minfo->dhandle, 8, unsignedp);
		4896	}
		4897	++*pp;
		4898	break;
		4899
		4900	case 'l': /* long */
		4901	if (ptype != NULL)
		4902	{
		4903	*ptype = debug_find_named_type (minfo->dhandle,
		4904	(unsignedp
		4905	? "long unsigned int"
		4906	: "long int"));
		4907	if (*ptype == DEBUG_TYPE_NULL)
		4908	*ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp);
		4909	}
		4910	++*pp;
		4911	break;
		4912
		4913	case 'i': /* int */
		4914	if (ptype != NULL)
		4915	{
		4916	*ptype = debug_find_named_type (minfo->dhandle,
		4917	(unsignedp
		4918	? "unsigned int"
		4919	: "int"));
		4920	if (*ptype == DEBUG_TYPE_NULL)
		4921	*ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp);
		4922	}
		4923	++*pp;
		4924	break;
		4925
		4926	case 's': /* short */
		4927	if (ptype != NULL)
		4928	{
		4929	*ptype = debug_find_named_type (minfo->dhandle,
		4930	(unsignedp
		4931	? "short unsigned int"
		4932	: "short int"));
		4933	if (*ptype == DEBUG_TYPE_NULL)
		4934	*ptype = debug_make_int_type (minfo->dhandle, 2, unsignedp);
		4935	}
		4936	++*pp;
		4937	break;
		4938
		4939	case 'b': /* bool */
		4940	if (ptype != NULL)
		4941	{
		4942	*ptype = debug_find_named_type (minfo->dhandle, "bool");
		4943	if (*ptype == DEBUG_TYPE_NULL)
		4944	*ptype = debug_make_bool_type (minfo->dhandle, 4);
		4945	}
		4946	++*pp;
		4947	break;
		4948
		4949	case 'c': /* char */
		4950	if (ptype != NULL)
		4951	{
		4952	*ptype = debug_find_named_type (minfo->dhandle,
		4953	(unsignedp
		4954	? "unsigned char"
		4955	: (signedp
		4956	? "signed char"
		4957	: "char")));
		4958	if (*ptype == DEBUG_TYPE_NULL)
		4959	*ptype = debug_make_int_type (minfo->dhandle, 1, unsignedp);
		4960	}
		4961	++*pp;
		4962	break;
		4963
		4964	case 'w': /* wchar_t */
		4965	if (ptype != NULL)
		4966	{
		4967	*ptype = debug_find_named_type (minfo->dhandle, "__wchar_t");
		4968	if (*ptype == DEBUG_TYPE_NULL)
		4969	*ptype = debug_make_int_type (minfo->dhandle, 2, TRUE);
		4970	}
		4971	++*pp;
		4972	break;
		4973
		4974	case 'r': /* long double */
		4975	if (ptype != NULL)
		4976	{
		4977	*ptype = debug_find_named_type (minfo->dhandle, "long double");
		4978	if (*ptype == DEBUG_TYPE_NULL)
		4979	*ptype = debug_make_float_type (minfo->dhandle, 8);
		4980	}
		4981	++*pp;
		4982	break;
		4983
		4984	case 'd': /* double */
		4985	if (ptype != NULL)
		4986	{
		4987	*ptype = debug_find_named_type (minfo->dhandle, "double");
		4988	if (*ptype == DEBUG_TYPE_NULL)
		4989	*ptype = debug_make_float_type (minfo->dhandle, 8);
		4990	}
		4991	++*pp;
		4992	break;
		4993
		4994	case 'f': /* float */
		4995	if (ptype != NULL)
		4996	{
		4997	*ptype = debug_find_named_type (minfo->dhandle, "float");
		4998	if (*ptype == DEBUG_TYPE_NULL)
		4999	*ptype = debug_make_float_type (minfo->dhandle, 4);
		5000	}
		5001	++*pp;
		5002	break;
		5003
		5004	case 'G':
		5005	++*pp;
		5006	if (! ISDIGIT (**pp))
		5007	{
		5008	stab_bad_demangle (orig);
		5009	return FALSE;
		5010	}
		5011	/* Fall through. */
		5012	case '0': case '1': case '2': case '3': case '4':
		5013	case '5': case '6': case '7': case '8': case '9':
		5014	{
		5015	const char *hold;
		5016
		5017	if (! stab_demangle_class (minfo, pp, &hold))
		5018	return FALSE;
		5019	if (ptype != NULL)
		5020	{
		5021	char *name;
		5022
		5023	name = savestring (hold, *pp - hold);
		5024	*ptype = debug_find_named_type (minfo->dhandle, name);
		5025	free (name);
		5026	if (*ptype == DEBUG_TYPE_NULL)
		5027	{
		5028	/* FIXME: It is probably incorrect to assume that
		5029	undefined types are tagged types. */
		5030	*ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
		5031	hold, *pp - hold,
		5032	DEBUG_KIND_ILLEGAL);
		5033	if (*ptype == DEBUG_TYPE_NULL)
		5034	return FALSE;
		5035	}
		5036	}
		5037	}
		5038	break;
		5039
		5040	case 't':
		5041	{
		5042	char *name;
		5043
		5044	if (! stab_demangle_template (minfo, pp,
		5045	ptype != NULL ? &name : NULL))
		5046	return FALSE;
		5047	if (ptype != NULL)
		5048	{
		5049	*ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
		5050	name, strlen (name),
		5051	DEBUG_KIND_CLASS);
		5052	free (name);
		5053	if (*ptype == DEBUG_TYPE_NULL)
		5054	return FALSE;
		5055	}
		5056	}
		5057	break;
		5058
		5059	default:
		5060	stab_bad_demangle (orig);
		5061	return FALSE;
		5062	}
		5063
		5064	if (ptype != NULL)
		5065	{
		5066	if (constp)
		5067	ptype = debug_make_const_type (minfo->dhandle, ptype);
		5068	if (volatilep)
		5069	ptype = debug_make_volatile_type (minfo->dhandle, ptype);
		5070	}
		5071
		5072	return TRUE;
		5073	}
		5074
		5075	/* Remember a type string in a demangled string. */
		5076
		5077	static bfd_boolean
		5078	stab_demangle_remember_type (struct stab_demangle_info *minfo,
		5079	const char *p, int len)
		5080	{
		5081	if (minfo->typestring_count >= minfo->typestring_alloc)
		5082	{
		5083	minfo->typestring_alloc += 10;
		5084	minfo->typestrings = ((struct stab_demangle_typestring *)
		5085	xrealloc (minfo->typestrings,
		5086	(minfo->typestring_alloc
		5087	* sizeof *minfo->typestrings)));
		5088	}
		5089
		5090	minfo->typestrings[minfo->typestring_count].typestring = p;
		5091	minfo->typestrings[minfo->typestring_count].len = (unsigned int) len;
		5092	++minfo->typestring_count;
		5093
		5094	return TRUE;
		5095	}
		5096
		5097	/* Demangle names encoded using the g++ V3 ABI. The newer versions of
		5098	g++ which use this ABI do not encode ordinary method argument types
		5099	in a mangled name; they simply output the argument types. However,
		5100	for a static method, g++ simply outputs the return type and the
		5101	physical name. So in that case we need to demangle the name here.
		5102	Here PHYSNAME is the physical name of the function, and we set the
		5103	variable pointed at by PVARARGS to indicate whether this function
		5104	is varargs. This returns NULL, or a NULL terminated array of
		5105	argument types. */
		5106
		5107	static debug_type *
		5108	stab_demangle_v3_argtypes (void dhandle, struct stab_handle info,
		5109	const char physname, bfd_boolean pvarargs)
		5110	{
		5111	struct demangle_component *dc;
		5112	void *mem;
		5113	debug_type *pargs;
		5114
		5115	dc = cplus_demangle_v3_components (physname, DMGL_PARAMS \| DMGL_ANSI, &mem);
		5116	if (dc == NULL)
		5117	{
		5118	stab_bad_demangle (physname);
		5119	return NULL;
		5120	}
		5121
		5122	/* We expect to see TYPED_NAME, and the right subtree describes the
		5123	function type. */
		5124	if (dc->type != DEMANGLE_COMPONENT_TYPED_NAME
		5125	\|\| dc->u.s_binary.right->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
		5126	{
		5127	fprintf (stderr, _("Demangled name is not a function\n"));
		5128	free (mem);
		5129	return NULL;
		5130	}
		5131
		5132	pargs = stab_demangle_v3_arglist (dhandle, info,
		5133	dc->u.s_binary.right->u.s_binary.right,
		5134	pvarargs);
		5135
		5136	free (mem);
		5137
		5138	return pargs;
		5139	}
		5140
		5141	/* Demangle an argument list in a struct demangle_component tree.
		5142	Returns a DEBUG_TYPE_NULL terminated array of argument types, and
		5143	sets PVARARGS to indicate whether this is a varargs function. /
		5144
		5145	static debug_type *
		5146	stab_demangle_v3_arglist (void dhandle, struct stab_handle info,
		5147	struct demangle_component *arglist,
		5148	bfd_boolean *pvarargs)
		5149	{
		5150	struct demangle_component *dc;
		5151	unsigned int alloc, count;
		5152	debug_type *pargs;
		5153
		5154	alloc = 10;
		5155	pargs = (debug_type ) xmalloc (alloc sizeof *pargs);
		5156	*pvarargs = FALSE;
		5157
		5158	count = 0;
		5159
		5160	for (dc = arglist;
		5161	dc != NULL;
		5162	dc = dc->u.s_binary.right)
		5163	{
		5164	debug_type arg;
		5165	bfd_boolean varargs;
		5166
		5167	if (dc->type != DEMANGLE_COMPONENT_ARGLIST)
		5168	{
		5169	fprintf (stderr, _("Unexpected type in v3 arglist demangling\n"));
		5170	free (pargs);
		5171	return NULL;
		5172	}
		5173
		5174	/* PR 13925: Cope if the demangler returns an empty
		5175	context for a function with no arguments. */
		5176	if (dc->u.s_binary.left == NULL)
		5177	break;
		5178
		5179	arg = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left,
		5180	NULL, &varargs);
		5181	if (arg == NULL)
		5182	{
		5183	if (varargs)
		5184	{
		5185	*pvarargs = TRUE;
		5186	continue;
		5187	}
		5188	free (pargs);
		5189	return NULL;
		5190	}
		5191
		5192	if (count + 1 >= alloc)
		5193	{
		5194	alloc += 10;
		5195	pargs = (debug_type ) xrealloc (pargs, alloc sizeof *pargs);
		5196	}
		5197
		5198	pargs[count] = arg;
		5199	++count;
		5200	}
		5201
		5202	pargs[count] = DEBUG_TYPE_NULL;
		5203
		5204	return pargs;
		5205	}
		5206
		5207	/* Convert a struct demangle_component tree describing an argument
		5208	type into a debug_type. */
		5209
		5210	static debug_type
		5211	stab_demangle_v3_arg (void dhandle, struct stab_handle info,
		5212	struct demangle_component *dc, debug_type context,
		5213	bfd_boolean *pvarargs)
		5214	{
		5215	debug_type dt;
		5216
		5217	if (pvarargs != NULL)
		5218	*pvarargs = FALSE;
		5219
		5220	switch (dc->type)
		5221	{
		5222	/* FIXME: These are demangle component types which we probably
		5223	need to handle one way or another. */
		5224	case DEMANGLE_COMPONENT_LOCAL_NAME:
		5225	case DEMANGLE_COMPONENT_TYPED_NAME:
		5226	case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
		5227	case DEMANGLE_COMPONENT_CTOR:
		5228	case DEMANGLE_COMPONENT_DTOR:
		5229	case DEMANGLE_COMPONENT_JAVA_CLASS:
		5230	case DEMANGLE_COMPONENT_RESTRICT_THIS:
		5231	case DEMANGLE_COMPONENT_VOLATILE_THIS:
		5232	case DEMANGLE_COMPONENT_CONST_THIS:
		5233	case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
		5234	case DEMANGLE_COMPONENT_COMPLEX:
		5235	case DEMANGLE_COMPONENT_IMAGINARY:
		5236	case DEMANGLE_COMPONENT_VENDOR_TYPE:
		5237	case DEMANGLE_COMPONENT_ARRAY_TYPE:
		5238	case DEMANGLE_COMPONENT_PTRMEM_TYPE:
		5239	case DEMANGLE_COMPONENT_ARGLIST:
		5240	default:
		5241	fprintf (stderr, _("Unrecognized demangle component %d\n"),
		5242	(int) dc->type);
		5243	return NULL;
		5244
		5245	case DEMANGLE_COMPONENT_NAME:
		5246	if (context != NULL)
		5247	{
		5248	const debug_field *fields;
		5249
		5250	fields = debug_get_fields (dhandle, context);
		5251	if (fields != NULL)
		5252	{
		5253	/* Try to find this type by looking through the context
		5254	class. */
		5255	for (; *fields != DEBUG_FIELD_NULL; fields++)
		5256	{
		5257	debug_type ft;
		5258	const char *dn;
		5259
		5260	ft = debug_get_field_type (dhandle, *fields);
		5261	if (ft == NULL)
		5262	return NULL;
		5263	dn = debug_get_type_name (dhandle, ft);
		5264	if (dn != NULL
		5265	&& (int) strlen (dn) == dc->u.s_name.len
		5266	&& strncmp (dn, dc->u.s_name.s, dc->u.s_name.len) == 0)
		5267	return ft;
		5268	}
		5269	}
		5270	}
		5271	return stab_find_tagged_type (dhandle, info, dc->u.s_name.s,
		5272	dc->u.s_name.len, DEBUG_KIND_ILLEGAL);
		5273
		5274	case DEMANGLE_COMPONENT_QUAL_NAME:
		5275	context = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left,
		5276	context, NULL);
		5277	if (context == NULL)
		5278	return NULL;
		5279	return stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.right,
		5280	context, NULL);
		5281
		5282	case DEMANGLE_COMPONENT_TEMPLATE:
		5283	{
		5284	char *p;
		5285	size_t alc;
		5286
		5287	/* We print this component to get a class name which we can
		5288	use. FIXME: This probably won't work if the template uses
		5289	template parameters which refer to an outer template. */
		5290	p = cplus_demangle_print (DMGL_PARAMS \| DMGL_ANSI, dc, 20, &alc);
		5291	if (p == NULL)
		5292	{
		5293	fprintf (stderr, _("Failed to print demangled template\n"));
		5294	return NULL;
		5295	}
		5296	dt = stab_find_tagged_type (dhandle, info, p, strlen (p),
		5297	DEBUG_KIND_CLASS);
		5298	free (p);
		5299	return dt;
		5300	}
		5301
		5302	case DEMANGLE_COMPONENT_SUB_STD:
		5303	return stab_find_tagged_type (dhandle, info, dc->u.s_string.string,
		5304	dc->u.s_string.len, DEBUG_KIND_ILLEGAL);
		5305
		5306	case DEMANGLE_COMPONENT_RESTRICT:
		5307	case DEMANGLE_COMPONENT_VOLATILE:
		5308	case DEMANGLE_COMPONENT_CONST:
		5309	case DEMANGLE_COMPONENT_POINTER:
		5310	case DEMANGLE_COMPONENT_REFERENCE:
		5311	dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL,
		5312	NULL);
		5313	if (dt == NULL)
		5314	return NULL;
		5315
		5316	switch (dc->type)
		5317	{
		5318	default:
		5319	abort ();
		5320	case DEMANGLE_COMPONENT_RESTRICT:
		5321	/* FIXME: We have no way to represent restrict. */
		5322	return dt;
		5323	case DEMANGLE_COMPONENT_VOLATILE:
		5324	return debug_make_volatile_type (dhandle, dt);
		5325	case DEMANGLE_COMPONENT_CONST:
		5326	return debug_make_const_type (dhandle, dt);
		5327	case DEMANGLE_COMPONENT_POINTER:
		5328	return debug_make_pointer_type (dhandle, dt);
		5329	case DEMANGLE_COMPONENT_REFERENCE:
		5330	return debug_make_reference_type (dhandle, dt);
		5331	}
		5332
		5333	case DEMANGLE_COMPONENT_FUNCTION_TYPE:
		5334	{
		5335	debug_type *pargs;
		5336	bfd_boolean varargs;
		5337
		5338	if (dc->u.s_binary.left == NULL)
		5339	{
		5340	/* In this case the return type is actually unknown.
		5341	However, I'm not sure this will ever arise in practice;
		5342	normally an unknown return type would only appear at
		5343	the top level, which is handled above. */
		5344	dt = debug_make_void_type (dhandle);
		5345	}
		5346	else
		5347	dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL,
		5348	NULL);
		5349	if (dt == NULL)
		5350	return NULL;
		5351
		5352	pargs = stab_demangle_v3_arglist (dhandle, info,
		5353	dc->u.s_binary.right,
		5354	&varargs);
		5355	if (pargs == NULL)
		5356	return NULL;
		5357
		5358	return debug_make_function_type (dhandle, dt, pargs, varargs);
		5359	}
		5360
		5361	case DEMANGLE_COMPONENT_BUILTIN_TYPE:
		5362	{
		5363	char *p;
		5364	size_t alc;
		5365	debug_type ret;
		5366
		5367	/* We print this component in order to find out the type name.
		5368	FIXME: Should we instead expose the
		5369	demangle_builtin_type_info structure? */
		5370	p = cplus_demangle_print (DMGL_PARAMS \| DMGL_ANSI, dc, 20, &alc);
		5371	if (p == NULL)
		5372	{
		5373	fprintf (stderr, _("Couldn't get demangled builtin type\n"));
		5374	return NULL;
		5375	}
		5376
		5377	/* The mangling is based on the type, but does not itself
		5378	indicate what the sizes are. So we have to guess. */
		5379	if (strcmp (p, "signed char") == 0)
		5380	ret = debug_make_int_type (dhandle, 1, FALSE);
		5381	else if (strcmp (p, "bool") == 0)
		5382	ret = debug_make_bool_type (dhandle, 1);
		5383	else if (strcmp (p, "char") == 0)
		5384	ret = debug_make_int_type (dhandle, 1, FALSE);
		5385	else if (strcmp (p, "double") == 0)
		5386	ret = debug_make_float_type (dhandle, 8);
		5387	else if (strcmp (p, "long double") == 0)
		5388	ret = debug_make_float_type (dhandle, 8);
		5389	else if (strcmp (p, "float") == 0)
		5390	ret = debug_make_float_type (dhandle, 4);
		5391	else if (strcmp (p, "__float128") == 0)
		5392	ret = debug_make_float_type (dhandle, 16);
		5393	else if (strcmp (p, "unsigned char") == 0)
		5394	ret = debug_make_int_type (dhandle, 1, TRUE);
		5395	else if (strcmp (p, "int") == 0)
		5396	ret = debug_make_int_type (dhandle, 4, FALSE);
		5397	else if (strcmp (p, "unsigned int") == 0)
		5398	ret = debug_make_int_type (dhandle, 4, TRUE);
		5399	else if (strcmp (p, "long") == 0)
		5400	ret = debug_make_int_type (dhandle, 4, FALSE);
		5401	else if (strcmp (p, "unsigned long") == 0)
		5402	ret = debug_make_int_type (dhandle, 4, TRUE);
		5403	else if (strcmp (p, "__int128") == 0)
		5404	ret = debug_make_int_type (dhandle, 16, FALSE);
		5405	else if (strcmp (p, "unsigned __int128") == 0)
		5406	ret = debug_make_int_type (dhandle, 16, TRUE);
		5407	else if (strcmp (p, "short") == 0)
		5408	ret = debug_make_int_type (dhandle, 2, FALSE);
		5409	else if (strcmp (p, "unsigned short") == 0)
		5410	ret = debug_make_int_type (dhandle, 2, TRUE);
		5411	else if (strcmp (p, "void") == 0)
		5412	ret = debug_make_void_type (dhandle);
		5413	else if (strcmp (p, "wchar_t") == 0)
		5414	ret = debug_make_int_type (dhandle, 4, TRUE);
		5415	else if (strcmp (p, "long long") == 0)
		5416	ret = debug_make_int_type (dhandle, 8, FALSE);
		5417	else if (strcmp (p, "unsigned long long") == 0)
		5418	ret = debug_make_int_type (dhandle, 8, TRUE);
		5419	else if (strcmp (p, "...") == 0)
		5420	{
		5421	if (pvarargs == NULL)
		5422	fprintf (stderr, _("Unexpected demangled varargs\n"));
		5423	else
		5424	*pvarargs = TRUE;
		5425	ret = NULL;
		5426	}
		5427	else
		5428	{
		5429	fprintf (stderr, _("Unrecognized demangled builtin type\n"));
		5430	ret = NULL;
		5431	}
		5432
		5433	free (p);
		5434
		5435	return ret;
		5436	}
		5437	}
		5438	}

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/binutils/stabs.c – Rev 6324